# Ollama Mcp Example

> Ollama MCP example for dummies.

- **Type:** MCP server
- **Install:** `agentstack add mcp-kirillsaidov-ollama-mcp-example`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [kirillsaidov](https://agentstack.voostack.com/s/kirillsaidov)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** Unlicense
- **Upstream author:** [kirillsaidov](https://github.com/kirillsaidov)
- **Source:** https://github.com/kirillsaidov/ollama-mcp-example

## Install

```sh
agentstack add mcp-kirillsaidov-ollama-mcp-example
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Ollama MCP for Dummies
This is a simple, beginner-friendly example showing how to set up and use an **MCP server and client from scratch with Ollama**. I assume you already know what MCP is conceptually.

## A summary of how MCP works
There are 3 components:
* **MCP server** - exposes your tools over a network.
* **MCP client** - connects to your MCP server and uses those tools.
* **LLM** - the language model that decides whether a tool is needed.

Basically, the MCP client is a wrapper for function calling. It connects to MCP servers and pulls their tools into a single list, exposing them to your language model as function calls.

Here is the schema:
```sh
┌─────────────┐         ┌─────────────┐         ┌──────────────┐
│   Ollama    │  │ MCP Client  │  │  MCP Server  │
│   (LLM)     │         │  (Wrapper)  │   SSE   │   (Tools)    │
└─────────────┘         └─────────────┘         └──────────────┘
                               │
                         Unifies tools
                         from multiple
                         MCP servers
```
The difference from regular function calling is that you don’t need to implement, define, or execute the tools yourself. MCP servers handle that. Most importantly, they are reusable and model-agnostic. _"Create once, then reuse."_

## What this example does
This project demonstrates how to set up and use MCP from scratch, showing what happens on both sides of the client and server under the hood:
1. Create MCP server. Expose tools over network. 
2. Create MCP client. Connect to MCP server and query for tools.
3. Handle chat and tool calls with Ollama.

I handle chat logic in [`mcp_client.py`](./mcp_client.py).

## Quick start

### Prerequisites
- Python 3.8+
- Ollama installed and running
- The `qwen3:4b-instruct` model (or modify the code for your preferred model in [`mcp_client.py`](./mcp_client.py))

### Installation
#### Clone repo
```sh
git clone https://github.com/kirillsaidov/ollama-mcp-example.git
cd ollama-mcp-example
```
#### Install dependencies
```sh
python3 -m venv venv
./venv/bin/pip install -r requirements.txt
```

#### Run the example
```sh
# start MCP server
./venv/bin/python mcp_server.py

# run MCP client
./venv/bin/python mcp_client.py
```

### Try it out
```sh
>> What's Apple's stock price?
Apple's current stock price is $252.13 per share.

>> How much is Google trading for?
Alphabet Inc. (GOOGL) is currently trading at 247.14 per share.
```

This is the same as my previous [`ollama-function-calling`](https://github.com/kirillsaidov/ollama-function-calling.git) example. The results are identical, but conceptually we now use MCP, which is more flexible and easily extensible. There is no need to modify your main app code. 

## How it works
The MCP client is essentially a tool wrapper that:
1. Connects to one or more MCP servers.
2. Collects all available tools from these servers.
3. Translates tools into a format your LLM understands (for function calling).
4. Routes tool calls back to the appropriate server instead of executing them locally.

## This project structure

```sh
ollama-function-calling/
├── mcp_server.py         # Exposing tools
├── mcp_client.py         # Connect to MCP server, get list of tools, expose them to LLM
├── README.md             # This file
└── requirements.txt      # Dependencies
```

## Customizing for your own functions

Want to add your own functions? Just add it to [`mcp_server.py`](./mcp_server.py):

```py
@mcp.tool()
def get_weather(city: str) -> str:
    # Your implementation here
    return f"Sunny, 75°F in {city}"
```

That's it. Now you can test it by running the client script. 

## LICENSE
Unlicense.

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [kirillsaidov](https://github.com/kirillsaidov)
- **Source:** [kirillsaidov/ollama-mcp-example](https://github.com/kirillsaidov/ollama-mcp-example)
- **License:** Unlicense

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-kirillsaidov-ollama-mcp-example
- Seller: https://agentstack.voostack.com/s/kirillsaidov
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.