L’outil bash permet à Claude d’exécuter des commandes shell dans une session bash persistante, permettant les opérations système, l’exécution de scripts et l’automatisation en ligne de commande.

Aperçu

L’outil bash fournit à Claude :

  • Session bash persistante qui maintient l’état
  • Capacité d’exécuter n’importe quelle commande shell
  • Accès aux variables d’environnement et au répertoire de travail
  • Capacités de chaînage de commandes et de script

Versions de l’outil

ModèleVersion de l’outil
Claude 4 & Sonnet 3.7bash_20250124
Claude Sonnet 3.5bash_20241022

Claude Sonnet 3.5 nécessite l’en-tête bêta computer-use-2024-10-22 lors de l’utilisation de l’outil bash.

L’outil bash est généralement disponible dans Claude 4 et Sonnet 3.7.

Cas d’usage

  • Flux de travail de développement : Exécuter des commandes de construction, des tests et des outils de développement
  • Automatisation système : Exécuter des scripts, gérer des fichiers, automatiser des tâches
  • Traitement de données : Traiter des fichiers, exécuter des scripts d’analyse, gérer des jeux de données
  • Configuration d’environnement : Installer des packages, configurer des environnements

Démarrage rapide

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "bash_20250124",
            "name": "bash"
        }
    ],
    messages=[
        {"role": "user", "content": "Lister tous les fichiers Python dans le répertoire courant."}
    ]
)

Comment ça fonctionne

L’outil bash maintient une session persistante :

  1. Claude détermine quelle commande exécuter
  2. Vous exécutez la commande dans un shell bash
  3. Retournez la sortie (stdout et stderr) à Claude
  4. L’état de la session persiste entre les commandes (variables d’environnement, répertoire de travail)

Paramètres

ParamètreRequisDescription
commandOui*La commande bash à exécuter
restartNonDéfinir à true pour redémarrer la session bash

*Requis sauf si vous utilisez restart

Exemple : Automatisation multi-étapes

Claude peut chaîner des commandes pour accomplir des tâches complexes :

# Demande de l'utilisateur
"Installer la bibliothèque requests et créer un script Python simple qui récupère une blague depuis une API, puis l'exécuter."

# Utilisations d'outils de Claude :
# 1. Installer le package
{"command": "pip install requests"}

# 2. Créer le 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. Exécuter le script
{"command": "python fetch_joke.py"}

La session maintient l’état entre les commandes, donc les fichiers créés à l’étape 2 sont disponibles à l’étape 3.


Implémenter l’outil bash

L’outil bash est implémenté comme un outil sans schéma. Lors de l’utilisation de cet outil, vous n’avez pas besoin de fournir un schéma d’entrée comme avec d’autres outils ; le schéma est intégré dans le modèle de Claude et ne peut pas être modifié.

1

Configurer un environnement bash

Créer une session bash persistante avec laquelle Claude peut 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

Gérer l'exécution des commandes

Créer une fonction pour exécuter des commandes et capturer la sortie :

def execute_command(self, command):
    # Envoyer la commande à bash
    self.process.stdin.write(command + '\n')
    self.process.stdin.flush()
    
    # Capturer la sortie avec timeout
    output = self._read_output(timeout=10)
    return output
3

Traiter les appels d'outils de Claude

Extraire et exécuter les commandes des réponses de Claude :

for content in response.content:
    if content.type == "tool_use" and content.name == "bash":
        if content.input.get("restart"):
            bash_session.restart()
            result = "Session bash redémarrée"
        else:
            command = content.input.get("command")
            result = bash_session.execute_command(command)
        
        # Retourner le résultat à Claude
        tool_result = {
            "type": "tool_result",
            "tool_use_id": content.id,
            "content": result
        }
4

Implémenter des mesures de sécurité

Ajouter validation et restrictions :

def validate_command(command):
    # Bloquer les commandes dangereuses
    dangerous_patterns = ['rm -rf /', 'format', ':(){:|:&};:']
    for pattern in dangerous_patterns:
        if pattern in command:
            return False, f"La commande contient un motif dangereux : {pattern}"
    
    # Ajouter plus de validation si nécessaire
    return True, None

Gérer les erreurs

Lors de l’implémentation de l’outil bash, gérer divers scénarios d’erreur :

Suivre les meilleures pratiques d’implémentation

Sécurité

L’outil bash fournit un accès direct au système. Implémentez ces mesures de sécurité essentielles :

  • Exécution dans des environnements isolés (Docker/VM)
  • Implémentation de filtrage de commandes et de listes d’autorisation
  • Définition de limites de ressources (CPU, mémoire, disque)
  • Enregistrement de toutes les commandes exécutées

Recommandations clés

  • Utiliser ulimit pour définir des contraintes de ressources
  • Filtrer les commandes dangereuses (sudo, rm -rf, etc.)
  • Exécuter avec des permissions utilisateur minimales
  • Surveiller et enregistrer toute exécution de commande

Tarification

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

Voir tarification d’utilisation d’outils pour les détails complets de tarification.

Modèles courants

Flux de travail de développement

  • Exécuter des tests : pytest && coverage report
  • Construire des projets : npm install && npm run build
  • Opérations Git : git status && git add . && git commit -m "message"

Opérations de fichiers

  • Traiter des données : wc -l *.csv && ls -lh *.csv
  • Rechercher dans les fichiers : find . -name "*.py" | xargs grep "pattern"
  • Créer des sauvegardes : tar -czf backup.tar.gz ./data

Tâches système

  • Vérifier les ressources : df -h && free -m
  • Gestion des processus : ps aux | grep python
  • Configuration d’environnement : export PATH=$PATH:/new/path && echo $PATH

Limitations

  • Pas de commandes interactives : Ne peut pas gérer vim, less, ou les invites de mot de passe
  • Pas d’applications GUI : Ligne de commande uniquement
  • Portée de session : Persiste dans la conversation, perdue entre les appels API
  • Limites de sortie : Les sorties volumineuses peuvent être tronquées
  • Pas de streaming : Résultats retournés après achèvement

Combinaison avec d’autres outils

L’outil bash est plus puissant lorsqu’il est combiné avec l’éditeur de texte et d’autres outils.

Prochaines étapes