Outil bash

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 :

Une session bash persistante qui maintient l'état
La capacité d'exécuter n'importe quelle commande shell
L'accès aux variables d'environnement et au répertoire de travail
Les capacités de chaînage de commandes et de scripting

Compatibilité des modèles

Modèle	Version de l'outil
Modèles Claude 4 et Sonnet 3.7 (obsolète)	`bash_20250124`

Les versions plus anciennes de l'outil ne sont pas garanties d'être rétro-compatibles avec les modèles plus récents. Utilisez toujours la version de l'outil qui correspond à votre version de modèle.

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 les fichiers, automatiser les tâches
Traitement des données : Traiter les fichiers, exécuter des scripts d'analyse, gérer les ensembles de données
Configuration de l'environnement : Installer des packages, configurer les environnements

Démarrage rapide

Fonctionnement

L'outil bash maintient une session persistante :

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

Paramètres

Paramètre	Requis	Description
`command`	Oui*	La commande bash à exécuter
`restart`	Non	Dé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
"Install the requests library and create a simple Python script that fetches a joke from an API, then run it."

# L'outil de Claude utilise :
# 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é au modèle de Claude et ne peut pas être modifié.

Gérer les erreurs

Lors de l'implémentation de l'outil bash, gérez 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 du filtrage des commandes et des listes blanches
Définition des limites de ressources (CPU, mémoire, disque)
Enregistrement de toutes les commandes exécutées

Recommandations clés

Utilisez ulimit pour définir les contraintes de ressources
Filtrez les commandes dangereuses (sudo, rm -rf, etc.)
Exécutez avec des permissions utilisateur minimales
Surveillez et enregistrez 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 de l'utilisation des outils pour les détails complets de la 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 sur les fichiers

Traiter les données : wc -l *.csv && ls -lh *.csv
Rechercher des 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 de l'environnement : export PATH=$PATH:/new/path && echo $PATH

Limitations

Pas de commandes interactives : Impossible de gérer vim, less ou les invites de mot de passe
Pas d'applications GUI : Ligne de commande uniquement
Portée de la session : Persiste dans la conversation, perdue entre les appels API
Limites de sortie : Les grandes sorties peuvent être tronquées
Pas de streaming : Les résultats retournés après la fin

Combinaison avec d'autres outils

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

Étapes suivantes

Aperçu de l'utilisation des outils

En savoir plus sur l'utilisation des outils avec 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."}
    ]
)

Configurer un environnement bash

Créez 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()

Gérer l'exécution des commandes

Créez une fonction pour exécuter les 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 délai d'attente
    output = self._read_output(timeout=10)
    return output

Traiter les appels d'outils de Claude

Extrayez et exécutez 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 = "Bash session restarted"
        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
        }

Implémenter les mesures de sécurité

Ajoutez la validation et les 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"Command contains dangerous pattern: {pattern}"
    
    # Ajouter plus de validation selon les besoins
    return True, None

Aperçu

Compatibilité des modèles

Cas d'usage

Démarrage rapide

Fonctionnement

Paramètres

Exemple d'utilisation

Exemple : Automatisation multi-étapes

Implémenter l'outil bash

Gérer les erreurs

Délai d'attente d'exécution de la commande

Commande non trouvée

Suivre les meilleures pratiques d'implémentation

Utiliser les délais d'attente des commandes

Sécurité

Recommandations clés

Tarification

Modèles courants

Flux de travail de développement

Opérations sur les fichiers

Tâches système

Limitations

Combinaison avec d'autres outils

Étapes suivantes

Permission refusée

Maintenir l'état de la session

Gérer les grandes sorties

Enregistrer toutes les commandes

Nettoyer les sorties