Eigenen MCP-Server erstellen

Was dieser Artikel über MCP-Server behandelt

• Wie ein MCP-Server aufgebaut ist.
• Wie man Tools und Ressourcen definiert.
• Wie Transport über stdio und HTTP funktioniert.
• Wie man einen Server in Python oder TypeScript umsetzt.
• Bereitstellung, Sicherheit und typische Stolpersteine.

Einleitung: Eigenen MCP-Server erstellen

MCP-Server sind das Rückgrat modularen Agenten-Ökosystems. Sie stellen Werkzeuge und Daten bereit, die KI-Agenten nutzen können. Wer einen eigenen MCP-Server baut, kann interne Datenbanken, APIs, Dateisysteme oder Spezialwerkzeuge für Agenten zugänglich machen, ohne den Agenten selbst anpassen zu müssen.

Der Bau eines Servers ist nicht schwierig. Ein paar Zeilen Code definieren Tools und Ressourcen. Die Herausforderung liegt weniger in der Technik als in der Sicherheit: Ein MCP-Server mit Dateisystem- oder Datenbankzugriff ist mächtig und muss gut abgesichert sein.

Warum brauche ich einen eigenen MCP-Server?

Fertige MCP-Server decken viele Standardwerkzeuge ab. Aber eigene Daten, interne APIs oder spezielle Abläufe brauchen maßgeschneiderte Server. Ein eigener Server ermöglicht:

• Anbindung interner Datenbanken,
• Bereitstellung firmeneigener APIs,
• Kapselung sicherheitskritischer Operationen,
• Wiederverwendung für mehrere Agenten,
• Klare Schnittstelle zwischen Agent und Infrastruktur.

MCP-Server kurz erklärt

Ein MCP-Server antwortet auf Anfragen eines MCP-Clients. Er teilt dem Client mit, welche Tools und Ressourcen er anbietet. Bei Bedarf führt er das gewünschte Tool aus oder liefert eine Ressource zurück. Kommunikation läuft über JSON-RPC.

Wichtige Begriffe:

• Tool: Ausführbare Funktion mit Input-Schema.
• Resource: Adressierbare Datenquelle.
• Prompt: Vordefinierte Nachrichtenvorlage.
• Capability: Fähigkeit, die der Server anmeldet.
• Transport: stdio oder HTTP/SSE.
• ServerInfo: Metadaten wie Name und Version.

Für wen ist ein MCP-Server gedacht?

• Für Entwickler, die interne Tools an Agenten anbinden wollen.
• Für Teams, die wiederverwendbare Werkzeuge bereitstellen.
• Für Sicherheitsverantwortliche, die Berechtigungen kontrollieren wollen.
• Für Architekten, die modulare KI-Systeme aufbauen.

Wichtige Begriffe rund um MCP-Server

• FastMCP: Einfaches Python-Framework für MCP-Server.
• mcp-sdk: Offizielle SDKs für Python und TypeScript.
• StdioServerTransport: Lokaler Transport über Prozess-Pipes.
• SSEServerTransport: HTTP-Transport für entfernte Clients.
• Pydantic: Validierung von Tool-Inputs in Python.

MCP-Server in Python mit FastMCP

FastMCP vereinfacht die Entwicklung stark:

from fastmcp import FastMCP

mcp = FastMCP('notizen-server')

@mcp.tool()
def suche_notiz(schluesselwort: str) -> str:
    """Sucht nach Notizen mit dem angegebenen Schluesselwort."""
    # Beispiel-Implementierung
    notizen = {
        'ollama': 'Ollama ist ein Tool für lokale KI.',
        'docker': 'Docker erleichtert die Bereitstellung.'
    }
    return notizen.get(schluesselwort, 'Keine Notiz gefunden.')

@mcp.resource('notizen://liste')
def notizen_liste() -> str:
    return 'Verfügbare Notizen: ollama, docker'

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

Der Server meldet das Tool und die Ressource. Ein Client kann beides aufrufen.

Tool-Definition

Tools brauchen ein klares Schema. In FastMCP helfen Python-Typ-Hinweise und Docstrings:

@mcp.tool()
def temperature_in_stadt(stadt: str) -> str:
    """Gibt die aktuelle Temperatur für eine Stadt zurück."""
    return f'22 Grad in {stadt}'

Der Docstring wird zum Modell gesendet, damit es versteht, wann es das Tool nutzt.

Transport wählen

stdio

Geeignet für lokale Prozesse. Der Client startet den Server als Unterprozess.

mcp.run(transport='stdio')

SSE

Geeignet für entfernte oder dauerhafte Verbindungen. Der Server bietet einen HTTP-Endpunkt.

mcp.run(transport='sse')

Bereitstellung

Python

python notizen-server.py

Oder in Docker:

services:
  mcp-notizen:
    build: .
    command: python notizen-server.py

Sicherheit

• Input-Validierung: Type-Hinweise und Pydantic-Validierung nutzen.
• Berechtigungen: Nur notwendige Operationen erlauben.
• Logging: Wer ruft was auf?
• Sandbox: Server in Container oder isolierter Umgebung laufen lassen.
• Menschliche Freigabe: Löschen, Schreiben oder externe Aufrufe nur bestätigt.

Typische Stolpersteine beim MCP-Server

• Schlechte Tool-Beschreibungen: Modell versteht nicht, wann es das Tool nutzen soll.
• Fehlende Fehlerbehandlung: Server bricht bei ungültigen Eingaben ab.
• Keine Versionierung: Schnittstellen ändern sich unbemerkt.
• Zu viele Rechte: Ein Server darf nicht alles können.
• Transport-Probleme: stdio vs. SSE je nach Einsatzfall wählen.
• Kein Monitoring: Nicht wissen, was der Agent aufruft.

Weiterführende Links und Infos

• BotServ.de MCP-Grundlagen
• BotServ.de KI-Agenten
• BotServ.de Coding-Agenten
• FastMCP
• MCP Spezifikation

FAQ: MCP-Server

Brauche ich TypeScript? Nein. Python funktioniert hervorragend mit FastMCP.

Kann ich mehrere Tools in einem Server haben? Ja. Ein Server kann beliebig viele Tools und Ressourcen anbieten.

Wie teste ich einen MCP-Server? Mit einem MCP-Client oder dem Inspector der MCP-SDK.

Laufen MCP-Server lokal? Ja, mit stdio oder SSE auf localhost.

Sind MCP-Server sicher? Nur so sicher wie ihre Berechtigungen und Validierung.

Quellen und weiterführende Literatur

• MCP: https://modelcontextprotocol.io/
• FastMCP: https://github.com/jlowin/fastmcp
• Python SDK: https://github.com/modelcontextprotocol/python-sdk

Zusammenfassung: Eigenen MCP-Server erstellen

Ein eigener MCP-Server macht interne Werkzeuge und Daten für KI-Agenten verfügbar. Mit FastMCP in Python oder den offiziellen SDKs ist der Einstieg schnell. Wichtig sind klare Tool-Schemata, gute Beschreibungen, Transportwahl und Sicherheit. Wer Berechtigungen, Validierung und Logging beachtet, bekommt ein robustes, wiederverwendbares Bindeglied zwischen Agent und Infrastruktur.