---
title: "Serveurs MCP et modèles compatibles OpenAI : le principe"
description: "MCP marche avec tout LLM : le client transforme les outils MCP en appels de fonction. MCP avec des modèles ouverts dans Cline, Continue, opencode, n8n ou en Python."
url: https://broadrouter.com/fr/blog/mcp-with-openai-compatible-models/
lang: fr
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/mcp-with-openai-compatible-models/) (mis à jour le 2026-11-16).

# Serveurs MCP avec des modèles compatibles OpenAI (tout fournisseur)

Par l’équipe BroadNet Inference · 4 min de lecture · Publié 2026-11-14 · Mis à jour 2026-11-16

MCP ne dépend pas du modèle. Le client MCP de votre application liste les outils de chaque serveur, les transmet au modèle comme des outils de function calling ordinaires et exécute tools/call quand le modèle le demande. Tout modèle compatible OpenAI doté d’un appel d’outils fiable peut utiliser des serveurs MCP. Configurez-les dans Cline, Continue, opencode ou n8n, ou faites le pont en une quarantaine de lignes de Python.

## À retenir

-   La documentation de MCP précise qu’il « does not dictate how AI applications use LLMs » (traduction : « n’impose pas la façon dont les applications d’IA utilisent les LLM »). L’application hôte traduit les outils MCP dans le format d’outils du modèle.
-   Le modèle a besoin de l’appel d’outils. Chez BroadNet Inference, GLM 5.3 et Qwen3.8 27B l’indiquent.
-   Cline, Continue (en mode Agent uniquement), opencode, n8n et l’OpenAI Agents SDK servent tous de client MCP avec un modèle personnalisé.
-   Chaque schéma d’outil MCP est envoyé à chaque appel du modèle. La documentation d’opencode prévient que les outils MCP consomment du contexte ; n’ajoutez que les serveurs dont vous avez besoin.
-   Les outils MCP hébergés qui tournent dans la Responses API d’OpenAI ne fonctionnent pas avec d’autres fournisseurs ; les clients MCP locaux, si.

**Sur cette page**

1.  Pourquoi MCP fonctionne-t-il avec n’importe quel modèle ?
2.  Quel modèle utiliser pour MCP ?
3.  Comment configurer MCP dans les clients courants ?
4.  Comment relier MCP à un modèle ouvert en Python ?
5.  Qu’est-ce qui coince avec MCP sur des modèles ouverts ?
6.  La place de BroadNet Inference

Le Model Context Protocol (MCP) donne aux agents un moyen standard d’accéder à des outils : GitHub, bases de données, systèmes de fichiers, navigateurs. Beaucoup de tutoriels MCP supposent Claude ou GPT. Vous n’avez besoin ni de l’un ni de l’autre. Cet article explique pourquoi MCP fonctionne avec tout modèle [compatible OpenAI](https://broadrouter.com/fr/glossary/openai-compatible-api/) qui gère l’appel d’outils, comment le configurer dans les clients que les développeurs utilisent vraiment, et comment relier MCP à un modèle ouvert dans votre propre code.

## Pourquoi MCP fonctionne-t-il avec n’importe quel modèle ?

MCP se place entre votre application et les serveurs d’outils, pas entre votre application et le modèle. La documentation d’architecture de MCP décrit trois rôles :

-   **Hôte** : l’application d’IA, par exemple une extension d’éditeur ou votre script.
-   **Client** : une connexion que l’hôte maintient avec chaque serveur MCP.
-   **Serveur** : un programme qui expose des outils, des ressources et des prompts, en local via stdio ou à distance via Streamable HTTP.

La documentation est explicite : MCP « does not dictate how AI applications use LLMs or manage the provided context. » (traduction : « n’impose pas la façon dont les applications d’IA utilisent les LLM ni dont elles gèrent le contexte fourni. ») L’hôte liste les outils de chaque serveur avec `tools/list`, les fusionne dans un registre unique visible par le modèle et, quand le modèle demande un outil, envoie `tools/call` au bon serveur.

Sur une API compatible OpenAI, « visible par le modèle » signifie que les outils vont dans le tableau `tools` ordinaire. Un outil MCP a déjà un nom, une description et un `inputSchema`, qui se transposent un pour un en définition de fonction. Le modèle ne sait jamais que MCP est en jeu. Il lui faut seulement un [appel d’outils](https://broadrouter.com/fr/glossary/tool-calling/) fiable.

## Quel modèle utiliser pour MCP ?

| Modèle chez BroadNet | Appel d’outils indiqué | Contexte | Adéquation à MCP |
| --- | --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/fr/models/glm-5.3/) | Oui | 1 048 576 | Bon choix par défaut pour de nombreux serveurs |
| [Qwen3.8 27B](https://broadrouter.com/fr/models/qwen3.8-27b/) | Oui | 262 144 | Bon, avec en plus l’entrée image |
| [DeepSeek V4.1 Flash](https://broadrouter.com/fr/models/deepseek-v4.1-flash/) | Non indiqué | 1 048 576 | À tester d’abord ; entrée image |
| [Gemma 4 VL 26B](https://broadrouter.com/fr/models/gemma-4-vl-26b/) | Non indiqué | 32 768 | Déconseillé |

Pour comparer côte à côte les deux modèles qui gèrent les outils, voir [GLM 5.3 vs Qwen3.8 27B](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/). Le contexte compte plus qu’on ne le croit. Chaque schéma d’outil MCP voyage avec chaque appel. La documentation d’opencode dit : « MCP tools consume model context, so add only the servers you need. » (traduction : « les outils MCP consomment du contexte du modèle : n’ajoutez que les serveurs dont vous avez besoin. ») L’article sur le [budget de tokens d’un agent](https://broadrouter.com/fr/blog/agent-token-budget/) montre comment le mesurer.

## Comment configurer MCP dans les clients courants ?

| Client | Où déclarer les serveurs MCP | Transports | Remarque |
| --- | --- | --- | --- |
| Cline | Panneau MCP Servers, JSON `mcpServers` | stdio, Streamable HTTP, SSE historique | Type distant `"streamableHttp"` |
| Continue | `mcpServers` dans `config.yaml` ou `.continue/mcpServers/` | stdio, sse, streamable-http | Mode Agent uniquement |
| opencode | `mcp.servers` dans `opencode.jsonc` | `local`, `remote` | Utiliser `{env:NAME}` pour les secrets |
| n8n | Nœud MCP Client Tool sur un AI Agent | Endpoint d’un serveur distant (sa documentation décrit un endpoint SSE) | Choisir All, Selected ou All Except |
| OpenAI Agents SDK | `mcp_servers=[...]` sur l’Agent | stdio, Streamable HTTP, SSE | Pas `HostedMCPTool` |

Pointez ensuite le modèle du client vers votre fournisseur : les guides [Cline](https://broadrouter.com/fr/guides/cline-openai-compatible/), [Continue](https://broadrouter.com/fr/guides/continue-dev-openai-compatible/) et [opencode](https://broadrouter.com/fr/guides/opencode-custom-provider/) couvrent la partie modèle pour BroadNet. Dans Continue, n’oubliez pas la capacité `tool_use`, sinon le mode Agent ne sera pas disponible.

Un exemple pour Continue, tiré de sa documentation :

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

## Comment relier MCP à un modèle ouvert en Python ?

Si vous construisez votre propre agent, le pont est court. Il utilise le `Client` du SDK Python de MCP (version 2.0 ou ultérieure ; `pip install "mcp>=2"`), qui lance un serveur stdio quand on lui passe des `StdioServerParameters`, et le SDK d’OpenAI pointé vers BroadNet :

```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.")))
```

Avec `mcp` 1.x, il n’existe pas de classe `Client` : ouvrez le serveur avec `stdio_client(...)`, enveloppez-le dans une `ClientSession`, appelez `initialize()` et lisez les champs en camelCase `inputSchema` et `isError`. Trois détails comptent :

1.  **Les erreurs deviennent des résultats d’outil.** Le SDK de MCP signale les échecs d’outil avec `is_error` au lieu de lever une exception. Renvoyez-les pour que le modèle s’adapte. Notre [guide de l’appel d’outils](https://broadrouter.com/fr/blog/tool-calling-open-models/) couvre la validation et les relances.
2.  **Bornez la boucle.** Ici, huit étapes. Les serveurs MCP qui renvoient de gros résultats remplissent vite le contexte.
3.  **Filtrez les outils.** N’exposez que ceux dont la tâche a besoin. L’OpenAI Agents SDK propose `tool_filter` pour cela, et n8n propose Selected et All Except.

Vous utilisez plutôt l’OpenAI Agents SDK ? Ses classes `MCPServerStdio` et `MCPServerStreamableHttp` tournent dans votre processus. Combinez-les avec un fournisseur personnalisé comme dans notre [guide de l’Agents SDK](https://broadrouter.com/fr/guides/openai-agents-sdk-custom-provider/). Son `HostedMCPTool` tourne dans la Responses API d’OpenAI et ne fonctionne qu’avec les modèles OpenAI.

## Qu’est-ce qui coince avec MCP sur des modèles ouverts ?

-   **Trop d’outils.** Le modèle choisit le mauvais ou ignore les outils. Gardez un ensemble actif réduit. Pour vos propres outils, le [générateur de JSON Schema](https://broadrouter.com/tools/json-schema-generator/) produit un schéma `parameters` propre et plat.
-   **Résultats d’outils volumineux.** Un serveur qui renvoie toute une table de base de données peut faire exploser la [fenêtre de contexte](https://broadrouter.com/fr/glossary/context-window/). Limitez ou paginez.
-   **Réponses vides ou coupées.** GLM 5.3 et Qwen3.8 27B raisonnent d’abord, et le raisonnement compte dans `max_tokens`. [Augmentez-le](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/).
-   **Confiance.** Les serveurs MCP exécutent du code sur votre machine ou appellent des services avec vos identifiants. Installez des serveurs de confiance et faites confirmer les actions qui écrivent ou dépensent.

## La place de BroadNet Inference

BroadNet Inference fournit la partie modèle : GLM 5.3 et Qwen3.8 27B, pour lesquels l’appel d’outils est indiqué, via le format standard des chat completions que tous les clients MCP ci-dessus savent utiliser, avec conservation zéro des données pour les prompts et les sorties. BroadNet ne fait pas tourner de serveurs MCP ni d’outils hébergés pour vous : c’est le rôle de votre client. Les prix au token des deux modèles figurent sur la [page des prix](https://broadrouter.com/fr/pricing/), et les clés s’obtiennent sur [inference.broadnet.ai](https://inference.broadnet.ai/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-mcp-with-openai-compatible-models&utm_content=body).

Outils gratuits sur ce sujet (en anglais)

-   [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.

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

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

MCP (Model Context Protocol) est un protocole ouvert, fondé sur JSON-RPC 2.0, qui normalise la façon dont les applications LLM se connectent à des outils et des données externes. Un serveur MCP expose des outils, des ressources et des prompts ; un client MCP, dans l’application hôte, les découvre et transmet au serveur les appels d’outils du modèle.

[Appel d’outils (tool calling, function calling)](https://broadrouter.com/fr/glossary/tool-calling/)

L’appel d’outils, aussi appelé function calling, est une fonctionnalité des API LLM dans laquelle le modèle renvoie une demande structurée d’exécution d’une fonction définie par le développeur, avec des arguments JSON. L’application exécute la fonction et renvoie le résultat ; le modèle n’exécute jamais de code lui-même.

[Server-sent events (SSE)](https://broadrouter.com/fr/glossary/sse/)

Les server-sent events (SSE) sont un standard du web qui permet à un serveur de pousser un flux d’événements texte vers un client, via une seule réponse HTTP de longue durée de type text/event-stream. Chaque événement se compose d’une ou plusieurs lignes de champ, comme data:, et se termine par une ligne vide.

[API compatible OpenAI](https://broadrouter.com/fr/glossary/openai-compatible-api/)

Une API compatible OpenAI est une API HTTP qui accepte les mêmes formats de requête et de réponse que l’API OpenAI, comme POST /v1/chat/completions. Les SDK et outils OpenAI peuvent donc l’utiliser en changeant seulement l’URL de base, la clé d’API et le nom du modèle.

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

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[Modèle open-weight (à poids ouverts)](https://broadrouter.com/fr/glossary/open-weight-model/)

Un modèle open-weight est un modèle d’apprentissage automatique dont les poids entraînés sont publiés pour que chacun puisse les télécharger et les exécuter, généralement sous une licence assortie de conditions. Il se distingue de l’IA entièrement open source, qui publie aussi le code d’entraînement et des informations détaillées sur les données, pour que d’autres puissent étudier et reproduire le modèle.

[Agent IA (AI agent)](https://broadrouter.com/fr/glossary/agent/)

Un agent IA est un système dans lequel un modèle de langage dirige lui-même ses étapes vers un objectif : il décide quels outils appeler, lit les résultats et recommence jusqu’à produire une réponse finale ou atteindre une limite. Un script fixe qui appelle un modèle à des moments prévus s’appelle plutôt un workflow.

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

L’API Chat Completions est l’endpoint HTTP d’OpenAI, POST /v1/chat/completions, qui reçoit un nom de modèle et une liste de messages associés à un rôle, et renvoie le message suivant du modèle. Sa forme de requête et de réponse est devenue le format commun que reprennent les fournisseurs et SDK compatibles OpenAI.

## Questions fréquentes

### Puis-je utiliser MCP avec un modèle qui n’est ni Claude ni GPT ?

Oui. MCP est un protocole entre votre application et des serveurs d’outils. L’application transmet les outils au modèle qu’elle utilise, dans le format d’appel d’outils de ce modèle. Tout modèle compatible OpenAI dont l’appel d’outils fonctionne peut utiliser des outils MCP.

### Le modèle doit-il prendre en charge MCP ?

Non. Le modèle a seulement besoin du function calling. Le client MCP de votre application fait le travail lié au protocole : lister les outils et les appeler.

### Quels agents de code prennent en charge MCP avec un modèle personnalisé compatible OpenAI ?

Cline, Continue en mode Agent et opencode permettent tous de configurer des serveurs MCP et un modèle personnalisé compatible OpenAI. Zoo Code, la suite de Roo Code, annonce aussi la prise en charge de MCP.

### Pourquoi ajouter des serveurs MCP rend-il mon agent plus lent et plus cher ?

Les définitions d’outils de chaque serveur sont ajoutées au prompt à chaque appel du modèle. Dix serveurs avec une douzaine d’outils chacun peuvent ajouter des milliers de tokens d’entrée par étape. N’activez que les serveurs utiles à la tâche, ou filtrez les outils.

### Les outils MCP hébergés fonctionnent-ils avec d’autres fournisseurs ?

Pas ceux qu’héberge OpenAI. Selon la documentation de l’OpenAI Agents SDK, HostedMCPTool fonctionne avec les modèles OpenAI qui prennent en charge l’intégration MCP hébergée de la Responses API. Avec d’autres fournisseurs, utilisez les classes de serveurs MCP locaux du SDK.

## À lire ensuite

-   [Appel d’outils et modèles ouverts : schémas, parallélisme, relances](https://broadrouter.com/fr/blog/tool-calling-open-models/)
-   [Modèles ouverts et agents de code : Aider, Cline, opencode, Codex](https://broadrouter.com/fr/blog/use-open-models-in-coding-agents/)
-   [Budget de tokens d’un agent : où partent les tokens d’une boucle](https://broadrouter.com/fr/blog/agent-token-budget/)
-   [Agent IA n8n sur un LLM bon marché : configuration, modèle, coût](https://broadrouter.com/fr/blog/n8n-ai-agent-cheap-llm/)
-   [Coût d’une exécution d’agent de code IA : étapes, contexte, cache](https://broadrouter.com/fr/blog/ai-coding-agent-run-cost/)
-   [Claude Code et modèles ouverts : proxys, endpoints natifs, limites](https://broadrouter.com/fr/blog/claude-code-with-openai-compatible-models/)
-   [Guide : Utiliser Cline avec BroadNet Inference (fournisseur OpenAI Compatible)](https://broadrouter.com/fr/guides/cline-openai-compatible/)
-   [Guide : Utiliser Continue avec BroadNet Inference (config.yaml et apiBase)](https://broadrouter.com/fr/guides/continue-dev-openai-compatible/)
-   [Guide : Ajouter BroadNet Inference à opencode comme fournisseur personnalisé](https://broadrouter.com/fr/guides/opencode-custom-provider/)
-   [Guide : Faire tourner l’OpenAI Agents SDK sur BroadNet Inference](https://broadrouter.com/fr/guides/openai-agents-sdk-custom-provider/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

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

**Sources**

-   [Model Context Protocol, vue d’ensemble de l’architecture (vérifié le 2026-11-14)](https://modelcontextprotocol.io/docs/learn/architecture)
-   [SDK Python de MCP, clients et transports (vérifié le 2026-11-14)](https://py.sdk.modelcontextprotocol.io/client/transports/)
-   [Documentation de Cline, vue d’ensemble de MCP (vérifié le 2026-11-14)](https://docs.cline.bot/mcp/mcp-overview)
-   [Documentation de Continue, MCP (vérifié le 2026-11-14)](https://docs.continue.dev/customize/deep-dives/mcp)
-   [Documentation d’opencode, serveurs MCP (vérifié le 2026-11-14)](https://opencode.ai/docs/mcp-servers/)
-   [Documentation de n8n, nœud MCP Client Tool (vérifié le 2026-11-14)](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolmcp/)
-   [Documentation de l’OpenAI Agents SDK, MCP (vérifié le 2026-11-14)](https://openai.github.io/openai-agents-python/mcp/)
