---
title: "MCP-Server mit OpenAI-kompatiblen Modellen: so geht’s"
description: "MCP funktioniert mit jedem LLM: Der Client macht aus MCP-Tools Function Calls. So nutzen Sie MCP mit offenen Modellen in Cline, Continue, opencode, n8n oder Python."
url: https://broadrouter.com/de/blog/mcp-with-openai-compatible-models/
lang: de
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/blog/mcp-with-openai-compatible-models/) (aktualisiert am 2026-11-16).

# MCP-Server mit OpenAI-kompatiblen Modellen nutzen (jeder Anbieter)

Vom Team von BroadNet Inference · 4 Min. Lesezeit · Veröffentlicht 2026-11-14 · Aktualisiert 2026-11-16

MCP ist modellunabhängig. Der MCP-Client in Ihrer App listet die Tools jedes Servers, übergibt sie dem Modell als gewöhnliche Function-Calling-Tools und führt tools/call aus, wenn das Modell danach fragt. Jedes OpenAI-kompatible Modell mit zuverlässigem Tool Calling kann MCP-Server nutzen. Konfigurieren Sie sie in Cline, Continue, opencode oder n8n, oder überbrücken Sie sie mit etwa 40 Zeilen Python.

## Das Wichtigste in Kürze

-   Laut MCP-Doku „does not dictate how AI applications use LLMs“ (Übersetzung: „schreibt nicht vor, wie KI-Anwendungen LLMs nutzen“). Die Host-App übersetzt MCP-Tools in das Tool-Format des Modells.
-   Das Modell braucht Tool Calling. Bei BroadNet Inference ist es für GLM 5.3 und Qwen3.8 27B gelistet.
-   Cline, Continue (nur im Agent-Modus), opencode, n8n und das OpenAI Agents SDK arbeiten alle als MCP-Client mit einem eigenen Modell.
-   Jedes MCP-Tool-Schema wird bei jedem Modellaufruf mitgesendet. Die opencode-Doku warnt, dass MCP-Tools Modellkontext verbrauchen; fügen Sie nur die Server hinzu, die Sie brauchen.
-   Gehostete MCP-Tools, die in der Responses API von OpenAI laufen, funktionieren nicht mit anderen Anbietern; lokale MCP-Clients schon.

**Auf dieser Seite**

1.  Warum funktioniert MCP mit jedem Modell?
2.  Welches Modell sollten Sie für MCP nutzen?
3.  Wie richten Sie MCP in gängigen Clients ein?
4.  Wie verbinden Sie MCP in Python mit einem offenen Modell?
5.  Was geht bei MCP mit offenen Modellen schief?
6.  Wo BroadNet Inference ins Bild passt

Das Model Context Protocol (MCP) gibt Agenten einen Standardweg zu Tools: GitHub, Datenbanken, Dateisysteme, Browser. Viele MCP-Tutorials setzen Claude oder GPT voraus. Sie brauchen keines von beiden. Dieser Beitrag erklärt, warum MCP mit jedem [OpenAI-kompatiblen](https://broadrouter.com/de/glossary/openai-compatible-api/) Modell funktioniert, das Tool Calling unterstützt, wie Sie es in den Clients einrichten, die Entwickler tatsächlich nutzen, und wie Sie MCP in Ihrem eigenen Code mit einem offenen Modell verbinden.

## Warum funktioniert MCP mit jedem Modell?

MCP sitzt zwischen Ihrer Anwendung und den Tool-Servern, nicht zwischen Ihrer Anwendung und dem Modell. Die Architektur-Doku von MCP beschreibt drei Rollen:

-   **Host:** die KI-Anwendung, etwa eine Editor-Erweiterung oder Ihr Skript.
-   **Client:** eine Verbindung, die der Host zu jedem MCP-Server hält.
-   **Server:** ein Programm, das Tools, Ressourcen und Prompts bereitstellt, lokal über stdio oder entfernt über Streamable HTTP.

Die Doku ist eindeutig: MCP „does not dictate how AI applications use LLMs or manage the provided context.“ (Übersetzung: „schreibt nicht vor, wie KI-Anwendungen LLMs nutzen oder den bereitgestellten Kontext verwalten.“) Der Host listet die Tools jedes Servers mit `tools/list`, führt sie zu einem Verzeichnis zusammen, das das Modell sehen kann, und sendet `tools/call` an den richtigen Server, wenn das Modell ein Tool anfordert.

Auf einer OpenAI-kompatiblen API bedeutet „das Modell kann sie sehen“, dass die Tools ins gewöhnliche `tools`\-Array kommen. Ein MCP-Tool hat bereits einen Namen, eine Beschreibung und ein `inputSchema`, das sich eins zu eins auf eine Funktionsdefinition abbilden lässt. Das Modell erfährt nie, dass MCP beteiligt ist. Es braucht nur zuverlässiges [Tool Calling](https://broadrouter.com/de/glossary/tool-calling/).

## Welches Modell sollten Sie für MCP nutzen?

| Modell bei BroadNet | Tool Calling gelistet | Kontext | Eignung für MCP |
| --- | --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/de/models/glm-5.3/) | Ja | 1.048.576 | Guter Standard für viele Server |
| [Qwen3.8 27B](https://broadrouter.com/de/models/qwen3.8-27b/) | Ja | 262.144 | Gut, dazu Bildeingabe |
| [DeepSeek V4.1 Flash](https://broadrouter.com/de/models/deepseek-v4.1-flash/) | Nicht gelistet | 1.048.576 | Zuerst testen; Bildeingabe |
| [Gemma 4 VL 26B](https://broadrouter.com/de/models/gemma-4-vl-26b/) | Nicht gelistet | 32.768 | Nicht empfohlen |

Die beiden Modelle mit Tool-Unterstützung im direkten Vergleich finden Sie unter [GLM 5.3 vs. Qwen3.8 27B](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/). Der Kontext zählt mehr, als viele erwarten. Jedes MCP-Tool-Schema reist bei jedem Aufruf mit. Die opencode-Doku sagt: „MCP tools consume model context, so add only the servers you need.“ (Übersetzung: „MCP-Tools verbrauchen Modellkontext, fügen Sie also nur die Server hinzu, die Sie brauchen.“) Wie Sie das messen, zeigt der Beitrag zum [Token-Budget von Agenten](https://broadrouter.com/de/blog/agent-token-budget/).

## Wie richten Sie MCP in gängigen Clients ein?

| Client | Wo die MCP-Server eingetragen werden | Transports | Hinweis |
| --- | --- | --- | --- |
| Cline | Panel MCP Servers, JSON `mcpServers` | stdio, Streamable HTTP, Legacy-SSE | Remote-Typ `"streamableHttp"` |
| Continue | `mcpServers` in `config.yaml` oder `.continue/mcpServers/` | stdio, sse, streamable-http | Nur im Agent-Modus |
| opencode | `mcp.servers` in `opencode.jsonc` | `local`, `remote` | `{env:NAME}` für Secrets verwenden |
| n8n | Node MCP Client Tool an einem AI Agent | Endpoint eines Remote-Servers (die Doku beschreibt einen SSE-Endpoint) | Tools wählen: All, Selected oder All Except |
| OpenAI Agents SDK | `mcp_servers=[...]` am Agent | stdio, Streamable HTTP, SSE | Nicht `HostedMCPTool` |

Richten Sie dann das Modell des Clients auf Ihren Anbieter aus: Die Leitfäden zu [Cline](https://broadrouter.com/de/guides/cline-openai-compatible/), [Continue](https://broadrouter.com/de/guides/continue-dev-openai-compatible/) und [opencode](https://broadrouter.com/de/guides/opencode-custom-provider/) behandeln die Modellseite für BroadNet. Denken Sie in Continue an die Capability `tool_use`, sonst ist der Agent-Modus nicht verfügbar.

Ein Beispiel für Continue, aus dessen Doku:

```yaml
mcpServers:
  - name: SQLite MCP
    type: stdio
    command: npx
    args: ["-y", "mcp-sqlite", "/path/to/your/database.db"]
```

## Wie verbinden Sie MCP in Python mit einem offenen Modell?

Wenn Sie Ihren eigenen Agenten bauen, ist die Brücke kurz. Sie nutzt den `Client` des MCP Python SDK (Version 2.0 oder neuer; `pip install "mcp>=2"`), der einen stdio-Server startet, wenn er `StdioServerParameters` erhält, und das OpenAI SDK mit BroadNet als Ziel:

```python
import asyncio, json, os
from mcp import Client, StdioServerParameters
from mcp.types import TextContent
from openai import OpenAI

llm = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
server = StdioServerParameters(command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "."])

async def main(question):
    async with Client(server) as mcp:
        listed = await mcp.list_tools()
        tools = [{"type": "function", "function": {
                    "name": t.name, "description": t.description or "",
                    "parameters": t.input_schema}} for t in listed.tools]
        messages = [{"role": "user", "content": question}]
        for _ in range(8):
            r = llm.chat.completions.create(model="broadnet/glm-5.3",
                    messages=messages, tools=tools, max_tokens=4000)
            msg = r.choices[0].message
            messages.append(msg.model_dump(exclude_none=True))
            if not msg.tool_calls:
                return msg.content
            for call in msg.tool_calls:
                try:
                    res = await mcp.call_tool(call.function.name,
                                              json.loads(call.function.arguments or "{}"))
                    text = "\n".join(b.text for b in res.content if isinstance(b, TextContent))
                    out = f"Error: {text}" if res.is_error else text
                except Exception as e:
                    out = f"Error: {e}"
                messages.append({"role": "tool", "tool_call_id": call.id, "content": out})

print(asyncio.run(main("List the Markdown files here and summarize the README.")))
```

In `mcp` 1.x gibt es keine Klasse `Client`: Öffnen Sie den Server mit `stdio_client(...)`, umschließen Sie ihn mit einer `ClientSession`, rufen Sie `initialize()` auf und lesen Sie die camelCase-Felder `inputSchema` und `isError`. Drei Details sind wichtig:

1.  **Fehler werden zu Tool-Ergebnissen.** Das MCP SDK meldet Tool-Fehler mit `is_error`, statt eine Ausnahme zu werfen. Geben Sie sie zurück, damit das Modell sich anpassen kann. Unser [Leitfaden zu Tool Calling](https://broadrouter.com/de/blog/tool-calling-open-models/) behandelt Validierung und Retries.
2.  **Begrenzen Sie die Schleife.** Hier sind es acht Schritte. MCP-Server, die große Ergebnisse liefern, füllen den Kontext schnell.
3.  **Filtern Sie Tools.** Stellen Sie nur die Tools bereit, die die Aufgabe braucht. Das OpenAI Agents SDK bietet dafür `tool_filter`, n8n hat Selected und All Except.

Sie nutzen stattdessen das OpenAI Agents SDK? Dessen Klassen `MCPServerStdio` und `MCPServerStreamableHttp` laufen in Ihrem Prozess. Kombinieren Sie sie mit einem eigenen Anbieter wie in unserem [Leitfaden zum Agents SDK](https://broadrouter.com/de/guides/openai-agents-sdk-custom-provider/). `HostedMCPTool` dagegen läuft in der Responses API von OpenAI und funktioniert nur mit OpenAI-Modellen.

## Was geht bei MCP mit offenen Modellen schief?

-   **Zu viele Tools.** Das Modell wählt das falsche oder ignoriert Tools. Halten Sie die aktive Menge klein. Für Ihre eigenen Tools erzeugt der [JSON-Schema-Generator](https://broadrouter.com/tools/json-schema-generator/) ein sauberes, flaches `parameters`\-Schema.
-   **Große Tool-Ergebnisse.** Ein Server, der eine ganze Datenbanktabelle zurückgibt, kann das [Kontextfenster](https://broadrouter.com/de/glossary/context-window/) sprengen. Begrenzen oder paginieren Sie.
-   **Leere oder abgeschnittene Antworten.** GLM 5.3 und Qwen3.8 27B denken zuerst nach, und das Reasoning zählt zu `max_tokens`. [Erhöhen Sie den Wert](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/).
-   **Vertrauen.** MCP-Server führen Code auf Ihrem Rechner aus oder rufen Dienste mit Ihren Zugangsdaten auf. Installieren Sie nur Server, denen Sie vertrauen, und bestätigen Sie Aktionen, die schreiben oder Geld ausgeben.

## Wo BroadNet Inference ins Bild passt

BroadNet Inference liefert die Modellseite: GLM 5.3 und Qwen3.8 27B mit gelistetem Tool Calling, über das Standardformat für Chat Completions, das jeder der oben genannten MCP-Clients nutzen kann, und mit Zero Data Retention für Prompts und Ausgaben. MCP-Server oder gehostete Tools betreibt BroadNet nicht für Sie; das übernimmt Ihr Client. Die Preise pro Token für beide Modelle stehen auf der [Preisseite](https://broadrouter.com/de/pricing/), Schlüssel gibt es unter [inference.broadnet.ai](https://inference.broadnet.ai/?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-mcp-with-openai-compatible-models&utm_content=body).

Kostenlose Tools zum Thema (auf Englisch)

-   [Agent run cost estimator](https://broadrouter.com/tools/agent-run-cost-estimator/) Context growth per step, total tokens and cost of one agent run, with a DeepSeek session comparison.
-   [LLM batch job planner](https://broadrouter.com/tools/llm-batch-job-planner/) Run time, binding limit, cost per model and the flat sessions needed to finish a big job by a deadline.
-   [Flat-rate vs per-token LLM cost calculator](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/) Break-even between an unlimited plan and paying per token, per agent.
-   [LLM rate limit and concurrency calculator](https://broadrouter.com/tools/llm-rate-limit-calculator/) Which limit binds first: RPM, TPM or concurrency, with Little's law.

[Kostenlose Tools (auf Englisch)](https://broadrouter.com/tools/)

## Begriffe in diesem Artikel

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

[MCP (Model Context Protocol)](https://broadrouter.com/de/glossary/mcp/)

MCP (Model Context Protocol) ist ein offenes Protokoll auf Basis von JSON-RPC 2.0, das standardisiert, wie LLM-Anwendungen sich mit externen Tools und Daten verbinden. Ein MCP-Server stellt Tools, Ressourcen und Prompts bereit; ein MCP-Client in der Host-Anwendung findet sie und leitet Tool Calls des Modells an den Server weiter.

[Server-Sent Events (SSE)](https://broadrouter.com/de/glossary/sse/)

Server-Sent Events (SSE) sind ein Webstandard, mit dem ein Server einem Client über eine einzige, lang offene HTTP-Antwort mit dem Content-Type text/event-stream einen Strom von Text-Events schickt. Jedes Event besteht aus einer oder mehreren Feldzeilen, etwa data:, und endet mit einer Leerzeile.

[Zero Data Retention (ZDR)](https://broadrouter.com/de/glossary/zero-data-retention/)

Zero Data Retention (ZDR) ist eine Datenrichtlinie, bei der ein KI-Anbieter Prompts und Outputs nur zur Bearbeitung einer Anfrage verarbeitet und diese Inhalte danach nicht speichert, weder in Logs noch in Caches oder Trainingsdaten. Inhaltsfreie Daten wie Token-Zahlen und Zeiten werden meist weiterhin aufbewahrt.

[Chat Completions API](https://broadrouter.com/de/glossary/chat-completions-api/)

Die Chat Completions API ist der HTTP-Endpoint von OpenAI, POST /v1/chat/completions, der einen Modellnamen und eine Liste von Nachrichten mit Rollen entgegennimmt und die nächste Nachricht des Modells zurückgibt. Ihr Format für Anfrage und Antwort wurde zum gemeinsamen Standard, den OpenAI-kompatible Anbieter und SDKs übernehmen.

[KI-Agent (AI Agent)](https://broadrouter.com/de/glossary/agent/)

Ein KI-Agent ist ein System, in dem ein Sprachmodell seine eigenen Schritte auf ein Ziel hin steuert: Es entscheidet, welche Tools es aufruft, liest die Ergebnisse und wiederholt das, bis es eine endgültige Antwort liefert oder an ein Limit stößt. Ein festes Skript, das ein Modell an vorgegebenen Stellen aufruft, heißt dagegen meist Workflow.

[Kontextfenster (Context Window)](https://broadrouter.com/de/glossary/context-window/)

Das Kontextfenster ist die maximale Anzahl an Tokens, mit der ein Sprachmodell in einer einzelnen Anfrage arbeiten kann. Es umfasst Prompt, Gesprächsverlauf, Tool-Definitionen, Bilder und den erzeugten Output einschließlich Reasoning-Tokens. Was nicht hineinpasst, muss gekürzt, zusammengefasst oder auf mehrere Anfragen verteilt werden.

[Token](https://broadrouter.com/de/glossary/token/)

Ein Token ist die Texteinheit, die ein Sprachmodell liest und schreibt: ein Wort, ein Wortteil, ein Satzzeichen oder eine Bytefolge, die der Tokenizer des Modells erzeugt. LLM-APIs zählen, begrenzen und berechnen die Nutzung meist in Tokens.

## Häufige Fragen

### Kann ich MCP mit einem Modell nutzen, das nicht Claude oder GPT ist?

Ja. MCP ist ein Protokoll zwischen Ihrer App und Tool-Servern. Die App übergibt die Tools an das jeweilige Modell im Tool-Calling-Format dieses Modells. Jedes OpenAI-kompatible Modell mit funktionierendem Tool Calling kann MCP-Tools nutzen.

### Muss das Modell MCP unterstützen?

Nein. Das Modell braucht nur Function Calling. Der MCP-Client in Ihrer App erledigt die Protokollarbeit, also Tools auflisten und aufrufen.

### Welche Coding-Agenten unterstützen MCP mit einem eigenen OpenAI-kompatiblen Modell?

In Cline, Continue im Agent-Modus und opencode können Sie MCP-Server und ein eigenes OpenAI-kompatibles Modell konfigurieren. Zoo Code, die Fortführung von Roo Code, nennt ebenfalls MCP-Unterstützung.

### Warum wird mein Agent durch zusätzliche MCP-Server langsamer und teurer?

Die Tool-Definitionen jedes Servers werden bei jedem Modellaufruf in den Prompt eingefügt. Zehn Server mit je einem Dutzend Tools können pro Schritt Tausende Input-Tokens hinzufügen. Aktivieren Sie nur die Server, die eine Aufgabe braucht, oder filtern Sie Tools.

### Funktionieren gehostete MCP-Tools mit anderen Anbietern?

Die von OpenAI gehosteten nicht. Laut der Doku des OpenAI Agents SDK funktioniert HostedMCPTool mit OpenAI-Modellen, die die gehostete MCP-Integration der Responses API unterstützen. Nutzen Sie bei anderen Anbietern die lokalen MCP-Server-Klassen des SDK.

## Weiterlesen

-   [Tool Calling mit offenen Modellen: Schemas, parallele Aufrufe, Retries](https://broadrouter.com/de/blog/tool-calling-open-models/)
-   [Offene Modelle in Coding-Agenten: Aider, Cline, opencode, Codex](https://broadrouter.com/de/blog/use-open-models-in-coding-agents/)
-   [Agenten-Token-Budget: wohin die Tokens einer Agenten-Schleife gehen](https://broadrouter.com/de/blog/agent-token-budget/)
-   [n8n AI Agent mit günstigem LLM: Setup, Modellwahl, Kosten pro Lauf](https://broadrouter.com/de/blog/n8n-ai-agent-cheap-llm/)
-   [Kosten eines KI-Coding-Agent-Laufs: Schritte, Kontext, Caching](https://broadrouter.com/de/blog/ai-coding-agent-run-cost/)
-   [Claude Code mit offenen Modellen: Proxys, native Endpoints, Grenzen](https://broadrouter.com/de/blog/claude-code-with-openai-compatible-models/)
-   [Anleitung: Cline mit BroadNet Inference nutzen (Provider OpenAI Compatible)](https://broadrouter.com/de/guides/cline-openai-compatible/)
-   [Anleitung: Continue mit BroadNet Inference nutzen (config.yaml und apiBase)](https://broadrouter.com/de/guides/continue-dev-openai-compatible/)
-   [Anleitung: BroadNet Inference als eigenen Provider in opencode einrichten](https://broadrouter.com/de/guides/opencode-custom-provider/)
-   [Anleitung: OpenAI Agents SDK mit BroadNet Inference betreiben](https://broadrouter.com/de/guides/openai-agents-sdk-custom-provider/)

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

[Loslegen](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-mcp-with-openai-compatible-models&utm_content=page-cta) ·

**Quellen**

-   [Model Context Protocol, Architekturüberblick (geprüft am 2026-11-14)](https://modelcontextprotocol.io/docs/learn/architecture)
-   [MCP Python SDK, Clients und Transports (geprüft am 2026-11-14)](https://py.sdk.modelcontextprotocol.io/client/transports/)
-   [Cline-Dokumentation, MCP-Überblick (geprüft am 2026-11-14)](https://docs.cline.bot/mcp/mcp-overview)
-   [Continue-Dokumentation, MCP (geprüft am 2026-11-14)](https://docs.continue.dev/customize/deep-dives/mcp)
-   [opencode-Dokumentation, MCP-Server (geprüft am 2026-11-14)](https://opencode.ai/docs/mcp-servers/)
-   [n8n-Dokumentation, Node MCP Client Tool (geprüft am 2026-11-14)](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolmcp/)
-   [OpenAI-Agents-SDK-Dokumentation, MCP (geprüft am 2026-11-14)](https://openai.github.io/openai-agents-python/mcp/)
