• Mensagens
  • Agentes Gerenciados
  • Administração

Search...
⌘K
Primeiros passos
Introdução ao ClaudeInício rápido
Desenvolvendo com o Claude
Visão geral dos recursosUsando a API de MensagensMotivos de parada e fallbackRecusas e fallbackCrédito de fallback
Capacidades do modelo
Pensamento estendidoPensamento adaptativoEsforçoOrçamentos de tarefas (beta)Modo rápido (prévia de pesquisa)Saídas estruturadasCitaçõesStreaming de MensagensProcessamento em loteResultados de pesquisaStreaming de recusasSuporte multilíngueEmbeddings
Ferramentas
Visão geralComo funciona o uso de ferramentasTutorial: Crie um agente com uso de ferramentasDefinir ferramentasLidar com chamadas de ferramentasUso de ferramentas em paraleloTool Runner (SDK)Uso de ferramentas estritoUso de ferramentas com cache de promptFerramentas de servidorSolução de problemasFerramenta de pesquisa na webFerramenta de busca na webFerramenta de execução de códigoFerramenta de consultoriaFerramenta de memóriaFerramenta BashFerramenta de uso de computadorFerramenta de editor de texto
Infraestrutura de ferramentas
Referência de ferramentasGerenciar contexto de ferramentasCombinações de ferramentasPesquisa de ferramentasChamada programática de ferramentasStreaming granular de ferramentas
Gerenciamento de contexto
Janelas de contextoCompactaçãoEdição de contextoCache de promptMensagens de sistema no meio da conversaCriar um modo de orquestraçãoDiagnóstico de cache (beta)Contagem de tokens
Trabalhando com arquivos
API de ArquivosSuporte a PDFImagens e visão
Skills
Visão geralInício rápidoPráticas recomendadasSkills para empresasSkills na API
MCP
Servidores MCP remotosConector MCP
Claude em plataformas de nuvem
Amazon BedrockAmazon Bedrock (legado)Claude Platform na AWSMicrosoft FoundryVertex AI

Log in
Ferramenta Bash
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...

Solutions

  • AI agents
  • Code modernization
  • Coding
  • Customer support
  • Education
  • Financial services
  • Government
  • Life sciences

Partners

  • Amazon Bedrock
  • Google Cloud's Vertex AI

Learn

  • Blog
  • Courses
  • Use cases
  • Connectors
  • Customer stories
  • Engineering at Anthropic
  • Events
  • Powered by Claude
  • Service partners
  • Startups program

Company

  • Anthropic
  • Careers
  • Economic Futures
  • Research
  • News
  • Responsible Scaling Policy
  • Security and compliance
  • Transparency

Learn

  • Blog
  • Courses
  • Use cases
  • Connectors
  • Customer stories
  • Engineering at Anthropic
  • Events
  • Powered by Claude
  • Service partners
  • Startups program

Help and security

  • Availability
  • Status
  • Support
  • Discord

Terms and policies

  • Privacy policy
  • Responsible disclosure policy
  • Terms of service: Commercial
  • Terms of service: Consumer
  • Usage policy
Mensagens/Ferramentas

Ferramenta Bash



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.

Visão geral

A ferramenta bash fornece ao Claude:

  • Sessão bash persistente que mantém o estado
  • Capacidade de executar qualquer comando de shell
  • Acesso a variáveis de ambiente e diretório de trabalho
  • Recursos de encadeamento de comandos e scripting

Para suporte de modelos, consulte a Referência de ferramentas.

Casos de uso

  • Fluxos de trabalho de desenvolvimento: Executar comandos de build, testes e ferramentas de desenvolvimento
  • Automação de sistema: Executar scripts, gerenciar arquivos, automatizar tarefas
  • Processamento de dados: Processar arquivos, executar scripts de análise, gerenciar conjuntos de dados
  • Configuração de ambiente: Instalar pacotes, configurar ambientes

Início rápido

Como funciona

A ferramenta bash mantém uma sessão persistente:

  1. O Claude determina qual comando executar
  2. Você executa o comando em um shell bash
  3. Retorna a saída (stdout e stderr) para o Claude
  4. O estado da sessão persiste entre comandos (variáveis de ambiente, diretório de trabalho)

Parâmetros

ParâmetroObrigatórioDescrição
commandSim*O comando bash a ser executado
restartNãoDefina como true para reiniciar a sessão bash

*Obrigatório, a menos que esteja usando restart

Exemplo: Automação em várias etapas

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.

Implementar a ferramenta bash

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.

Tratar erros

Ao implementar a ferramenta bash, trate vários cenários de erro:

Seguir as melhores práticas de implementação

Segurança



A ferramenta bash fornece acesso direto ao sistema. Implemente estas medidas de segurança essenciais:

  • Executar em ambientes isolados (Docker/VM)
  • Implementar filtragem de comandos e allowlists
  • Definir limites de recursos (CPU, memória, disco)
  • Registrar todos os comandos executados

Principais recomendações

  • Use ulimit para definir restrições de recursos
  • Filtre comandos perigosos (sudo, rm -rf, etc.)
  • Execute com permissões mínimas de usuário
  • Monitore e registre toda a execução de comandos

Preços

A ferramenta bash adiciona 245 tokens de entrada às suas chamadas de API.

Tokens adicionais são consumidos por:

  • Saídas de comando (stdout/stderr)
  • Mensagens de erro
  • Conteúdos de arquivos grandes

Consulte preços de uso de ferramentas para obter detalhes completos de preços.

Padrões comuns

Fluxos de trabalho de desenvolvimento

  • Executar testes: pytest && coverage report
  • Compilar projetos: npm install && npm run build
  • Operações Git: git status && git add . && git commit -m "message"

Checkpointing baseado em Git

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:

  • Capturar uma linha de base: Antes de qualquer trabalho do agente começar, faça commit do estado atual. Esse é o ponto de partida conhecido como bom.
  • Commit por funcionalidade: Cada funcionalidade concluída recebe seu próprio commit. Eles servem como pontos de rollback caso algo dê errado mais tarde.
  • Reconstruir o estado no início da sessão: Leia git log junto com um arquivo de progresso para entender o que já foi feito e o que vem a seguir.
  • Reverter em caso de falha: Se o trabalho sair dos trilhos, git checkout reverte para o último commit bom em vez de tentar depurar um estado quebrado.

Operações de arquivo

  • Processar dados: wc -l *.csv && ls -lh *.csv
  • Pesquisar arquivos: find . -name "*.py" | xargs grep "pattern"
  • Criar backups: tar -czf backup.tar.gz ./data

Tarefas de sistema

  • Verificar recursos: df -h && free -m
  • Gerenciamento de processos: ps aux | grep python
  • Configuração de ambiente: export PATH=$PATH:/new/path && echo $PATH

Limitações

  • Sem comandos interativos: Não pode lidar com vim, less ou prompts de senha
  • Sem aplicações GUI: Apenas linha de comando
  • Escopo da sessão: O estado da sessão bash fica do lado do cliente. A API é stateless. Sua aplicação é responsável por manter a sessão de shell entre os turnos.
  • Limites de saída: Saídas grandes podem ser truncadas
  • Sem streaming: Resultados retornados após a conclusão

Combinando com outras ferramentas

A 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.

Próximos passos


Visão geral do uso de ferramentas

Saiba mais sobre o uso de ferramentas com o Claude


Ferramenta de editor de texto

Visualize e edite arquivos de texto com o Claude

Was this page helpful?

  • Visão geral
  • Casos de uso
  • Início rápido
  • Como funciona
  • Parâmetros
  • Exemplo: Automação em várias etapas
  • Implementar a ferramenta bash
  • Tratar erros
  • Seguir as melhores práticas de implementação
  • Segurança
  • Principais recomendações
  • Preços
  • Padrões comuns
  • Fluxos de trabalho de desenvolvimento
  • Operações de arquivo
  • Tarefas de sistema
  • Limitações
  • Combinando com outras ferramentas
  • Próximos passos
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)
  1. 1

    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()
  2. 2

    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
    
  3. 3

    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,
            }
  4. 4

    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, None

    Essa 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.