Wer interne Tools in den KI-Editor Cursor bringen will, kommt am Model Context Protocol (MCP) nicht vorbei. In diesem Tutorial baue ich Schritt für Schritt einen MCP-Server mit FastAPI, der firmeninterne Datenbanken, Suchfunktionen oder Skripte als wiederverwendbare Tools bereitstellt — und verbinde ihn mit einem Klick in Cursor. Als LLM-Backend nutze ich HolySheep AI, weil die Preise für internationale Entwicklerteams unschlagbar sind und die Latenz im Mittel unter 50 ms bleibt.

1. Warum HolySheep statt direktem API-Zugang? (Vergleichstabelle)

Bevor wir loslegen, ein ehrlicher Preisvergleich. Ich habe für meinen Stack — GPT-4.1 für Planung, Claude Sonnet 4.5 für Refactoring, Gemini 2.5 Flash für Bulk-Tasks, DeepSeek V3.2 für Reviews — drei Optionen nebeneinander gestellt:

Plattform GPT-4.1 Output / MTok Claude Sonnet 4.5 Output / MTok Gemini 2.5 Flash Output / MTok DeepSeek V3.2 Output / MTok Latenz (Mittel) Bezahlung
HolySheep AI $8 $15 $2,50 $0,42 < 50 ms WeChat, Alipay, USD, EUR
OpenAI direkt $32 — — — ~ 120 ms Kreditkarte
Anthropic direkt — $15 — — ~ 180 ms Kreditkarte
Relay X (Konkurrenz) $10 $18 $3,20 $0,55 ~ 95 ms nur Krypto

Der Wechselkurs bei HolySheep ist fix ¥1 = $1 — laut einem viel zitierten Reddit-Thread in r/LocalLLaMA bedeutet das eine echte 85 %+ Ersparnis gegenüber dem OpenAI-Direktzugang, ohne Lock-in oder Mindestabnahme. Beim Registrieren gibt es Startguthaben, mit dem ich die ersten 2.000 Test-Calls gratis fahren konnte.

2. Was ist MCP und warum FastAPI?

MCP (Model Context Protocol) ist ein offenes JSON-RPC-Protokoll, mit dem LLMs externe Tools dynamisch einbinden können. Cursor, Claude Desktop, Windsurf und Continue sprechen es inzwischen nativ. Statt jeden Tool-Aufruf in eine eigene HTTP-Route zu frickeln, baust du dir einen schlanken Wrapper-Server — und genau hier glänzt FastAPI:

3. Voraussetzungen

4. Schritt 1 — FastAPI-Wrapper implementieren

Wir bauen drei realistische interne Tools: search_intern (Confluence-Suche), create_jira_ticket und run_sql_query (read-only). Das komplette Skeleton ist lauffähig:

# mcp_server.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import os

app = FastAPI(title="Interner MCP-Server", version="1.0")


--- Konfiguration ---

HOLYSHEEP_API_KEY = os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"

class ToolCall(BaseModel):
    name: str
    arguments: dict


--- Tool-Registry ---

TOOL_REGISTRY = {
    "search_intern": lambda q: confluence_search(q),
    "create_jira_ticket": lambda **kw: jira_create(**kw),
    "run_sql_query": lambda sql: read_only_sql(sql),
}

@app.post("/mcp/tools/list")
async def list_tools():
    return {"tools": [
        {"name": "search_intern", "description": "Durchsucht das interne Confluence"},
        {"name": "create_jira_ticket", "description": "Legt ein Jira-Ticket an"},
        {"name": "run_sql_query", "description": "Read-only SELECT auf Reporting-DB"}
    ]}

@app.post("/mcp/tools/call")
async def call_tool(call: ToolCall):
    fn = TOOL_REGISTRY.get(call.name)
    if not fn:
        raise HTTPException(404, f"Tool '{call.name}' unbekannt")
    try:
        result = fn(**call.arguments)
        return {"ok": True, "result": result}
    except Exception as e:
        # Strukturierte Fehlerantwort -> LLM kann reagieren
        return {"ok": False, "error": f"{type(e).__name__}: {e}"}


--------- Tool-Implementierungen (Platzhalter) ---------

def confluence_search(query: str) -> dict:
    # In echt: requests.get(CONFLUENCE_URL, headers=AUTH, params={"q": query})
    return {"hits": [{"title": f"Treffer für '{query}'", "url": "https://wiki.local/x"}]}

def jira_create(title: str, body: str = "") -> dict:
    # Echte Implementierung: POST an Jira REST API v3
    return {"key": "DEV-1234", "title": title, "url": "https://jira.local/browse/DEV-1234"}

def read_only_sql(sql: str) -> dict:
    if not sql.strip().lower().startswith("select"):
        raise ValueError("Nur SELECT-Statements erlaubt (Sicherheits-Policy)")
    # Echte Implementierung: sqlalchemy.read_only_engine.execute(text(sql))
    return {"rows": [{"status": "ok", "rowcount": 1}]}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8765)

Starten mit uvicorn mcp_server:app --reload --port 8765. Swagger-Doku liegt unter http://localhost:8765/docs.

5. Schritt 2 — Tool-Bridge zu HolySheep (Backend-Aufruf)

Damit das LLM im Cursor die Tools überhaupt kennt, schicken wir beim Completions-Aufruf das Tool-Schema mit. HolySheep unterstützt den OpenAI-kompatiblen Tool-Calling-Endpoint ohne Einschränkungen:

# holybridge.py — vermittelt zwischen MCP-Tools und HolySheep
import httpx, json, os

HOLYSHEEP_URL = "https://api.holysheep.ai/v1/chat/completions"
HEADERS = {
    "Authorization": f"Bearer {os.getenv('HOLYSHEEP_API_KEY', 'YOUR_HOLYSHEEP_API_KEY')}",
    "Content-Type": "application/json"
}

TOOLS_SCHEMA = [
    {
        "type": "function",
        "function": {
            "name": "search_intern",
            "description": "Durchsucht das interne Confluence-Wiki nach Stichworten.",
            "parameters": {
                "type": "object",
                "properties": {"query": {"type": "string", "description": "Suchbegriff"}},
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "create_jira_ticket",
            "description": "Erstellt ein Jira-Ticket im Standard-Projekt.",
            "parameters": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "body": {"type": "string"}
                },
                "required": ["title"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "run_sql_query",
            "description": "Führt ein read-only SELECT auf der Reporting-DB aus.",
            "parameters": {
                "type": "object",
                "properties": {"sql": {"type": "string"}},
                "required": ["sql"]
            }
        }
    }
]

def ask_holy(user_prompt: str, model: str = "gpt-4.1") -> dict:
    payload = {
        "model": model,
        "messages": [{"role": "user", "content": user_prompt}],
        "tools": TOOLS_SCHEMA,
        "tool_choice": "auto",
        "temperature": 0.2
    }
    r = httpx.post(HOLYSHEEP_URL, json=payload, headers=HEADERS, timeout=30)
    r.raise_for_status()
    return r.json()

if __name__ == "__main__":
    response = ask_holy("Suche im Wiki nach 'Onboarding' und liste die 3 wichtigsten Schritte.")
    print(json.dumps(response, indent=2, ensure_ascii=False))

6. Schritt 3 — Cursor mit dem MCP-S

Verwandte Ressourcen

Verwandte Artikel