---
title: "What is MCP? The Model Context Protocol explained | BroadRouter"
description: "MCP is an open protocol that lets LLM apps discover and call tools and data from separate servers over JSON-RPC. How hosts, clients and servers fit together."
url: https://broadrouter.com/glossary/mcp/
lang: en
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

# MCP (Model Context Protocol)

Updated 2026-11-14

MCP (Model Context Protocol) is an open protocol, built on JSON-RPC 2.0, that standardises how LLM applications connect to external tools and data. An MCP server exposes tools, resources and prompts; an MCP client inside the host application discovers them and passes tool calls from the model to the server.

Also called: Model Context Protocol, MCP server, MCP client, MCP tools

MCP is a plug standard for LLM apps: write a tool server once, and any MCP-aware client can use it.

## How it works

The specification describes three roles that talk in JSON-RPC 2.0 messages:

-   **Hosts**: “LLM applications that initiate connections”, such as an IDE agent or a chat app.
-   **Clients**: “Connectors within the host application”, one per server.
-   **Servers**: “Services that provide context and capabilities.”

Servers can offer **tools** (functions the model may run), **resources** (data and context) and **prompts** (message templates). The spec defines two standard transports: stdio for a local subprocess, and Streamable HTTP, where each message is an HTTP POST and replies come back as JSON or a server-sent event stream.

For tools, the client sends `tools/list` and gets names, descriptions and an `inputSchema` in JSON Schema. It passes those to the model as tool definitions. When the model returns a [tool call](https://broadrouter.com/glossary/tool-calling/), the client sends `tools/call` with the arguments and hands the result back to the model.

```json
{"jsonrpc": "2.0", "id": 2, "method": "tools/call",
 "params": {"name": "get_weather", "arguments": {"location": "New York"}}}
```

The model never talks to the MCP server. It only sees tool definitions and results, which is why MCP works with any model that handles tool calls well.

## Why it matters

-   **Reuse.** One GitHub or database server serves every [agent](https://broadrouter.com/glossary/agent/) and editor that speaks MCP.
-   **Token cost.** Every listed tool’s name, description and schema is sent as input on each turn. Many servers with many tools make every request longer. Enable only what the task needs.
-   **Security.** The spec says tools “represent arbitrary code execution” and that hosts must get user consent before invoking any tool. Tool results are also a path for [prompt injection](https://broadrouter.com/glossary/prompt-injection/).

## On BroadNet Inference

BroadNet’s docs do not list an MCP server or MCP-specific endpoint. You run MCP in your client (Cline, Continue, opencode and others) and point the client’s model at BroadNet’s OpenAI-compatible API. BroadNet’s docs list tool calling for [GLM 5.3](https://broadrouter.com/models/glm-5.3/) and [Qwen3.8 27B](https://broadrouter.com/models/qwen3.8-27b/). The [MCP with OpenAI-compatible models](https://broadrouter.com/blog/mcp-with-openai-compatible-models/) post shows client setups and a Python bridge.

## Questions

### Does MCP only work with Claude?

No. MCP is model-agnostic. The client turns MCP tools into ordinary tool definitions, so any model that supports tool calling through your client can use them.

### What is the difference between MCP and tool calling?

Tool calling is the model API feature that returns a function name and arguments. MCP is the protocol your app uses to find tools on a server and run them. MCP sits on the application side of the tool loop.

### Does BroadNet run an MCP server?

BroadNet's docs do not list an MCP server. You run MCP servers in your own client or agent, and the client sends tool calls to a BroadNet model over the OpenAI-compatible API.

## See also

-   [Tool calling](https://broadrouter.com/glossary/tool-calling/) (term)
-   [AI agent](https://broadrouter.com/glossary/agent/) (term)
-   [OpenAI-compatible API](https://broadrouter.com/glossary/openai-compatible-api/) (term)
-   [Prompt injection](https://broadrouter.com/glossary/prompt-injection/) (term)
-   [Structured output](https://broadrouter.com/glossary/structured-output/) (term)
-   [Use Cline with BroadNet Inference (OpenAI Compatible provider)](https://broadrouter.com/guides/cline-openai-compatible/) (guide)
-   [Use Continue with BroadNet Inference (config.yaml and apiBase)](https://broadrouter.com/guides/continue-dev-openai-compatible/) (guide)
-   [Add BroadNet Inference to opencode as a custom provider](https://broadrouter.com/guides/opencode-custom-provider/) (guide)
-   [Use MCP servers with OpenAI-compatible models (any provider)](https://broadrouter.com/blog/mcp-with-openai-compatible-models/) (article)
-   [Tool calling with open models: schemas, parallel calls, retries](https://broadrouter.com/blog/tool-calling-open-models/) (article)

Try it on your real workload. New accounts start with $5 of credit for Gemma and transcription. DeepSeek, GLM and Qwen3.8 need a top-up.

[Get started](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=glossary-mcp&utm_content=page-cta) ·

**Sources**

-   [Model Context Protocol specification (overview, hosts, clients and servers)](https://modelcontextprotocol.io/specification/latest)
-   [Model Context Protocol specification, server tools (tools/list, tools/call)](https://modelcontextprotocol.io/specification/2026-07-28/server/tools)
-   [Model Context Protocol specification, transports (stdio, Streamable HTTP)](https://modelcontextprotocol.io/specification/2026-07-28/basic/transports)
