---
title: "Server MCP dengan model kompatibel OpenAI: cara kerjanya"
description: "MCP bisa dipakai dengan LLM apa pun: client mengubah tool MCP menjadi function call. Cara memakai MCP dengan model terbuka di Cline, Continue, opencode, n8n, Python."
url: https://broadrouter.com/id/blog/mcp-with-openai-compatible-models/
lang: id
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Diterjemahkan dari bahasa Inggris dengan bantuan AI. [Baca versi asli bahasa Inggris](https://broadrouter.com/blog/mcp-with-openai-compatible-models/) (diperbarui 2026-11-16).

# Memakai server MCP dengan model kompatibel OpenAI (penyedia apa pun)

Oleh tim BroadNet Inference · 4 menit baca · Dipublikasikan 2026-11-14 · Diperbarui 2026-11-16

MCP tidak bergantung pada model. Client MCP di aplikasi Anda mendaftar tool setiap server, meneruskannya ke model sebagai tool function calling biasa, dan menjalankan tools/call saat model memintanya. Model kompatibel OpenAI apa pun dengan tool calling yang andal bisa memakai server MCP. Konfigurasikan di Cline, Continue, opencode, atau n8n, atau jembatani dengan sekitar 40 baris Python.

## Poin penting

-   Dokumentasi MCP menyebut protokol ini "does not dictate how AI applications use LLMs" (Terjemahan BroadRouter: tidak mengatur bagaimana aplikasi AI memakai LLM). Aplikasi host yang menerjemahkan tool MCP ke format tool milik model.
-   Model perlu mendukung tool calling. Di BroadNet Inference, GLM 5.3 dan Qwen3.8 27B mencantumkannya.
-   Cline, Continue (hanya mode Agent), opencode, n8n, dan OpenAI Agents SDK semuanya bisa bertindak sebagai client MCP dengan model kustom.
-   Setiap skema tool MCP dikirim di setiap panggilan model. Dokumentasi opencode memperingatkan bahwa tool MCP memakan konteks model; tambahkan hanya server yang Anda perlukan.
-   Tool MCP ter-hosting yang berjalan di dalam Responses API OpenAI tidak bekerja dengan penyedia lain; client MCP lokal bisa.

**Di halaman ini**

1.  Kenapa MCP bisa bekerja dengan model apa pun?
2.  Model mana yang sebaiknya dipakai untuk MCP?
3.  Bagaimana menyiapkan MCP di client yang umum?
4.  Bagaimana menjembatani MCP ke model terbuka di Python?
5.  Apa yang sering salah dengan MCP pada model terbuka?
6.  Posisi BroadNet Inference

Model Context Protocol (MCP) memberi agen cara standar untuk menjangkau tool: GitHub, database, file system, browser. Banyak tutorial MCP mengasumsikan Anda memakai Claude atau GPT. Anda tidak memerlukan keduanya. Artikel ini menjelaskan kenapa MCP bekerja dengan model [kompatibel OpenAI](https://broadrouter.com/id/glossary/openai-compatible-api/) apa pun yang mendukung tool calling, cara menyiapkannya di client yang benar-benar dipakai developer, dan cara menjembatani MCP ke model terbuka di kode Anda sendiri.

## Kenapa MCP bisa bekerja dengan model apa pun?

MCP berada di antara aplikasi Anda dan server tool, bukan di antara aplikasi Anda dan model. Dokumentasi arsitektur MCP menjelaskan tiga peran:

-   **Host:** aplikasi AI, seperti ekstensi editor atau skrip Anda.
-   **Client:** satu koneksi yang dijaga host ke setiap server MCP.
-   **Server:** program yang menyediakan tool, resource, dan prompt, secara lokal lewat stdio atau secara remote lewat Streamable HTTP.

Dokumentasinya tegas: MCP “does not dictate how AI applications use LLMs or manage the provided context.” (Terjemahan BroadRouter: tidak mengatur bagaimana aplikasi AI memakai LLM atau mengelola konteks yang diberikan.) Host mendaftar tool setiap server dengan `tools/list`, menggabungkannya ke satu registry yang bisa dilihat model, dan ketika model meminta sebuah tool, host mengirim `tools/call` ke server yang tepat.

Di API yang kompatibel dengan OpenAI, “bisa dilihat model” berarti tool-tool itu masuk ke array `tools` biasa. Tool MCP sudah punya nama, deskripsi, dan `inputSchema`, yang dipetakan satu-satu ke definisi fungsi. Model tidak pernah tahu bahwa MCP terlibat. Yang dibutuhkannya hanyalah [tool calling](https://broadrouter.com/id/glossary/tool-calling/) yang andal.

## Model mana yang sebaiknya dipakai untuk MCP?

| Model di BroadNet | Tool calling tercantum | Konteks | Kecocokan untuk MCP |
| --- | --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/id/models/glm-5.3/) | Ya | 1.048.576 | Pilihan default yang baik untuk banyak server |
| [Qwen3.8 27B](https://broadrouter.com/id/models/qwen3.8-27b/) | Ya | 262.144 | Baik, plus input gambar |
| [DeepSeek V4.1 Flash](https://broadrouter.com/id/models/deepseek-v4.1-flash/) | Tidak tercantum | 1.048.576 | Uji dulu; input gambar |
| [Gemma 4 VL 26B](https://broadrouter.com/id/models/gemma-4-vl-26b/) | Tidak tercantum | 32.768 | Tidak direkomendasikan |

Untuk perbandingan dua model yang mendukung tool, lihat [GLM 5.3 vs Qwen3.8 27B](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/). Konteks lebih penting daripada yang orang kira. Setiap skema tool MCP ikut terkirim di setiap panggilan. Dokumentasi opencode menyebut “MCP tools consume model context, so add only the servers you need.” (Terjemahan BroadRouter: tool MCP memakan konteks model, jadi tambahkan hanya server yang Anda perlukan.) Artikel [anggaran token agen](https://broadrouter.com/id/blog/agent-token-budget/) menunjukkan cara mengukurnya.

## Bagaimana menyiapkan MCP di client yang umum?

| Client | Tempat server MCP | Transport | Catatan |
| --- | --- | --- | --- |
| Cline | Panel MCP Servers, JSON `mcpServers` | stdio, Streamable HTTP, SSE lama | Tipe remote `"streamableHttp"` |
| Continue | `mcpServers` di `config.yaml` atau `.continue/mcpServers/` | stdio, sse, streamable-http | Hanya mode Agent |
| opencode | `mcp.servers` di `opencode.jsonc` | `local`, `remote` | Pakai `{env:NAME}` untuk secret |
| n8n | Node MCP Client Tool pada AI Agent | Endpoint server remote (dokumentasinya menjelaskan endpoint SSE) | Pilih tool All, Selected, atau All Except |
| OpenAI Agents SDK | `mcp_servers=[...]` pada Agent | stdio, Streamable HTTP, SSE | Bukan `HostedMCPTool` |

Lalu arahkan model di client ke penyedia Anda: panduan [Cline](https://broadrouter.com/id/guides/cline-openai-compatible/), [Continue](https://broadrouter.com/id/guides/continue-dev-openai-compatible/), dan [opencode](https://broadrouter.com/id/guides/opencode-custom-provider/) membahas sisi model untuk BroadNet. Di Continue, jangan lupa capability `tool_use`, kalau tidak mode Agent tidak akan tersedia.

Contoh Continue, dari dokumentasinya:

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

## Bagaimana menjembatani MCP ke model terbuka di Python?

Jika Anda membangun agen sendiri, jembatannya pendek. Contoh ini memakai `Client` dari MCP Python SDK (versi 2.0 atau lebih baru; `pip install "mcp>=2"`), yang menjalankan server stdio jika diberi `StdioServerParameters`, dan OpenAI SDK yang diarahkan ke 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.")))
```

Di `mcp` 1.x tidak ada kelas `Client`: buka server dengan `stdio_client(...)`, bungkus dengan `ClientSession`, panggil `initialize()`, dan baca field camelCase `inputSchema` dan `isError`. Tiga detail penting:

1.  **Error menjadi hasil tool.** MCP SDK melaporkan kegagalan tool lewat `is_error`, bukan dengan memunculkan exception. Teruskan kembali agar model bisa menyesuaikan diri. [Panduan tool calling](https://broadrouter.com/id/blog/tool-calling-open-models/) kami membahas validasi dan retry.
2.  **Batasi loop-nya.** Delapan langkah di sini. Server MCP yang mengembalikan hasil besar cepat memenuhi konteks.
3.  **Filter tool.** Sediakan hanya tool yang dibutuhkan tugas tersebut. OpenAI Agents SDK menyediakan `tool_filter` untuk ini, dan n8n punya opsi Selected dan All Except.

Memakai OpenAI Agents SDK? Kelas `MCPServerStdio` dan `MCPServerStreamableHttp` miliknya berjalan di proses Anda. Gabungkan dengan penyedia kustom seperti di [panduan Agents SDK](https://broadrouter.com/id/guides/openai-agents-sdk-custom-provider/) kami. `HostedMCPTool`\-nya berjalan di dalam Responses API OpenAI dan hanya bekerja dengan model OpenAI.

## Apa yang sering salah dengan MCP pada model terbuka?

-   **Terlalu banyak tool.** Model memilih tool yang salah atau mengabaikan tool. Jaga agar set tool aktif tetap kecil. Untuk tool Anda sendiri, [generator JSON schema](https://broadrouter.com/tools/json-schema-generator/) menghasilkan skema `parameters` yang bersih dan datar.
-   **Hasil tool yang besar.** Server yang mengembalikan seluruh tabel database bisa melampaui [context window](https://broadrouter.com/id/glossary/context-window/). Batasi atau pakai paginasi.
-   **Balasan kosong atau terpotong.** GLM 5.3 dan Qwen3.8 27B bernalar dulu, dan penalaran dihitung ke dalam `max_tokens`. [Naikkan batasnya](https://broadrouter.com/id/guides/reasoning-tokens-empty-response/).
-   **Kepercayaan.** Server MCP menjalankan kode di mesin Anda atau memanggil layanan dengan kredensial Anda. Pasang server yang Anda percayai, dan konfirmasi aksi yang menulis data atau mengeluarkan biaya.

## Posisi BroadNet Inference

BroadNet Inference menyediakan sisi model: GLM 5.3 dan Qwen3.8 27B dengan tool calling tercantum, lewat format chat-completions standar yang bisa dipakai setiap client MCP di atas, dengan zero data retention untuk prompt dan output. BroadNet tidak menjalankan server MCP atau tool ter-hosting untuk Anda; itu tugas client Anda. Harga per token untuk kedua model ada di [halaman harga](https://broadrouter.com/id/pricing/), dan kunci API tersedia di [inference.broadnet.ai](https://inference.broadnet.ai/?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-mcp-with-openai-compatible-models&utm_content=body).

Alat gratis untuk topik ini (bahasa Inggris)

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

[Alat gratis (bahasa Inggris)](https://broadrouter.com/tools/)

## Istilah dalam artikel ini

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

MCP (Model Context Protocol) adalah protokol terbuka berbasis JSON-RPC 2.0 yang menstandarkan cara aplikasi LLM terhubung ke tool dan data eksternal. Server MCP menyediakan tools, resources, dan prompts; client MCP di dalam aplikasi host menemukannya dan meneruskan tool call dari model ke server.

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

Tool calling, disebut juga function calling, adalah fitur API LLM di mana model mengembalikan permintaan terstruktur untuk menjalankan fungsi yang didefinisikan developer, lengkap dengan argumen JSON. Aplikasi yang menjalankan fungsi itu dan mengirim hasilnya kembali; model tidak pernah menjalankan kode sendiri.

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

Server-sent events (SSE) adalah standar web yang memungkinkan server mengirim aliran event teks ke client melalui satu respons HTTP yang tetap terbuka lama, dengan content type text/event-stream. Setiap event terdiri dari satu atau beberapa baris field, seperti data:, dan diakhiri baris kosong.

[Model open-weight (bobot terbuka)](https://broadrouter.com/id/glossary/open-weight-model/)

Model open-weight adalah model machine learning yang bobot hasil pelatihannya dipublikasikan agar bisa diunduh dan dijalankan siapa saja, biasanya di bawah lisensi dengan syarat tertentu. Model ini berbeda dari AI yang sepenuhnya open source, yang juga merilis kode pelatihan dan informasi rinci tentang data pelatihan agar orang lain bisa mempelajari dan mereproduksinya.

[Context window (jendela konteks)](https://broadrouter.com/id/glossary/context-window/)

Context window adalah jumlah token maksimum yang bisa diolah model bahasa dalam satu permintaan. Cakupannya meliputi prompt, riwayat percakapan, definisi tool, gambar, dan output yang dihasilkan, termasuk token penalaran. Apa pun yang tidak muat harus dipotong, diringkas, atau dibagi ke beberapa permintaan.

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

Token adalah satuan teks yang dibaca dan ditulis model bahasa: sebuah kata, bagian kata, tanda baca, atau urutan byte yang dihasilkan tokenizer model. API LLM menghitung, membatasi, dan biasanya menagih pemakaian dalam token.

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

Zero data retention (ZDR) adalah kebijakan penanganan data di mana penyedia AI memproses prompt dan output hanya untuk melayani permintaan dan tidak menyimpan konten itu sesudahnya, baik di log, cache, maupun data pelatihan. Catatan tanpa konten seperti jumlah token dan durasi biasanya tetap disimpan.

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

Agen AI adalah sistem di mana model bahasa mengarahkan langkahnya sendiri menuju suatu tujuan: model memutuskan tool mana yang dipanggil, membaca hasilnya, dan mengulanginya sampai menghasilkan jawaban akhir atau mencapai batas. Skrip tetap yang memanggil model di titik-titik tertentu biasanya disebut workflow.

## Pertanyaan umum

### Bisakah saya memakai MCP dengan model selain Claude atau GPT?

Bisa. MCP adalah protokol antara aplikasi Anda dan server tool. Aplikasi meneruskan tool ke model apa pun yang dipakainya lewat format tool calling model tersebut. Model kompatibel OpenAI apa pun yang tool call-nya berfungsi bisa memakai tool MCP.

### Apakah modelnya harus mendukung MCP?

Tidak. Model hanya perlu mendukung function calling. Client MCP di aplikasi Anda yang mengerjakan urusan protokolnya, yaitu mendaftar tool dan memanggilnya.

### Agen coding mana yang mendukung MCP dengan model kustom yang kompatibel OpenAI?

Cline, Continue dalam mode Agent, dan opencode semuanya memungkinkan Anda mengonfigurasi server MCP dan model kustom yang kompatibel OpenAI. Zoo Code, kelanjutan dari Roo Code, juga mencantumkan dukungan MCP.

### Kenapa menambah server MCP membuat agen saya lebih lambat dan lebih mahal?

Definisi tool dari setiap server ditambahkan ke prompt di setiap panggilan model. Sepuluh server dengan masing-masing selusin tool bisa menambah ribuan token input per langkah. Aktifkan hanya server yang dibutuhkan tugas itu, atau filter tool-nya.

### Apakah tool MCP ter-hosting bekerja dengan penyedia lain?

Tidak untuk yang di-hosting OpenAI. Dokumentasi OpenAI Agents SDK menyebut HostedMCPTool bekerja dengan model OpenAI yang mendukung integrasi MCP ter-hosting di Responses API. Pakai kelas server MCP lokal milik SDK untuk penyedia lain.

## Baca juga

-   [Tool calling dengan model terbuka: skema, panggilan paralel, retry](https://broadrouter.com/id/blog/tool-calling-open-models/)
-   [Model terbuka di agen coding: Aider, Cline, opencode, Codex](https://broadrouter.com/id/blog/use-open-models-in-coding-agents/)
-   [Anggaran token agen: ke mana token loop agen pergi](https://broadrouter.com/id/blog/agent-token-budget/)
-   [AI Agent n8n dengan LLM murah: setup, pilihan model, biaya per run](https://broadrouter.com/id/blog/n8n-ai-agent-cheap-llm/)
-   [Berapa biaya sekali jalan agen coding AI: langkah, konteks, caching](https://broadrouter.com/id/blog/ai-coding-agent-run-cost/)
-   [Claude Code dengan model terbuka: proxy, endpoint native, dan batasnya](https://broadrouter.com/id/blog/claude-code-with-openai-compatible-models/)
-   [Panduan: Memakai Cline dengan BroadNet Inference (provider OpenAI Compatible)](https://broadrouter.com/id/guides/cline-openai-compatible/)
-   [Panduan: Memakai Continue dengan BroadNet Inference (config.yaml dan apiBase)](https://broadrouter.com/id/guides/continue-dev-openai-compatible/)
-   [Panduan: Menambahkan BroadNet Inference ke opencode sebagai custom provider](https://broadrouter.com/id/guides/opencode-custom-provider/)
-   [Panduan: Menjalankan OpenAI Agents SDK di BroadNet Inference](https://broadrouter.com/id/guides/openai-agents-sdk-custom-provider/)

Coba dengan beban kerja Anda yang sebenarnya. Akun baru mendapat kredit US$5 untuk Gemma dan transkripsi. DeepSeek, GLM, dan Qwen3.8 memerlukan top up.

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

**Sumber**

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