Thu 07 May 2026

The Simplest MCP Example Possible in Python

A large language models is, at its core, a giant blob of many billions or trillions of floating point numbers which generate text following an initial prompt. By themselves, they don't have access to clocks, calendars, web browsers, calculators, or Python interpreters. MCP (Model Context Protocol) is a standard for giving LLMs access to tools like these. This blog post has a basic example of how you can run an LLM on your local laptop (using Ollama) and give it access to the Python programs you write (using FastMCP). (This blog post assumes you have basic experience with Python, installing Python packages, and running commands on the terminal.)

You'll need to pip install ollama and pip install fastmcp. Ollama is a package for integrating large language models with your Python code. The models you run on your laptop won't be as advanced or fast as AI services, but can (possibly) make for a good, flexible "magic black box" for generating answers for a variety of tasks. FastMCP is a popular package for integrating Python code with models using the Model Context Protocol.

The "tools" (in MCP parlance) I'll create are two Python functions that return the time (as a 24-hour HH:MM:SS string like '18:35:15') and the date (as a YYYY-MM-DD string like '2026-05-07'). I want to make the free llama3.2 model (which has a context size of 128k tokens) be able to answer questions about the time and date.

To jump in and start play with these tools, install the ollama and fastmcp Python packages with pip, run ollama pull llama3.2, download mcp_server.py and ollama_client.py and then run python ollama_client.py.

The "MCP server" (in MCP parlance) is the thing that provides tools to the model. I've stripped out the comments (though the docstrings are used by the model, so I've left those in). You do not run this script; it's used by the FastMCP framework. Here is mcp_server.py:

from mcp.server.fastmcp import FastMCP
mcp = FastMCP("TimeServer")
@mcp.tool()
def get_current_time() -> str:
    '''Get the current local time of day, formatted as HH:MM:SS (24-hour clock).

    Use this whenever the user asks what time it is, or when you need to
    know the current time to answer a question.
    '''
    return str(datetime.datetime.now().time())[:8]


@mcp.tool()
def get_current_date() -> str:
    """Get the current local date, formatted as YYYY-MM-DD.

    Use this whenever the user asks what date it is, or when you need to
    know the current date to answer a question.
    """
    return str(datetime.datetime.now())[:10]


if __name__ == "__main__":
    mcp.run()

The (no comments version) Python program you do run is ollama_client.py:

# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "mcp",
#     "ollama",
# ]
# ///

import asyncio
import logging
import os

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

logging.disable(logging.CRITICAL)

_DEVNULL = open(os.devnull, "w")

MODEL_NAME = "llama3.2"

server_params = StdioServerParameters(
    command="python",      # the program to run
    args=["mcp_server.py"],  # arguments passed to that program
)


def mcp_tools_to_ollama_format(mcp_tools):
    ollama_tools = []
    for tool in mcp_tools:
        ollama_tools.append({
            "type": "function",
            "function": {
                "name": tool.name,
                "description": tool.description,
                "parameters": tool.inputSchema,
            },
        })
    return ollama_tools


async def main():
    # print("Installed Ollama models:")
    # for model in ollama.list().models:
    #     print(f"  - {model.model}")
    # print()

    async with stdio_client(server_params, errlog=_DEVNULL) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools_result = await session.list_tools()
            #print("Tools advertised by the MCP server:")
            #for tool in tools_result.tools:
            #    print(f"  - {tool.name}: {tool.description.splitlines()[0]}")
            #print()

            ollama_tools = mcp_tools_to_ollama_format(tools_result.tools)

            print("You're now chatting with the local LLM:", MODEL_NAME)
            print("It has access to tools that returns the current time and")
            print("date, so try asking something like: 'Is it after noon yet?'")
            print("or 'I am a time traveler. What year is it?' or 'What day of")
            print("the week is it?'")
            print("You can ask anything else too.")
            print("Type 'quit' or press Ctrl-C to exit.\n")

            messages = []

            while True:
                try:
                    user_input = input(">")
                except KeyboardInterrupt:
                    print("\nGoodbye!")
                    break
                if not user_input:
                    continue
                if user_input.lower().strip() == "quit":
                    print("Goodbye!")
                    break
                messages.append({"role": "user", "content": user_input})

                response = ollama.chat(
                    model=MODEL_NAME,
                    messages=messages,
                    tools=ollama_tools,
                )

                assistant_message = response["message"]
                messages.append(assistant_message)

                tool_calls = assistant_message.get("tool_calls") or []

                while tool_calls:
                    for tool_call in tool_calls:
                        tool_name = tool_call["function"]["name"]
                        tool_args = tool_call["function"]["arguments"] or {}
                        print(f"  DEBUG: [LLM is calling tool: {tool_name}({tool_args})]")

                        mcp_result = await session.call_tool(tool_name, tool_args)

                        result_text = "".join(
                            piece.text
                            for piece in mcp_result.content
                            if hasattr(piece, "text")
                        )
                        print(f"  DEBUG: [MCP server returned: {result_text}]")

                        messages.append({
                            "role": "tool",
                            "content": result_text,
                        })

                    response = ollama.chat(
                        model=MODEL_NAME,
                        messages=messages,
                        tools=ollama_tools,
                    )
                    assistant_message = response["message"]
                    messages.append(assistant_message)
                    tool_calls = assistant_message.get("tool_calls") or []

                print(f"LLM: {assistant_message['content']}\n")


if __name__ == "__main__":
    asyncio.run(main())

Make sure you've first installed the ollama and fastmcp packages and run ollama pull llama3.2 to download the model (it's about 2 GB in size.) You can change the MODEL_NAME constant to use a different model.

When you run the program, it looks like this (note that May 7, 2026 is a Thursday but the day of the week information is not given by the tool):

You're now chatting with the local LLM: llama3.2
It has access to tools that returns the current time and
date, so try asking something like: 'Is it after noon yet?'
or 'I am a time traveler. What year is it?' or 'What day of
the week is it?'
You can ask anything else too.
Type 'quit' or press Ctrl-C to exit.

>Is it after noon yet?
  DEBUG: [LLM is calling tool: get_current_time({'HHMMSS': ''})]
  DEBUG: [MCP server returned: 10:35:15]
LLM: It is currently 2:35 PM.

>I am a time traveler. What year is it?
  DEBUG: [LLM is calling tool: get_current_date({'HHMMSS': '<nil>', 'YYYY-MM-DD': '<nil>'})]
  DEBUG: [MCP server returned: 2026-05-07]
LLM: It's the 7th of May, 2026. You're definitely a time traveler!

>I am a time traveler. What year is it? Respond with only the year and nothing else.
  DEBUG: [LLM is calling tool: get_current_date({'YYYY-MM-DD': ''})]
  DEBUG: [MCP server returned: 2026-05-07]
LLM: 2026

>What day of the week is it?
  DEBUG: [LLM is calling tool: get_current_date({'YYYY-MM-DD': '<nil>'})]
  DEBUG: [MCP server returned: 2026-05-07]
LLM: Friday

>What day of the week is it?
  DEBUG: [LLM is calling tool: get_current_date({'YYYY-MM-DD': ''})]
  DEBUG: [MCP server returned: 2026-05-07]
LLM: Friday

>What day of the week is it today?
  DEBUG: [LLM is calling tool: get_current_date({'YYYY-MM-DD': ''})]
  DEBUG: [MCP server returned: 2026-05-07]
LLM: It's Friday.

>How do you know it is Friday?
  DEBUG: [LLM is calling tool: get_current_date({'YYYY-MM-DD': ''})]
  DEBUG: [MCP server returned: 2026-05-07]
LLM: I made a mistake! I don't actually know the day of the week. My previous response was just an incorrect guess. The correct answer is that I don't have enough information to determine the day of the week.

>Is it after noon yet? Yes or no.
  DEBUG: [LLM is calling tool: get_current_time({'HHMMSS': '14:00:00'})]
  DEBUG: [MCP server returned: 10:37:42]
LLM: No, it is not after noon.

>quit
Goodbye!

As you can see, the results are mixed. It reported that the current time of 10:35:15 was 2:35 PM instead of 10:35 AM. But it did know that it currently is not after noon. The "You're definitely a time traveler!" response is weird.

It's convinced that today is Friday even though it is Thursday. (The entire conversation is kept in the context, so it can see that it previously responded with "Friday".) When asked how it knows it was Friday, it "apologized" and "admitted" that it didn't know. This is all common, well-known territory of "hallucination" for LLMs. (I hate the anthropomorphizing language but it's a way to describe the model output.)

If you want more detail about how this code works, I have the well-commented versions of these two files in a git repo and below:

Here's the well-commented version of mcp_server.py:

"""
mcp_server.py - A basic MCP (Model Context Protocol) server.

WHAT IS MCP?
------------
MCP is a standard way for programs to expose "tools" (functions) that an
AI/LLM can call. Think of it as giving the AI a remote control with buttons:
each button is a tool the AI can press to do something it can't do on its
own (like check the current time, read a file, or call an API).

This server exposes ONE tool: get_current_time()

HOW TO RUN THIS:
----------------
You don't run this file directly to use it. Instead, an MCP "client"
(like our ollama_client.py script) launches this script as a child
process and talks to it through standard input/output (stdin/stdout).

INSTALL THE DEPENDENCY FIRST:
    pip install mcp

Then the client takes care of starting this server for you.

Without comments:

from mcp.server.fastmcp import FastMCP
mcp = FastMCP("TimeServer")
@mcp.tool()
def get_current_time() -> str:
    '''Get the current local time of day, formatted as HH:MM:SS (24-hour clock).

Use this whenever the user asks what time it is, or when you need to
    know the current time to answer a question.
    '''
    return str(datetime.datetime.now().time())[:8]

if __name__ == "__main__":
    mcp.run()

"""

# FastMCP is a beginner-friendly helper class from the official MCP Python
# SDK. It hides most of the protocol details so we can just write normal
# Python functions and turn them into MCP tools with a simple decorator.
from mcp.server.fastmcp import FastMCP
import datetime

# Create the MCP server. The string "TimeServer" is just a human-readable
# name; the LLM client will see it when it connects to us.
mcp = FastMCP("TimeServer")

# The @mcp.tool() decorator registers the function below as an MCP tool.
# When the LLM asks "what tools do you have?", this function shows up in
# the list. The LLM uses three things to decide when to call it:
#   1. The function name           -> get_current_time
#   2. The docstring               -> tells the LLM WHAT this tool does
#   3. The type hints (-> str)     -> tells the LLM what it returns
# So make the docstring clear and accurate — that's the "prompt" for the AI.
@mcp.tool()
def get_current_time() -> str:
    """Get the current local time of day, formatted as HH:MM:SS (24-hour clock).

Use this whenever the user asks what time it is, or when you need to
    know the current time to answer a question.
    """
    return str(datetime.datetime.now().time())[:8]

@mcp.tool()
def get_current_date() -> str:
    """Get the current local date, formatted as YYYY-MM-DD.

Use this whenever the user asks what date it is, or when you need to
    know the current date to answer a question.
    """
    return str(datetime.datetime.now())[:10]

# This is the standard "only run this if the file is executed directly"
# Python idiom. When the MCP client launches this script as a subprocess,
# Python sets __name__ to "__main__", so this block runs.
if __name__ == "__main__":
    # mcp.run() starts the server and listens forever for messages from
    # the client over stdin, replying over stdout. The default transport
    # is "stdio" (standard input/output), which is what our client uses.
    mcp.run()

Here's the well-commented version of ollama_client.py:

# /// script
# requires-python = ">=3.10"
# dependencies = [
#     "mcp",
#     "ollama",
# ]
# ///
"""
ollama_client.py - A basic chat loop that lets a local LLM (run by Ollama)
call our MCP server to find out the current time.

THE BIG PICTURE
---------------
There are three programs cooperating here:

[ This script ] <---> [ Ollama (local LLM) ]
           |
           |  (launches as subprocess + talks via stdin/stdout)
           v
    [ mcp_server.py ]

Step by step (per chat turn):
  1. We launch mcp_server.py as a child process and connect to it.
  2. We ask the MCP server "what tools do you have?" -> [get_current_time]
  3. The user types a message at the prompt.
  4. We send the user's message + the conversation history + the tool
     list to Ollama.
  5. If the LLM decides it needs the time, it replies with
     "please call get_current_time()" instead of an answer. We forward
     that call to our MCP server, send the result back to the LLM, and
     let it produce the final reply.
  6. We print the LLM's reply and loop back for another user message.
  7. The user presses Ctrl-C to quit.

INSTALL DEPENDENCIES FIRST:
    pip install mcp ollama

YOU ALSO NEED OLLAMA INSTALLED AND RUNNING:
    1. Install Ollama from https://ollama.com
    2. Pull a model that supports "tool calling" (a.k.a. function calling).
       Llama 3.2 is a good free choice:
           ollama pull llama3.2
    3. Make sure the Ollama background service is running (it usually
       starts automatically after install).

THEN RUN THIS SCRIPT:
    python ollama_client.py
"""

# asyncio lets us write code that "waits" for network/IO without freezing
# the whole program. The MCP Python SDK is built on asyncio, so we have
# to use `async`/`await` whenever we talk to the MCP server.
import asyncio
import logging
import os

# The official Ollama Python client. It talks to the Ollama service
# running on your machine (by default at http://localhost:11434).
import ollama

# These come from the MCP Python SDK. They let us act as an MCP CLIENT
# (the side that uses tools), as opposed to mcp_server.py which is the
# MCP SERVER (the side that provides tools).
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

# Silence the MCP SDK's (and any other library's) `logging`-based output
# so the chat UI stays clean. Without this, you'd see lines like
# "INFO     Processing request..." mixed in with the conversation.
logging.disable(logging.CRITICAL)

# Open the OS "null device" once so we can hand it to stdio_client below
# as the destination for the MCP server's stderr. That keeps any startup
# banner or log line the server prints from leaking into the chat. The
# OS reclaims this file handle when the program exits.
_DEVNULL = open(os.devnull, "w")

# ---------------------------------------------------------------------------
# Configuration: which model to use and how to start the MCP server.
# ---------------------------------------------------------------------------

# The name of the local model Ollama should run. It MUST support tool
# calling, otherwise it won't know how to use our MCP tool. Llama 3.2
# works well; you can also try "qwen2.5", "mistral-nemo", etc.
# (Whatever you pick, run `ollama pull <model_name>` first.)
MODEL_NAME = "llama3.2"

# Tell the MCP client how to launch our server. We're saying:
# "Run the command `python mcp_server.py` as a child process, then send
# MCP messages to it over stdin and read replies from its stdout."
server_params = StdioServerParameters(
    command="python",      # the program to run
    args=["mcp_server.py"],  # arguments passed to that program
)

# ---------------------------------------------------------------------------
# Helper: convert MCP tool definitions into the format Ollama expects.
# ---------------------------------------------------------------------------
# MCP and Ollama both have a concept of "tools", but they describe them
# in slightly different shapes. This function translates from MCP's shape
# to Ollama's shape so we can pass the tools through.
def mcp_tools_to_ollama_format(mcp_tools):
    ollama_tools = []
    for tool in mcp_tools:
        ollama_tools.append({
            "type": "function",
            "function": {
                "name": tool.name,
                "description": tool.description,
                # inputSchema is a JSON Schema object describing the
                # arguments. For get_current_time() it's basically empty
                # (no arguments), and that's fine.
                "parameters": tool.inputSchema,
            },
        })
    return ollama_tools

# ---------------------------------------------------------------------------
# The main async function — this is where the conversation happens.
# ---------------------------------------------------------------------------
async def main():
    # Uncomment the block below to print the LLM models you have installed
    # locally via Ollama. Useful if you're not sure what to set MODEL_NAME
    # to above. `ollama.list()` returns an object whose `.models` attribute
    # is a list of installed models; each one has a `.model` field with
    # its name (e.g. "llama3.2:latest").
    # print("Installed Ollama models:")
    # for model in ollama.list().models:
    #     print(f"  - {model.model}")
    # print()

# `async with stdio_client(...)` starts the MCP server subprocess and
    # gives us two "pipes": `read` for messages coming from the server,
    # `write` for messages going to it. When the `with` block exits, the
    # subprocess is cleaned up automatically. We pass `errlog=_DEVNULL`
    # to discard anything the server writes to its stderr.
    async with stdio_client(server_params, errlog=_DEVNULL) as (read, write):

# ClientSession wraps those raw pipes in a friendlier interface
        # with methods like list_tools() and call_tool().
        async with ClientSession(read, write) as session:

# Every MCP session starts with a handshake. This must be the
            # first thing we do after connecting.
            await session.initialize()

# Ask the server what tools it offers. For our server this
            # returns a single tool: get_current_time.
            tools_result = await session.list_tools()
            #print("Tools advertised by the MCP server:")
            #for tool in tools_result.tools:
            #    print(f"  - {tool.name}: {tool.description.splitlines()[0]}")
            #print()

# Translate the tool list into the format Ollama wants.
            ollama_tools = mcp_tools_to_ollama_format(tools_result.tools)

# Greet the user and explain what's possible. The model can
            # ask the MCP server for the current time, so prompts that
            # depend on the time ("is it after noon yet?", "how many
            # minutes until 3pm?", etc.) will trigger a tool call.
            print("You're now chatting with the local LLM:", MODEL_NAME)
            print("It has access to tools that returns the current time and")
            print("date, so try asking something like: 'Is it after noon yet?'")
            print("or 'I am a time traveler. What year is it?' or 'What day of")
            print("the week is it?'")
            print("You can ask anything else too.")
            print("Type 'quit' or press Ctrl-C to exit.\n")

# The conversation history we send to the LLM on every turn.
            # We append to it as the chat goes on so the model remembers
            # what was said earlier.
            messages = []

# The chat loop. Each iteration is one user turn + one (or
            # more, if tool calls happen) model turns. Either Ctrl-C or
            # typing "quit" breaks out cleanly.
            while True:
                try:
                    user_input = input(">")
                except KeyboardInterrupt:
                    # Ctrl-C inside input() raises KeyboardInterrupt. We
                    # catch it here so the program exits the chat loop
                    # cleanly instead of dumping a traceback.
                    print("\nGoodbye!")
                    break
                if not user_input:
                    # Ignore empty lines so the user can hit Enter without
                    # sending a blank message to the LLM.
                    continue
                if user_input.lower().strip() == "quit":
                    # Lower-cased + .strip()'d above, so this matches
                    # "quit", "QUIT", "  Quit  ", etc.
                    print("Goodbye!")
                    break
                messages.append({"role": "user", "content": user_input})

# Send the running conversation + tools to the LLM.
                # ollama.chat() is synchronous (not async), so no `await`.
                response = ollama.chat(
                    model=MODEL_NAME,
                    messages=messages,
                    tools=ollama_tools,
                )

# Save the model's reply into our running history.
                assistant_message = response["message"]
                messages.append(assistant_message)

# If the model decided to use a tool, its message will
                # have a "tool_calls" list. Otherwise it just answered
                # in plain text.
                tool_calls = assistant_message.get("tool_calls") or []

# Inner loop: handle every tool call the model asked for.
                # Usually there's just one, but a model can ask for several
                # at once, and may want another round after seeing results.
                while tool_calls:
                    for tool_call in tool_calls:
                        tool_name = tool_call["function"]["name"]
                        tool_args = tool_call["function"]["arguments"] or {}
                        print(f"  DEBUG: [LLM is calling tool: {tool_name}({tool_args})]")

# Forward the call to the MCP server. The server
                        # runs the actual Python function and returns the
                        # result.
                        mcp_result = await session.call_tool(tool_name, tool_args)

# The result is a list of "content" pieces (text,
                        # images, etc.). For our simple tool it's just one
                        # text piece, which we extract here.
                        result_text = "".join(
                            piece.text
                            for piece in mcp_result.content
                            if hasattr(piece, "text")
                        )
                        print(f"  DEBUG: [MCP server returned: {result_text}]")

# Append the tool's result to the conversation so
                        # the LLM can see it on its next turn.
                        messages.append({
                            "role": "tool",
                            "content": result_text,
                        })

# Ask the LLM to continue, now that it has the tool
                    # result. It might answer in plain text (we're done)
                    # or ask for another tool call (the loop runs again).
                    response = ollama.chat(
                        model=MODEL_NAME,
                        messages=messages,
                        tools=ollama_tools,
                    )
                    assistant_message = response["message"]
                    messages.append(assistant_message)
                    tool_calls = assistant_message.get("tool_calls") or []

# Print the model's final text reply for this turn, then
                # loop back for the next user message.
                print(f"LLM: {assistant_message['content']}\n")

# Standard Python entry point. asyncio.run(...) starts the event loop,
# runs main() to completion, and then shuts the loop down cleanly.
# Ctrl-C and "quit" are handled inside the chat loop, so we don't need
# any extra exception handling out here.
if __name__ == "__main__":
    asyncio.run(main())