Texteditor-Tool

Claude kann ein Texteditor-Tool mit Anthropic-Schema verwenden, um Textdateien anzuzeigen und zu ändern. So hilft es dir, deinen Code oder andere Textdokumente zu debuggen, zu korrigieren und zu verbessern. Dadurch kann Claude direkt mit deinen Dateien interagieren und praktische Unterstützung leisten, anstatt nur Änderungen vorzuschlagen.

Informationen zur Modellunterstützung findest du in der Tool-Referenz.

Wann das Texteditor-Tool verwendet werden sollte

Einige Beispiele für den Einsatz des Texteditor-Tools:

• Code-Debugging: Lass Claude Fehler in deinem Code identifizieren und beheben, von Syntaxfehlern bis hin zu Logikproblemen.
• Code-Refactoring: Lass Claude die Struktur, Lesbarkeit und Performance deines Codes durch gezielte Bearbeitungen verbessern.
• Dokumentationserstellung: Bitte Claude, Docstrings, Kommentare oder README-Dateien zu deiner Codebasis hinzuzufügen.
• Testerstellung: Lass Claude Unit-Tests für deinen Code erstellen, basierend auf seiner Analyse der Implementierung.

Das Texteditor-Tool verwenden

Stelle Claude das Texteditor-Tool (mit dem Namen str_replace_based_edit_tool) über die Messages API bereit.

Optional kannst du einen max_characters-Parameter angeben, um die Kürzung beim Anzeigen großer Dateien zu steuern.

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)

Verwende das Texteditor-Tool folgendermaßen:

1. 1

   Stelle Claude das Texteditor-Tool und einen Benutzer-Prompt bereit

   • Füge das Texteditor-Tool in deine API-Anfrage ein
   • Gib einen Benutzer-Prompt an, der möglicherweise das Untersuchen oder Ändern von Dateien erfordert, z. B. „Kannst du den Syntaxfehler in meinem Code beheben?“
2. 2

   Claude verwendet das Tool, um Dateien oder Verzeichnisse zu untersuchen

   • Claude beurteilt, was es sich ansehen muss, und verwendet den Befehl view, um Dateiinhalte zu untersuchen oder Verzeichnisinhalte aufzulisten
   • Die API-Antwort enthält einen tool_use-Inhaltsblock mit dem Befehl view
3. 3

   Führe den view-Befehl aus und gib die Ergebnisse zurück

   • Extrahiere den Datei- oder Verzeichnispfad aus Claudes Tool-Nutzungsanfrage
   • Lies den Inhalt der Datei oder liste den Verzeichnisinhalt auf
   • Wenn in der Tool-Konfiguration ein max_characters-Parameter angegeben wurde, kürze den Dateiinhalt auf diese Länge
   • Gib die Ergebnisse an Claude zurück, indem du die Konversation mit einer neuen user-Nachricht fortsetzt, die einen tool_result-Inhaltsblock enthält
4. 4

   Claude verwendet das Tool, um Dateien zu ändern

   • Nach dem Untersuchen der Datei oder des Verzeichnisses kann Claude einen Befehl wie str_replace verwenden, um Änderungen vorzunehmen, oder insert, um Text an einer bestimmten Zeilennummer einzufügen.
   • Wenn Claude den Befehl str_replace verwendet, erstellt Claude eine korrekt formatierte Tool-Nutzungsanfrage mit dem alten Text und dem neuen Text, durch den er ersetzt werden soll
5. 5

   Führe die Bearbeitung aus und gib die Ergebnisse zurück

   • Extrahiere den Dateipfad, den alten Text und den neuen Text aus Claudes Tool-Nutzungsanfrage
   • Führe die Textersetzung in der Datei durch
   • Gib die Ergebnisse an Claude zurück
6. 6

   Claude liefert seine Analyse und Erklärung

   • Nach dem Untersuchen und gegebenenfalls Bearbeiten der Dateien liefert Claude eine vollständige Erklärung dessen, was es gefunden und welche Änderungen es vorgenommen hat

Befehle des Texteditor-Tools

Das Texteditor-Tool unterstützt mehrere Befehle zum Anzeigen und Ändern von Dateien:

view

Der Befehl view ermöglicht es Claude, den Inhalt einer Datei zu untersuchen oder den Inhalt eines Verzeichnisses aufzulisten. Er kann die gesamte Datei oder einen bestimmten Zeilenbereich lesen.

Parameter:

• command: Muss "view" sein
• path: Der Pfad zur anzuzeigenden Datei oder zum anzuzeigenden Verzeichnis
• view_range (optional): Ein Array aus zwei Ganzzahlen, das die Start- und Endzeilennummer für die Anzeige angibt. Zeilennummern sind 1-indiziert, und -1 als Endzeile bedeutet, dass bis zum Ende der Datei gelesen wird. Dieser Parameter gilt nur beim Anzeigen von Dateien, nicht von Verzeichnissen.

{
  "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

Der Befehl str_replace ermöglicht es Claude, eine bestimmte Zeichenkette in einer Datei durch eine neue Zeichenkette zu ersetzen. Dies wird für präzise Bearbeitungen verwendet.

Parameter:

• command: Muss "str_replace" sein
• path: Der Pfad zur zu ändernden Datei
• old_str: Der zu ersetzende Text (muss exakt übereinstimmen, einschließlich Leerzeichen und Einrückung)
• new_str: Der neue Text, der anstelle des alten Textes eingefügt werden soll

{
  "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

Der Befehl create ermöglicht es Claude, eine neue Datei mit angegebenem Inhalt zu erstellen.

Parameter:

• command: Muss "create" sein
• path: Der Pfad, unter dem die neue Datei erstellt werden soll
• file_text: Der Inhalt, der in die neue Datei geschrieben werden soll

{
  "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

Der Befehl insert ermöglicht es Claude, Text an einer bestimmten Stelle in einer Datei einzufügen.

Parameter:

• command: Muss "insert" sein
• path: Der Pfad zur zu ändernden Datei
• insert_line: Die Zeilennummer, nach der der Text eingefügt werden soll (0 für den Dateianfang)
• insert_text: Der einzufügende Text

{
  "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"
  }
}

Beispiel: Einen Syntaxfehler mit dem Texteditor-Tool beheben

Dieses Beispiel zeigt, wie Claude das Texteditor-Tool verwendet, um einen Syntaxfehler in einer Python-Datei zu beheben.

Zunächst stellt deine Anwendung Claude das Texteditor-Tool und einen Prompt zum Beheben eines Syntaxfehlers bereit:

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 verwendet das Texteditor-Tool zunächst, um die Datei anzuzeigen:

{
  "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"
      }
    }
  ]
}

Deine Anwendung sollte dann die Datei lesen und ihren Inhalt an Claude zurückgeben:

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 identifiziert den Syntaxfehler und verwendet den Befehl str_replace, um ihn zu beheben:

{
  "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):"
      }
    }
  ]
}

Deine Anwendung sollte dann die Bearbeitung vornehmen und das Ergebnis zurückgeben:

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=[{"type": "text_editor_20250728", "name": "str_replace_based_edit_tool"}],
    messages=[
        # Vorherige Nachrichten...
        {
            "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)

Schließlich liefert Claude eine vollständige Erklärung der Korrektur:

{
  "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."
    }
  ]
}

Das Texteditor-Tool implementieren

Das Texteditor-Tool ist als schemaloses Tool implementiert. Bei der Verwendung dieses Tools musst du kein Eingabeschema wie bei anderen Tools angeben; das Schema ist in Claudes Modell integriert und kann nicht geändert werden.

Der Tool-Typ ist type: "text_editor_20250728" für Claude 4 und spätere Modelle.

1. 1

   Initialisiere deine Editor-Implementierung

   Erstelle Hilfsfunktionen für Dateioperationen wie das Lesen, Schreiben und Ändern von Dateien. Erwäge die Implementierung einer Backup-Funktionalität, um Fehler rückgängig machen zu können.

2. 2

   Verarbeite Editor-Tool-Aufrufe

   Erstelle eine Funktion, die Tool-Aufrufe von Claude basierend auf dem Befehlstyp verarbeitet:

   PythonTypeScriptC#GoJavaPHPRuby

   

   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":
               # Dateiinhalt lesen und zurückgeben
               pass
           case "str_replace":
               # Text in Datei ersetzen
               pass
           case "create":
               # Neue Datei erstellen
               pass
           case "insert":
               # Text an Position einfügen
               pass

3. 3

   Implementiere Sicherheitsmaßnahmen

   Füge Validierungs- und Sicherheitsprüfungen hinzu:

   • Validiere Dateipfade, um Directory Traversal zu verhindern
   • Erstelle Backups, bevor du Änderungen vornimmst
   • Behandle Fehler angemessen
   • Implementiere Berechtigungsprüfungen
4. 4

   Verarbeite Claudes Antworten

   Extrahiere und verarbeite Tool-Aufrufe aus Claudes Antworten:

   PythonTypeScriptC#GoJavaPHPRuby

   

   # Tool-Nutzung in Claudes Antwort verarbeiten
   for content in response.content:
       if content.type == "tool_use":
           # Tool basierend auf dem Befehl ausführen
           result = handle_editor_tool(content)
   
           # Ergebnis an Claude zurückgeben
           tool_result = {
               "type": "tool_result",
               "tool_use_id": content.id,
               "content": result,
           }

Fehler behandeln

Bei der Verwendung des Texteditor-Tools können verschiedene Fehler auftreten. Hier findest du Hinweise, wie du damit umgehst:

{
  "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
    }
  ]
}

Best Practices für die Implementierung befolgen

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:
        # Bei Python-Dateien auf Syntaxfehler prüfen
        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)}"

Preise und Token-Nutzung

Das Text-Editor-Tool verwendet dieselbe Preisstruktur wie andere Tools, die mit Claude verwendet werden. Es folgt der standardmäßigen Preisgestaltung für Input- und Output-Token, basierend auf dem Claude-Modell, das du verwendest.

Zusätzlich zu den Basis-Token werden für das Text-Editor-Tool die folgenden zusätzlichen Input-Token benötigt:

Ausführlichere Informationen zu den Tool-Preisen findest du unter Preise für Tool-Nutzung.

Das Texteditor-Tool mit anderen Tools integrieren

Du kannst das Texteditor-Tool zusammen mit anderen Claude-Tools verwenden. Achte beim Kombinieren von Tools darauf, dass du:

• Die Tool-Version auf das verwendete Modell abstimmst
• Die zusätzliche Token-Nutzung für alle in deiner Anfrage enthaltenen Tools berücksichtigst

Änderungsprotokoll

Nächste Schritte

Hier sind einige Ideen, wie du das Texteditor-Tool auf bequemere und leistungsfähigere Weise nutzen kannst:

• In deinen Entwicklungs-Workflow integrieren: Baue das Texteditor-Tool in deine Entwicklungstools oder IDE ein
• Ein Code-Review-System erstellen: Lass Claude deinen Code überprüfen und Verbesserungen vornehmen
• Einen Debugging-Assistenten bauen: Erstelle ein System, in dem Claude dir helfen kann, Probleme in deinem Code zu diagnostizieren und zu beheben
• Dateiformatkonvertierung implementieren: Lass Claude dir helfen, Dateien von einem Format in ein anderes zu konvertieren
• Dokumentation automatisieren: Richte Workflows ein, mit denen Claude deinen Code automatisch dokumentiert

Das Texteditor-Tool ermöglicht es Claude, direkt mit deiner Codebasis zu arbeiten, und unterstützt Workflows vom Debugging bis zur automatisierten Dokumentation.