Este recurso é elegível para Zero Data Retention (ZDR). Quando sua organização possui um acordo de ZDR, os dados enviados por meio deste recurso não são armazenados após a resposta da API ser retornada.
A ferramenta bash permite que o Claude execute comandos de shell em uma sessão bash persistente, possibilitando operações de sistema, execução de scripts e automação de linha de comando. O acesso ao shell é uma capacidade fundamental de agentes. No Terminal-Bench 2.0, um benchmark que avalia tarefas reais de terminal usando validação exclusivamente via shell, o Claude apresenta ganhos significativos de desempenho com acesso a uma sessão bash persistente.
A ferramenta bash fornece ao Claude:
Para suporte de modelos, consulte a Referência de ferramentas.
A ferramenta bash mantém uma sessão persistente:
| Parâmetro | Obrigatório | Descrição |
|---|---|---|
command | Sim* | O comando bash a ser executado |
restart | Não | Defina como true para reiniciar a sessão bash |
*Obrigatório, a menos que esteja usando restart
O Claude pode encadear comandos para concluir tarefas complexas:
User request:
"Install the requests library and create a simple Python script that
fetches a joke from an API, then run it."
Claude's tool uses:
1. Install package
{"command": "pip install requests"}
2. Create 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. Run script
{"command": "python fetch_joke.py"}A sessão mantém o estado entre comandos, então os arquivos criados na etapa 2 estão disponíveis na etapa 3.
A ferramenta bash é implementada como uma ferramenta sem esquema. Ao usar essa ferramenta, você não precisa fornecer um esquema de entrada como em outras ferramentas; o esquema está incorporado ao modelo do Claude e não pode ser modificado.
Ao implementar a ferramenta bash, trate vários cenários de erro:
A ferramenta bash fornece acesso direto ao sistema. Implemente estas medidas de segurança essenciais:
ulimit para definir restrições de recursossudo, rm -rf, etc.)A ferramenta bash adiciona 245 tokens de entrada às suas chamadas de API.
Tokens adicionais são consumidos por:
Consulte preços de uso de ferramentas para obter detalhes completos de preços.
pytest && coverage reportnpm install && npm run buildgit status && git add . && git commit -m "message"O Git serve como um mecanismo estruturado de recuperação em fluxos de trabalho de agentes de longa duração, não apenas como uma forma de salvar alterações:
git log junto com um arquivo de progresso para entender o que já foi feito e o que vem a seguir.git checkout reverte para o último commit bom em vez de tentar depurar um estado quebrado.wc -l *.csv && ls -lh *.csvfind . -name "*.py" | xargs grep "pattern"tar -czf backup.tar.gz ./datadf -h && free -mps aux | grep pythonexport PATH=$PATH:/new/path && echo $PATHvim, less ou prompts de senhaA ferramenta bash é mais poderosa quando combinada com o editor de texto e outras ferramentas.
Se você também estiver usando a ferramenta de execução de código, o Claude tem acesso a dois ambientes de execução separados: sua sessão bash local e o contêiner em sandbox da Anthropic. O estado não é compartilhado entre eles. Consulte Usando execução de código com outras ferramentas de execução para obter orientações sobre como instruir o Claude a distinguir entre os ambientes.
Saiba mais sobre o uso de ferramentas com o Claude
Visualize e edite arquivos de texto com o Claude
Was this page helpful?
import anthropic
client = anthropic.Anthropic()
response = client.messages.create(
model="claude-opus-4-8",
max_tokens=1024,
tools=[{"type": "bash_20250124", "name": "bash"}],
messages=[
{"role": "user", "content": "List all Python files in the current directory."}
],
)
print(response)Configurar um ambiente bash
Crie uma sessão bash persistente com a qual o Claude possa interagir:
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()Tratar a execução de comandos
Crie uma função para executar comandos e capturar a saída:
def execute_command(self, command):
# Enviar comando para o bash
self.process.stdin.write(command + "\n")
self.process.stdin.flush()
# Capturar saída com timeout
output = self._read_output(timeout=10)
return output
Processar as chamadas de ferramenta do Claude
Extraia e execute comandos das respostas do 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)
# Retornar o resultado ao Claude
tool_result = {
"type": "tool_result",
"tool_use_id": content.id,
"content": result,
}Implementar medidas de segurança
Adicione validação e restrições. Use uma "allowlist" (lista de permissões) em vez de uma "blocklist" (lista de bloqueios), já que blocklists são fáceis de contornar. Rejeite operadores de shell para que comandos encadeados não consigam passar pela allowlist:
import shlex
ALLOWED_COMMANDS = {"ls", "cat", "echo", "pwd", "grep", "find", "wc", "head", "tail"}
SHELL_OPERATORS = {"&&", "||", "|", ";", "&", ">", "<", ">>"}
def validate_command(command):
# Permitir apenas comandos de uma lista de permissões explícita
try:
tokens = shlex.split(command)
except ValueError:
return False, "Could not parse command"
if not tokens:
return False, "Empty command"
executable = tokens[0]
if executable not in ALLOWED_COMMANDS:
return False, f"Command '{executable}' is not in the allowlist"
# Rejeitar operadores de shell que encadeariam comandos adicionais
for token in tokens[1:]:
if token in SHELL_OPERATORS or token.startswith(("$", "`")):
return False, f"Shell operator '{token}' is not allowed"
return True, NoneEssa verificação é uma primeira linha de defesa. Para um isolamento mais forte, execute comandos validados com shell=False e passe shlex.split(command) como a lista de argumentos, para que o shell nunca interprete a string.