BroadRouter

Paano gamitin ang MCP server sa OpenAI-compatible na model

Ng BroadNet Inference team · 4 minutong basa · Nailathala · Na-update

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.

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

Aling model ang dapat gamitin para sa MCP?

Model sa BroadNet Nakalista ang tool calling Context Bagay sa MCP
GLM 5.3 Oo 1,048,576 Magandang default para sa maraming server
Qwen3.8 27B Oo 262,144 Maganda, may image input pa
DeepSeek V4.1 Flash Hindi nakalista 1,048,576 I-test muna; image input
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. 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 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, Continue at opencode 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:

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:

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 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. 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 ng malinis at flat na parameters schema.
  • Malalaking tool result. Puwedeng lumampas sa 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.
  • 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 ang presyo kada token ng dalawang model, at nasa inference.broadnet.ai ang mga key.

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.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity