mcp-client-for-ollama (ollmcp): a terminal MCP client for local Ollama models

The gap ollmcp fills between a local model and an MCP server

Ollama gives you a local model and an HTTP API. MCP servers give you tools, prompts and resources over stdio, SSE or Streamable HTTP. Neither side speaks the other's protocol on its own, so wiring them together means writing a client that lists tools, feeds their schemas to the model, parses the model's tool calls, executes them against the right server, and puts the results back into the conversation. ollmcp is that client, packaged as an interactive terminal application rather than a library.

The intended user is someone doing harness work: building and testing MCP servers, or exploring what a local model can do when it has real tools attached. The README frames it as a controlled terminal space where you steer and the agent executes. That framing matters, because the project's answer to the safety problem is not sandboxing but visibility. Tool calls can be reviewed before they run, individual tools or whole servers can be disabled mid-session, and Agent Mode stops at a configurable loop limit and asks whether to continue, wrap up or abort. It is aimed at a person sitting at the keyboard, not at a scheduler.

How tool calls and MCP primitives flow through the client

The client connects to multiple MCP servers at once over three transports: STDIO, SSE and Streamable HTTP. From each server it can enumerate the three core MCP primitives. Tools become callable functions. Prompts are browsable and invokable with argument collection, a preview step and what the README calls safe rollback. Resources are read as contextual data: files, documents, structured data.

On the model side, Ollama is the default provider, and the dependency list in pyproject.toml pulls in any-llm-sdk with the ollama, openai and atlascloud extras, so OpenAI-compatible endpoints (OpenAI, OpenRouter, DeepSeek and similar) are reachable through the same interface, with connection settings remembered per provider. Responses stream as they are generated, and the display can be switched between Plain, Markdown, Both and Markdown (blocks) while streaming.

Agent Mode is the part that changes the shape of a session. When a model asks for several tool calls in sequence, the client keeps looping instead of stopping after the first result. That loop has a limit, and hitting it produces an interactive choice rather than a silent truncation. Human-in-the-Loop sits in front of execution: tool calls can be approved before they run. Neither behaviour is on by default in the sense of being invisible, both are session controls, which is consistent with the project treating the operator as the last line of defence.

Installing ollmcp and connecting a first MCP server

The package requires Python 3.11 or later. Two distribution names appear in the README and on PyPI: mcp-client-for-ollama and ollmcp. The project metadata declares both console entry points, so either command name starts the same CLI.

pip install mcp-client-for-ollama

After installation, the README's Quick Start path is to launch the TUI. Running it with no server configured gives you a session with Ollama models available and no tools attached, which is the baseline you build from.

ollmcp

Servers are added either from inside the application or through a CLI subcommand, mcp add, which the README documents along with scopes and options. The configuration format is the familiar MCP server JSON. A STDIO server entry carries a command and its arguments; the exact keys are described in the Server Configuration Format section of the README rather than reproduced here, so check that section before hand-writing a file.

The README also points to a Tips section with a working example of where to put MCP server configs. Once a server is connected, its tools appear in the session, and you can enable or disable them individually. If a model requests a tool call, you should see the request and, depending on your Human-in-the-Loop setting, an approval prompt before anything executes. Server hot-reloading lets you edit a server during development and reload it without restarting the client, which is the feature that makes this usable while you are writing the server itself.

Where ollmcp stops being the right tool

The most concrete limitation is that this is a TUI. Everything runs through an interactive terminal session with prompt-toolkit and rich. If your use case is a batch job, a scheduled task, or a step inside a CI pipeline, there is no documented non-interactive execution path in the README. The CLI subcommands manage server configuration; they are not described as a way to run a headless agent turn.

Model capability is the second constraint, and it is not the client's to fix. Tool calling depends on the model, and the README keeps a Compatible Models section rather than asserting that any Ollama model works. A model that does not emit well-formed tool calls will not become an agent because a client is attached to it.

There is also a versioning wrinkle worth noticing. The release list shows v0.34.0 as the most recent tagged release, while pyproject.toml on main declares version 0.35.0. That is normal for a project that bumps the manifest before tagging, but it means the version you read in the source tree and the version you install from PyPI can differ. Check the tag, not the manifest, when you need to know what you are running.

Finally, the client is a client. It does not sandbox MCP servers, and the approval step is a prompt, not a policy engine. If a server's tools are dangerous, the mitigation is that you read the call before approving it.

How ollmcp differs from a coding-agent CLI

The obvious comparison is a general-purpose coding agent that also speaks MCP. The difference is scope and surface. A coding agent typically assumes a repository, edits files, and hides the protocol behind its own workflow. ollmcp exposes the protocol: you can browse prompts, read resources, toggle servers, and watch tool calls arrive. Its README lists MCP Prompts and MCP Resources as first-class features alongside tools, which is unusual, since most MCP clients stop at tools.

The second difference is provider posture. ollmcp defaults to Ollama and treats OpenAI-compatible endpoints as an alternative, which inverts the assumption of most agent CLIs that a hosted API is the primary path. If you already have Ollama running and want the model to stay on your machine, this is the direction you want. If you want the agent to manage your working tree, a coding agent will do more for you out of the box, and the MCP support in ollmcp will look like plumbing you have to drive yourself.

Maintenance, licence and what an upgrade costs you

The repository is not archived, and the last push was on 2026-09-10, ten days before this writing. Releases have been frequent: v0.33.2 on 2026-07-25, v0.33.3 on 2026-08-18, v0.34.0 on 2026-09-01. The README carries a NEW marker on several features, including managing MCP servers via CLI, inference provider configuration, answer display modes, thinking mode, and per-provider profiles, which tells you the surface is still moving.

That pace has a cost. The dependency set pins loosely but not trivially: mcp is pinned to the 2.1.x line, any-llm-sdk to 1.27.x, typer to 0.27.x, prompt-toolkit to 3.0.53, rich to the 14.2 range, httpx below 1.0. A major MCP SDK release will require a coordinated bump here, and the client sits directly on that protocol. A uv.lock is committed, so reproducible installs are possible if you use uv; pip users get whatever the ranges resolve to.

The licence is MIT, declared in both pyproject.toml and the repository. MIT is permissive: it allows commercial use, modification and redistribution provided the copyright notice and licence text are kept. It offers no patent grant and no warranty, and it says nothing about the licences of the MCP servers you connect to or the models you run. Those are separate questions, and the README's Security section is where the project addresses its own posture.

Editorial conclusion

Adopt ollmcp if you run Ollama locally and want a terminal session where a model calls MCP tools under your review, with prompts and resources browsable from the same prompt. Skip it if you need an unattended pipeline component or a graphical interface: the project is a TUI, and its own documentation describes it as an interactive terminal application. Before committing, verify that your Ollama model actually emits tool calls, since the README lists compatible models rather than guaranteeing every model works.

Frequently asked questions

Official sources

1. Issues
2. jonigl/mcp-client-for-ollama on GitHub
3. License: MIT
4. README
5. Releases