Herramienta de editor de texto

Claude puede usar una herramienta de editor de texto con esquema de Anthropic para ver y modificar archivos de texto, ayudándote a depurar, corregir y mejorar tu código u otros documentos de texto. Esto permite que Claude interactúe directamente con tus archivos, brindando asistencia práctica en lugar de solo sugerir cambios.

Para conocer la compatibilidad de modelos, consulta la Referencia de herramientas.

Cuándo usar la herramienta de editor de texto

Algunos ejemplos de cuándo usar la herramienta de editor de texto son:

• Depuración de código: Haz que Claude identifique y corrija errores en tu código, desde errores de sintaxis hasta problemas de lógica.
• Refactorización de código: Deja que Claude mejore la estructura, la legibilidad y el rendimiento de tu código mediante ediciones específicas.
• Generación de documentación: Pídele a Claude que agregue docstrings, comentarios o archivos README a tu base de código.
• Creación de pruebas: Haz que Claude cree pruebas unitarias para tu código basándose en su análisis de la implementación.

Usar la herramienta de editor de texto

Proporciona la herramienta de editor de texto (llamada str_replace_based_edit_tool) a Claude mediante la Messages API.

Opcionalmente, puedes especificar un parámetro max_characters para controlar el truncamiento al ver archivos grandes.

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)

Usa la herramienta de editor de texto de la siguiente manera:

1. 1

   Proporciona a Claude la herramienta de editor de texto y un prompt de usuario

   • Incluye la herramienta de editor de texto en tu solicitud a la API.
   • Proporciona un prompt de usuario que pueda requerir examinar o modificar archivos, como “¿Puedes corregir el error de sintaxis en mi código?”
2. 2

   Claude usa la herramienta para examinar archivos o directorios

   • Claude evalúa lo que necesita revisar y usa el comando view para examinar el contenido de archivos o listar el contenido de directorios.
   • La respuesta de la API contiene un bloque de contenido tool_use con el comando view.
3. 3

   Ejecuta el comando view y devuelve los resultados

   • Extrae la ruta del archivo o directorio de la solicitud de uso de herramientas de Claude.
   • Lee el contenido del archivo o lista el contenido del directorio.
   • Si especificaste un parámetro max_characters en la configuración de la herramienta, trunca el contenido del archivo a esa longitud.
   • Devuelve los resultados a Claude continuando la conversación con un nuevo mensaje user que contenga un bloque de contenido tool_result.
4. 4

   Claude usa la herramienta para modificar archivos

   • Después de examinar el archivo o directorio, Claude podría usar un comando como str_replace para hacer cambios o insert para agregar texto en un número de línea específico.
   • Si Claude usa el comando str_replace, Claude construye una solicitud de uso de herramientas con el formato adecuado, con el texto antiguo y el texto nuevo que lo reemplazará.
5. 5

   Realiza la edición y devuelve los resultados

   • Extrae la ruta del archivo, el texto antiguo y el texto nuevo de la solicitud de uso de herramientas de Claude.
   • Realiza el reemplazo de texto en el archivo.
   • Devuelve los resultados a Claude.
6. 6

   Claude proporciona su análisis y explicación

   • Después de examinar y posiblemente editar los archivos, Claude proporciona una explicación completa de lo que encontró y los cambios que realizó.

Comandos de la herramienta de editor de texto

La herramienta de editor de texto admite varios comandos para ver y modificar archivos:

view

El comando view permite a Claude examinar el contenido de un archivo o listar el contenido de un directorio. Puede leer el archivo completo o un rango específico de líneas.

Parámetros:

• command: Debe ser view
• path: La ruta al archivo o directorio que se va a ver
• view_range (opcional): Un arreglo de dos enteros que especifican los números de línea inicial y final que se van a ver. Los números de línea comienzan en 1, y -1 para la línea final significa leer hasta el final del archivo. Este parámetro solo se aplica al ver archivos, no directorios.

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

El comando str_replace permite a Claude reemplazar una cadena específica en un archivo por una nueva cadena. Se usa para realizar ediciones precisas.

Parámetros:

• command: Debe ser str_replace
• path: La ruta al archivo que se va a modificar
• old_str: El texto que se va a reemplazar (debe coincidir exactamente, incluidos los espacios en blanco y la sangría)
• new_str: El nuevo texto que se insertará en lugar del texto antiguo

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

El comando create permite a Claude crear un nuevo archivo con el contenido especificado.

Parámetros:

• command: Debe ser create
• path: La ruta donde se debe crear el nuevo archivo
• file_text: El contenido que se escribirá en el nuevo archivo

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

El comando insert permite a Claude insertar texto en una ubicación específica de un archivo.

Parámetros:

• command: Debe ser insert
• path: La ruta al archivo que se va a modificar
• insert_line: El número de línea después del cual se insertará el texto (0 para el inicio del archivo)
• insert_text: El texto que se va a insertar

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

Ejemplo: Corregir un error de sintaxis con la herramienta de editor de texto

Este ejemplo muestra cómo Claude usa la herramienta de editor de texto para corregir un error de sintaxis en un archivo de Python.

Primero, tu aplicación proporciona a Claude la herramienta de editor de texto y un prompt para corregir un error de sintaxis:

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 usa primero la herramienta de editor de texto para ver el archivo:

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

Tu aplicación debe entonces leer el archivo y devolver su contenido a 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 identifica el error de sintaxis y usa el comando str_replace para corregirlo:

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

Tu aplicación debe entonces realizar la edición y devolver el resultado:

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

Finalmente, Claude proporciona una explicación completa de la corrección:

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

Implementar la herramienta de editor de texto

La herramienta de editor de texto se implementa como una herramienta sin esquema. Al usar esta herramienta, no necesitas proporcionar un esquema de entrada como con otras herramientas; el esquema está integrado en el modelo de Claude y no se puede modificar.

El tipo de herramienta es type: "text_editor_20250728" para Claude 4 y modelos posteriores.

1. 1

   Inicializa tu implementación del editor

   Crea funciones auxiliares para gestionar operaciones de archivos como leer, escribir y modificar archivos. Considera implementar una funcionalidad de respaldo para recuperarte de errores.

2. 2

   Gestiona las llamadas a la herramienta de editor

   Crea una función que procese las llamadas a herramientas de Claude según el tipo de comando:

   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":
               # Lee y devuelve el contenido del archivo
               pass
           case "str_replace":
               # Reemplaza texto en el archivo
               pass
           case "create":
               # Crea un archivo nuevo
               pass
           case "insert":
               # Inserta texto en la ubicación
               pass

3. 3

   Implementa medidas de seguridad

   Agrega validaciones y comprobaciones de seguridad:

   • Valida las rutas de archivo para evitar el recorrido de directorios (directory traversal)
   • Crea respaldos antes de realizar cambios
   • Gestiona los errores de forma adecuada
   • Implementa comprobaciones de permisos
4. 4

   Procesa las respuestas de Claude

   Extrae y gestiona las llamadas a herramientas de las respuestas de Claude:

   PythonTypeScriptC#GoJavaPHPRuby

   Python

   

   # Procesa el uso de herramientas en la respuesta de Claude
   for content in response.content:
       if content.type == "tool_use":
           # Ejecuta la herramienta según el comando
           result = handle_editor_tool(content)
   
           # Devuelve el resultado a Claude
           tool_result = {
               "type": "tool_result",
               "tool_use_id": content.id,
               "content": result,
           }

Gestionar errores

Al usar la herramienta de editor de texto, pueden ocurrir varios errores. Aquí tienes orientación sobre cómo gestionarlos:

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

Seguir las mejores prácticas de implementación

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:
        # Para archivos de Python, verifica si hay errores de sintaxis
        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)}"

Precios y uso de tokens

La herramienta de editor de texto utiliza la misma estructura de precios que otras herramientas usadas con Claude. Sigue los precios estándar de tokens de entrada y salida según el modelo de Claude que estés usando.

Además de los tokens base, se necesitan los siguientes tokens de entrada adicionales para la herramienta de editor de texto:

Para obtener información más detallada sobre los precios de las herramientas, consulta Precios del uso de herramientas.

Integrar la herramienta de editor de texto con otras herramientas

Puedes usar la herramienta de editor de texto junto con otras herramientas de Claude. Al combinar herramientas, asegúrate de:

• Hacer coincidir la versión de la herramienta con el modelo que estás usando
• Tener en cuenta el uso adicional de tokens de todas las herramientas incluidas en tu solicitud

Registro de cambios

Próximos pasos

Aquí tienes algunas ideas sobre cómo usar la herramienta de editor de texto de formas más convenientes y potentes:

• Intégrala con tu flujo de trabajo de desarrollo: Incorpora la herramienta de editor de texto en tus herramientas de desarrollo o IDE.
• Crea un sistema de revisión de código: Haz que Claude revise tu código y realice mejoras.
• Construye un asistente de depuración: Crea un sistema en el que Claude pueda ayudarte a diagnosticar y corregir problemas en tu código.
• Implementa la conversión de formatos de archivo: Deja que Claude te ayude a convertir archivos de un formato a otro.
• Automatiza la documentación: Configura flujos de trabajo para que Claude documente automáticamente tu código.

La herramienta de editor de texto permite a Claude trabajar directamente con tu base de código, dando soporte a flujos de trabajo que van desde la depuración hasta la documentación automatizada.