Strumenti

Strumento bash

Lo strumento bash consente a Claude di eseguire comandi shell in una sessione bash persistente, permettendo operazioni di sistema, esecuzione di script e automazione da riga di comando.

Panoramica

Lo strumento bash fornisce a Claude:

Sessione bash persistente che mantiene lo stato
Capacità di eseguire qualsiasi comando shell
Accesso alle variabili di ambiente e alla directory di lavoro
Capacità di concatenamento di comandi e scripting

Compatibilità dei modelli

Modello	Versione dello strumento
Modelli Claude 4 e Sonnet 3.7 (deprecato)	`bash_20250124`

Le versioni precedenti dello strumento non sono garantite essere retrocompatibili con i modelli più recenti. Utilizza sempre la versione dello strumento che corrisponde alla versione del tuo modello.

Casi d'uso

Flussi di lavoro di sviluppo: Esegui comandi di build, test e strumenti di sviluppo
Automazione del sistema: Esegui script, gestisci file, automatizza attività
Elaborazione dei dati: Elabora file, esegui script di analisi, gestisci dataset
Configurazione dell'ambiente: Installa pacchetti, configura ambienti

Avvio rapido

Come funziona

Lo strumento bash mantiene una sessione persistente:

Claude determina quale comando eseguire
Esegui il comando in una shell bash
Restituisci l'output (stdout e stderr) a Claude
Lo stato della sessione persiste tra i comandi (variabili di ambiente, directory di lavoro)

Parametri

Parametro	Obbligatorio	Descrizione
`command`	Sì*	Il comando bash da eseguire
`restart`	No	Impostare su `true` per riavviare la sessione bash

*Obbligatorio a meno che non si utilizzi restart

Esempio: Automazione multi-step

Claude può concatenare comandi per completare attività complesse:

# Richiesta dell'utente
"Install the requests library and create a simple Python script that fetches a joke from an API, then run it."

# Lo strumento di Claude utilizza:
# 1. Installa il pacchetto
{"command": "pip install requests"}

# 2. Crea lo script
{"command": "cat > fetch_joke.py << 'EOF'\nimport requests\nresponse = requests.get('https://official-joke-api.appspot.com/random_joke')\njoke = response.json()\nprint(f\"Setup: {joke['setup']}\")\nprint(f\"Punchline: {joke['punchline']}\")\nEOF"}

# 3. Esegui lo script
{"command": "python fetch_joke.py"}

La sessione mantiene lo stato tra i comandi, quindi i file creati nel passaggio 2 sono disponibili nel passaggio 3.

Implementare lo strumento bash

Lo strumento bash è implementato come uno strumento senza schema. Quando utilizzi questo strumento, non è necessario fornire uno schema di input come con altri strumenti; lo schema è integrato nel modello di Claude e non può essere modificato.

Gestisci gli errori

Quando implementi lo strumento bash, gestisci vari scenari di errore:

Segui le best practice di implementazione

Sicurezza

Lo strumento bash fornisce accesso diretto al sistema. Implementa queste misure di sicurezza essenziali:

Esecuzione in ambienti isolati (Docker/VM)
Implementazione del filtraggio dei comandi e delle liste di autorizzazione
Impostazione dei limiti di risorse (CPU, memoria, disco)
Registrazione di tutti i comandi eseguiti

Raccomandazioni chiave

Utilizza ulimit per impostare vincoli di risorse
Filtra i comandi pericolosi (sudo, rm -rf, ecc.)
Esegui con permessi utente minimi
Monitora e registra tutta l'esecuzione dei comandi

Prezzi

The bash tool adds 245 input tokens to your API calls.

Additional tokens are consumed by:

Command outputs (stdout/stderr)
Error messages
Large file contents

Vedi prezzi dell'utilizzo degli strumenti per i dettagli completi sui prezzi.

Modelli comuni

Flussi di lavoro di sviluppo

Esecuzione dei test: pytest && coverage report
Compilazione dei progetti: npm install && npm run build
Operazioni Git: git status && git add . && git commit -m "message"

Operazioni su file

Elaborazione dei dati: wc -l *.csv && ls -lh *.csv
Ricerca nei file: find . -name "*.py" | xargs grep "pattern"
Creazione di backup: tar -czf backup.tar.gz ./data

Attività di sistema

Verifica delle risorse: df -h && free -m
Gestione dei processi: ps aux | grep python
Configurazione dell'ambiente: export PATH=$PATH:/new/path && echo $PATH

Limitazioni

Nessun comando interattivo: Non può gestire vim, less o prompt di password
Nessuna applicazione GUI: Solo riga di comando
Ambito della sessione: Persiste all'interno della conversazione, perso tra le chiamate API
Limiti di output: Gli output di grandi dimensioni possono essere troncati
Nessuno streaming: I risultati vengono restituiti dopo il completamento

Combinazione con altri strumenti

Lo strumento bash è più potente quando combinato con l'editor di testo e altri strumenti.

Passaggi successivi

Panoramica dell'utilizzo degli strumenti

Scopri l'utilizzo degli strumenti con Claude

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=[
        {
            "type": "bash_20250124",
            "name": "bash"
        }
    ],
    messages=[
        {"role": "user", "content": "List all Python files in the current directory."}
    ]
)

Configura un ambiente bash

Crea una sessione bash persistente con cui Claude può interagire:

import subprocess
import threading
import queue

class BashSession:
    def __init__(self):
        self.process = subprocess.Popen(
            ['/bin/bash'],
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            bufsize=0
        )
        self.output_queue = queue.Queue()
        self.error_queue = queue.Queue()
        self._start_readers()

Gestisci l'esecuzione dei comandi

Crea una funzione per eseguire comandi e acquisire l'output:

def execute_command(self, command):
    # Invia il comando a bash
    self.process.stdin.write(command + '\n')
    self.process.stdin.flush()
    
    # Acquisisci l'output con timeout
    output = self._read_output(timeout=10)
    return output

Elabora le chiamate degli strumenti di Claude

Estrai ed esegui i comandi dalle risposte di Claude:

for content in response.content:
    if content.type == "tool_use" and content.name == "bash":
        if content.input.get("restart"):
            bash_session.restart()
            result = "Bash session restarted"
        else:
            command = content.input.get("command")
            result = bash_session.execute_command(command)
        
        # Restituisci il risultato a Claude
        tool_result = {
            "type": "tool_result",
            "tool_use_id": content.id,
            "content": result
        }

Implementa misure di sicurezza

Aggiungi convalida e restrizioni:

def validate_command(command):
    # Blocca i comandi pericolosi
    dangerous_patterns = ['rm -rf /', 'format', ':(){:|:&};:']
    for pattern in dangerous_patterns:
        if pattern in command:
            return False, f"Command contains dangerous pattern: {pattern}"
    
    # Aggiungi ulteriore convalida secondo le necessità
    return True, None

Panoramica

Compatibilità dei modelli

Casi d'uso

Avvio rapido

Come funziona

Parametri

Esempio di utilizzo

Esempio: Automazione multi-step

Implementare lo strumento bash

Gestisci gli errori

Timeout dell'esecuzione del comando

Comando non trovato

Segui le best practice di implementazione

Utilizza timeout dei comandi

Sicurezza

Raccomandazioni chiave

Prezzi

Modelli comuni

Flussi di lavoro di sviluppo

Operazioni su file

Attività di sistema

Limitazioni

Combinazione con altri strumenti

Passaggi successivi

Panoramica

Compatibilità dei modelli

Casi d'uso

Avvio rapido

Come funziona

Parametri

Esempio di utilizzo

Esempio: Automazione multi-step

Implementare lo strumento bash

Gestisci gli errori

Timeout dell'esecuzione del comando

Comando non trovato

Segui le best practice di implementazione

Utilizza timeout dei comandi

Sicurezza

Raccomandazioni chiave

Prezzi

Modelli comuni

Flussi di lavoro di sviluppo

Operazioni su file

Attività di sistema

Limitazioni

Combinazione con altri strumenti

Passaggi successivi

Permesso negato

Mantieni lo stato della sessione

Gestisci output di grandi dimensioni

Registra tutti i comandi

Sanitizza gli output