A local model can already call a function. What it usually cannot do is reach the program that does the work: the file on disk, the git repository, the browser session. The Model Context Protocol (MCP) is the layer that connects a model to those programs, and the local runtimes disagree about how to do it. llama.cpp’s server takes stdio servers only. Open WebUI’s own server configuration takes Streamable HTTP only, and only from an administrator, though its Tether app can launch a local stdio server on your own machine. LM Studio takes both. Ollama’s current release ships no MCP endpoint in its published API.
Key Takeaways
- MCP carries JSON-RPC over two standard transports: stdio (a client-launched subprocess) and Streamable HTTP. The revision in force is 2026-07-28 (MCP versioning).
- llama.cpp’s
llama-serverv1.0.0 hosts stdio MCP servers and exposes each of their tools as<server>_<tool>(llama.cpp server README at v1.0.0). - LM Studio has been an MCP Host since 0.3.17 and reads servers from
mcp.json; its REST API can also attach one per request (app docs, API docs). - Open WebUI has supported MCP since v0.6.31, but its own server configuration takes Streamable HTTP only and only an administrator can add one; since v0.13.4 its Tether app can launch a local stdio server on your own computer (Open WebUI MCP docs, v0.13.4 release notes).
- Ollama v0.40.17 ships no MCP endpoint in its published API: the OpenAPI specification lists 16 paths and none of them is one (Ollama OpenAPI specification).
- The stdio transport provides no isolation. A local MCP server is an ordinary process running with your privileges, so containment is your decision, not the protocol’s (MCP local server security).
What MCP Actually Is
MCP is a protocol, not a model and not a runtime. It uses JSON-RPC to encode messages, and a transport only defines how messages are framed and delivered, not what they mean: the message patterns are the same on every binding (MCP transports overview).
Version identifiers are strings in YYYY-MM-DD form, marking the last date a backwards-incompatible change was made. The current protocol version is 2026-07-28 (MCP versioning, release tag), and it is not incremented for changes that stay backwards compatible. Every request carries the version it is speaking in the _meta field under io.modelcontextprotocol/protocolVersion; on Streamable HTTP the same value travels in the MCP-Protocol-Version header. A server that does not support the requested version answers with an UnsupportedProtocolVersionError listing what it does support.
Servers must also implement server/discover, a single request that returns the supported protocol versions, capabilities and identity together. Clients may call it or skip it, but on stdio a client that speaks both the modern and the older handshake-based protocol is expected to probe with it first, because there is no HTTP status code to drive the fallback (MCP discovery). The identity a server reports there is self-reported and not verified by the protocol, so clients are told not to base security decisions on it.
The 2026-07-28 revision also deprecated a chunk of the original surface area: Roots, Sampling, Logging and Dynamic Client Registration are all marked Deprecated, with the earliest removal set as the first revision released on or after 2027-07-28 (MCP deprecated features registry). If you are starting fresh, that is four fewer things to learn.
Which Local Runtime Can Host MCP Servers
| Runtime | Current release | MCP host | Transport | Where you configure it |
|---|---|---|---|---|
llama.cpp llama-server | v1.0.0 | Yes | stdio only (server side) | --mcp-servers-config PATH or --mcp-servers-json JSON on the command line |
| LM Studio | 0.4.28 | Yes | stdio and remote | mcp.json in the app, or the integrations field on a REST request |
| Open WebUI | v0.13.4 | Yes | Streamable HTTP only; stdio via Tether | Settings > Admin > Integrations, type MCP (Streamable HTTP); Tether Settings > Integrations for stdio |
| Ollama | v0.40.17 | No MCP endpoint in its OpenAPI spec | - | - |
llama.cpp is the most direct option for a headless server. The v1.0.0 README documents an MCP servers section: “Only the stdio transport is supported”, because the server is a child process speaking JSON-RPC over stdin and stdout, so nothing has to be started or maintained outside llama-server (llama.cpp server README at v1.0.0). That limit applies to servers llama-server hosts; the README separately notes that the bundled Web UI can connect to MCP servers directly from the browser. The llama-server config file uses Cursor’s notation:
{
"mcpServers": {
"files": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/project"] }
}
}
Each entry takes command (required), args, env, cwd and timeout_ms, which defaults to 30000. Every server is spawned once at startup to list its tools, then stopped, and respawned on demand when one of its tools is called. The tools appear as <server>_<tool> in the Web UI and in GET /tools. Both flags are labelled experimental, and the README is explicit: “The child process runs with the same privileges as the server, so only declare commands you trust.”
LM Studio is the only one of the three that takes both kinds of server in the same application. Its app documentation says LM Studio has acted as an MCP Host since 0.3.17 and supports local and remote servers, following Cursor’s mcp.json notation (LM Studio app docs). The REST route is a separate step up: the API documentation requires LM Studio 0.4.0 or newer, and splits servers into ephemeral ones defined per request under integrations and pre-configured ones from mcp.json referenced by an id such as mcp/playwright (LM Studio API docs).
Open WebUI is the odd one out. It supports MCP from v0.6.31 onwards, but its own documentation is explicit that native support is Streamable HTTP only, because it is a web-based multi-tenant environment rather than a local desktop process. Adding a server to the instance is an administrator action under Settings > Admin > Integrations, and the type must be set to MCP (Streamable HTTP). Entering MCP-style JSON into an OpenAPI connection is a documented mistake that leaves the frontend on an infinite loading screen. For a stdio server, Open WebUI points at the mcpo proxy, which translates stdio or SSE servers into OpenAPI-compatible endpoints (Open WebUI MCP docs).
That has changed since. v0.13.4, released on 17 November 2026, added a second path for stdio servers: the Tether app, which runs on your own computer, can launch a local stdio server and pass its tools to Open WebUI, so a stdio server no longer needs the mcpo proxy and no port has to be opened. The release notes put the floor at Tether 0.1.16 for MCP servers, with an ENABLE_TOOL_SERVERS setting to turn on, and Tether’s own documentation notes that local commands run with your own account’s access and outside its workspace sandbox (v0.13.4 release notes, Tether MCP docs).
Ollama ships no MCP endpoint in its published API. Its OpenAPI specification lists 16 endpoint paths and none is an MCP endpoint, and its documentation index has no MCP page (Ollama OpenAPI specification, Ollama documentation index). Ollama is still useful in the other direction, as the model behind an MCP client: v0.40.17 made ollama launch claude load MCP tools on demand rather than all at once (v0.40.17 release notes). That is a separate piece of work covered in Best Ollama Models to Drive Claude Code.
Verifying a Server Before You Trust It
The MCP Inspector is the reference tool for this, and it needs Node.js 22.23.4+, 24.22.1+ or 26.12.1+. One package ships three clients: a browser UI, a scriptable CLI and a terminal UI. The CLI shows what a server exposes without a model in the loop:
npx @modelcontextprotocol/inspector --cli node path/to/server/index.js --method tools/list
The same tool can call a tool and pipe the result into jq, and it will connect to a remote server over HTTP with --transport http and --server-url (MCP Inspector docs).
One practical warning from LM Studio’s own documentation applies to every local model: some MCP servers were designed for Claude, ChatGPT or Gemini and may use excessive amounts of tokens, which can quickly bog down a local model and trigger frequent context overflows (LM Studio app docs). Start with one server and two tools, not with a dozen servers and full filesystem access.
The Part You Have to Own
The MCP project’s security documentation is unusually direct about local servers, and the reason is worth repeating here: no sandbox is provided by the protocol. A local server is an ordinary operating system process, launched by the host application, and it carries whatever access that implies (MCP local server security).
That process inherits your environment variables, can read anything your account can read, and can open outbound network connections. The stdio design assumes client and server share one trust domain, so the security decisions happen before launch rather than at runtime. Three consequences follow.
First, containment is manual. The baseline is to run third-party servers inside a container with no volume mounts beyond what the server needs, which leaves stdio working unchanged, because the client talks to the container’s stdin and stdout as it would to a bare process. llama.cpp has a related flag, --tools-runtime docker:<image>, which spins up a container and reuses it for every invocation of its built-in tools; its README does not say the flag also applies to MCP servers, so do not count on it for them.
Second, the trust domain is cumulative. Every server shares the same model context, so a malicious server can influence how the agent uses every other server’s tools, even if the poisoned tool is never called. Keep the roster small.
Third, tool definitions are untrusted input. The model reads tool names and descriptions as instructions, and a server can change those definitions after you approved it. Read the tool list before you rely on a server, and prefer a client that asks again when a definition changes.
The consent duty sits with the client, not the server. The protocol’s security best practices require a client offering one-click local server configuration to show the exact command that will run, untruncated, and get explicit approval before executing it (MCP security best practices). A consent dialog only helps if you read the command it shows you.
What This Means
MCP is what turns a local model from something that writes text into something that acts on your machine, and that shift moves the risk. A wrong answer is annoying; a wrong tool call running with your SSH keys in the environment is a different category. The protocol is mature enough to be worth using and young enough that the deprecated list is still moving.
As hosts, the four runtimes split by transport: stdio servers go to llama.cpp’s llama-server, LM Studio, or Open WebUI’s Tether app, Streamable HTTP servers to LM Studio or Open WebUI, and Ollama stays out of the picture as a host. Whichever you pick, the containment work is the same and it is not optional.
The Bottom Line
Start with the Inspector, not with the model. Run tools/list against a server you have read the source of, look at what it exposes, and only then point a runtime at it. Give each server its own narrowly scoped credentials through its per-server config rather than inheriting your shell environment. And run it in a container with a single directory mounted, because the protocol is not going to stop it reading the rest of your disk.
If you want the layer underneath this one, Structured Output and Tool Use with Local LLMs covers how models emit tool calls at all, and How to Call a Local LLM API covers the HTTP surface these runtimes expose. Our other local AI guides are under Local AI coverage.