Du nutzt Claude oder ChatGPT jeden Tag. Du bist gut darin — Prompts, Nachfragen, der ganze Tanz. Aber jedes Mal, wenn du Daten aus dem CRM, dem Projekttracker oder der internen Datenbank deiner Firma brauchst, wirst du zum menschlichen USB-Kabel: Kopieren aus Browser-Tab A, Einfügen in Chatbot-Tab B, wiederholen, bis die Seele den Körper verlässt.

Hier ist die Sache, die dir kein Tutorial direkt ins Gesicht sagt: Die Lücke zwischen "KI, die das Internet kennt" und "KI, die dein Unternehmen kennt" ist genau eine Python-Datei breit. Kein Plattformwechsel. Kein sechsstelliger Beratervertrag. Eine einzige Datei mit einem Decorator und einem Docstring. Das Protokoll existiert bereits, jeder große KI-Anbieter hat es übernommen, und du kannst es an einem Nachmittag anschließen. Ich zeig dir wie.

Warum die naheliegenden Lösungen nicht funktionieren

"Nimm doch einfach die API" — toller Ratschlag, nur hat deine KI leider keine Hände. Sie kann die REST-API deines Unternehmens (eine URL, die Daten zurückgibt, wenn man nett fragt) nicht selbständig aufrufen. Du könntest die API-Doku in den Chat pasten, aber das frisst dein Context Window auf — also wie viel Text die KI gleichzeitig "sehen" kann, ihr Arbeitsspeicher — und du machst immer noch die Kopierarbeit. Zapier-artige Integrationen gibt es auch, aber die sind starr: vordefinierte Trigger, vordefinierte Aktionen, und eine Preisseite, bei der dein Controller Schnappatmung bekommt.

Was du wirklich brauchst, ist eine Möglichkeit, deine KI interne Tools direkt entdecken und aufrufen zu lassen — ohne dass du als Mittelsperson fungierst.

MCP: Der Standard, der das Problem gelöst hat

MCP (Model Context Protocol) ist ein universeller Stecker-Standard für KI-Tools — denk an USB-C, nur für die Verbindung zwischen KI und deinen Daten. Anthropic hat es im November 2024 als Open Source veröffentlicht. Bis März 2026 erreichte es 97 Millionen monatliche SDK-Downloads. OpenAI, Google und Microsoft haben es alle übernommen. Stand 26. April 2026 sind über 17.000 MCP-Server in den Registries indexiert.

Mit dem Python SDK kannst du einen funktionierenden Server in einer einzigen Datei bauen. So geht's.

Schritt 1: SDK installieren

Du brauchst Python 3.10+ und entweder uv (Anthropics empfohlener Paketmanager) oder normales pip.

# Option A: uv (empfohlen)
uv init my-mcp-server && cd my-mcp-server
uv add "mcp[cli]" httpx

# Option B: pip
pip install "mcp[cli]" httpx

httpx ist eine Python-HTTP-Bibliothek — damit holt dein Server Daten von externen APIs. Wenn deine Daten in einer Datenbank liegen, tausch es gegen deinen Datenbanktreiber aus.

Schritt 2: Den Server schreiben

Erstelle server.py. Hier ist ein vollständiger MCP-Server, der Wetterwarnungen vom US National Weather Service abruft — eine echte API, kein API-Key nötig, perfekt zum Lernen:

from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP

# FastMCP — ein High-Level-Wrapper, der
# normale Python-Funktionen in MCP-Tools verwandelt
mcp = FastMCP("weather")

NWS_API_BASE = "https://api.weather.gov"

async def make_request(url: str) -> dict[str, Any] | None:
    headers = {
        "User-Agent": "mcp-weather-demo/1.0",
        "Accept": "application/geo+json",
    }
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(
                url, headers=headers, timeout=30.0
            )
            response.raise_for_status()
            return response.json()
        except Exception:
            return None

@mcp.tool()
async def get_alerts(state: str) -> str:
    """Get active weather alerts for a US state.

    Args:
        state: Two-letter US state code (e.g. CA, NY)
    """
    data = await make_request(
        f"{NWS_API_BASE}/alerts/active/area/{state}"
    )
    if not data or "features" not in data:
        return "No alerts found."

    alerts = []
    for feature in data["features"][:5]:
        props = feature["properties"]
        alerts.append(
            f"Event: {props.get('event', 'Unknown')}\n"
            f"Area: {props.get('areaDesc', 'Unknown')}\n"
            f"Severity: {props.get('severity', 'Unknown')}"
        )
    return "\n---\n".join(alerts) or "No active alerts."

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

Etwa 40 Zeilen echter Code. Der @mcp.tool()-Decorator — eine Python-Kurzform, die deine Funktion als KI-aufrufbares Tool registriert — erledigt die Schwerstarbeit. FastMCP liest deine Type Hints (state: str) und den Docstring (die Beschreibung in dreifachen Anführungszeichen), um automatisch Tool-Definitionen zu generieren, die die KI versteht.

Das ist das Kernmuster. Jeder MCP-Server, den du je gesehen hast — Slack, GitHub, Figma, alle 17.000+ — ist dieses Grundgerüst mit mehr Endpoints.

Schritt 3: Mit Claude Desktop verbinden

Claude Desktop liest eine JSON-Konfigurationsdatei (eine Einstellungsdatei in einem bestimmten Format), um zu wissen, welche MCP-Server gestartet werden sollen. Du findest sie hier:

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

Erstelle oder bearbeite sie:

{
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": [
        "--directory",
        "/absoluter/pfad/zu/my-mcp-server",
        "run",
        "server.py"
      ]
    }
  }
}

Ersetze /absoluter/pfad/zu/my-mcp-server mit dem tatsächlichen vollständigen Pfad. Relative Pfade funktionieren nicht — daran scheitert beim ersten Mal jeder.

Starte Claude Desktop neu. Achte auf das Hammer-Symbol unten rechts im Chat-Eingabefeld. Klick drauf — du solltest get_alerts in der Liste sehen. Falls nicht, prüfe die Logs unter ~/Library/Logs/Claude/mcp*.log auf macOS.

Schritt 4: Claude etwas fragen

Tippe: "Gibt es gerade Wetterwarnungen in Kalifornien?"

Claude erkennt, dass es ein get_alerts-Tool hat, fragt um Erlaubnis es aufzurufen, pingt deinen Server an und antwortet mit Live-Daten des NWS, auf die es vor fünf Minuten noch keinen Zugriff hatte.

Das ist der Aha-Moment. Dein Chatbot hat gerade aufgehört, generisch zu sein.

Schritt 5: Die Wetter-API durch deine eigene ersetzen

Jetzt tausch make_request gegen die API aus, die dein Team nutzt — Jira, Linear, euer internes Dashboard. Wenn sie einen Endpoint hat, der Daten zurückgibt, ist sie eine Funktion davon entfernt, ein KI-Tool zu werden. Das Muster ist immer:

  1. Schreib eine async-Funktion, die Daten holt
  2. Dekoriere sie mit @mcp.tool()
  3. Schreib einen klaren Docstring (warum das wichtig ist, kommt gleich)
  4. Füg es zur Config hinzu, Neustart

Ein paar Design-Prinzipien, die nützliche MCP-Tools von frustrierenden unterscheiden: Benenne deine Tools mit Verb-Nomen-Paaren (get_alerts, search_tickets, create_issue), damit das Modell die Absicht allein am Namen erkennen kann. Halte jedes Tool auf eine Aktion fokussiert — eine Funktion, die abruft, filtert und zurückschreibt, sind drei Tools, die sich als eines ausgeben. Und beim Parameter-Design: Bevorzuge explizite, typisierte Argumente statt Allzweck-Strings; state: str mit einem Docstring, der "Zweibuchstabiger US-Staatscode" sagt, gibt dem Modell genug, um seine eigene Eingabe zu validieren.

Fallstricke, die dich erwischen werden

1. Deine Tool-Beschreibung IST das Produkt

Eine Studie der Queen's University vom Februar 2026 hat 856 MCP-Tools aus 103 Servern analysiert. Ergebnis: 97,1 % der Tool-Beschreibungen hatten mindestens einen Qualitätsmangel. 56 % schafften es nicht mal, ihren Zweck zu formulieren. Als die Forscher die Beschreibungen verbesserten, stieg die Erfolgsrate um +5,85 Prozentpunkte. Dein Docstring ist keine Dokumentation — er ist die Benutzeroberfläche, die deine KI liest. Schreib ihn wie eine Produktspezifikation: Zweck, Parametererklärungen, Einschränkungen, Beispiele.

2. Niemals print() auf stdout

Bei stdio-basierten Servern (das ist, was Claude Desktop nutzt) korrumpiert die Ausgabe auf stdout die JSON-RPC-Nachrichten — das Protokoll, über das KI und Server kommunizieren. Dein Server bricht lautlos zusammen und du starrst 45 Minuten ins Leere. Verwende print("debug", file=sys.stderr) oder Pythons logging-Modul.

3. Security ist DEIN Job

MCP hat keine eingebaute Authentifizierung für lokale Server. Das ist in Ordnung, solange er per stdio auf deinem Laptop läuft — nur ein lokaler Prozess. Aber in dem Moment, in dem du überlegst, ihn per HTTP zu exponieren: Stopp. Die OWASP MCP Top 10, veröffentlicht Anfang 2026, existieren, weil Leute diesen Schritt übersprungen haben. Allein im Januar–Februar 2026 wurden über dreißig CVEs gegen MCP-Tooling gemeldet. FastMCP selbst hatte eine Command-Injection-Schwachstelle (CVE-2025-64340, offengelegt Ende 2025) in allen Versionen unter 3.2.0.

Wenn dein Server auf interne APIs zugreift, behandle ihn wie jeden anderen Backend-Service: Validiere jede Eingabe, die das Modell schickt (es wird Parameterwerte halluzinieren — rechne fest damit), erzwinge Least-Privilege-Zugriff, sodass jedes Tool nur die Daten erreichen kann, die es braucht, und pinne deine Abhängigkeiten. Lokales stdio ist der einzige sichere Standard, bis du Authentifizierung sauber gelöst hast.

4. Der Config-Pfad muss absolut sein

Relative Pfade in claude_desktop_config.json scheitern lautlos. Kein Fehler, kein Log, nur ein fehlendes Hammer-Symbol und ein Entwickler, der langsam den Glauben verliert. Verwende /Users/deinname/... auf macOS — Tilde-Expansion ist hier unzuverlässig.

Was du jetzt tun kannst

Du besitzt ein wiederholbares Muster. Jede API, die dein Team bereits nutzt — Projekttracker, CRM, internes Dashboard, Datenbank — ist eine Python-Datei davon entfernt, etwas zu werden, das deine KI direkt abfragen kann. Keine Warteliste für Vendor-Integrationen. Keine Zapier-Steuer. Kein Tab-Wechsel-Kopieren mehr wie im Jahr 2019.

Die Mauer zwischen "KI, die das Internet kennt" und "KI, die dein Unternehmen kennt" hat jetzt eine Tür. Und du hast sie in weniger Zeilen gebaut als eine typische Config-Datei.