Outil d’édition de texte

Claude peut utiliser un outil d’éditeur de texte au schéma défini par Anthropic pour afficher et modifier des fichiers texte, vous aidant ainsi à déboguer, corriger et améliorer votre code ou d’autres documents texte. Cela permet à Claude d’interagir directement avec vos fichiers, en fournissant une assistance concrète plutôt que de simplement suggérer des modifications.

Pour la prise en charge des modèles, consultez la référence des outils.

Quand utiliser l’outil d’éditeur de texte

Voici quelques exemples de situations où utiliser l’outil d’éditeur de texte :

• Débogage de code : Demandez à Claude d’identifier et de corriger les bugs dans votre code, des erreurs de syntaxe aux problèmes de logique.
• Refactorisation de code : Laissez Claude améliorer la structure, la lisibilité et les performances de votre code grâce à des modifications ciblées.
• Génération de documentation : Demandez à Claude d’ajouter des docstrings, des commentaires ou des fichiers README à votre base de code.
• Création de tests : Demandez à Claude de créer des tests unitaires pour votre code en fonction de son analyse de l’implémentation.

Utiliser l’outil d’éditeur de texte

Fournissez l’outil d’éditeur de texte (nommé str_replace_based_edit_tool) à Claude en utilisant l’API Messages.

Vous pouvez éventuellement spécifier un paramètre max_characters pour contrôler la troncature lors de l’affichage de fichiers volumineux.

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=[
        {
            "type": "text_editor_20250728",
            "name": "str_replace_based_edit_tool",
            "max_characters": 10000,
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "There's a syntax error in my primes.py file. Can you help me fix it?",
        }
    ],
)

print(response)

Utilisez l’outil d’éditeur de texte de la manière suivante :

1. 1

   Fournir à Claude l’outil d’éditeur de texte et un prompt utilisateur

   • Incluez l’outil d’éditeur de texte dans votre requête API.
   • Fournissez un prompt utilisateur qui pourrait nécessiter l’examen ou la modification de fichiers, par exemple « Pouvez-vous corriger l’erreur de syntaxe dans mon code ? ».
2. 2

   Claude utilise l’outil pour examiner des fichiers ou des répertoires

   • Claude évalue ce qu’il doit consulter et utilise la commande view pour examiner le contenu des fichiers ou lister le contenu des répertoires.
   • La réponse de l’API contient un bloc de contenu tool_use avec la commande view.
3. 3

   Exécuter la commande view et renvoyer les résultats

   • Extrayez le chemin du fichier ou du répertoire de la requête d’utilisation d’outils de Claude.
   • Lisez le contenu du fichier ou listez le contenu du répertoire.
   • Si vous avez spécifié un paramètre max_characters dans la configuration de l’outil, tronquez le contenu du fichier à cette longueur.
   • Renvoyez les résultats à Claude en poursuivant la conversation avec un nouveau message user contenant un bloc de contenu tool_result.
4. 4

   Claude utilise l’outil pour modifier des fichiers

   • Après avoir examiné le fichier ou le répertoire, Claude peut utiliser une commande telle que str_replace pour effectuer des modifications ou insert pour ajouter du texte à un numéro de ligne spécifique.
   • Si Claude utilise la commande str_replace, Claude construit une requête d’utilisation d’outils correctement formatée avec l’ancien texte et le nouveau texte qui doit le remplacer.
5. 5

   Effectuer la modification et renvoyer les résultats

   • Extrayez le chemin du fichier, l’ancien texte et le nouveau texte de la requête d’utilisation d’outils de Claude.
   • Effectuez le remplacement du texte dans le fichier.
   • Renvoyez les résultats à Claude.
6. 6

   Claude fournit son analyse et son explication

   • Après avoir examiné et éventuellement modifié les fichiers, Claude fournit une explication complète de ce qu’il a trouvé et des modifications qu’il a apportées.

Commandes de l’outil d’éditeur de texte

L’outil d’éditeur de texte prend en charge plusieurs commandes pour afficher et modifier des fichiers :

view

La commande view permet à Claude d’examiner le contenu d’un fichier ou de lister le contenu d’un répertoire. Elle peut lire le fichier entier ou une plage de lignes spécifique.

Paramètres :

• command : Doit être view
• path : Le chemin du fichier ou du répertoire à afficher
• view_range (facultatif) : Un tableau de deux entiers spécifiant les numéros de ligne de début et de fin à afficher. Les numéros de ligne commencent à 1, et -1 pour la ligne de fin signifie lire jusqu’à la fin du fichier. Ce paramètre s’applique uniquement lors de l’affichage de fichiers, pas de répertoires.

{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_based_edit_tool",
  "input": {
    "command": "view",
    "path": "primes.py"
  }
}

{
  "type": "tool_use",
  "id": "toolu_02B19r91rw91mr917835mr9",
  "name": "str_replace_based_edit_tool",
  "input": {
    "command": "view",
    "path": "src/"
  }
}

str_replace

La commande str_replace permet à Claude de remplacer une chaîne spécifique dans un fichier par une nouvelle chaîne. Elle est utilisée pour effectuer des modifications précises.

Paramètres :

• command : Doit être str_replace
• path : Le chemin du fichier à modifier
• old_str : Le texte à remplacer (doit correspondre exactement, y compris les espaces et l’indentation)
• new_str : Le nouveau texte à insérer à la place de l’ancien texte

{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_based_edit_tool",
  "input": {
    "command": "str_replace",
    "path": "primes.py",
    "old_str": "for num in range(2, limit + 1)",
    "new_str": "for num in range(2, limit + 1):"
  }
}

create

La commande create permet à Claude de créer un nouveau fichier avec un contenu spécifié.

Paramètres :

• command : Doit être create
• path : Le chemin où le nouveau fichier doit être créé
• file_text : Le contenu à écrire dans le nouveau fichier

{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_based_edit_tool",
  "input": {
    "command": "create",
    "path": "test_primes.py",
    "file_text": "import unittest\nimport primes\n\nclass TestPrimes(unittest.TestCase):\n    def test_is_prime(self):\n        self.assertTrue(primes.is_prime(2))\n        self.assertTrue(primes.is_prime(3))\n        self.assertFalse(primes.is_prime(4))\n\nif __name__ == '__main__':\n    unittest.main()"
  }
}

insert

La commande insert permet à Claude d’insérer du texte à un emplacement spécifique dans un fichier.

Paramètres :

• command : Doit être insert
• path : Le chemin du fichier à modifier
• insert_line : Le numéro de ligne après lequel insérer le texte (0 pour le début du fichier)
• insert_text : Le texte à insérer

{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_based_edit_tool",
  "input": {
    "command": "insert",
    "path": "primes.py",
    "insert_line": 0,
    "insert_text": "\"\"\"Module for working with prime numbers.\n\nThis module provides functions to check if a number is prime\nand to generate a list of prime numbers up to a given limit.\n\"\"\"\n"
  }
}

Exemple : Corriger une erreur de syntaxe avec l’outil d’éditeur de texte

Cet exemple montre comment Claude utilise l’outil d’éditeur de texte pour corriger une erreur de syntaxe dans un fichier Python.

Tout d’abord, votre application fournit à Claude l’outil d’éditeur de texte et un prompt pour corriger une erreur de syntaxe :

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=[{"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"}],
    messages=[
        {
            "role": "user",
            "content": "There's a syntax error in my primes.py file. Can you help me fix it?",
        }
    ],
)

print(response)

Claude utilise d’abord l’outil d’éditeur de texte pour afficher le fichier :

{
  "id": "msg_01XAbCDeFgHiJkLmNoPQrStU",
  "model": "claude-opus-5-5",
  "stop_reason": "tool_use",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I'll help you fix the syntax error in your primes.py file. First, let me take a look at the file to identify the issue."
    },
    {
      "type": "tool_use",
      "id": "toolu_01AbCdEfGhIjKlMnOpQrStU",
      "name": "str_replace_based_edit_tool",
      "input": {
        "command": "view",
        "path": "primes.py"
      }
    }
  ]
}

Votre application doit ensuite lire le fichier et renvoyer son contenu à Claude :

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=[{"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"}],
    messages=[
        {
            "role": "user",
            "content": "There's a syntax error in my primes.py file. Can you help me fix it?",
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "I'll help you fix the syntax error in your primes.py file. First, let me take a look at the file to identify the issue.",
                },
                {
                    "type": "tool_use",
                    "id": "toolu_01AbCdEfGhIjKlMnOpQrStU",
                    "name": "str_replace_based_edit_tool",
                    "input": {"command": "view", "path": "primes.py"},
                },
            ],
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01AbCdEfGhIjKlMnOpQrStU",
                    "content": '1: def is_prime(n):\n2:     """Check if a number is prime."""\n3:     if n <= 1:\n4:         return False\n5:     if n <= 3:\n6:         return True\n7:     if n % 2 == 0 or n % 3 == 0:\n8:         return False\n9:     i = 5\n10:     while i * i <= n:\n11:         if n % i == 0 or n % (i + 2) == 0:\n12:             return False\n13:         i += 6\n14:     return True\n15: \n16: def get_primes(limit):\n17:     """Generate a list of prime numbers up to the given limit."""\n18:     primes = []\n19:     for num in range(2, limit + 1)\n20:         if is_prime(num):\n21:             primes.append(num)\n22:     return primes\n23: \n24: def main():\n25:     """Main function to demonstrate prime number generation."""\n26:     limit = 100\n27:     prime_list = get_primes(limit)\n28:     print(f"Prime numbers up to {limit}:")\n29:     print(prime_list)\n30:     print(f"Found {len(prime_list)} prime numbers.")\n31: \n32: if __name__ == "__main__":\n33:     main()',
                }
            ],
        },
    ],
)

print(response)

Claude identifie l’erreur de syntaxe et utilise la commande str_replace pour la corriger :

{
  "id": "msg_01VwXyZAbCdEfGhIjKlMnO",
  "model": "claude-opus-5-5",
  "stop_reason": "tool_use",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I found the syntax error in your primes.py file. In the `get_primes` function, there is a missing colon (:) at the end of the for loop line. Let me fix that for you."
    },
    {
      "type": "tool_use",
      "id": "toolu_01PqRsTuVwXyZAbCdEfGh",
      "name": "str_replace_based_edit_tool",
      "input": {
        "command": "str_replace",
        "path": "primes.py",
        "old_str": "    for num in range(2, limit + 1)",
        "new_str": "    for num in range(2, limit + 1):"
      }
    }
  ]
}

Votre application doit ensuite effectuer la modification et renvoyer le résultat :

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=[{"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"}],
    messages=[
        # Messages précédents...
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "I found the syntax error in your primes.py file. In the `get_primes` function, there is a missing colon (:) at the end of the for loop line. Let me fix that for you.",
                },
                {
                    "type": "tool_use",
                    "id": "toolu_01PqRsTuVwXyZAbCdEfGh",
                    "name": "str_replace_based_edit_tool",
                    "input": {
                        "command": "str_replace",
                        "path": "primes.py",
                        "old_str": "    for num in range(2, limit + 1)",
                        "new_str": "    for num in range(2, limit + 1):",
                    },
                },
            ],
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01PqRsTuVwXyZAbCdEfGh",
                    "content": "Successfully replaced text at exactly one location.",
                }
            ],
        },
    ],
)

print(response)

Enfin, Claude fournit une explication complète de la correction :

{
  "id": "msg_01IjKlMnOpQrStUvWxYzAb",
  "model": "claude-opus-5-5",
  "stop_reason": "end_turn",
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I've fixed the syntax error in your primes.py file. The issue was in the `get_primes` function at line 19. There was a missing colon (:) at the end of the for loop line.\n\nHere's what I changed:\n\nFrom:\n```python\nfor num in range(2, limit + 1)\n```\n\nTo:\n```python\nfor num in range(2, limit + 1):\n```\n\nIn Python, a colon is required at the end of statements that start a new code block, such as for loops, if statements, function definitions, etc. Without the colon, Python raises a syntax error because it doesn't know where the code block begins.\n\nYour code should now run correctly. The function will properly generate a list of prime numbers up to the specified limit."
    }
  ]
}

Implémenter l’outil d’éditeur de texte

L’outil d’éditeur de texte est implémenté comme un outil sans schéma. Lorsque vous utilisez cet outil, vous n’avez pas besoin de fournir un schéma d’entrée comme avec les autres outils ; le schéma est intégré au modèle de Claude et ne peut pas être modifié.

Le type d’outil est type: "text_editor_20250728" pour Claude 4 et les modèles ultérieurs.

1. 1

   Initialiser votre implémentation de l’éditeur

   Créez des fonctions utilitaires pour gérer les opérations sur les fichiers telles que la lecture, l’écriture et la modification de fichiers. Envisagez d’implémenter une fonctionnalité de sauvegarde pour récupérer en cas d’erreur.

2. 2

   Gérer les appels à l’outil d’éditeur

   Créez une fonction qui traite les appels d’outils de Claude en fonction du type de commande :

   PythonTypeScriptC#GoJavaPHPRuby

   Python

   

   def handle_editor_tool(tool_call):
       input_params = tool_call.input
       command = input_params.get("command", "")
       file_path = input_params.get("path", "")
   
       match command:
           case "view":
               # Lire et renvoyer le contenu du fichier
               pass
           case "str_replace":
               # Remplacer du texte dans le fichier
               pass
           case "create":
               # Créer un nouveau fichier
               pass
           case "insert":
               # Insérer du texte à l'emplacement indiqué
               pass

3. 3

   Implémenter des mesures de sécurité

   Ajoutez des validations et des contrôles de sécurité :

   • Validez les chemins de fichiers pour empêcher la traversée de répertoires
   • Créez des sauvegardes avant d’effectuer des modifications
   • Gérez les erreurs de manière appropriée
   • Implémentez des vérifications des autorisations
4. 4

   Traiter les réponses de Claude

   Extrayez et gérez les appels d’outils à partir des réponses de Claude :

   PythonTypeScriptC#GoJavaPHPRuby

   Python

   

   # Traiter l'utilisation d'outils dans la réponse de Claude
   for content in response.content:
       if content.type == "tool_use":
           # Exécuter l'outil en fonction de la commande
           result = handle_editor_tool(content)
   
           # Renvoyer le résultat à Claude
           tool_result = {
               "type": "tool_result",
               "tool_use_id": content.id,
               "content": result,
           }

Gérer les erreurs

Lors de l’utilisation de l’outil d’éditeur de texte, diverses erreurs peuvent survenir. Voici des conseils pour les gérer :

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: File not found",
      "is_error": true
    }
  ]
}

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: Found 3 matches for replacement text. Please provide more context to make a unique match.",
      "is_error": true
    }
  ]
}

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: No match found for replacement. Please check your text and try again.",
      "is_error": true
    }
  ]
}

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01A09q90qw90lq917835lq9",
      "content": "Error: Permission denied. Cannot write to file.",
      "is_error": true
    }
  ]
}

Suivre les bonnes pratiques d’implémentation

def backup_file(file_path):
    """Create a backup of a file before editing."""
    backup_path = f"{file_path}.backup"
    if os.path.exists(file_path):
        with open(file_path, "r") as src, open(backup_path, "w") as dst:
            dst.write(src.read())

def safe_replace(file_path, old_text, new_text):
    """Replace text only if there's exactly one match."""
    with open(file_path, "r") as f:
        content = f.read()

    count = content.count(old_text)
    if count == 0:
        return "Error: No match found"
    elif count > 1:
        return f"Error: Found {count} matches"
    else:
        new_content = content.replace(old_text, new_text)
        with open(file_path, "w") as f:
            f.write(new_content)
        return "Successfully replaced text"

def verify_changes(file_path):
    """Run tests or checks after making changes."""
    try:
        # Pour les fichiers Python, vérifier les erreurs de syntaxe.
        if file_path.endswith(".py"):
            import ast

            with open(file_path, "r") as f:
                ast.parse(f.read())
            return "Syntax check passed"
    except Exception as e:
        return f"Verification failed: {str(e)}"

Tarification et utilisation des tokens

L’outil d’édition de texte utilise la même structure tarifaire que les autres outils utilisés avec Claude. Il suit la tarification standard des tokens d’entrée et de sortie en fonction du modèle Claude que vous utilisez.

En plus des tokens de base, les tokens d’entrée supplémentaires suivants sont nécessaires pour l’outil d’édition de texte :

Pour des informations plus détaillées sur la tarification des outils, consultez Tarification de l’utilisation d’outils.

Intégrer l’outil d’éditeur de texte avec d’autres outils

Vous pouvez utiliser l’outil d’éditeur de texte conjointement avec d’autres outils de Claude. Lorsque vous combinez des outils, assurez-vous de :

• Faire correspondre la version de l’outil avec le modèle que vous utilisez
• Tenir compte de l’utilisation supplémentaire de tokens pour tous les outils inclus dans votre requête

Journal des modifications

Prochaines étapes

Voici quelques idées pour utiliser l’outil d’éditeur de texte de manière plus pratique et plus puissante :

• Intégrer à votre flux de travail de développement : Intégrez l’outil d’éditeur de texte à vos outils de développement ou à votre IDE.
• Créer un système de revue de code : Demandez à Claude de relire votre code et d’y apporter des améliorations.
• Construire un assistant de débogage : Créez un système dans lequel Claude peut vous aider à diagnostiquer et corriger les problèmes de votre code.
• Implémenter la conversion de formats de fichiers : Laissez Claude vous aider à convertir des fichiers d’un format à un autre.
• Automatiser la documentation : Mettez en place des flux de travail permettant à Claude de documenter automatiquement votre code.

L’outil d’éditeur de texte permet à Claude de travailler directement avec votre base de code, prenant en charge des flux de travail allant du débogage à la documentation automatisée.

Disponibilité