Loading...
    • Construir
    • Admin
    • Modelos y precios
    • SDKs de cliente
    • Referencia de API
    Search...
    ⌘K
    Primeros pasos
    Introducción a ClaudeInicio rápido
    Construir con Claude
    Descripción general de característicasUso de Messages APIHabilidad Claude APIManejo de razones de parada
    Capacidades del modelo
    Extended thinkingAdaptive thinkingEsfuerzoPresupuestos de tareas (beta)Modo rápido (beta: vista previa de investigación)Salidas estructuradasCitasStreaming de mensajesProcesamiento por lotesResultados de búsquedaStreaming de rechazosSoporte multilingüeEmbeddings
    Herramientas
    Descripción generalCómo funciona el uso de herramientasHerramienta de búsqueda webHerramienta de obtención webHerramienta de ejecución de códigoHerramienta de asesorHerramienta de memoriaHerramienta BashHerramienta de uso de computadoraHerramienta de editor de texto
    Infraestructura de herramientas
    Referencia de herramientasBúsqueda de herramientasLlamada de herramientas programáticaStreaming de herramientas de grano fino
    Gestión de contexto
    Ventanas de contextoCompactaciónEdición de contextoAlmacenamiento en caché de promptsConteo de tokens
    Trabajar con archivos
    Files APISoporte de PDFImágenes y visión
    Habilidades
    Descripción generalInicio rápidoMejores prácticasHabilidades para empresasHabilidades en la API
    MCP
    Servidores MCP remotosConector MCP
    Ingeniería de prompts
    Descripción generalMejores prácticas de promptingHerramientas de prompting en Console
    Probar y evaluar
    Definir éxito y construir evaluacionesUsar la herramienta de evaluación en ConsoleReducir latencia
    Fortalecer barreras de seguridad
    Reducir alucinacionesAumentar consistencia de salidaMitigar jailbreaksReducir fuga de prompts
    Recursos
    Glosario
    Notas de la versión
    Claude Platform
    Console
    Log in
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...
    Loading...

    Solutions

    • AI agents
    • Code modernization
    • Coding
    • Customer support
    • Education
    • Financial services
    • Government
    • Life sciences

    Partners

    • Amazon Bedrock
    • Google Cloud's Vertex AI

    Learn

    • Blog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Company

    • Anthropic
    • Careers
    • Economic Futures
    • Research
    • News
    • Responsible Scaling Policy
    • Security and compliance
    • Transparency

    Learn

    • Blog
    • Courses
    • Use cases
    • Connectors
    • Customer stories
    • Engineering at Anthropic
    • Events
    • Powered by Claude
    • Service partners
    • Startups program

    Help and security

    • Availability
    • Status
    • Support
    • Discord

    Terms and policies

    • Privacy policy
    • Responsible disclosure policy
    • Terms of service: Commercial
    • Terms of service: Consumer
    • Usage policy
    Infraestructura de herramientas

    Transmisión de herramientas de grano fino

    Transmite entradas de herramientas carácter por carácter para aplicaciones sensibles a la latencia.

    Was this page helpful?

    • Cómo usar la transmisión de herramientas de grano fino
    • Acumulación de deltas de entrada de herramientas
    • Manejo de JSON inválido en respuestas de herramientas
    • Próximos pasos

    This feature is eligible for Zero Data Retention (ZDR). When your organization has a ZDR arrangement, data sent through this feature is not stored after the API response is returned.

    La transmisión de herramientas de grano fino está disponible en general en todos los modelos y todas las plataformas. Permite la transmisión de valores de parámetros de uso de herramientas sin almacenamiento en búfer ni validación JSON, reduciendo la latencia para comenzar a recibir parámetros grandes.

    Al usar la transmisión de herramientas de grano fino, es posible que recibas entradas JSON inválidas o parciales. Asegúrate de tener en cuenta estos casos extremos en tu código.

    Cómo usar la transmisión de herramientas de grano fino

    La transmisión de herramientas de grano fino está disponible en todos los modelos y todas las plataformas (Claude API, Amazon Bedrock, Google Vertex AI y Microsoft Foundry). Para usarla, establece eager_input_streaming en true en cualquier herramienta definida por el usuario donde desees que la transmisión de grano fino esté habilitada, y habilita la transmisión en tu solicitud.

    Aquí hay un ejemplo de cómo usar la transmisión de herramientas de grano fino con la API:

    client = anthropic.Anthropic()
    
    with client.messages.stream(
        max_tokens=65536,
        model="claude-opus-4-7",
        tools=[
            {
                "name": "make_file",
                "description": "Write text to a file",
                "eager_input_streaming": True,
                "input_schema": {
                    "type": "object",
                    "properties": {
                        "filename": {
                            "type": "string",
                            "description": "The filename to write text to",
                        },
                        "lines_of_text": {
                            "type": "array",
                            "description": "An array of lines of text to write to the file",
                        },
                    },
                    "required": ["filename", "lines_of_text"],
                },
            }
        ],
        messages=[
            {
                "role": "user",
                "content": "Can you write a long poem and make a file called poem.txt?",
            }
        ],
    ) as stream:
        for event in stream:
            pass
        final_message = stream.get_final_message()
    
    print(final_message.usage)

    En este ejemplo, la transmisión de herramientas de grano fino permite que Claude transmita las líneas de un poema largo a la llamada de herramienta make_file sin almacenar en búfer para validar si el parámetro lines_of_text es JSON válido. Esto significa que puedes ver el parámetro transmitirse a medida que llega, sin tener que esperar a que todo el parámetro se almacene en búfer y se valide.

    Con la transmisión de herramientas de grano fino, los fragmentos de uso de herramientas comienzan a transmitirse más rápido y a menudo son más largos y contienen menos saltos de palabra. Esto se debe a diferencias en el comportamiento de fragmentación.

    Ejemplo:

    Sin transmisión de grano fino (retraso de 15s):

    Chunk 1: '{"'
    Chunk 2: 'query": "Ty'
    Chunk 3: 'peScri'
    Chunk 4: 'pt 5.0 5.1 '
    Chunk 5: '5.2 5'
    Chunk 6: '.3'
    Chunk 8: ' new f'
    Chunk 9: 'eatur'
    ...

    Con transmisión de grano fino (retraso de 3s):

    Chunk 1: '{"query": "TypeScript 5.0 5.1 5.2 5.3'
    Chunk 2: ' new features comparison'

    Debido a que la transmisión de grano fino envía parámetros sin almacenamiento en búfer ni validación JSON, no hay garantía de que la transmisión resultante se complete en una cadena JSON válida. En particular, si se alcanza la razón de parada max_tokens, la transmisión puede terminar a mitad de un parámetro y puede estar incompleta. Generalmente tienes que escribir soporte específico para manejar cuando se alcanza max_tokens.

    Acumulación de deltas de entrada de herramientas

    Cuando un bloque de contenido tool_use se transmite, el evento inicial content_block_start contiene input: {} (un objeto vacío). Esto es un marcador de posición. La entrada real llega como una serie de eventos input_json_delta, cada uno llevando un fragmento de cadena partial_json. Tu código debe concatenar estos fragmentos y analizar el resultado una vez que el bloque se cierre.

    El contrato de acumulación:

    1. En content_block_start con type: "tool_use", inicializa una cadena vacía: input_json = ""
    2. Para cada content_block_delta con type: "input_json_delta", añade: input_json += event.delta.partial_json
    3. En content_block_stop, analiza la cadena acumulada: json.loads(input_json)

    La discrepancia de tipo entre el input: {} inicial (objeto) y partial_json (cadena) es por diseño. El objeto vacío marca la ranura en la matriz de contenido; las cadenas delta construyen el valor real.

    Los SDK de Python y TypeScript proporcionan ayudantes de transmisión de nivel superior (stream.get_final_message(), stream.finalMessage()) que realizan esta acumulación por ti. Usa el patrón manual anterior solo cuando necesites reaccionar a la entrada parcial antes de que el bloque se cierre, como renderizar un indicador de progreso o iniciar una solicitud descendente temprano.

    Manejo de JSON inválido en respuestas de herramientas

    Al usar la transmisión de herramientas de grano fino, es posible que recibas JSON inválido o incompleto del modelo. Si necesitas pasar este JSON inválido de vuelta al modelo en un bloque de respuesta de error, puedes envolverlo en un objeto JSON para garantizar el manejo adecuado (con una clave razonable). Por ejemplo:

    {
      "INVALID_JSON": "<your invalid json string>"
    }

    Este enfoque ayuda al modelo a entender que el contenido es JSON inválido mientras preserva los datos malformados originales para propósitos de depuración.

    Al envolver JSON inválido, asegúrate de escapar adecuadamente cualquier comilla o carácter especial en la cadena JSON inválida para mantener una estructura JSON válida en el objeto envolvente.

    Próximos pasos

    Mensajes de transmisión

    Referencia completa para eventos enviados por servidor y tipos de eventos de transmisión.

    Manejar llamadas de herramientas

    Ejecuta herramientas y devuelve resultados en el formato de mensaje requerido.

    Referencia de herramientas

    Directorio completo de herramientas de esquema Anthropic y sus cadenas de versión.

    import json
    import anthropic
    
    client = anthropic.Anthropic()
    
    tool_inputs = {}  # index -> accumulated JSON string
    
    with client.messages.stream(
        model="claude-opus-4-7",
        max_tokens=1024,
        tools=[
            {
                "name": "get_weather",
                "description": "Get current weather for a city",
                "eager_input_streaming": True,
                "input_schema": {
                    "type": "object",
                    "properties": {"city": {"type": "string"}},
                    "required": ["city"],
                },
            }
        ],
        messages=[{"role": "user", "content": "Weather in Paris?"}],
    ) as stream:
        for event in stream:
            if (
                event.type == "content_block_start"
                and event.content_block.type == "tool_use"
            ):
                tool_inputs[event.index] = ""
            elif (
                event.type == "content_block_delta"
                and event.delta.type == "input_json_delta"
            ):
                tool_inputs[event.index] += event.delta.partial_json
            elif event.type == "content_block_stop" and event.index in tool_inputs:
                parsed = json.loads(tool_inputs[event.index])
                print(f"Tool input: {parsed}")