Strumento editor di testo

Claude può utilizzare uno strumento editor di testo definito da Anthropic per visualizzare e modificare file di testo, aiutandoti a eseguire il debug, correggere e migliorare il tuo codice o altri documenti di testo. Questo consente a Claude di interagire direttamente con i tuoi file, fornendo assistenza pratica piuttosto che limitarsi a suggerire modifiche.

Prima di utilizzare lo strumento editor di testo

Utilizza un modello compatibile

Lo strumento editor di testo di Anthropic è disponibile per diversi modelli Claude:

Claude 4 Opus & Sonnet: text_editor_20250429
Claude Sonnet 3.7: text_editor_20250124
Claude Sonnet 3.5: text_editor_20241022

Il più recente text_editor_20250429 per i modelli Claude 4 non include il comando undo_edit. Se hai bisogno di questa funzionalità, dovrai utilizzare Claude 3.7 o Sonnet 3.5 con le rispettive versioni dello strumento.

Valuta l’adeguatezza del tuo caso d’uso

Alcuni esempi di quando utilizzare lo strumento editor di testo sono:

Debug del codice: Fai identificare e correggere a Claude i bug nel tuo codice, dagli errori di sintassi ai problemi logici.
Refactoring del codice: Lascia che Claude migliori la struttura, la leggibilità e le prestazioni del tuo codice attraverso modifiche mirate.
Generazione di documentazione: Chiedi a Claude di aggiungere docstring, commenti o file README al tuo codebase.
Creazione di test: Fai creare a Claude test unitari per il tuo codice basati sulla sua comprensione dell’implementazione.

Utilizza lo strumento editor di testo

Fornisci lo strumento editor di testo (chiamato str_replace_based_edit_tool) a Claude utilizzando l’API Messages:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "text_editor_20250429",
            "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?"
        }
    ]
)

Fornisci lo strumento editor di testo (chiamato str_replace_based_edit_tool) a Claude utilizzando l’API Messages:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "text_editor_20250429",
            "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?"
        }
    ]
)

Fornisci lo strumento editor di testo (chiamato str_replace_editor) a Claude utilizzando l’API Messages:

import anthropic

client = anthropic.Anthropic()

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

Fornisci lo strumento editor di testo (chiamato str_replace_editor) a Claude utilizzando l’API Messages:

import anthropic

client = anthropic.Anthropic()

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

Lo strumento editor di testo può essere utilizzato nel seguente modo:

Fornisci a Claude lo strumento editor di testo e un prompt utente

Includi lo strumento editor di testo nella tua richiesta API
Fornisci un prompt utente che potrebbe richiedere l’esame o la modifica di file, come “Puoi correggere l’errore di sintassi nel mio codice?”

Claude utilizza lo strumento per esaminare file o directory

Claude valuta ciò che deve esaminare e utilizza il comando view per esaminare il contenuto del file o elencare il contenuto della directory
La risposta API conterrà un blocco di contenuto tool_use con il comando view

Esegui il comando view e restituisci i risultati

Estrai il percorso del file o della directory dalla richiesta di utilizzo dello strumento di Claude
Leggi il contenuto del file o elenca il contenuto della directory e restituiscili a Claude
Restituisci i risultati a Claude continuando la conversazione con un nuovo messaggio user contenente un blocco di contenuto tool_result

Claude utilizza lo strumento per modificare i file

Dopo aver esaminato il file o la directory, Claude potrebbe utilizzare un comando come str_replace per apportare modifiche o insert per aggiungere testo a un numero di riga specifico.
Se Claude utilizza il comando str_replace, Claude costruisce una richiesta di utilizzo dello strumento correttamente formattata con il vecchio testo e il nuovo testo con cui sostituirlo

Esegui la modifica e restituisci i risultati

Estrai il percorso del file, il vecchio testo e il nuovo testo dalla richiesta di utilizzo dello strumento di Claude
Esegui la sostituzione del testo nel file
Restituisci i risultati a Claude

Claude fornisce la sua analisi e spiegazione

Dopo aver esaminato e possibilmente modificato i file, Claude fornisce una spiegazione completa di ciò che ha trovato e delle modifiche che ha apportato

Comandi dello strumento editor di testo

Lo strumento editor di testo supporta diversi comandi per visualizzare e modificare i file:

view

Il comando view consente a Claude di esaminare il contenuto di un file o elencare il contenuto di una directory. Può leggere l’intero file o un intervallo specifico di righe.

Parametri:

command: Deve essere “view”
path: Il percorso del file o della directory da visualizzare
view_range (opzionale): Un array di due numeri interi che specificano i numeri di riga iniziale e finale da visualizzare. I numeri di riga iniziano da 1, e -1 per la riga finale significa leggere fino alla fine del file. Questo parametro si applica solo quando si visualizzano file, non directory.

Esempi di comandi view

// Esempio per visualizzare un file
{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_editor",
  "input": {
    "command": "view",
    "path": "primes.py"
  }
}

// Esempio per visualizzare una directory
{
  "type": "tool_use",
  "id": "toolu_02B19r91rw91mr917835mr9",
  "name": "str_replace_editor",
  "input": {
    "command": "view",
    "path": "src/"
  }
}

str_replace

Il comando str_replace consente a Claude di sostituire una stringa specifica in un file con una nuova stringa. Viene utilizzato per apportare modifiche precise.

Parametri:

command: Deve essere “str_replace”
path: Il percorso del file da modificare
old_str: Il testo da sostituire (deve corrispondere esattamente, inclusi spazi bianchi e indentazione)
new_str: Il nuovo testo da inserire al posto del vecchio testo

Esempio di comando str_replace

{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_editor",
  "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

Il comando create consente a Claude di creare un nuovo file con contenuto specificato.

Parametri:

command: Deve essere “create”
path: Il percorso in cui deve essere creato il nuovo file
file_text: Il contenuto da scrivere nel nuovo file

Esempio di comando create

{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_editor",
  "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

Il comando insert consente a Claude di inserire testo in una posizione specifica in un file.

Parametri:

command: Deve essere “insert”
path: Il percorso del file da modificare
insert_line: Il numero di riga dopo il quale inserire il testo (0 per l’inizio del file)
new_str: Il testo da inserire

Esempio di comando insert

{
  "type": "tool_use",
  "id": "toolu_01A09q90qw90lq917835lq9",
  "name": "str_replace_editor",
  "input": {
    "command": "insert",
    "path": "primes.py",
    "insert_line": 0,
    "new_str": "\"\"\"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"
  }
}

undo_edit

Il comando undo_edit consente a Claude di annullare l’ultima modifica apportata a un file.

Questo comando è disponibile solo in Claude Sonnet 3.7 e Claude Sonnet 3.5. Non è supportato nei modelli Claude 4 che utilizzano text_editor_20250429.

Parametri:

command: Deve essere “undo_edit”
path: Il percorso del file la cui ultima modifica deve essere annullata

Esempio di comando undo_edit

Esempio: Correzione di un errore di sintassi con lo strumento editor di testo

Questo esempio dimostra come Claude 4 utilizza lo strumento editor di testo per correggere un errore di sintassi in un file Python.

Prima, la tua applicazione fornisce a Claude lo strumento editor di testo e un prompt per correggere un errore di sintassi:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "text_editor_20250429",
            "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)

Numeri di riga

Nell’esempio sopra, il risultato dello strumento view include il contenuto del file con i numeri di riga anteposti a ciascuna riga (ad esempio, “1: def is_prime(n):”). I numeri di riga non sono obbligatori, ma sono essenziali per utilizzare con successo il parametro view_range per esaminare sezioni specifiche di file e il parametro insert_line per aggiungere contenuto in posizioni precise.

Claude utilizzerà lo strumento editor di testo prima per visualizzare il file:

{
  "id": "msg_01XAbCDeFgHiJkLmNoPQrStU",
  "model": "claude-opus-4-20250514",
  "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"
      }
    }
  ]
}

La tua applicazione dovrebbe quindi leggere il file e restituire il suo contenuto a Claude:

response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "text_editor_20250429",
            "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_01AbCdEfGhIjK1MnOpQrStU",
                    "name": "str_replace_based_edit_tool",
                    "input": {
                        "command": "view",
                        "path": "primes.py"
                    }
                }
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01AbCdEfGhIjK1MnOpQrStU",
                    "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()"
                }
            ]
        }
    ]
)

Claude identificherà l’errore di sintassi e utilizzerà il comando str_replace per correggerlo:

{
  "id": "msg_01VwXyZAbCdEfGhIjKlMnO",
  "model": "claude-opus-4-20250514",
  "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):"
      }
    }
  ]
}

La tua applicazione dovrebbe quindi apportare la modifica e restituire il risultato:

response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "text_editor_20250429",
            "name": "str_replace_based_edit_tool"
        }
    ],
    messages=[
        # Messaggi precedenti...
        {
            "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."
                }
            ]
        }
    ]
)

Infine, Claude fornirà una spiegazione completa della correzione:

{
  "id": "msg_01IjKlMnOpQrStUvWxYzAb",
  "model": "claude-opus-4-20250514",
  "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."
    }
  ]
}

Questo esempio dimostra come Claude 4 utilizza lo strumento editor di testo per correggere un errore di sintassi in un file Python.

Prima, la tua applicazione fornisce a Claude lo strumento editor di testo e un prompt per correggere un errore di sintassi:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "text_editor_20250429",
            "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)

Numeri di riga

Claude utilizzerà lo strumento editor di testo prima per visualizzare il file:

{
  "id": "msg_01XAbCDeFgHiJkLmNoPQrStU",
  "model": "claude-opus-4-20250514",
  "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"
      }
    }
  ]
}

La tua applicazione dovrebbe quindi leggere il file e restituire il suo contenuto a Claude:

response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "text_editor_20250429",
            "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_01AbCdEfGhIjK1MnOpQrStU",
                    "name": "str_replace_based_edit_tool",
                    "input": {
                        "command": "view",
                        "path": "primes.py"
                    }
                }
            ]
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_01AbCdEfGhIjK1MnOpQrStU",
                    "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()"
                }
            ]
        }
    ]
)

Claude identificherà l’errore di sintassi e utilizzerà il comando str_replace per correggerlo:

{
  "id": "msg_01VwXyZAbCdEfGhIjKlMnO",
  "model": "claude-opus-4-20250514",
  "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):"
      }
    }
  ]
}

La tua applicazione dovrebbe quindi apportare la modifica e restituire il risultato:

response = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1024,
    tools=[
        {
            "type": "text_editor_20250429",
            "name": "str_replace_based_edit_tool"
        }
    ],
    messages=[
        # Messaggi precedenti...
        {
            "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."
                }
            ]
        }
    ]
)

Infine, Claude fornirà una spiegazione completa della correzione:

{
  "id": "msg_01IjKlMnOpQrStUvWxYzAb",
  "model": "claude-opus-4-20250514",
  "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."
    }
  ]
}

Questo esempio dimostra come Claude Sonnet 3.7 utilizza lo strumento editor di testo per correggere un errore di sintassi in un file Python.

Prima, la tua applicazione fornisce a Claude lo strumento editor di testo e un prompt per correggere un errore di sintassi:

import anthropic

client = anthropic.Anthropic()

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

print(response)

Gli esempi di Claude Sonnet 3.7 seguono lo stesso formato degli esempi di Claude 4 sopra, utilizzando le stesse chiamate e risposte dello strumento ma con il tipo di strumento text_editor_20250124 e il nome str_replace_editor.

Implementare lo strumento editor di testo

Lo strumento editor di testo è implementato come uno strumento senza schema. Quando utilizzi questo strumento, non è necessario fornire uno schema di input come con altri strumenti; lo schema è integrato nel modello di Claude e non può essere modificato.

Il tipo di strumento dipende dalla versione del modello:

Claude 4: type: "text_editor_20250429"
Claude Sonnet 3.7: type: "text_editor_20250124"
Claude Sonnet 3.5: type: "text_editor_20241022"

Inizializza l'implementazione del tuo editor

Crea funzioni di supporto per gestire operazioni sui file come lettura, scrittura e modifica. Considera l’implementazione di funzionalità di backup per recuperare da errori.

Gestisci le chiamate allo strumento editor

Crea una funzione che elabora le chiamate allo strumento da Claude in base al tipo di comando:

def handle_editor_tool(tool_call, model_version):
    input_params = tool_call.input
    command = input_params.get('command', '')
    file_path = input_params.get('path', '')
    
    if command == 'view':
        # Leggi e restituisci il contenuto del file
        pass
    elif command == 'str_replace':
        # Sostituisci il testo nel file
        pass
    elif command == 'create':
        # Crea un nuovo file
        pass
    elif command == 'insert':
        # Inserisci testo in una posizione
        pass
    elif command == 'undo_edit':
        # Controlla se è un modello Claude 4
        if 'str_replace_based_edit_tool' in model_version:
            return {"error": "undo_edit command is not supported in Claude 4"}
        # Ripristina dal backup per Claude 3.7/3.5
        pass

Implementa misure di sicurezza

Aggiungi controlli di validazione e sicurezza:

Convalida i percorsi dei file per prevenire l’attraversamento delle directory
Crea backup prima di apportare modifiche
Gestisci gli errori con eleganza
Implementa controlli di autorizzazione

Elabora le risposte di Claude

Estrai e gestisci le chiamate allo strumento dalle risposte di Claude:

# Elabora l'uso dello strumento nella risposta di Claude
for content in response.content:
    if content.type == "tool_use":
        # Esegui lo strumento in base al comando
        result = handle_editor_tool(content)
        
        # Restituisci il risultato a Claude
        tool_result = {
            "type": "tool_result",
            "tool_use_id": content.id,
            "content": result
        }

Quando implementi lo strumento editor di testo, tieni presente:

Sicurezza: Lo strumento ha accesso al tuo filesystem locale, quindi implementa adeguate misure di sicurezza.
Backup: Crea sempre backup prima di consentire modifiche a file importanti.
Validazione: Convalida tutti gli input per prevenire modifiche non intenzionali.
Corrispondenza univoca: Assicurati che le sostituzioni corrispondano esattamente a una posizione per evitare modifiche non intenzionali.

Gestire gli errori

Quando si utilizza lo strumento editor di testo, possono verificarsi vari errori. Ecco una guida su come gestirli:

File non trovato

Se Claude tenta di visualizzare o modificare un file che non esiste, restituisci un messaggio di errore appropriato nel tool_result:

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

Corrispondenze multiple per la sostituzione

Se il comando str_replace di Claude corrisponde a più posizioni nel file, restituisci un messaggio di errore appropriato:

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

Nessuna corrispondenza per la sostituzione

Se il comando str_replace di Claude non corrisponde a nessun testo nel file, restituisci un messaggio di errore appropriato:

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

Errori di autorizzazione

Se ci sono problemi di autorizzazione con la creazione, la lettura o la modifica dei file, restituisci un messaggio di errore appropriato:

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

Segui le migliori pratiche di implementazione

Fornisci un contesto chiaro

Sii esplicito sui percorsi dei file

Crea backup prima di modificare

Implementa un sistema di backup nella tua applicazione che crei copie dei file prima di consentire a Claude di modificarli, specialmente per codice importante o di produzione.

def backup_file(file_path):
    """Crea un backup di un file prima della modifica."""
    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())

Gestisci con attenzione la sostituzione di testo univoca

Il comando str_replace richiede una corrispondenza esatta per il testo da sostituire. La tua applicazione dovrebbe assicurarsi che ci sia esattamente una corrispondenza per il vecchio testo o fornire messaggi di errore appropriati.

def safe_replace(file_path, old_text, new_text):
    """Sostituisci il testo solo se c'è esattamente una corrispondenza."""
    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"

Verifica le modifiche

Dopo che Claude ha apportato modifiche a un file, verifica le modifiche eseguendo test o controllando che il codice funzioni ancora come previsto.

def verify_changes(file_path):
    """Esegui test o controlli dopo aver apportato modifiche."""
    try:
        # Per i file Python, controlla gli errori di sintassi
        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)}"

Prezzi e utilizzo dei token

Lo strumento editor di testo utilizza la stessa struttura di prezzi degli altri strumenti utilizzati con Claude. Segue i prezzi standard dei token di input e output basati sul modello Claude che stai utilizzando.

Oltre ai token di base, sono necessari i seguenti token di input aggiuntivi per lo strumento editor di testo:

Strumento	Token di input aggiuntivi
`text_editor_20250429` (Claude 4)	700 token
`text_editor_20250124` (Claude Sonnet 3.7)	700 token
`text_editor_20241022` (Claude Sonnet 3.5)	700 token

Per informazioni più dettagliate sui prezzi degli strumenti, consulta Prezzi per l’uso degli strumenti.

Integrare lo strumento editor di testo con l’uso del computer

Lo strumento editor di testo può essere utilizzato insieme allo strumento di uso del computer e ad altri strumenti definiti da Anthropic. Quando combini questi strumenti, dovrai:

Includere l’intestazione beta appropriata (se utilizzato con l’uso del computer)
Abbinare la versione dello strumento con il modello che stai utilizzando
Tenere conto dell’utilizzo aggiuntivo di token per tutti gli strumenti inclusi nella tua richiesta

Per ulteriori informazioni sull’utilizzo dello strumento editor di testo in un contesto di uso del computer, consulta Uso del computer.

Registro delle modifiche

Data	Versione	Modifiche
29 aprile 2025	`text_editor_20250429`	Rilascio dello strumento editor di testo per Claude 4. Questa versione rimuove il comando `undo_edit` ma mantiene tutte le altre funzionalità. Il nome dello strumento è stato aggiornato per riflettere la sua architettura basata su str_replace.
13 marzo 2025	`text_editor_20250124`	Introduzione della documentazione autonoma dello strumento editor di testo. Questa versione è ottimizzata per Claude Sonnet 3.7 ma ha funzionalità identiche alla versione precedente.
22 ottobre 2024	`text_editor_20241022`	Rilascio iniziale dello strumento editor di testo con Claude Sonnet 3.5. Fornisce funzionalità per visualizzare, creare e modificare file attraverso i comandi `view`, `create`, `str_replace`, `insert` e `undo_edit`.

Prossimi passi

Ecco alcune idee su come utilizzare lo strumento editor di testo in modi più convenienti e potenti:

Integra con il tuo flusso di lavoro di sviluppo: Incorpora lo strumento editor di testo nei tuoi strumenti di sviluppo o IDE
Crea un sistema di revisione del codice: Fai revisionare e migliorare il tuo codice da Claude
Costruisci un assistente per il debug: Crea un sistema in cui Claude può aiutarti a diagnosticare e risolvere problemi nel tuo codice
Implementa la conversione di formato file: Lascia che Claude ti aiuti a convertire file da un formato all’altro
Automatizza la documentazione: Configura flussi di lavoro per far documentare automaticamente il tuo codice da Claude

Mentre costruisci applicazioni con lo strumento editor di testo, siamo entusiasti di vedere come sfrutterai le capacità di Claude per migliorare il tuo flusso di lavoro di sviluppo e la tua produttività.

Panoramica sull'uso degli strumenti

Scopri come implementare flussi di lavoro degli strumenti per l’uso con Claude.

Uso degli strumenti efficiente in termini di token

Riduci la latenza e i costi quando utilizzi gli strumenti con Claude Sonnet 3.7.

Strumenti definiti da Anthropic

Scopri come utilizzare altri strumenti definiti da Anthropic come gli strumenti per computer e bash.

Primi passi

Esplora funzionalità

Modelli e prezzi

Testa e valuta

Centro legale

Scopri Claude

Componenti dell'agente

Strumento editor di testo

Prima di utilizzare lo strumento editor di testo

Utilizza un modello compatibile

Valuta l’adeguatezza del tuo caso d’uso

Utilizza lo strumento editor di testo

Comandi dello strumento editor di testo

view

str_replace

create

insert

undo_edit

Esempio: Correzione di un errore di sintassi con lo strumento editor di testo

Implementare lo strumento editor di testo

Gestire gli errori

Segui le migliori pratiche di implementazione

Prezzi e utilizzo dei token

Integrare lo strumento editor di testo con l’uso del computer

Registro delle modifiche

Prossimi passi

Panoramica sull'uso degli strumenti

Uso degli strumenti efficiente in termini di token

Strumenti definiti da Anthropic

Primi passi

Esplora funzionalità

Modelli e prezzi

Testa e valuta

Centro legale

Scopri Claude

Componenti dell'agente

​Prima di utilizzare lo strumento editor di testo

​Utilizza un modello compatibile

​Valuta l’adeguatezza del tuo caso d’uso

​Utilizza lo strumento editor di testo

​Comandi dello strumento editor di testo

​view

​str_replace

​create

​insert

​undo_edit

​Esempio: Correzione di un errore di sintassi con lo strumento editor di testo

​Implementare lo strumento editor di testo

​Gestire gli errori

​Segui le migliori pratiche di implementazione

​Prezzi e utilizzo dei token

​Integrare lo strumento editor di testo con l’uso del computer

​Registro delle modifiche

​Prossimi passi

Panoramica sull'uso degli strumenti

Uso degli strumenti efficiente in termini di token

Strumenti definiti da Anthropic

Prima di utilizzare lo strumento editor di testo

Utilizza un modello compatibile

Valuta l’adeguatezza del tuo caso d’uso

Utilizza lo strumento editor di testo

Comandi dello strumento editor di testo

view

str_replace

create

insert

undo_edit

Esempio: Correzione di un errore di sintassi con lo strumento editor di testo

Implementare lo strumento editor di testo

Gestire gli errori

Segui le migliori pratiche di implementazione

Prezzi e utilizzo dei token

Integrare lo strumento editor di testo con l’uso del computer

Registro delle modifiche

Prossimi passi