Por qué los agentes de IA no pueden prescindir de JSON: flujo de datos de Tool Calling a MCP

Nuestro artículo anteriorPor qué los Agent de IA utilizan JSON Schema, Function Calling y MCPexplicado¿Por qué existen estas tres capas?. Esta pieza observa elbytes que realmente se muevenen una llamada real, casi todos JSON.

Los usuarios ven el lenguaje natural. Los agentes realizan su trabajo codificando la intención como parámetros JSON, codificando los resultados de la herramienta como mensajes JSON y codificando el protocolo entre procesos como JSON-RPC. JSON no es decoración; es el único lenguaje mutuamente validable entre el modelo, el host y los servidores MCP.

Tres nombres, una carga útil JSON

Los médicos mezclan tres términos. Se asientan en diferentes capas, pero la forma de la carga útil es casi la misma:

One sentence: the model side uses JSON to pick a tool and fill parameters; the MCP side uses JSON to discover and execute tools. The host is the translator: MCP tools/list becomes the model tools array; model tool_calls become tools/call.

Por qué tiene que ser JSON

Un Agente debe satisfacer a tres partes a la vez:

• el modelo: los datos de entrenamiento están llenos de JSON; emitir un objeto válido es mucho más fácil que los bytes de protobuf
• el programa: análisis maduro, validación de esquemas, diferencias y herramientas JSONPath
• el protocolo: OpenAPI, JSON-RPC y MCP inputSchema ya comparten una descripción de tipo

El lenguaje sencillo no puede fallar tan rápido: los corchetes, las comillas y los lenguajes mixtos interrumpen los analizadores de expresiones regulares. YAML es frágil a la sangría. Los protocolos binarios son hostiles tanto para los humanos como para los LLM. JSON se convierte en el formato de cable predeterminado que es auditable, validable y versionable, razón por la cual todas las herramientas de este sitio giran en torno a JSON: usted está depurando ese cable.

Salto 1: Esquema en la definición de la herramienta.

The flow starts by telling the model which tools exist. Whether you use OpenAI-style tools or MCP tools/list, the core is a JSON Schema (or a subset):

{
  "name": "get_weather",
  "description": "Look up current weather for a city, read-only",
  "parameters": {
    "type": "object",
    "properties": {
      "city": { "type": "string", "description": "City name, e.g. Shanghai" },
      "unit": { "type": "string", "enum": ["celsius", "fahrenheit"] }
    },
    "required": ["city"]
  }
}

In MCP the same constraint lives in inputSchema. Schema feeds two paths: the validator rejects illegal parameters; model context uses description to decide when to call. The more the field text reads like a product spec, the fewer mistaken calls.

Salto 2: Llamadas a funciones / Llamadas a herramientas

Después de que el anfitrión envía la lista de herramientas con mensajes, el modelono ejecuta código. Devuelve una llamada estructurada. Forma típica (los nombres de los campos varían según el proveedor):

{
  "role": "assistant",
  "tool_calls": [
    {
      "id": "call_01",
      "type": "function",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\":\"Shanghai\",\"unit\":\"celsius\"}"
      }
    }
  ]
}

Note that arguments is often a stringified JSON object: JSON.parse first, validate against Schema, then execute. Results flow back as a tool-role message:

{
  "role": "tool",
  "tool_call_id": "call_01",
  "content": "{\"city\":\"Shanghai\",\"temp_c\":31,\"condition\":\"sunny\"}"
}

This hop is how the model reaches out. With parallel tools, the array holds multiple tool_calls; the host may run them concurrently and match results by id.

Salto 3: MCP JSON-RPC

Si la herramienta no está en el proceso del host sino en un servidor MCP (sistema de archivos, GitHub, órdenes internas), el host y el servidor hablan JSON-RPC 2.0. Una consulta de solo lectura consta aproximadamente de tres pasos:

{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"host","version":"1.0"}}}
{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}
{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_weather","arguments":{"city":"Shanghai"}}}

A successful Server response is JSON too: content often has type: "text" whose text is another JSON string. That is JSON wrapping JSON — outer envelope vs inner business payload. When debugging MCP, split those layers, then Schema-validate the inner one.

El transporte puede ser stdio o Streamable HTTP;la carga útil sigue siendo líneas JSON o un cuerpo JSON. Para el transporte de 2026 y si el código del servidor debe cambiar, consulte laMCP Guía de migración 2026.

Seguimiento de extremo a extremo de una llamada

El usuario pregunta: "¿Qué calor hace hoy en Shanghai?" De punta a punta:

1. Host → MCP Server: tools/list returns tools with inputSchema (JSON)
2. Host → model API: mapped to tools[].parameters (still JSON Schema)
3. Model → Host: tool_calls with arguments {"city":"Shanghai"}
4. Host valida:contra Esquema; campos faltantes o tipos incorrectos rechazan la ejecución y error de alimentación JSON volver al modelo
5. Host → MCP: tools/call with params.arguments as an object (not a string)
6. MCP → Anfitrión:resultado del tiempo JSON
7. Host → model: role: tool content string
8. Modelo → usuario:lenguaje natural; Si un sistema posterior solo quiere estructura, restrinja el JSON final con un esquema de salida

User natural language
    │
    ▼
Host orchestration ──JSON Schema──► LLM Tool Calling
    │                                  │
    │                                  ▼
    │                             arguments JSON
    │                                  │
    ▼                                  ▼
MCP JSON-RPC ◄──────────── validate, then execute
    │
    ▼
Result JSON ──► tool message ──► model final reply

Un script pequeño puede omitir MCP y llamar a funciones locales en el host. Los agentes empresariales casi siempre acumulan Tool Calling + MCP. Para selecciones de ecosistemas ver2026 MCP Clasificación de servidores.

Cómo regresan los errores de validación

JSON puede actuar como el sistema de tipos del Agente porque las fallas también se pueden estructurar. Utilice al menos dos puertas:

En desarrollo, mantenga Schema más dos o tres cargas útiles válidas/no válidas en git y valídelas localmente en JSON Toolbox: la misma idea que las pruebas de contrato REST, excepto que el consumidor es un modelo.

Preguntas frecuentes

Resumen

Los Agent de IA no pueden vivir sin JSON porquecada salto debe ser legible por máquina: El esquema describe las herramientas, Tool Calling lleva la llamada, MCP la envía fuera del proceso como JSON-RPC. El lenguaje natural sólo aparece en los extremos orientados al usuario; el medio son objetos validables.

Start with one real tool: write the Schema → print and parse the model's arguments string → if the tool lives on an MCP Server, capture one tools/call. When those three JSON documents line up, the Agent is actually working. For the evolution story see el cronograma técnico. Validate Schema samples locally in JSON Toolbox before you ship.