MCP Server for Ollama: Use MCP Tools with Local Models

Can Ollama Use MCP Servers?

Not by itself. Ollama serves models and supports tool calling, but it is not an MCP client: it never launches or connects to MCP servers. To use an MCP server with Ollama, run an MCP client that talks to Ollama as its model backend, such as ollmcp in the terminal, Claude Code or Codex through ollama launch, Goose, or Open WebUI, and pick a local model that supports tools.

This guide compares those options, walks through a working setup, and lists the limits that bite when you swap a frontier model for a local one. If you still need servers to try, start with the MCP server directory.

How the Pieces Fit

An MCP setup has three parts, and Ollama only fills one:

1. The model, which decides when to call a tool. This is Ollama.
2. The MCP client (also called the host), which starts or connects to MCP servers, gives the model their tool list, executes the calls, and feeds results back. Ollama doesn't do this.
3. The MCP servers, which provide the actual tools, for example a browser, a filesystem or GitHub.

So the question "which MCP server for Ollama?" is really "which client lets my Ollama model use MCP servers?" Any MCP server from the directory works once you have that client. For the background, see how MCP works and our MCP client guide.

Your Options at a Glance

All of these were actively maintained as of October 2026. One that often appears in older tutorials, mcphost, is now archived on GitHub, so it's left out.

Step 1: Pick a Model That Supports Tools

MCP only works if the model can emit tool calls. Ollama marks those models with a tools tag; the full list is at ollama.com/search?c=tools. Models with that tag at the time of writing include:

A practical rule: small models (1 to 4B parameters) can call one well-described tool, but they get confused when many servers expose dozens of tools. For agent-style work with several servers, 20B and up behaves noticeably better.

Raise the context length

This is the most common reason MCP "doesn't work" with Ollama. Every tool definition goes into the prompt, and Ollama's default context depends on VRAM: 4k tokens under 24 GiB, 32k between 24 and 48 GiB, 256k at 48 GiB or more. Ollama recommends at least 64,000 tokens for agents and coding tools. Set it in the Ollama app's settings slider, or when starting the server:

OLLAMA_CONTEXT_LENGTH=64000 ollama serve

Then check what was actually allocated with ollama ps (the CONTEXT column).

Step 2 (Fastest): ollmcp in the Terminal

ollmcp is an MCP client built specifically for Ollama. It supports stdio, SSE and Streamable HTTP servers, lets you toggle tools, and asks for confirmation before each tool call.

# install
uv tool install --upgrade ollmcp    # or: pip install --upgrade ollmcp

# add MCP servers (saved for future sessions)
ollmcp mcp add playwright -- npx @playwright/mcp@latest
ollmcp mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem ~/Documents

# start a chat with a tool-capable model
ollmcp --model qwen3:8b

Inside the session, /tools opens the tool selector, /model switches models, and /hil toggles the human-in-the-loop confirmations. Remote servers work too:

ollmcp mcp add --transport http github https://api.githubcopilot.com/mcp/ \
  --header "Authorization: Bearer $YOUR_GITHUB_PAT"

That's the GitHub MCP server with a personal access token. If you already have servers in Claude Desktop, ollmcp --claude-desktop loads them from its config. A good first test is the Playwright MCP server: ask the model to open a page and summarize it, and watch the tool calls in the terminal.

Step 2 (Coding): Claude Code or Codex on Ollama

Ollama can launch the two big coding agents against local models, and both are full MCP clients.

Claude Code. ollama launch claude starts Claude Code using Ollama's Anthropic-compatible API. Add MCP servers the normal way; they're stored in Claude Code's config, not Ollama's:

claude mcp add --transport http context7 https://mcp.context7.com/mcp
ollama launch claude --model qwen3.5

To set it up manually instead, Ollama's docs use these variables:

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model qwen3.5

See our Claude Code MCP guide for scopes, OAuth and /mcp.

Codex CLI. ollama launch codex (or codex --oss -m gpt-oss:20b) runs Codex on Ollama. MCP servers go in ~/.codex/config.toml via codex mcp add; our Codex MCP setup covers the details. Both agents need a 64k+ context window to be usable.

Step 2 (Desktop): Goose

Goose is an open-source agent with an Ollama provider and MCP servers as "extensions":

1. Connect Ollama: in Goose Desktop open Settings, then Configure Provider, find Ollama and confirm the API host is http://localhost:11434. In the CLI, run goose configure, choose Configure Providers, then Ollama, and enter a model name like qwen3.
2. Add an MCP server: in Desktop, open Extensions in the sidebar and click Add custom extension. In the CLI, goose configure, then Add Extension, then Command-line Extension (stdio) or Remote Extension (Streamable HTTP).

Extensions are saved in ~/.config/goose/config.yaml.

Step 2 (Web UI): Open WebUI

Open WebUI supports MCP natively from v0.6.31, and it already pairs with Ollama for the models. As an admin:

1. Go to Settings, Admin, then Integrations.
2. Under External Tool Servers, click + Add Connection.
3. Set Type to MCP (Streamable HTTP), enter the server URL and pick an auth mode (None, Bearer, OAuth 2.1 and others).
4. Save, then enable the tool in a chat.

Native MCP here is Streamable HTTP only. For a stdio server, wrap it with mcpo, which exposes it as an OpenAPI tool server:

uvx mcpo --port 8000 --api-key "top-secret" -- your_mcp_server_command

Two common gotchas: don't choose the OpenAPI type for an MCP URL, and the server URL must be reachable from the Open WebUI backend, not just your browser.

Other Routes

• VS Code. The Ollama extension adds your local models to the VS Code Chat model picker, and MCP servers are configured in VS Code itself; see VS Code MCP setup. Pick a tools-tagged model if you want the agent to call MCP tools.
• oterm. A terminal chat client for Ollama (uvx oterm) with MCP tools over stdio and Streamable HTTP, configured under mcpServers in its config.json.
• Your own client. Ollama's Python and JavaScript libraries support tool calling, so you can connect them to the official MCP SDKs: list the server's tools, pass them to chat() as tool definitions, run the calls through the MCP session and return the results. Our Python MCP server guide covers the SDK side.

Limitations to Expect

• Tool-call quality. Local models skip tools, invent arguments or loop more often than frontier models. Fewer tools and clear tool descriptions help more than anything else; see MCP tool discovery.
• Context pressure. A single large server can add thousands of tokens of tool schemas. Enable only the servers a task needs.
• Speed. Each tool round trip is another full generation. Partial CPU offloading (check ollama ps) makes agent loops slow.
• Local doesn't mean offline. The model runs locally, but remote MCP servers (GitHub, Notion) still send your data to those services.
• Same security rules. A local stdio server runs with your permissions whatever the model. Keep confirmations on, and read MCP security best practices.

Troubleshooting

Next Steps

• Find servers to plug into your local setup in the MCP server directory; Filesystem, Playwright and Memory are good first picks because they run fully locally.
• New to the protocol? Read what is MCP and MCP vs RAG.
• Want to expose your own tools to a local model? Start with building an MCP server.