---
title: "MCP server sa OpenAI-compatible na model: paano gumagana"
description: "Gumagana ang MCP sa kahit anong LLM: ginagawang function call ng client ang MCP tools. Gamitin ang MCP sa open model sa Cline, Continue, opencode, n8n o Python."
url: https://broadrouter.com/fil/blog/mcp-with-openai-compatible-models/
lang: fil
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Isinalin mula sa Ingles sa tulong ng AI. [Basahin ang orihinal sa Ingles](https://broadrouter.com/blog/mcp-with-openai-compatible-models/) (na-update noong 2026-11-16).

# Paano gamitin ang MCP server sa OpenAI-compatible na model

Ng BroadNet Inference team · 4 minutong basa · Nailathala 2026-11-14 · Na-update 2026-11-16

Hindi nakatali sa model ang MCP. Inililista ng MCP client sa app mo ang tools ng bawat server, ipinapasa ang mga ito sa model bilang ordinaryong function-calling tool, at pinapatakbo ang tools/call kapag hiningi ng model. Kayang gumamit ng MCP server ang anumang OpenAI-compatible na model na may maaasahang tool calling. I-configure ang mga ito sa Cline, Continue, opencode o n8n, o ikonekta sa mga 40 linya ng Python.

## Mga pangunahing punto

-   Sabi ng docs ng MCP, "does not dictate how AI applications use LLMs" (salin: hindi nito idinidikta kung paano gumagamit ng LLM ang mga AI application). Ang host app ang nagsasalin ng MCP tools sa tool format ng model.
-   Kailangan ng model ng tool calling. Sa BroadNet Inference, nakalista ito para sa GLM 5.3 at Qwen3.8 27B.
-   Kumikilos bilang MCP client na may custom na model ang Cline, Continue (sa Agent mode lang), opencode, n8n at OpenAI Agents SDK.
-   Ipinapadala ang bawat MCP tool schema sa bawat model call. Babala ng docs ng opencode na kumakain ng context ng model ang MCP tools; idagdag lang ang mga server na kailangan mo.
-   Hindi gumagana sa ibang provider ang hosted MCP tools na tumatakbo sa loob ng Responses API ng OpenAI; gumagana ang mga lokal na MCP client.

**Sa page na ito**

1.  Bakit gumagana ang MCP sa kahit anong model?
2.  Aling model ang dapat gamitin para sa MCP?
3.  Paano i-set up ang MCP sa mga karaniwang client?
4.  Paano ikonekta ang MCP sa open model gamit ang Python?
5.  Ano ang karaniwang nagkakamali sa MCP sa mga open model?
6.  Saan bagay ang BroadNet Inference

Binibigyan ng Model Context Protocol (MCP) ang mga agent ng standard na paraan para maabot ang tools: GitHub, database, file system, browser. Maraming MCP tutorial ang nag-aakalang Claude o GPT ang gamit mo. Hindi mo kailangan ang alinman. Ipinapaliwanag ng post na ito kung bakit gumagana ang MCP sa kahit anong [OpenAI-compatible](https://broadrouter.com/fil/glossary/openai-compatible-api/) na model na sumusuporta sa tool calling, paano ito i-set up sa mga client na talagang ginagamit ng mga developer, at paano ikonekta ang MCP sa isang open model sa sarili mong code.

## Bakit gumagana ang MCP sa kahit anong model?

Nasa pagitan ng application mo at ng mga tool server ang MCP, hindi sa pagitan ng application mo at ng model. Tatlong role ang inilalarawan ng architecture docs ng MCP:

-   **Host:** ang AI application, gaya ng editor extension o ng script mo.
-   **Client:** isang connection na pinapanatili ng host sa bawat MCP server.
-   **Server:** isang program na naglalantad ng tools, resources at prompts, lokal sa stdio o remote sa Streamable HTTP.

Malinaw ang docs: “does not dictate how AI applications use LLMs or manage the provided context” (salin: hindi idinidikta ng MCP kung paano gumagamit ng LLM ang mga AI application o kung paano nila pinamamahalaan ang ibinigay na context). Inililista ng host ang tools ng bawat server gamit ang `tools/list`, pinagsasama ang mga ito sa iisang registry na nakikita ng model, at kapag humingi ang model ng tool, nagpapadala ang host ng `tools/call` sa tamang server.

Sa OpenAI-compatible na API, ang “nakikita ng model” ay nangangahulugang pumapasok ang tools sa ordinaryong `tools` array. May pangalan, description at `inputSchema` na ang MCP tool, na direktang tumutugma sa isang function definition. Hindi kailanman nalalaman ng model na may MCP. Ang kailangan lang nito ay maaasahang [tool calling](https://broadrouter.com/fil/glossary/tool-calling/).

## Aling model ang dapat gamitin para sa MCP?

| Model sa BroadNet | Nakalista ang tool calling | Context | Bagay sa MCP |
| --- | --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/fil/models/glm-5.3/) | Oo | 1,048,576 | Magandang default para sa maraming server |
| [Qwen3.8 27B](https://broadrouter.com/fil/models/qwen3.8-27b/) | Oo | 262,144 | Maganda, may image input pa |
| [DeepSeek V4.1 Flash](https://broadrouter.com/fil/models/deepseek-v4.1-flash/) | Hindi nakalista | 1,048,576 | I-test muna; image input |
| [Gemma 4 VL 26B](https://broadrouter.com/fil/models/gemma-4-vl-26b/) | Hindi nakalista | 32,768 | Hindi inirerekomenda |

Para sa magkatabing paghahambing ng dalawang model na may tool support, tingnan ang [GLM 5.3 vs Qwen3.8 27B](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/). Mas mahalaga ang context kaysa sa inaakala ng marami. Kasama sa bawat call ang bawat MCP tool schema. Sabi ng docs ng opencode, “MCP tools consume model context, so add only the servers you need.” (salin: kumakain ng context ng model ang MCP tools, kaya idagdag lang ang mga server na kailangan mo.) Ipinapakita ng post tungkol sa [token budget ng agent](https://broadrouter.com/fil/blog/agent-token-budget/) kung paano ito sukatin.

## Paano i-set up ang MCP sa mga karaniwang client?

| Client | Saan ilalagay ang MCP server | Transport | Tala |
| --- | --- | --- | --- |
| Cline | MCP Servers panel, `mcpServers` JSON | stdio, Streamable HTTP, legacy SSE | Remote type na `"streamableHttp"` |
| Continue | `mcpServers` sa `config.yaml` o `.continue/mcpServers/` | stdio, sse, streamable-http | Sa Agent mode lang |
| opencode | `mcp.servers` sa `opencode.jsonc` | `local`, `remote` | Gamitin ang `{env:NAME}` para sa mga secret |
| n8n | MCP Client Tool node sa isang AI Agent | Remote na server endpoint (SSE endpoint ang inilalarawan ng docs nito) | Pumili ng All, Selected o All Except na tools |
| OpenAI Agents SDK | `mcp_servers=[...]` sa Agent | stdio, Streamable HTTP, SSE | Hindi `HostedMCPTool` |

Pagkatapos, ituro ang model ng client sa provider mo: tinatalakay ng mga gabay sa [Cline](https://broadrouter.com/fil/guides/cline-openai-compatible/), [Continue](https://broadrouter.com/fil/guides/continue-dev-openai-compatible/) at [opencode](https://broadrouter.com/fil/guides/opencode-custom-provider/) ang panig ng model para sa BroadNet. Sa Continue, tandaan ang `tool_use` capability, kung hindi ay hindi magagamit ang Agent mode.

Isang halimbawa sa Continue, mula sa docs nito:

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

## Paano ikonekta ang MCP sa open model gamit ang Python?

Kung sarili mong agent ang ginagawa mo, maikli lang ang tulay. Ginagamit nito ang `Client` ng MCP Python SDK (bersyon 2.0 o mas bago; `pip install "mcp>=2"`), na naglulunsad ng stdio server kapag binigyan ng `StdioServerParameters`, at ang OpenAI SDK na nakaturo sa 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.")))
```

Sa `mcp` 1.x, walang `Client` class: buksan ang server gamit ang `stdio_client(...)`, ibalot ito sa `ClientSession`, tawagin ang `initialize()`, at basahin ang mga camelCase na field na `inputSchema` at `isError`. Tatlong detalye ang mahalaga:

1.  **Nagiging tool result ang mga error.** Iniuulat ng MCP SDK ang palya ng tool gamit ang `is_error` sa halip na mag-raise. Ibalik ang mga ito para makapag-adjust ang model. Tinatalakay ng [gabay namin sa tool calling](https://broadrouter.com/fil/blog/tool-calling-open-models/) ang validation at retry.
2.  **Lagyan ng hangganan ang loop.** Walong hakbang dito. Mabilis mapuno ang context ng mga MCP server na nagbabalik ng malalaking result.
3.  **I-filter ang tools.** Ilantad lang ang tools na kailangan ng gawain. May `tool_filter` ang OpenAI Agents SDK para dito, at may Selected at All Except ang n8n.

OpenAI Agents SDK ba ang gamit mo? Tumatakbo sa process mo ang mga class nitong `MCPServerStdio` at `MCPServerStreamableHttp`. Pagsamahin ang mga ito sa custom na provider gaya ng nasa [gabay namin sa Agents SDK](https://broadrouter.com/fil/guides/openai-agents-sdk-custom-provider/). Ang `HostedMCPTool` nito ay tumatakbo sa loob ng Responses API ng OpenAI at gumagana lang sa mga model ng OpenAI.

## Ano ang karaniwang nagkakamali sa MCP sa mga open model?

-   **Sobrang daming tool.** Maling tool ang napipili ng model o hindi nito pinapansin ang tools. Panatilihing maliit ang aktibong set. Para sa sarili mong tools, gumagawa ang [JSON schema generator](https://broadrouter.com/tools/json-schema-generator/) ng malinis at flat na `parameters` schema.
-   **Malalaking tool result.** Puwedeng lumampas sa [context window](https://broadrouter.com/fil/glossary/context-window/) ang server na nagbabalik ng buong table ng database. Lagyan ng limit o i-paginate.
-   **Walang laman o naputol na sagot.** Nagre-reason muna ang GLM 5.3 at Qwen3.8 27B, at kasama ang reasoning sa `max_tokens`. [Taasan ito](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/).
-   **Tiwala.** Nagpapatakbo ng code sa machine mo ang mga MCP server o tumatawag ng mga serbisyo gamit ang credentials mo. Mag-install lang ng mga server na pinagkakatiwalaan mo, at kumpirmahin ang mga aksyong nagsusulat o gumagastos.

## Saan bagay ang BroadNet Inference

Ang BroadNet Inference ang nagbibigay ng panig ng model: GLM 5.3 at Qwen3.8 27B na may nakalistang tool calling, sa pamamagitan ng standard na chat-completions format na magagamit ng bawat MCP client sa itaas, na may zero data retention sa mga prompt at output. Hindi ito nagpapatakbo ng MCP server o hosted na tool para sa iyo; ang client mo ang gumagawa niyon. Nasa [pricing page](https://broadrouter.com/fil/pricing/) ang presyo kada token ng dalawang model, at nasa [inference.broadnet.ai](https://inference.broadnet.ai/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-mcp-with-openai-compatible-models&utm_content=body) ang mga key.

Mga libreng tool para rito (Ingles)

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

[Libreng tools (Ingles)](https://broadrouter.com/tools/)

## Mga termino sa artikulong ito

[Tool calling (function calling)](https://broadrouter.com/fil/glossary/tool-calling/)

Ang tool calling, tinatawag ding function calling, ay feature ng LLM API kung saan nagbabalik ang model ng structured na request para magpatakbo ng function na tinukoy ng developer, kasama ang JSON arguments. Ang application ang nagpapatakbo ng function at nagpapadala pabalik ng resulta; hindi kailanman nagpapatakbo ng code ang model mismo.

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

Ang AI agent ay isang system kung saan ang language model mismo ang nagdidirekta ng mga hakbang nito tungo sa isang layunin: pinipili nito kung aling tools ang tatawagin, binabasa ang mga resulta at umuulit hanggang makabuo ng huling sagot o maabot ang limit. Workflow naman ang karaniwang tawag sa fixed na script na tumatawag sa model sa takdang punto.

[Context window](https://broadrouter.com/fil/glossary/context-window/)

Ang context window ay ang pinakamaraming token na kayang hawakan ng isang language model sa iisang request. Sakop nito ang prompt, history ng usapan, tool definitions, mga larawan at ang nabuong output, kasama ang anumang reasoning tokens. Ang hindi kasya ay kailangang bawasan, ibuod o hatiin sa ilang request.

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

Ang MCP (Model Context Protocol) ay isang open protocol na nakabatay sa JSON-RPC 2.0 na nag-i-standardise kung paano kumokonekta ang mga LLM application sa external na tools at data. Naglalantad ang MCP server ng tools, resources at prompts; hinahanap ito ng MCP client sa host application at ipinapasa sa server ang mga tool call ng model.

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

Ang server-sent events (SSE) ay web standard kung saan nagpapadala ang server ng tuloy-tuloy na text event sa client sa iisang matagal na HTTP response na may content type na text/event-stream. Ang bawat event ay isa o higit pang field line, gaya ng data:, na tinatapos ng blank line.

[Open-weight model](https://broadrouter.com/fil/glossary/open-weight-model/)

Ang open-weight model ay machine learning model na inilathala ang trained weights para i-download at patakbuhin ng kahit sino, kadalasan sa ilalim ng lisensyang may kondisyon. Iba ito sa ganap na open-source AI, na naglalabas din ng training code at detalyadong impormasyon tungkol sa training data para mapag-aralan at ma-reproduce ng iba ang model.

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

Ang token ay ang yunit ng text na binabasa at isinusulat ng isang language model: isang salita, bahagi ng salita, bantas o byte sequence na ginawa ng tokenizer ng model. Sa token binibilang, nililimitahan at kadalasang sinisingil ng mga LLM API ang paggamit.

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

Ang zero data retention (ZDR) ay patakaran kung saan pinoproseso lang ng AI provider ang mga prompt at output para i-serve ang isang request, at hindi na nito itinatago ang content na iyon pagkatapos, sa log, cache o training data. Kadalasang itinatago pa rin ang mga record na walang content, gaya ng bilang ng token at timing.

## Mga tanong

### Puwede ko bang gamitin ang MCP sa model na hindi Claude o GPT?

Oo. Protocol ang MCP sa pagitan ng app mo at ng mga tool server. Ipinapasa ng app ang tools sa kahit anong model na gamit nito sa pamamagitan ng tool-calling format ng model na iyon. Kayang gumamit ng MCP tools ang anumang OpenAI-compatible na model na may gumaganang tool call.

### Kailangan bang sumuporta sa MCP ang model?

Hindi. Function calling lang ang kailangan ng model. Ang MCP client sa app mo ang gumagawa ng trabaho ng protocol: paglista at pagtawag sa tools.

### Aling mga coding agent ang sumusuporta sa MCP na may custom na OpenAI-compatible na model?

Sa Cline, Continue sa Agent mode at opencode, puwede kang mag-configure ng MCP server at custom na OpenAI-compatible na model. May nakalistang MCP support din ang Zoo Code, ang pagpapatuloy ng Roo Code.

### Bakit bumabagal at mas mahal ang agent ko kapag nagdagdag ng MCP server?

Idinadagdag sa prompt ang mga tool definition ng bawat server sa bawat model call. Ang sampung server na may tig-isang dosenang tool ay puwedeng magdagdag ng libu-libong input token kada hakbang. I-enable lang ang mga server na kailangan ng gawain, o i-filter ang tools.

### Gumagana ba ang hosted MCP tools sa ibang provider?

Hindi ang uring naka-host sa OpenAI. Sabi ng docs ng OpenAI Agents SDK, gumagana ang HostedMCPTool sa mga model ng OpenAI na sumusuporta sa hosted MCP integration ng Responses API. Gamitin ang mga lokal na MCP server class ng SDK sa ibang provider.

## Magbasa pa

-   [Tool calling sa open model: schema, parallel call, retry](https://broadrouter.com/fil/blog/tool-calling-open-models/)
-   [Open model sa coding agent: Aider, Cline, opencode, Codex](https://broadrouter.com/fil/blog/use-open-models-in-coding-agents/)
-   [Token budget ng agent: saan napupunta ang token ng agent loop](https://broadrouter.com/fil/blog/agent-token-budget/)
-   [n8n AI Agent sa murang LLM: setup, pagpili ng model at gastos kada run](https://broadrouter.com/fil/blog/n8n-ai-agent-cheap-llm/)
-   [Magkano ang isang run ng AI coding agent: hakbang, context, caching](https://broadrouter.com/fil/blog/ai-coding-agent-run-cost/)
-   [Claude Code sa open model: proxy, native endpoint at mga limit](https://broadrouter.com/fil/blog/claude-code-with-openai-compatible-models/)
-   [Gabay: Cline sa BroadNet Inference: setup ng OpenAI Compatible provider](https://broadrouter.com/fil/guides/cline-openai-compatible/)
-   [Gabay: Continue sa BroadNet Inference: config.yaml at apiBase](https://broadrouter.com/fil/guides/continue-dev-openai-compatible/)
-   [Gabay: Idagdag ang BroadNet Inference sa opencode bilang custom provider](https://broadrouter.com/fil/guides/opencode-custom-provider/)
-   [Gabay: Patakbuhin ang OpenAI Agents SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-agents-sdk-custom-provider/)

Subukan ito sa totoong workload mo. May US$5 na panimulang credit ang mga bagong account para sa Gemma at transcription. Kailangan ng top-up para sa DeepSeek, GLM, at Qwen3.8.

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

**Mga source**

-   [Model Context Protocol, pangkalahatang-tanaw ng architecture (sinuri noong 2026-11-14)](https://modelcontextprotocol.io/docs/learn/architecture)
-   [MCP Python SDK, mga client at transport (sinuri noong 2026-11-14)](https://py.sdk.modelcontextprotocol.io/client/transports/)
-   [Docs ng Cline, pangkalahatang-tanaw ng MCP (sinuri noong 2026-11-14)](https://docs.cline.bot/mcp/mcp-overview)
-   [Docs ng Continue, MCP (sinuri noong 2026-11-14)](https://docs.continue.dev/customize/deep-dives/mcp)
-   [Docs ng opencode, MCP servers (sinuri noong 2026-11-14)](https://opencode.ai/docs/mcp-servers/)
-   [Docs ng n8n, MCP Client Tool node (sinuri noong 2026-11-14)](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolmcp/)
-   [Docs ng OpenAI Agents SDK, MCP (sinuri noong 2026-11-14)](https://openai.github.io/openai-agents-python/mcp/)
