MCP-Grundlagen für KI-Agenten

Was dieser Artikel über MCP behandelt

• Was das Model Context Protocol ist und warum es wichtig ist.
• Wie MCP KI-Agenten mit externen Werkzeugen verbindet.
• Welche Komponenten Client, Server und Transport bilden.
• Wie ein einfacher MCP-Server aufgebaut wird.
• Vorteile, Grenzen und typische Stolpersteine.

Einleitung: MCP-Grundlagen für KI-Agenten

KI-Agenten müssen mit der Welt interagieren können. Sie müssen Dateien lesen, APIs aufrufen, Datenbanken abfragen oder Befehle ausführen. Bisher war jede dieser Verbindungen projektspezifisch. Das Model Context Protocol, kurz MCP, will das ändern. Es ist ein offener Standard, der Agenten und Werkzeuge standardisiert verbindet.

MCP funktioniert wie eine universelle Steckdose. Ein Agent spricht MCP, ein Werkzeug bietet einen MCP-Server. So lassen sich Tools und Agenten kombinieren, ohne dass jede Verbindung neu programmiert wird. Wer Agenten baut, profitiert von einem wachsenden Ökosystem an MCP-Servern.

Warum brauche ich MCP?

Bisher musste jede Agenten-Anwendung eigene Adapter für Tools schreiben. Ein Discord-Tool, ein Datenbank-Tool, ein Dateisystem-Tool - alles eigene Schnittstellen. MCP reduziert diesen Aufwand. Der Agent spricht MCP, der Server implementiert das Werkzeug. Vorteile:

• Wiederverwendbarkeit: Ein Server funktioniert für viele Clients.
• Austauschbarkeit: Server lassen sich leicht tauschen.
• Sicherheit: Klare Protokolle und Berechtigungen.
• Offenheit: Keine Herstellerbindung.
• Flexibilität: Neue Tools lassen sich schnell integrieren.

MCP kurz erklärt

MCP basiert auf einem Client-Server-Modell. Der Client ist die KI-Anwendung, der Server stellt Ressourcen und Werkzeuge bereit. Kommunikation läuft über JSON-RPC.

Wichtige Begriffe:

• Host: Die Anwendung, die den Agenten ausführt.
• Client: Verbindung des Hosts zu einem MCP-Server.
• Server: Stellt Tools, Ressourcen und Prompts bereit.
• Tool: Funktion, die der Agent aufrufen kann.
• Resource: Daten, die der Agent abfragen kann.
• Prompt: Vordefinierte Eingaben für das Modell.
• Transport: Übertragungsweg, z. B. stdio oder SSE.

Für wen ist MCP gedacht?

• Für Entwickler, die Agenten mit Werkzeugen verbinden.
• Für Teams, die eigene Tools bereitstellen wollen.
• Für Architekten, die modulare KI-Systeme planen.
• Für alle, die Herstellerbindung vermeiden wollen.

Wichtige Begriffe rund um MCP

• JSON-RPC: Standard für entfernte Prozeduraufrufe.
• stdio: Transport über Standard-Ein- und Ausgabe.
• SSE: Server-Sent Events für HTTP-Transport.
• Capability: Fähigkeit, die ein Server anbietet.
• Schema: Beschreibung von Tools und Ressourcen.
• StdioClientTransport: Verbindung über Prozess-Pipes.

Aufbau eines MCP-Systems

1. Host: Startet den Agenten und MCP-Clients.
2. Clients: Verbinden sich mit MCP-Servern.
3. Servern: Stellen Tools und Ressourcen bereit.
4. Model: Wählt Tools aus und führt sie über die Clients aus.
5. Transport: Sorgt für die Kommunikation.

Praxisbeispiel: Einfacher MCP-Server in Python

from mcp.server import Server
from mcp.types import TextContent

server = Server('mein-server')

@server.tool()
def addiere(a: int, b: int) -> TextContent:
    return TextContent(text=str(a + b))

@server.resource('greeting://welt')
def greeting() -> TextContent:
    return TextContent(text='Hallo, Welt!')

if __name__ == '__main__':
    server.run()

Der Server bietet ein Tool und eine Ressource. Ein MCP-Client kann beides aufrufen.

Praxisbeispiel: Client in Python

from mcp import ClientSession, StdioServerTransport

transport = StdioServerTransport('python', ['mein_server.py'])
async with ClientSession(transport) as session:
    tools = await session.list_tools()
    ergebnis = await session.call_tool('addiere', {'a': 2, 'b': 3})
    print(ergebnis)

Der Client startet den Server als Unterprozess und ruft das Tool auf.

Sicherheit bei MCP

• Berechtigungen: Server sollten nur das erlauben, was nötig ist.
• Sandbox: Server-Prozesse isolieren.
• Authentifizierung: Bei HTTP-Transport wichtig.
• Audit: Protokollieren, welche Tools aufgerufen werden.
• Menschliche Freigabe: Kritische Operationen nicht automatisch ausführen.

Typische Stolpersteine bei MCP

• Fehlende Tool-Beschreibung: Modelle brauchen gute Schemata.
• Komplexe Fehlerbehandlung: Netzwerk- und Prozessfehler.
• Sicherheit unterschätzen: Ein Server mit Dateisystemzugriff ist mächtig.
• Transport-Wahl: stdio für lokal, SSE für entfernt.
• Versionskompatibilität: MCP ist noch jung und entwickelt sich.
• Debugging schwierig: Asynchrone Kommunikation erschwert Tracing.

Weiterführende Links und Infos

• BotServ.de KI-Agenten
• BotServ.de Tool-Calling
• BotServ.de Coding-Agenten
• MCP Spec
• MCP SDK Python

FAQ: MCP

Ist MCP nur für Claude? Nein. Es ist ein offener Standard, den verschiedene Clients nutzen können.

Brauche ich Python? Nein. Es gibt SDKs für TypeScript, Python und andere Sprachen.

Kann MCP nur lokal laufen? Nein. HTTP/SSE ermöglicht auch entfernte Server.

Sind MCP-Server sicher? Nur mit Berechtigungen, Sandbox und Audit. Sie haben direkten Zugriff auf Tools.

Was ist der Unterschied zu Funktion Calling? MCP standardisiert die Anbindung. Function Calling ist die Fähigkeit des Modells, Funktionen aufzurufen.

Quellen und weiterführende Literatur

• Model Context Protocol: https://modelcontextprotocol.io/
• Python SDK: https://github.com/modelcontextprotocol/python-sdk
• TypeScript SDK: https://github.com/modelcontextprotocol/typescript-sdk

Zusammenfassung: MCP-Grundlagen für KI-Agenten

MCP ist ein offener Standard, der KI-Agenten modular mit Werkzeugen verbindet. Client, Server und Transport bilden eine saubere Architektur. Python- und TypeScript-SDKs machen den Einstieg einfach. Wichtig sind gute Tool-Beschreibungen, Berechtigungen und Sicherheit. Wer MCP nutzt, kann Agenten bauen, die leicht mit neuen Fähigkeiten erweitert werden.