Ollama MCP: How to Connect Local LLMs to Any MCP Server

User prompt
  → Bridge sends prompt + MCP tool schemas to Ollama
    → Ollama returns tool_call (e.g. "read_file", {"path": "src/index.ts"})
      → Bridge calls MCP server: session.call_tool("read_file", {"path": "src/index.ts"})
        → MCP server reads the file, returns contents
      → Bridge sends file contents back to Ollama as tool result
    → Ollama generates final response using the file contents
  → Bridge displays response to user

# Install Ollama (macOS/Linux)
curl -fsSL https://ollama.com/install.sh | sh

# Pull a model with tool calling support
ollama pull qwen3:14b

# Verify it's running
curl http://localhost:11434/api/tags

# Requires Go 1.22+
go install github.com/mark3labs/mcphost@latest

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/you/projects"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

# Start an interactive session
mcphost -m ollama:qwen3:14b --config mcp-servers.json

# MCPHost will:
# 1. Start the MCP servers listed in config
# 2. Discover all available tools
# 3. Send them to Ollama with each prompt
# 4. Execute tool calls and feed results back

# Example prompt in the session:
> List all TypeScript files in src/ and summarize what each one does

git clone https://github.com/patruff/ollama-mcp-bridge
cd ollama-mcp-bridge
npm install

# Copy the template config
cp bridge_config.json.template bridge_config.json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/dir"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your_brave_api_key"
      }
    }
  },
  "llm": {
    "model": "qwen3:14b",
    "baseUrl": "http://localhost:11434",
    "temperature": 0.1,
    "maxTokens": 4096
  }
}

npm start

# The bridge starts all MCP servers, connects to Ollama,
# and opens an interactive chat session.
# Tool calls are handled automatically.

pip install "mcp[cli]" ollama

import asyncio
import json
import ollama
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client


def mcp_tools_to_ollama(mcp_tools) -> list[dict]:
    """Convert MCP tool schemas to Ollama/OpenAI format."""
    ollama_tools = []
    for tool in mcp_tools:
        ollama_tools.append({
            "type": "function",
            "function": {
                "name": tool.name,
                "description": tool.description or "",
                "parameters": tool.inputSchema,
            },
        })
    return ollama_tools


async def run(model: str, server_command: str, server_args: list[str]):
    server_params = StdioServerParameters(
        command=server_command,
        args=server_args,
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # Discover tools
            tools_response = await session.list_tools()
            tools = mcp_tools_to_ollama(tools_response.tools)
            print(f"Connected. {len(tools)} tools available.")

            messages = []

            while True:
                user_input = input("\nYou: ")
                if user_input.lower() in ("quit", "exit"):
                    break

                messages.append({"role": "user", "content": user_input})

                # Call Ollama with tools
                response = ollama.chat(
                    model=model,
                    messages=messages,
                    tools=tools,
                    options={"temperature": 0.1},
                )

                # Process tool calls in a loop
                while response.message.tool_calls:
                    for tool_call in response.message.tool_calls:
                        name = tool_call.function.name
                        args = tool_call.function.arguments
                        print(f"  → Calling tool: {name}({json.dumps(args)})")

                        result = await session.call_tool(name, arguments=args)
                        text = result.content[0].text if result.content else ""

                        messages.append(response.message)
                        messages.append({
                            "role": "tool",
                            "content": text,
                        })

                    # Let the model process tool results
                    response = ollama.chat(
                        model=model,
                        messages=messages,
                        tools=tools,
                        options={"temperature": 0.1},
                    )

                print(f"\nAssistant: {response.message.content}")
                messages.append(response.message)


if __name__ == "__main__":
    asyncio.run(run(
        model="qwen3:14b",
        server_command="npx",
        server_args=["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
    ))

python ollama_mcp_client.py

# Connected. 11 tools available.
#
# You: What files are in /tmp?
#   → Calling tool: list_directory({"path": "/tmp"})
#
# Assistant: Here are the files in /tmp:
# - session.log (2.1 KB)
# - build-output/ (directory)
# - notes.txt (340 bytes)
# ...

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    },
    "git": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-git", "--repository", "."]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": { "BRAVE_API_KEY": "BSA_your_key" }
    },
    "morph": {
      "command": "npx",
      "args": ["-y", "@morphllm/morphmcp@latest"],
      "env": { "MORPH_API_KEY": "sk-morph-..." }
    }
  }
}

# Local development
mcphost -m ollama:qwen3:14b --config mcp-servers.json

# Production (switch to cloud)
mcphost -m anthropic:claude-sonnet-4-20250514 --config mcp-servers.json
mcphost -m openai:gpt-4o --config mcp-servers.json