---
title: "Server MCP con modelli compatibili OpenAI: come funziona"
description: "MCP funziona con qualsiasi LLM: il client trasforma i tool MCP in function call. Come usare MCP con modelli aperti in Cline, Continue, opencode, n8n o in Python."
url: https://broadrouter.com/it/blog/mcp-with-openai-compatible-models/
lang: it
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/mcp-with-openai-compatible-models/) (aggiornato il 2026-11-16).

# Server MCP con modelli compatibili con OpenAI, di qualsiasi provider

A cura del team di BroadNet Inference · 4 min di lettura · Pubblicato 2026-11-14 · Aggiornato 2026-11-16

MCP è indipendente dal modello. Il client MCP nella tua app elenca i tool di ogni server, li passa al modello come normali tool di function calling ed esegue tools/call quando il modello lo chiede. Qualsiasi modello compatibile con OpenAI con un tool calling affidabile può usare server MCP. Configurali in Cline, Continue, opencode o n8n, oppure collegali con circa 40 righe di Python.

## Punti chiave

-   La documentazione di MCP dice che «does not dictate how AI applications use LLMs» (traduzione: non impone come le applicazioni AI usano gli LLM). È l’app host a tradurre i tool MCP nel formato dei tool del modello.
-   Il modello deve supportare il tool calling. Su BroadNet Inference lo dichiarano GLM 5.3 e Qwen3.8 27B.
-   Cline, Continue (solo in modalità Agent), opencode, n8n e l’OpenAI Agents SDK fanno tutti da client MCP con un modello personalizzato.
-   Ogni schema di tool MCP viene inviato a ogni chiamata al modello. La documentazione di opencode avverte che i tool MCP consumano contesto del modello; aggiungi solo i server che ti servono.
-   I tool MCP ospitati che girano dentro la Responses API di OpenAI non funzionano con altri provider; i client MCP locali sì.

**In questa pagina**

1.  Perché MCP funziona con qualsiasi modello?
2.  Quale modello usare con MCP?
3.  Come si configura MCP nei client più comuni?
4.  Come si collega MCP a un modello aperto in Python?
5.  Cosa va storto con MCP sui modelli aperti?
6.  Dove si inserisce BroadNet Inference

Il Model Context Protocol (MCP) offre agli agenti un modo standard per raggiungere i tool: GitHub, database, file system, browser. Molti tutorial su MCP danno per scontato Claude o GPT. Non ti serve nessuno dei due. Questo articolo spiega perché MCP funziona con qualsiasi modello [compatibile con OpenAI](https://broadrouter.com/it/glossary/openai-compatible-api/) che supporti il tool calling, come configurarlo nei client che gli sviluppatori usano davvero e come collegare MCP a un modello aperto nel tuo codice.

## Perché MCP funziona con qualsiasi modello?

MCP sta tra la tua applicazione e i server di tool, non tra la tua applicazione e il modello. La documentazione sull’architettura di MCP descrive tre ruoli:

-   **Host:** l’applicazione AI, come un’estensione dell’editor o il tuo script.
-   **Client:** una connessione che l’host mantiene verso ciascun server MCP.
-   **Server:** un programma che espone tool, risorse e prompt, in locale via stdio o in remoto via Streamable HTTP.

La documentazione è esplicita: MCP «does not dictate how AI applications use LLMs or manage the provided context.» (traduzione: non impone come le applicazioni AI usano gli LLM o gestiscono il contesto fornito). L’host elenca i tool di ogni server con `tools/list`, li unisce in un unico registro visibile al modello e, quando il modello chiede un tool, invia `tools/call` al server giusto.

Su un’API compatibile con OpenAI, “visibile al modello” significa che i tool finiscono nel normale array `tools`. Un tool MCP ha già un nome, una descrizione e un `inputSchema`, che corrispondono uno a uno a una definizione di funzione. Il modello non sa nemmeno che c’è di mezzo MCP. Gli serve solo un [tool calling](https://broadrouter.com/it/glossary/tool-calling/) affidabile.

## Quale modello usare con MCP?

| Modello su BroadNet | Tool calling dichiarato | Contesto | Adatto a MCP |
| --- | --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/it/models/glm-5.3/) | Sì | 1.048.576 | Buona scelta predefinita con molti server |
| [Qwen3.8 27B](https://broadrouter.com/it/models/qwen3.8-27b/) | Sì | 262.144 | Buono, con in più l’input di immagini |
| [DeepSeek V4.1 Flash](https://broadrouter.com/it/models/deepseek-v4.1-flash/) | Non dichiarato | 1.048.576 | Provalo prima; input di immagini |
| [Gemma 4 VL 26B](https://broadrouter.com/it/models/gemma-4-vl-26b/) | Non dichiarato | 32.768 | Sconsigliato |

Per confrontare fianco a fianco i due modelli con i tool, vedi [GLM 5.3 vs Qwen3.8 27B](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/). Il contesto conta più di quanto si pensi. Ogni schema di tool MCP viaggia con ogni chiamata. La documentazione di opencode dice: «MCP tools consume model context, so add only the servers you need.» (traduzione: i tool MCP consumano contesto del modello, quindi aggiungi solo i server che ti servono). L’articolo sul [budget di token di un agente](https://broadrouter.com/it/blog/agent-token-budget/) mostra come misurarlo.

## Come si configura MCP nei client più comuni?

| Client | Dove vanno i server MCP | Trasporti | Nota |
| --- | --- | --- | --- |
| Cline | Pannello MCP Servers, JSON `mcpServers` | stdio, Streamable HTTP, SSE legacy | Tipo remoto `"streamableHttp"` |
| Continue | `mcpServers` in `config.yaml` o `.continue/mcpServers/` | stdio, sse, streamable-http | Solo modalità Agent |
| opencode | `mcp.servers` in `opencode.jsonc` | `local`, `remote` | Usa `{env:NAME}` per i segreti |
| n8n | Nodo MCP Client Tool su un AI Agent | Endpoint di server remoto (la documentazione descrive un endpoint SSE) | Scegli i tool con All, Selected o All Except |
| OpenAI Agents SDK | `mcp_servers=[...]` sull’Agent | stdio, Streamable HTTP, SSE | Non `HostedMCPTool` |

Poi punta il modello del client al tuo provider: le guide per [Cline](https://broadrouter.com/it/guides/cline-openai-compatible/), [Continue](https://broadrouter.com/it/guides/continue-dev-openai-compatible/) e [opencode](https://broadrouter.com/it/guides/opencode-custom-provider/) coprono la parte del modello per BroadNet. In Continue ricordati la capability `tool_use`, altrimenti la modalità Agent non sarà disponibile.

Un esempio per Continue, dalla sua documentazione:

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

## Come si collega MCP a un modello aperto in Python?

Se stai costruendo il tuo agente, il collegamento è breve. Questo usa il `Client` dell’MCP Python SDK (versione 2.0 o successiva; `pip install "mcp>=2"`), che avvia un server stdio quando riceve `StdioServerParameters`, e l’SDK di OpenAI puntato su 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.")))
```

Con `mcp` 1.x non esiste la classe `Client`: apri il server con `stdio_client(...)`, avvolgilo in una `ClientSession`, chiama `initialize()` e leggi i campi in camelCase `inputSchema` e `isError`. Contano tre dettagli:

1.  **Gli errori diventano risultati dei tool.** L’MCP SDK segnala i fallimenti dei tool con `is_error` invece di sollevare eccezioni. Rimandali al modello così può correggersi. La nostra [guida al tool calling](https://broadrouter.com/it/blog/tool-calling-open-models/) copre validazione e retry.
2.  **Limita il ciclo.** Qui sono otto passaggi. I server MCP che restituiscono risultati grandi riempiono in fretta il contesto.
3.  **Filtra i tool.** Esponi solo i tool che servono al compito. L’OpenAI Agents SDK offre `tool_filter` per questo, e n8n ha Selected e All Except.

Usi invece l’OpenAI Agents SDK? Le sue classi `MCPServerStdio` e `MCPServerStreamableHttp` girano nel tuo processo. Combinale con un provider personalizzato come nella nostra [guida all’Agents SDK](https://broadrouter.com/it/guides/openai-agents-sdk-custom-provider/). Il suo `HostedMCPTool` gira dentro la Responses API di OpenAI e funziona solo con i modelli OpenAI.

## Cosa va storto con MCP sui modelli aperti?

-   **Troppi tool.** Il modello sceglie quello sbagliato o ignora i tool. Tieni piccolo l’insieme attivo. Per i tuoi tool, il [generatore di JSON schema](https://broadrouter.com/tools/json-schema-generator/) produce uno schema `parameters` pulito e piatto.
-   **Risultati dei tool troppo grandi.** Un server che restituisce un’intera tabella di database può sforare la [finestra di contesto](https://broadrouter.com/it/glossary/context-window/). Metti un tetto o pagina i risultati.
-   **Risposte vuote o tagliate.** GLM 5.3 e Qwen3.8 27B ragionano prima, e il ragionamento conta in `max_tokens`. [Alzalo](https://broadrouter.com/it/guides/reasoning-tokens-empty-response/).
-   **Fiducia.** I server MCP eseguono codice sulla tua macchina o chiamano servizi con le tue credenziali. Installa server di cui ti fidi e chiedi conferma per le azioni che scrivono o spendono.

## Dove si inserisce BroadNet Inference

BroadNet Inference fornisce la parte del modello: GLM 5.3 e Qwen3.8 27B con tool calling dichiarato, tramite il formato standard chat completions che tutti i client MCP visti sopra possono usare, con zero data retention (nessuna conservazione dei dati) su prompt e output. Non esegue server MCP né tool ospitati per te; quello lo fa il tuo client. I prezzi per token di entrambi i modelli sono nella [pagina dei prezzi](https://broadrouter.com/it/pricing/), e le chiavi su [inference.broadnet.ai](https://inference.broadnet.ai/?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-mcp-with-openai-compatible-models&utm_content=body).

Strumenti gratuiti sul tema (in inglese)

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

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

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

L’MCP (Model Context Protocol) è un protocollo aperto, basato su JSON-RPC 2.0, che standardizza il modo in cui le applicazioni LLM si collegano a strumenti e dati esterni. Un server MCP espone strumenti, risorse e prompt; un client MCP dentro l’applicazione host li scopre e inoltra al server le chiamate agli strumenti fatte dal modello.

[Zero data retention (nessuna conservazione dei dati)](https://broadrouter.com/it/glossary/zero-data-retention/)

La zero data retention (ZDR) è una policy di gestione dei dati in cui un provider AI elabora prompt e output solo per servire una richiesta e poi non ne conserva il contenuto, né in log né in cache né in dati di addestramento. Di solito restano registri senza contenuti, come conteggi di token e tempi.

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

I server-sent events (SSE) sono uno standard web con cui un server invia a un client un flusso di eventi testuali su un’unica risposta HTTP di lunga durata, con content type text/event-stream. Ogni evento è composto da una o più righe di campo, come data:, ed è chiuso da una riga vuota.

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

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[AI multimodale (multimodal AI)](https://broadrouter.com/it/glossary/multimodal/)

L’AI multimodale è un modello o un sistema che lavora con più di un tipo di dato, come testo, immagini, video e audio. Un modello multimodale può leggere insieme una foto e una domanda, oppure ricevere parlato e rispondere in testo. Il tipo più comune è il modello vision-language.

[Agente AI (AI agent)](https://broadrouter.com/it/glossary/agent/)

Un agente AI è un sistema in cui un modello linguistico dirige da solo i propri passi verso un obiettivo: decide quali strumenti chiamare, legge i risultati e ripete finché produce una risposta finale o raggiunge un limite. Uno script fisso che chiama un modello in punti prestabiliti di solito si chiama invece workflow.

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

Un’API compatibile con OpenAI è un’API HTTP che accetta gli stessi formati di richiesta e di risposta dell’API di OpenAI, come POST /v1/chat/completions, così SDK e strumenti di OpenAI possono usarla cambiando solo base URL, chiave API e nome del modello.

## Domande frequenti

### Posso usare MCP con un modello che non sia Claude o GPT?

Sì. MCP è un protocollo tra la tua app e i server di tool. L’app passa i tool al modello che usa, nel formato di tool calling di quel modello. Qualsiasi modello compatibile con OpenAI con chiamate ai tool funzionanti può usare i tool MCP.

### Il modello deve supportare MCP?

No. Al modello serve solo il function calling. Il lavoro di protocollo, cioè elencare i tool e chiamarli, lo fa il client MCP nella tua app.

### Quali agenti di coding supportano MCP con un modello personalizzato compatibile con OpenAI?

Cline, Continue in modalità Agent e opencode ti permettono di configurare server MCP e un modello personalizzato compatibile con OpenAI. Anche Zoo Code, la prosecuzione di Roo Code, dichiara il supporto a MCP.

### Perché aggiungere server MCP rende il mio agente più lento e costoso?

Le definizioni dei tool di ogni server vengono aggiunte al prompt a ogni chiamata al modello. Dieci server con una dozzina di tool ciascuno possono aggiungere migliaia di token di input per passaggio. Attiva solo i server che servono al compito, oppure filtra i tool.

### I tool MCP ospitati funzionano con altri provider?

Non quelli ospitati da OpenAI. La documentazione dell’OpenAI Agents SDK dice che HostedMCPTool funziona con i modelli OpenAI che supportano l’integrazione MCP ospitata della Responses API. Con altri provider usa le classi per server MCP locali dell’SDK.

## Continua a leggere

-   [Tool calling con modelli aperti: schemi, chiamate parallele, retry](https://broadrouter.com/it/blog/tool-calling-open-models/)
-   [Modelli aperti negli agenti di coding: Aider, Cline, opencode, Codex](https://broadrouter.com/it/blog/use-open-models-in-coding-agents/)
-   [Budget di token di un agente: dove vanno i token di un ciclo](https://broadrouter.com/it/blog/agent-token-budget/)
-   [AI Agent n8n con un LLM economico: setup, modello e costo a esecuzione](https://broadrouter.com/it/blog/n8n-ai-agent-cheap-llm/)
-   [Costo di un’esecuzione di un agente di coding: passi, contesto, cache](https://broadrouter.com/it/blog/ai-coding-agent-run-cost/)
-   [Claude Code con modelli open-weight: proxy, endpoint nativi e limiti](https://broadrouter.com/it/blog/claude-code-with-openai-compatible-models/)
-   [Guida: Usare Cline con BroadNet Inference (provider OpenAI Compatible)](https://broadrouter.com/it/guides/cline-openai-compatible/)
-   [Guida: Usare Continue con BroadNet Inference (config.yaml e apiBase)](https://broadrouter.com/it/guides/continue-dev-openai-compatible/)
-   [Guida: Aggiungere BroadNet Inference a opencode come provider personalizzato](https://broadrouter.com/it/guides/opencode-custom-provider/)
-   [Guida: Usare l’OpenAI Agents SDK con BroadNet Inference](https://broadrouter.com/it/guides/openai-agents-sdk-custom-provider/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

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

**Fonti**

-   [Model Context Protocol, panoramica dell’architettura (verifica del 2026-11-14)](https://modelcontextprotocol.io/docs/learn/architecture)
-   [MCP Python SDK, client e trasporti (verifica del 2026-11-14)](https://py.sdk.modelcontextprotocol.io/client/transports/)
-   [Documentazione di Cline, panoramica MCP (verifica del 2026-11-14)](https://docs.cline.bot/mcp/mcp-overview)
-   [Documentazione di Continue, MCP (verifica del 2026-11-14)](https://docs.continue.dev/customize/deep-dives/mcp)
-   [Documentazione di opencode, server MCP (verifica del 2026-11-14)](https://opencode.ai/docs/mcp-servers/)
-   [Documentazione di n8n, nodo MCP Client Tool (verifica del 2026-11-14)](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolmcp/)
-   [Documentazione dell’OpenAI Agents SDK, MCP (verifica del 2026-11-14)](https://openai.github.io/openai-agents-python/mcp/)
