Zum Inhalt springen
Helped by a Nerd

KI-Tools

MCP-Server erstellen – Einstieg für Anfänger

Veröffentlicht am Lesezeit: 5 Min.

  • #mcp
MCP-Server erstellen – Einstieg für Anfänger
Inhalt

Du weißt schon, was ein MCP-Server ist, und willst jetzt endlich selbst einen bauen? Gute Idee. In diesem Tutorial erstellst du von null einen funktionierenden MCP-Server in Python, der ein einziges Tool bereitstellt. Du brauchst keine Erfahrung mit Netzwerkprogrammierung – nur Python 3.10 oder neuer und zehn Minuten Zeit.

Was du brauchst

Du brauchst keine externe API und keinen Cloud-Account. Folgendes reicht:

  • Python 3.10 oder höher – prüfe mit python --version
  • uv – ein moderner Python-Paketmanager (schneller als pip, von Astral)
  • Ein Terminal und ein Texteditor

Kein uv installiert? Auf macOS/Linux:

curl -LsSf https://astral.sh/uv/install.sh | sh

Auf Windows (PowerShell):

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

Starte danach dein Terminal neu, damit uv gefunden wird.

Grundgerüst eines MCP-Servers

Ein MCP-Server ist im Kern ein Programm, das über das standardisierte MCP-Protokoll (JSON-RPC 2.0 über stdio) Tools, Ressourcen oder Prompts anbietet. Das klingt komplizierter als es ist – das offizielle Python-SDK nimmt dir den ganzen Protokoll-Kram ab.

Das offizielle Python-SDK heißt mcp und wird als mcp[cli] installiert.

Leg jetzt dein Projekt an:

# Neues Verzeichnis erstellen und initialisieren
uv init mein-server
cd mein-server

# Virtuelle Umgebung erstellen und aktivieren
uv venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate

# Das offizielle MCP-SDK installieren (Version 1.2.0 oder neuer erforderlich)
uv add "mcp[cli]"

# Serverdatei anlegen
touch server.py             # Windows: new-item server.py

Deine Projektstruktur sieht jetzt so aus:

mein-server/
├── .venv/
├── pyproject.toml
└── server.py

Öffne server.py und füge diese Basis ein:

from mcp.server.fastmcp import FastMCP

# Server-Instanz anlegen – "mein-server" ist der Name, den Clients sehen
mcp = FastMCP("mein-server")

FastMCP ist die High-Level-Klasse aus dem offiziellen SDK. Sie liest deine Python-Typ-Hints und Docstrings aus und generiert daraus automatisch die Tool-Definitionen, die ein MCP-Client braucht. Du schreibst normale Python-Funktionen – den Rest erledigt das SDK.

Ein erstes Tool bereitstellen

Ein Tool ist eine Funktion, die der KI-Client (z.B. Claude) aufrufen darf. Du registrierst es mit dem @mcp.tool()-Decorator.

Hier ist das vollständige server.py für ein minimales Beispiel – ein Tool, das einen Namen entgegennimmt und ihn rückwärts ausgibt:

from mcp.server.fastmcp import FastMCP

# Server-Instanz
mcp = FastMCP("mein-server")


@mcp.tool()
def name_umkehren(name: str) -> str:
    """Kehrt einen eingegebenen Text zeichenweise um.

    Args:
        name: Der Text, der umgekehrt werden soll.
    """
    return name[::-1]


if __name__ == "__main__":
    mcp.run(transport="stdio")

Ein paar wichtige Details:

  • @mcp.tool() registriert die Funktion als aufrufbares Tool.
  • Der Docstring wird als Beschreibung ans Modell weitergegeben – schreib ihn klar, denn Claude entscheidet anhand dieser Beschreibung, wann es das Tool benutzt.
  • Typ-Hints (name: str) definieren das Schema des Tools. FastMCP generiert daraus automatisch das JSON-Schema für den Client.
  • mcp.run(transport="stdio") startet den Server über Standard-I/O – das ist der normale Modus für lokale Server.
  • Wichtig: Schreib niemals print() in einen stdio-Server. Das korrumpiert den JSON-RPC-Stream. Nutze stattdessen import sys; print("...", file=sys.stderr) oder das logging-Modul für Debug-Ausgaben.

Den Server lokal testen

Du kannst den Server mit dem MCP Inspector testen – einem offiziellen Entwicklungswerkzeug, das mit dem SDK mitgeliefert wird. Es öffnet eine Web-Oberfläche, über die du deine Tools direkt aufrufen kannst, ohne Claude Desktop zu konfigurieren.

# Im Projektordner, mit aktivierter venv:
mcp dev server.py

Der Inspector startet und gibt dir eine lokale URL aus (meistens http://localhost:5173). Öffne sie im Browser. Du siehst:

  • eine Liste der registrierten Tools (hier: name_umkehren)
  • ein Formular, in das du den Parameter name eingibst
  • die Antwort deines Servers in Echtzeit

Wenn name_umkehren mit dem Input "Hallo" den Wert "ollaH" zurückgibt, läuft dein Server korrekt.

Alternativ: direkt mit uv run starten

uv run server.py

Der Server wartet dann auf JSON-RPC-Nachrichten über stdin. Das ist der Modus, den Claude Desktop später nutzt – für schnelle Tests ist der Inspector aber deutlich komfortabler.

Den Server mit Claude Desktop verbinden

Sobald dein Server funktioniert, kannst du ihn in Claude Desktop einbinden. Öffne die Konfigurationsdatei:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %AppData%\Claude\claude_desktop_config.json

Trag deinen Server ein:

{
  "mcpServers": {
    "mein-server": {
      "command": "uv",
      "args": [
        "--directory",
        "/ABSOLUTER/PFAD/ZU/mein-server",
        "run",
        "server.py"
      ]
    }
  }
}

Ersetze /ABSOLUTER/PFAD/ZU/mein-server durch den echten Pfad auf deinem System (pwd auf Mac/Linux, cd auf Windows). Starte Claude Desktop neu. Das Tool name_umkehren steht Claude jetzt zur Verfügung.

Wie du den Server dauerhaft mit Claude verbindest und mehrere Tools strukturierst, erklärt der Artikel MCP-Server mit Claude verbinden.

Nächste Schritte

Du hast jetzt einen laufenden MCP-Server mit einem eigenen Tool. Was du als nächstes ausbauen kannst:

  • Mehr Tools hinzufügen: Füge weitere Funktionen mit @mcp.tool() hinzu – z.B. einen Taschenrechner, einen Datei-Leser oder eine API-Abfrage.
  • Ressourcen bereitstellen: Mit @mcp.resource() kannst du Dateien oder Daten als lesbare Kontexte anbieten (ähnlich wie Datei-Attachments).
  • Fehlerbehandlung: Wirf in deinen Tools normale Python-Exceptions – FastMCP übersetzt sie automatisch in MCP-Fehlermeldungen.
  • Produktiv gehen: Für den Einsatz im Team oder in der Cloud gibt es den Streamable-HTTP-Transport statt stdio.

Das offizielle SDK und alle Beispiele findest du auf modelcontextprotocol.io und im GitHub-Repository der MCP-SDKs.

Wie es weitergeht

FAQ

Wie erstelle ich einen MCP-Server? Du installierst das offizielle Python-SDK (uv add "mcp[cli]"), erstellst eine FastMCP-Instanz und registrierst deine Funktionen mit dem @mcp.tool()-Decorator. Mit mcp.run(transport="stdio") startest du den Server. Die vollständige Anleitung findest du oben in diesem Artikel.

Welche Programmiersprache brauche ich für einen MCP-Server? Du kannst Python oder TypeScript verwenden – beide haben ein offizielles SDK. Dieser Artikel zeigt Python, weil der Einstieg dort am schnellsten geht. Das TypeScript-SDK heißt @modelcontextprotocol/sdk und wird über npm installiert.

Wie teste ich meinen MCP-Server lokal? Am einfachsten mit dem MCP Inspector: mcp dev server.py startet eine Web-Oberfläche, in der du alle registrierten Tools direkt aufrufen kannst – ohne Claude Desktop zu benötigen. Der Inspector ist Teil des offiziellen mcp[cli]-Pakets.

Muss mein MCP-Server immer laufen? Nein. Bei lokalen Servern über stdio startet der MCP-Client (z.B. Claude Desktop) den Server-Prozess bei Bedarf selbst und beendet ihn wieder. Du musst nichts im Hintergrund laufen lassen.

Kann ich externe APIs in meinem Tool aufrufen? Ja. Du kannst in deinen Tool-Funktionen beliebige Python-Bibliotheken nutzen – z.B. httpx für HTTP-Anfragen oder sqlite3 für lokale Datenbanken. Installiere sie einfach mit uv add <paketname>.

Mehr zum Thema

Newsletter

Kein KI-Update mehr verpassen

Neue Tools, Anleitungen und Deals – einmal pro Woche direkt in dein Postfach.

100% kostenlos, jederzeit kündbar.