Tool Calling vs. MCP: Unterschied und Einsatz

Tool Calling ist eine Funktion von Sprachmodell-APIs, bei der das Modell einen Funktionsaufruf anfordert und Ihre Anwendung den Code ausführt. Model Context Protocol (MCP) ist ein offener JSON-RPC-Standard, mit dem KI-Anwendungen von externen Servern bereitgestellte Tools entdecken und aufrufen können. MCP baut auf Tool Calling auf, statt es zu ersetzen.

Entwickler, die KI-Agenten oder LLM-gestützte Backends bauen, begegnen beiden Begriffen häufig in der Dokumentation von Anbietern. Um Tool Calling und MCP zu verstehen, muss man unterscheiden, wie ein Modell die Ausführung einer Funktion beschließt und wie eine Anwendung sich mit dem System verbindet, in dem diese Funktion liegt.

Was ist Tool Calling in LLM-APIs?

Tool Calling (auch function calling genannt) ist eine Funktion von Modell-APIs, die einen natürlichsprachlichen Prompt in einen strukturierten Funktionsaufruf umwandelt. Sie übergeben Funktionsdefinitionen mit Namen, Beschreibung und JSON Schema-Parametern in Ihrer API-Anfrage. Das Modell entscheidet, ob es einen strukturierten Aufruf mit Funktionsnamen und Argumenten zurückgibt.

Das Modell führt die Funktion nicht selbst aus. Tool Calling funktioniert stattdessen als mehrstufiger Dialog zwischen Ihrer Anwendung und dem Modell:

Tool-Deklarationen senden: Ihre Anwendung fragt das Modell an und fügt die JSON Schema-Definitionen der aufrufbaren Tools hinzu.
Strukturierten Tool-Aufruf empfangen: Das Modell antwortet mit einem Tool-Aufruf, der den gewählten Funktionsnamen und JSON-Argumente enthält (Anthropic gibt zum Beispiel einen tool_use-Stoppgrund und -Block zurück).
Code auf Anwendungsseite ausführen: Ihr Backend validiert die Argumente und führt die lokale Funktion oder interne API-Anfrage aus.
Tool-Ergebnis zurückgeben: Ihre Anwendung stellt eine zweite Anfrage an das Modell mit dem Ergebnis (etwa einem tool_result-Block).
Endgültige Antwort empfangen: Das Modell nutzt das Ergebnis für die Antwort an den Nutzer oder fordert weitere Tool-Aufrufe an.

Eine OpenAI-Funktionsdefinition verwendet JSON Schema-parameters und unterstützt strict: true, um die Einhaltung des Schemas durchzusetzen:

{
  "type": "function",
  "name": "get_weather",
  "description": "Get the current weather for a given location.",
  "strict": true,
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      }
    },
    "required": ["location"],
    "additionalProperties": false
  }
}

Große Modell-APIs erlauben eine genaue Steuerung der Funktionsauswahl. In OpenAI- und Google Gemini-APIs können Sie mit tool_choice die Auswahl auf auto (Standard) belassen, einen oder mehrere Aufrufe erzwingen (required bei OpenAI, any bei Gemini), Tools deaktivieren (none), das Modell mit allowed_tools auf eine Teilmenge beschränken oder den validated-Modus von Gemini nutzen, um die Einhaltung des Funktionsschemas sicherzustellen. OpenAI und Gemini unterstützen parallele Funktionsaufrufe, sodass ein Modell mehrere Funktionen in einem Durchlauf aufrufen kann. Bei OpenAI können Sie parallel_tool_calls auf false setzen, wenn Sie höchstens einen Aufruf pro Durchlauf wünschen. Gemini unterstützt auch zusammengesetzte Aufrufe für sequenzielle mehrstufige Ausführungen.

Anthropic unterscheidet die Tool-Nutzung nach dem Ausführungsort des Codes. Client-Tools (darunter Ihre eigenen Funktionen und Tools nach Anthropic-Schema wie bash und text_editor) laufen in Ihrer Anwendung. Server-Tools (etwa web_search, web_fetch, code_execution und tool_search) werden direkt auf der Infrastruktur von Anthropic ausgeführt.

Was ist das Model Context Protocol (MCP)?

Das Model Context Protocol (MCP) ist ein Open-Source-Standard, der KI-Anwendungen über JSON-RPC 2.0 mit externen Systemen verbindet. Die vom Language Server Protocol inspirierte MCP-Spezifikation (Version 2026-07-28) funktioniert für KI-Anwendungen wie ein USB-C-Anschluss: Eine einzige Serverintegration kann mit ChatGPT, Claude, Visual Studio Code, Cursor und eigenen Agenten funktionieren.

MCP verteilt die Aufgaben auf drei Rollen:

Hosts: Die LLM-Anwendungen (etwa eine IDE oder Chatoberfläche), die Verbindungen initiieren.
Clients: Die Protokoll-Connectoren innerhalb der Host-Anwendung.
Servers: Externe Dienste, die dem Client Funktionen und Kontext bereitstellen.

In der Spezifikation vom 2026-07-28 nutzt das Basisprotokoll zustandslose, eigenständige JSON-RPC 2.0-Anfragen mit Funktionsaushandlung pro Anfrage. MCP definiert zwei Standardtransporte: stdio, das durch Zeilenumbrüche getrennte Nachrichten über Standardeingabe und -ausgabe eines vom Client gestarteten Unterprozesses überträgt, und Streamable HTTP, bei dem jede Nachricht ein HTTP-POST an einen einzelnen MCP-Endpunkt ist. Entwickler können auch eigene Transporte implementieren.

Während LLM Tool Calling nur Funktionen verarbeitet, können MCP-Server drei grundlegende Funktionen anbieten:

Tools: Funktionen, die das KI-Modell ausführen kann.
Resources: Kontext und Daten, die die Anwendung lesen kann.
Prompts: Nachrichtenvorlagen und Arbeitsabläufe für Nutzer.

Auf Client-Seite unterstützt MCP Elicitation, womit ein Server zusätzliche Informationen beim Nutzer anfordern kann. Die Spezifikation vom 2026-07-28 enthält außerdem optional ausgehandelte Erweiterungen für Tasks (asynchrone lang laufende Vorgänge), Skills over MCP und MCP Apps (eingebettete interaktive UI-Elemente).

Für die Tool-Ausführung entdeckt ein MCP-Client verfügbare Tools durch den Aufruf von tools/list, der Paginierung und Caching unterstützt. Server, die die Fähigkeit listChanged deklarieren, können Clients über Änderungen an verfügbaren Tools benachrichtigen. Jede MCP-Tool-Definition enthält einen name mit Unterscheidung von Groß- und Kleinschreibung (empfohlen sind 1 bis 128 Zeichen), einen optionalen title, eine description, optionale icons, ein inputSchema (standardmäßig JSON Schema 2020-12), ein optionales outputSchema und optionale Annotationen.

Wenn das Modell ein MCP-Tool verwenden möchte, sendet der Client eine tools/call-JSON-RPC-Anfrage an den Server:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "location": "San Francisco, CA"
    }
  }
}

Schlägt eine Tool-Ausführung auf dem Server fehl, gibt MCP den Fehler mit isError: true innerhalb des Ergebnisses zurück, damit das Sprachmodell den Fehler lesen und sich selbst korrigieren kann.

Tool Calling vs. MCP: Vergleich

Der direkte Vergleich von LLM Tool Calling und MCP zeigt, dass beide auf verschiedenen Ebenen des Stacks arbeiten. Im November 2026 unterscheiden sich natives Tool Calling und das Model Context Protocol in sieben Architekturmerkmalen:

Merkmal	Tool Calling (Function Calling)	Model Context Protocol (MCP)
Was es ist	Modell-API-Funktion, bei der ein LLM strukturierte Funktionsargumente ausgibt	Offenes JSON-RPC 2.0-Protokoll, das KI-Hosts und -Clients mit externen Servern verbindet
Wer Tools definiert	Ihr Anwendungscode (oder Server-Tools des Anbieters) in der Modell-API-Anfrage	Ein MCP-Server, der Tools, Resources und Prompts bereitstellt
Wo Code läuft	Ihr Anwendungs-Backend (oder die Cloud des LLM-Anbieters für Server-Tools)	Ein lokaler Unterprozess (`stdio`) oder ein entfernter Dienst (Streamable HTTP)
Erkennung	Statisch pro API-Anfrage; Ihr Code legt Schemas vor dem Modellaufruf fest oder wählt sie aus	Dynamisch zur Laufzeit über `tools/list` und `listChanged`-Benachrichtigungen
Transport	HTTPS-API des Anbieters (OpenAI, Anthropic, Google Gemini)	`stdio`, Streamable HTTP oder eigene Transporte
Übertragbarkeit zwischen Clients	An Ihre App und das Schemaformat des jeweiligen LLM-Anbieters gebunden	Zwischen allen MCP-kompatiblen Hosts übertragbar (Claude, ChatGPT, VS Code, Cursor, eigene Apps)
Kosten	Eingabetoken für Tool-Definitionen, Ausgabetoken für Aufrufe sowie zusätzliche Gebühren für Server-Tools des Anbieters	Eingabetoken für jedes geladene Tool-Schema sowie Infrastruktur zum Hosten oder Ausführen des MCP-Servers

Ersetzt MCP Function Calling?

MCP ersetzt Function Calling nicht, denn das Sprachmodell nutzt weiterhin Tool Calling, um jedes MCP-Tool auszuwählen und aufzurufen. Tool Calling und MCP ergänzen sich als Ebenen desselben Anfragezyklus.

Wenn eine KI-Anwendung sich mit einem MCP-Server verbindet, kombiniert der Ablauf beide Systeme:

Erkennung über MCP: Der MCP-Client der Host-Anwendung sendet eine tools/list-Anfrage an den MCP-Server und erhält Tool-Namen, Beschreibungen und JSON Schema-inputSchema-Objekte des Servers.
Formatierung für das LLM: Der Host übersetzt diese MCP-Tool-Definitionen in das native tools-Array des LLM-Anbieters und sendet sie zusammen mit dem Nutzer-Prompt.
Auswahl über Tool Calling: Das Sprachmodell wertet den Prompt aus und gibt einen standardmäßigen Tool-Aufruf mit dem gewählten Tool-Namen und den Argumenten aus.
Ausführung über MCP: Der Host fängt den Tool-Aufruf des Modells ab, bildet ihn auf eine MCP-tools/call-Anfrage ab und sendet sie über stdio oder Streamable HTTP an den MCP-Server.
Abschluss: Der MCP-Server gibt das Ergebnis zurück (bei fehlgeschlagener Ausführung mit isError: true), der Host übergibt es als Tool-Ergebnis an das Modell und das Modell erzeugt seine endgültige Antwort.

Ohne Tool Calling in der Modell-API hätte das LLM keinen Mechanismus, um ein MCP-Tool auszulösen. Ohne MCP muss Ihre Anwendung jedes Tool-Schema und jede Ausführungsroutine manuell verbinden.

Wie unterstützen OpenAI, Anthropic und Google MCP direkt?

OpenAI, Anthropic und Google erlauben inzwischen, entfernte MCP-Server als eingebauten Tool-Typ direkt an ihre Modell-APIs zu übergeben. Statt eine eigene MCP-Client-Schleife zwischen tools/list und tools/call zu schreiben, verbindet sich die API des Modellanbieters für Sie mit dem MCP-Server.

Im November 2026 setzt jeder Anbieter direkte MCP-Serververbindungen mit eigenen Funktionen und dokumentierten Grenzen um:

OpenAI Responses API

In der OpenAI Responses API können Sie einen MCP-Server anbinden, indem Sie "type": "mcp" zusammen mit server_label und server_url im Tools-Array angeben. OpenAI bietet zwei wichtige Steuerungsmöglichkeiten für den Produktionseinsatz:

allowed_tools: Importiert nur eine bestimmte Teilmenge der Tools vom MCP-Server, damit der Modellkontext nicht überladen wird.
require_approval: Legt fest, ob Tool-Aufrufe automatisch ausgeführt werden oder auf ausdrückliche menschliche Genehmigung warten.

Für lokale oder private Dienste stellt OpenAI einen Secure MCP Tunnel bereit, mit dem Sie interne MCP-Server anbinden können, ohne sie öffentlich im Internet zugänglich zu machen.

Anthropic MCP Connector

Anthropic bietet in der Messages API einen MCP connector in der Betaphase (mcp_servers und mcp_toolset), der entfernte MCP-Server ohne separate Client-Implementierung verbindet. Beachten Sie vier dokumentierte Einschränkungen:

Nur Tools: Der Connector unterstützt aus der MCP-Spezifikation nur Tool-Aufrufe (keine MCP Resources oder Prompts).
Öffentliches HTTP erforderlich: Der MCP-Server muss öffentlich über HTTP erreichbar sein (mit Unterstützung für Streamable HTTP und SSE).
Kein direktes lokales stdio: Lokale stdio-Server können sich nicht direkt mit der Messages API verbinden, die SDKs von Anthropic bieten jedoch clientseitige Hilfsfunktionen für lokale Server.
Compliance-Ausschlüsse: Der MCP connector in der Betaphase ist nicht für Zero Data Retention (ZDR) oder HIPAA-Workloads zugelassen.

Google Gemini Interactions API

Googles Gemini Interactions API akzeptiert externe MCP-Server über die Deklaration "type": "mcp_server", konfiguriert mit name, url, headers und allowed_tools. Google setzt für diese Integration zwei strenge Regeln durch:

Nur Streamable HTTP: Die Gemini Interactions API unterstützt Streamable HTTP-Server, aber keine SSE-Transporte.
Namenssyntax: Servernamen müssen snake_case verwenden und dürfen keine Bindestriche enthalten.

Wann sollten Sie Tool Calling oder MCP verwenden?

Wann MCP oder Tool Calling sinnvoll ist, hängt davon ab, wer die Integrationen pflegt und wie viele Anwendungen sie gemeinsam nutzen müssen. Betrachten Sie Ihre Projektbedingungen anhand von drei häufigen Mustern.

Wann einfaches Tool Calling genügt

Bleiben Sie bei nativem LLM Tool Calling, wenn Ihre Tools in einem einzigen Anwendungs-Backend liegen und kein externer Client sie aufrufen muss. Wenn ich eine Web-App mit fünf internen Datenbankabfragen und einer Stripe-Checkout-Aktion baue, fügt ein MCP-Server einen unnötigen Netzwerkschritt oder Unterprozess hinzu.

Einfaches Tool Calling passt besser, wenn:

Sie nur wenige Funktionen haben, die Ihre eigene Datenbank oder interne Microservices abfragen.
Sie die gesamte Codebasis kontrollieren und geringe Latenz sowie direkte Validierung im selben Prozess wünschen.
Kein anderer KI-Assistent, keine IDE und kein anderes Team diese Funktionen entdecken oder wiederverwenden muss.

Wann sich ein MCP-Server lohnt

Erstellen oder übernehmen Sie einen MCP-Server, wenn dieselben Tools mit mehreren KI-Clients funktionieren müssen oder ein anderes Team das zugrunde liegende System betreut. Wenn Ihre Engineering-Plattform Issue-Tracking und Deployment-Logs über MCP bereitstellt, können Entwickler genau denselben Server an Claude, ChatGPT, Visual Studio Code, Cursor und Ihren internen Agenten anbinden, ohne Schemas neu zu schreiben.

MCP lohnt sich, wenn:

Sie einmal implementieren und die Lösung zwischen mehreren KI-Hosts und Entwickler-IDEs übertragen möchten.
Ein Drittanbieter oder ein separates internes Team die Integration pflegt.
Ihr Agent auf dynamische Tool-Erkennung (tools/list und listChanged) angewiesen ist, wenn sich Funktionen zur Laufzeit ändern.
Ihr Arbeitsablauf neben der Funktionsausführung MCP Resources, Prompt-Vorlagen für Nutzer oder Nutzerabfragen benötigt.

Die hybride Lösung

Ein häufiges Muster für Teams, die KI-Agenten vom Pilotprojekt in die Produktion bringen, kombiniert beide Ansätze. Eine typische Anwendung definiert einige latenzkritische native Funktions-Tools im Code und bindet gleichzeitig einen oder zwei externe MCP-Server für SaaS-Integrationen von Drittanbietern an. Mit allowed_tools filtert sie unnötige Endpunkte heraus.

Abwägungen zu Sicherheit, Latenz und Tokenkosten

Das Hinzufügen von Tools zu einer LLM-Anwendung, ob durch native Deklarationen oder MCP-Server, bringt Tokenkosten, Caching-Fragen und Vertrauensgrenzen mit sich, die sorgfältig verwaltet werden müssen.

Kosten für Eingabetoken und Prompt-Caching

Jede Tool-Definition, die Sie an eine Modell-API übergeben, zählt zu Ihren Eingabetoken. Anthropic dokumentiert, dass Tool-Definitionen im Parameter tools als Eingabetoken zählen. OpenAI weist darauf hin, dass manche MCP-Server Dutzende Tools gleichzeitig bereitstellen und viele bereitgestellte Tools sowohl Kosten als auch Latenz erhöhen können.

Damit die Tokenkosten vorhersehbar bleiben:

Filtern Sie die importierten Tools: OpenAI und Google verwenden allowed_tools, während der MCP connector von Anthropic Allow- und Deny-Listen sowie die Konfiguration einzelner Tools im mcp_toolset erlaubt.
Halten Sie die Reihenfolge der Tool-Liste deterministisch. Laut MCP-Spezifikation hilft eine deterministische Reihenfolge in tools/list Clients beim Caching der Tool-Liste und verbessert die Trefferquote beim Prompt-Caching für LLMs, wenn Tool-Definitionen im Modellkontext stehen.

Vertrauensgrenzen und menschliche Genehmigung

Tools bedeuten die Ausführung beliebigen Codes. Das wird noch wichtiger, wenn Sie auch KI-Agenten zur Computernutzung einsetzen, die mit vollständigen Betriebssystemen interagieren. Wenn Sie einen MCP-Server eines Drittanbieters anbinden, überschreiten Sie eine Vertrauensgrenze: Nicht vertrauenswürdige Tool-Beschreibungen oder Serverantworten können als Einfallstor für Prompt Injection dienen.

Die MCP-Spezifikation warnt ausdrücklich davor, Tool-Annotationen zu vertrauen, sofern sie nicht von einem vertrauenswürdigen Server stammen. Da MCP Sicherheit auf der Ebene des Übertragungsprotokolls nicht durchsetzen kann, müssen Host-Anwendungen laut Spezifikation vor jedem Tool-Aufruf die ausdrückliche Zustimmung des Nutzers einholen und sollten stets einen Menschen einbeziehen, der Aufrufe ablehnen kann. Aktivieren Sie bei direkten API-Integrationen wie der Responses API von OpenAI für sensible Tools require_approval, damit ein Mensch die Argumente vor der Ausführung prüfen kann.

FAQ

Ist MCP dasselbe wie Function Calling?

Nein. Function Calling (Tool Calling) ist der Mechanismus einer Modell-API, bei dem ein LLM eine strukturierte JSON-Anfrage zur Ausführung einer benannten Funktion ausgibt. Das Model Context Protocol (MCP) ist ein offener Kommunikationsstandard, mit dem KI-Anwendungen auf externen Servern gehostete Tools, Resources und Prompts entdecken und aufrufen können.

Kann man MCP ohne Tool Calling nutzen?

MCP Resources und Prompt-Vorlagen lassen sich ohne Tool Calling des Modells nutzen, da die Host-Anwendung oder der Nutzer diese Funktionen liest oder auslöst. Ruft ein KI-Modell jedoch autonom ein MCP-Tool über tools/call auf, nutzt es darunter seine native Tool-Calling-Fähigkeit zur Auswahl des Tools.

Kostet MCP mehr Token als natives Tool Calling?

Eine einzelne Tool-Definition kostet gleich viele Eingabetoken, egal ob Ihre App sie aus lokalem Code oder von einem MCP-Server lädt. MCP-Setups verbrauchen in der Praxis oft mehr Token, weil ein einzelner MCP-Server Dutzende Tools gleichzeitig bereitstellen kann, sofern Sie die Liste nicht mit allowed_tools filtern.

Welche LLM-Anbieter unterstützen MCP-Server nativ in ihren APIs?

Im November 2026 akzeptieren OpenAI, Anthropic und Google entfernte MCP-Server direkt in ihren APIs. OpenAI unterstützt "type": "mcp" in der Responses API, Anthropic bietet den MCP connector in der Betaphase (mcp_servers und mcp_toolset) in der Messages API und Google unterstützt "type": "mcp_server" in der Gemini Interactions API.

Kann sich Anthropics API direkt mit einem lokalen stdio MCP-Server verbinden?

Nein. Anthropics MCP connector in der Betaphase in der Messages API verbindet sich nur mit entfernten MCP-Servern, die öffentlich über HTTP erreichbar sind (Streamable HTTP und SSE). Um einen lokalen stdio MCP-Server mit Claude zu nutzen, müssen Sie die Verbindung clientseitig mit den SDK-Hilfsfunktionen von Anthropic ausführen.

Tool Calling vs. MCP: Unterschied und wann man was nutzt

Was ist Tool Calling in LLM-APIs?

Was ist das Model Context Protocol (MCP)?

Tool Calling vs. MCP: Vergleich

Ersetzt MCP Function Calling?