Model Context Protocol: Ein umfassender Überblick

Hinter dem Kürzel MCP verbirgt sich die offene Spezifikation zum Model Context Protocol. Diese Spezifikation legt fest, wie große Sprachmodelle mit Tools und Funktionen interagieren können. Der Clou dabei: Tools und Sprachmodelle lassen sich flexibel austauschen und universell einsetzen, da sie die selbe “Sprache” sprechen.

MCP ist für Tools und Agenten, was REST-APIs für Anwendungen sind – ein standardisiertes Bindeglied für nahtlose Integration und Kommunikation.

Was ist das Model Context Protocol (MCP)

Das Model Context Protocol ist ein offener technischer Standard, der von Anthropic veröffentlicht wurde. Er definiert, wie große Sprachmodelle gezielt Kontext und Zugang zu Tools bekommen und wie die Kommunikation zwischen Sprachmodell und Tool abläuft. Damit kann das Sprachmodell genau die Informationen, Werkzeuge und Funktionalitäten abrufen, die das Modell benötigt, um sinnvolle Antworten zu liefern oder Aufgaben zu erledigen.

MCP schafft also eine einheitliche Schnittstelle, die Komplexität reduziert. Statt jedes Mal neue Speziallösungen zu bauen, schafft MCP Ordnung und Wiederverwendbarkeit. Ob Dateizugriff, Webdienst oder Automatisierung – mit MCP lassen sich viele Dinge einfacher verknüpfen und für LLMs nutzbar machen.

Warum MCP nützlich ist

Sprachmodelle können Text und Bilder inhaltlich erfassen und auf Basis des Sprachmodell Wissens (antrainiertes Wissen) agieren. Dieses Wissen ist eine Limitation, die schnell erreicht ist. Beispielsweise weiß ein LLM nichts über aktuelle Ereignisse, da das Training des Sprachmodells meist Monate zuvor abgeschlossen wurde und keine aktuellen Ereignisse antrainiert sind, ergo weiß das LLM nichts über die Nachrichten oder das Wetter von heute.  

MCP hat das Potential diese Lücke zu schließen. Es verbindet ein Sprachmodell mit dem passenden Werkzeugkasten und wodurch die Limitation des statischen Wissens aufgelöst werden kann.

Einem Sprachmodell kann beispielsweise Zugang zu einer Suchmaschine und zu einem Wetterdienst gegeben werden, sodass das LLM diese Werkzeuge aktiv nutzen kann, um die aktuellen Nachrichten oder das Wetter von heute abzufragen und diese Informationen zu nutzen. Diese Kombination von LLM und Werkzeug kann beispielsweise für ein tägliches Morgenupdate genutzt werden, in dem das LLM die wichtigsten Nachrichten und einen Wetterbericht für heute zusammenfasst.

Ein weiterer, etwas spezieller aber nützlicher, Anwendungsfall ist der Einsatz eines MCP-Servers zur Optimierung von Archivprozessen.

Auch im NLWeb (Natural Language Web) ist das MCP Protokoll ein fester Bestandteil und spielt seine Stärken aus.

Die Architektur hinter MCP

Das Model Context Protocol (MCP) folgt einem typischen Client-Server-Modell. Das Herzstück ist der MCP-Host, ein Sprachmodell, das Befehle ausführt. Der MCP-Client fungiert als Schnittstelle und leitet Anfragen zwischen dem Modell und dem MCP-Server weiter. Ein MCP-Server kann eine Vielzahl von Tools bereit stellen, wie beispielsweise Funktionen, Dateien oder APIs. Diese Tools ermöglichen es dem Modell, auf externe Ressourcen wie Datenbanken oder Dienste zuzugreifen. Prompts definieren spezifische Aufgaben für das Modell, und Tools sind ausführbare Funktionen, die das Modell nutzen kann, um diese Aufgaben zu erfüllen.

• MCP-Host – das Modell, das Aufgaben ausführt
• MCP-Client – vermittelt zwischen Modell und Server
• MCP-Server – stellt Werkzeuge in Form von Funktionen, Dateien oder APIs bereit
• Ressourcen – Datenbanken, Dateien oder Dienste
• Prompts – vorgefertigte Aufgaben
• Tools – ausführbare Funktionen

Das Model Context Protocol nutzt eine Client-Server-Struktur, bei der eine zentrale Anwendung gleichzeitig mit mehreren Servern kommunizieren kann.

So wie USB-C verschiedene Funktionen über einen einzigen Anschluss bündelt, etwa Laden, Daten und Bildsignal, verbindet MCP Modelle mit Daten, Tools und Diensten über eine einheitliche Schnittstelle.

Vorteile des MCP Standards

Der MCP-Standard bietet eine Vielzahl praktischer Vorteile, die die Zukunft der LLM-basierten Softwareentwicklung effizienter und modularer gestalten. Diese Standardisierung ermöglicht es, aufwendige Speziallösungen und starre Softwareimplementierungen aufzulösen, was zu einer agileren Entwicklung und Nutzung der Software führt.
Im Folgenden sind die wesentlichen Vorteile des MCP-Standards aufgeführt:

• Standardisierung – Das Prinzip „Einmal einrichten, mehrfach nutzen“ steht im Mittelpunkt. Ähnlich wie bei USB-C passen alle Komponenten nahtlos zusammen, unabhängig von Hersteller oder Anbieter. Diese Vereinheitlichung reduziert den Integrationsaufwand erheblich und fördert die Wiederverwendbarkeit von Modulen und Diensten.
• Flexibilität – Modelle, Tools oder Anbieter können teilweise oder vollständig ausgetauscht werden, da alle dieselbe „Sprache“ (MCP) sprechen. Diese Flexibilität ermöglicht es, sich schnell an neue Anforderungen oder Technologien anzupassen, ohne das gesamte System überarbeiten zu müssen.
• Sicherheit – Der Zugriff auf Tools und Daten kann präzise gesteuert und abgekapselt werden. Durch definierte Schnittstellen und Berechtigungen wird sichergestellt, dass nur autorisierte Komponenten auf sensible Informationen und Funktionen zugreifen können.
• Modularität – MCP-Server sind kleine, in sich geschlossene Bausteine, die sich leicht kombinieren, austauschen und erweitern lassen. Diese modulare Architektur fördert die Entwicklung skalierbarer und wartungsfreundlicher Systeme, da einzelne Komponenten unabhängig voneinander aktualisiert oder ersetzt werden können.

Durch diese Vorteile ermöglicht der MCP-Standard eine effizientere, sicherere und flexiblere Nutzung von LLM-basierten Anwendungen und Diensten.

Was MCP-Server leisten können

Im Kern erweitert ein MCP-Server das Sprachmodell um konkrete Fähigkeiten.
Einfach gesagt sind MCP-Server Werkzeuge, die das Sprachmodell verwenden kann, wenn es ihm von Nutzen ist.

Typische Anwendungsfälle die ein MCP-Server abdecken kann:

• Zugriff auf definierte Ordner, Dateien oder direkt auf eine Datenbank
• Verbindung mit Webdiensten wie z.B. die Suchmaschine Google
• Nutzung von Anwendungen wie Outlook oder Teams
• Anwendung vordefinierter Prompts und Workflows

Beispiele für beliebte MCP-Server

Die Github-Seite punkpeye/awesome-mcp-servers listet viele nützliche Server, die sofort genutzt werden können. 

Hier einige Beispiele:

Diese Server funktionieren nach dem gleichen Prinzip wie Adapter – einstecken und loslegen.

Diese Vielfalt an MCP-Servern zeigt, wie flexibel und erweiterbar das Model Context Protocol ist. Die Community entwickelt ständig neue Server, die auf spezifische Bedürfnisse zugeschnitten sind und die Möglichkeiten von LLMs erweitern.

Erste Schritte mit MCP-Servern

Für den schnellen Einstieg

Wer einfach loslegen möchte, nutzt eine Anwendung wie Claude Desktop. Damit kann man eigene Dateien mit dem Modell verknüpfen. Die Anleitung auf modelcontextprotocol.io/quickstart/user hilft dabei.

Hier eine Beispiel-Konfiguration der claude_desktop_config.json Datei, die einen Github- und Brave-Search-MCP-Server einbindet und direkt nutzbar macht.

{
  "mcpServers": {
    "brave-search": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "BRAVE_API_KEY",
        "mcp/brave-search"
      ],
      "env": {
        "BRAVE_API_KEY": "YOUR_ACTUAL_BRAVE_API_KEY"
      }
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_ACTUAL_GITHUB_TOKEN"
      }
    }
  }
}

Für technisch Interessierte

Der MCP-Server Quickstart zeigt, wie man selbst einen Server baut. Alles was es braucht ist Python oder TypeScript Erfahrung, das offizielle SDK und etwas Neugier.

Folgender Code stellt einen minimalen MCP-Server dar, der einem LLM dazu dienen kann, Zeiten für verschiedene Zeitzonen korrekt umzurechnen.

#!/usr/bin/env python3
"""Minimal MCP-Server - Timezone Converter"""
import json
import sys
from datetime import datetime
import pytz
def convert_timezone(time_str, from_tz, to_tz):
    """Convert time between timezones"""
    dt = datetime.strptime(time_str, "%Y-%m-%d %H:%M")
    dt_with_tz = pytz.timezone(from_tz).localize(dt)
    converted = dt_with_tz.astimezone(pytz.timezone(to_tz))
    return {
        "original": f"{time_str} {from_tz}",
        "converted": f"{converted.strftime('%Y-%m-%d %H:%M')} {to_tz}",
        "offset": converted.strftime('%z')
    }
def handle_request(request):
    """Route and handle MCP requests"""
    method = request["method"]
    params = request.get("params", {})
    
    if method == "initialize":
        return {
            "protocolVersion": "0.1.0",
            "capabilities": {"tools": {}},
            "serverInfo": {"name": "timezone-converter", "version": "1.0.0"}
        }
    
    elif method == "tools/list":
        return {
            "tools": [{
                "name": "convert_timezone",
                "description": "Convert time between timezones",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "time": {"type": "string", "description": "Time 'YYYY-MM-DD HH:MM'"},
                        "from_tz": {"type": "string", "description": "Source timezone"},
                        "to_tz": {"type": "string", "description": "Target timezone"}
                    },
                    "required": ["time", "from_tz", "to_tz"]
                }
            }]
        }
    
    elif method == "tools/call":
        if params.get("name") != "convert_timezone":
            raise Exception(f"Unknown tool: {params.get('name')}")
        
        args = params["arguments"]
        try:
            result = convert_timezone(args["time"], args["from_tz"], args["to_tz"])
            return {"content": [{"type": "text", "text": json.dumps(result, indent=2)}]}
        except Exception as e:
            raise Exception(f"Tool error: {str(e)}")
    
    else:
        raise Exception(f"Unknown method: {method}")
def main():
    """Main server loop"""
    while True:
        try:
            line = sys.stdin.readline()
            if not line:
                break
            
            request = json.loads(line.strip())
            
            try:
                response = handle_request(request)
                output = {
                    "jsonrpc": "2.0",
                    "id": request.get("id"),
                    "result": response
                }
            except Exception as e:
                output = {
                    "jsonrpc": "2.0",
                    "id": request.get("id"),
                    "error": {"code": -32000, "message": str(e)}
                }
            
            print(json.dumps(output))
            sys.stdout.flush()
            
        except json.JSONDecodeError:
            error = {
                "jsonrpc": "2.0",
                "id": None,
                "error": {"code": -32700, "message": "Parse error"}
            }
            print(json.dumps(error))
            sys.stdout.flush()
if __name__ == "__main__":
    main()

Deep Dive Tutorial

Für einen tieferen Einblick, zeigt Mahesh Murag von Anthropic in folgendem Video einen detailierten Einblick in den Aufbau von Agenten mit Model Context Protocol. 

Mit dem Laden des Videos akzeptieren Sie die Datenschutzerklärung von YouTube.
Mehr erfahren

Video laden

YouTube immer entsperren

Fazit

Das Model Context Protocol bringt Ordnung und Modularität in die Welt der Sprachmodelle. Statt ständig neue Schnittstellen zu bauen, sorgt MCP für einen stabilen Standard. MCP-Server machen LLMs nicht nur schlauer, sondern auch handlungsfähig. Mit MCP lassen sich Daten, Dienste und Modelle sauber verbinden, unabhängig ob im Unternehmen, im Projekt oder für alltägliche Aufgaben. Diese Standardisierung und die damit einhergehende Flexibilität bedeuten, dass sich LLM-basierte Lösungen leichter skalieren und an neue Anforderungen anpassen lassen. Zudem fördert MCP die Entwicklung einer lebendigen Community, in der Entwickler und Unternehmen ihre eigenen Server und Tools teilen und gemeinsam weiterentwickeln können. Letztlich ebnet MCP den Weg für eine Zukunft, in der Sprachmodelle noch tiefer in unseren digitalen Alltag integriert sind und uns bei einer Vielzahl von Aufgaben unterstützen können.