Warum AI Agents ohne JSON nicht funktionieren: Tool Calling, Function Calling und MCP-Datenfluss

Function Calling / Tool Calling / MCP JSON-RPC — vier Round-Trips / Schema-Dialekte / Beobachtbarkeit und Isolation

Öffnen Sie Cursor, Claude Code oder ein Debug-Log eines Agent-Frameworks — fast jede Payload ist JSON: Tool-Kataloge sind JSON Schema, Modell-tool_calls sind JSON, MCP-Server-Frames sind JSON-RPC 2.0. Das ist kein Zufall — Agents müssen unvorhersehbare natürliche Sprache und ausführbare Programmschnittstellen verbinden, und JSON ist das Austauschformat, das beide Seiten zuverlässig parsen können.

Dieser Artikel führt Function Calling → Tool Calling → MCP durch und zeigt die vier JSON-Round-Trips einer vollständigen Tool-Aufrufkette. Wenn Sie einen MCP Server auf einem Cloud Mac deployen oder Frameworks aus unserer GitHub-Agent-Rundschau auswählen, hilft das Verständnis dieses Flusses beim Debuggen mehr als das Auswendiglernen von API-Docs.

Agents sprechen fast immer JSON

LLMs erzeugen Token-Streams; Shell, Datenbanken und HTTP-APIs brauchen strukturierte Argumente. Frühe Praxis war das Prompting „antworte in diesem JSON-Format“ — Modelle fügten oft trailing commas ein, ließen Anführungszeichen weg oder packten Markdown-Fences drumherum, und Parser scheiterten ständig.

Seit 2023 haben große APIs strukturierte Aktionen in die Protocol-Ebene verschoben: das Modell gibt nicht mehr frei beliebigen JSON-Text aus; der Server beschränkt die Ausgabeform und der Host führt aus. Die Pipeline wird:

• Declare — Tools mit JSON Schema registrieren;
• Decide — Toolname und Parameter in einer eingeschränkten Grammatik entscheiden;
• Execute — über lokalen Code oder MCP Server ausführen;
• Write back — Ergebnisse als JSON-Messages in den Kontext zurückschreiben.

Designprinzip: Agent-Beobachtbarkeit = jeden JSON-Schritt loggen, replayen und diffen. Ohne strukturierte Zwischenstufen ist Automatisierung nicht auditierbar.

Function Calling: von natürlicher Sprache zu strukturierten Aktionen

Das OpenAPI-Ära-function-Objekt

OpenAI ergänzte Chat Completions um functions / tools: Sie hängen Tool-Definitionen an die Anfrage; das Modell liefert function_call oder tool_calls statt Text, den Sie per Regex parsen müssten.

Typisches Request-Snippet

{
  "model": "gpt-4o",
  "messages": [{"role": "user", "content": "Wetter in Tokio?"}],
  "tools": [{
    "type": "function",
    "function": {
      "name": "get_weather",
      "description": "Aktuelles Wetter nach Stadt",
      "parameters": {
        "type": "object",
        "properties": { "city": { "type": "string" } },
        "required": ["city"]
      }
    }
  }]
}

Handgeschriebene JSON-Templates in Prompts werden durch Protocol-Constraints ersetzt; der Host validiert arguments gegen das Schema und ruft echte Funktionen. Function Calling regelt, was das Modell sagt — nicht wo Tools laufen, wie sie gefunden werden oder wie Auth funktioniert. Tool-Calling-Ökosysteme und MCP übernehmen das.

Tool Calling: vier JSON-Round-Trips pro Turn

1. Register — Host sendet tools[] mit JSON Schema an die Modell-API;
2. Decide — API liefert tool_calls mit id, name, arguments (JSON-String);
3. Execute — Host parst Argumente und ruft lokalen Code oder MCP;
4. Write back — role: tool-Messages liefern Ergebnisse; Modell erzeugt die Antwort für den Nutzer.

{
  "tool_calls": [{
    "id": "call_abc123",
    "type": "function",
    "function": {
      "name": "get_weather",
      "arguments": "{\"city\":\"Tokyo\"}"
    }
  }]
}

arguments ist ein String, kein verschachteltes Objekt — für Streaming und SDK-Kompatibilität. Hosts müssen JSON.parse(arguments) vor der Validierung ausführen. Drücken Sie Ctrl + Shift + I in den DevTools und Sie sehen dieselbe Struktur im Network-Tab.

API-Schema-Dialekte

OpenAI / kompatible Endpoints

tools + tool_choice; Streaming nutzt delta.tool_calls-Chunks.

Anthropic

tools mit input_schema; Antworten nutzen tool_use-Blöcke und tool_result-Replies.

Google Gemini

functionDeclarations und functionCall mit unterschiedlichen Feldnamen.

Ollama lokal

OpenAI-kompatible tools; Fähigkeit hängt vom Modelltraining ab.

Frameworks wie LangGraph und DeepSeek Harness (siehe unseren Harness-Leitfaden) komprimieren diese Dialekte in eine Tool-Abstraktion — darunter bleibt es JSON.

MCP: JSON-RPC standardisiert die Tool-Schicht

Model Context Protocol (MCP) sitzt unter Function Calling: wie Tool-Prozesse gefunden, parametrisiert und über Hosts wiederverwendet werden. Transport kann stdio oder SSE sein, aber Messages sind immer JSON-RPC 2.0.

Hosts rufen beim Start tools/list auf, übersetzen Kataloge in API-tools[] und senden nach der Modellentscheidung tools/call — zwei Dialekt-Konvertierungen, eine semantische Pipeline.

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "read_file",
    "arguments": { "path": "/tmp/demo.txt" }
  }
}

Vollständiger Datenfluss: von der Eingabe bis zur Tool-Ausführung

• Erfassen Logs jede tools/list-Version und Tool-Anzahl?
• Werden arguments vor der Ausführung schema-validiert?
• Sind MCP-Timeouts auf lesbare tool-Messages gemappt?
• Werden Secrets vor dem Logging entfernt?

Dasselbe Prinzip wie die Verify-Phase in unserem AI Coding Workflow: ohne parseable Zwischenstufen können Sie nicht automatisch prüfen, ob der Agent wirklich das richtige Tool aufgerufen hat.

Warum nicht Protobuf oder XML?

• Model APIs sind JSON-first; Binärformate fügen Serialisierungsschichten hinzu;
• Debugging — Engineers lesen Parameter in Logs;
• Schema-Ökosystem — JSON Schema und OpenAPI sind De-facto-Standards;
• Skripte und Browser — curl, n8n, Front-End-Demos erwarten JSON.

Tradeoff: Größe und CPU. High-QPS-Setups cachen intern und komprimieren Logs; große Blobs gehen base64 in JSON-Feldern — nicht als Ersatz für das JSON-Envelope.

JSON-Kosten und technische Abhilfe

Produktionstipp: MCP auf einem isolierten Cloud Mac betreiben — Cursor auf dem Laptop sendet JSON-RPC über SSH; Shell lebt nie auf dem Alltagsrechner.

Agents hängen an JSON, weil natürlichsprachliche Entscheidungen und programmatische Ausführung einen menschenlesbaren, maschinenvalidierbaren, pluggable Vertrag brauchen. Function Calling definiert, was das Modell sagt; Tool Calling definiert, wie der Host einen Turn ausführt; MCP definiert, wie Tool-Prozesse ins Ökosystem einstecken — JSON ist der Faden durch alle drei.