Introduction

Hello readers,

There’s so much excitement surrounding agentic AI right now, and like many of you, I was very interested in dipping my toe in the water. In this article, I want to share my first-hand experience learning the basics of agentic AI and the Model Context Protocol (MCP).

I’ll walk you through my process, the key concepts I pieced together, and the practical lessons I learned, hopefully giving you a head start on your own agentic AI projects.

A Quick Look at Agentic AI

The development of AI has unfolded in pivotal stages. Machine learning began as pattern recognition and statistical methods in the mid-20th century, leading to neural networks, which sparked deeper models with the advent of backpropagation in the 1980s. The 1990s and 2000s saw the rise of support vector machines and the first real-world successes of deep learning, driven by improved algorithms and data availability.

Deep learning’s breakthrough enabled systems to surpass humans in vision and language tasks by the 2010s, introducing large language models (LLMs) and advanced reinforcement learning. Generative Adversarial Networks (GANs) in the mid-2010s allowed for image and content generation with adversarial training, while diffusion models soon overtook GANs for image synthesis due to better sample diversity and stability.

Today, the landscape includes agentic AI—interactive systems that plan and interact autonomously—and multi-agent frameworks, where teams of AI agents collaborate to solve complex problems, marking the era of adaptive, collaborative, and generative AI.

This brief history highlights how AI evolved from learning directly from human-provided answers (supervised learning) and carefully chosen algorithms, to discovering patterns from unlabeled or vaguely labeled data through unsupervised learning and autoencoders. The journey continued as AI models advanced further to generate new content, exemplified by large language models for natural language and vision models for image generation—demonstrating how machines now learn, interpret, and create in ways that increasingly mirror human capabilities Of course, this isn’t to say that supervised learning has become less relevant; it remains foundational for many AI applications. In fact, the rise of “zero-shot” classification demonstrates how supervised learning concepts continue to evolve. Zero-shot learning allows models to classify new, previously unseen categories without needing labeled training examples for each one, greatly reducing the cost and effort of data annotation. By leveraging semantic relationships, auxiliary descriptions, or shared attributes between classes, zero-shot methods enable efficient supervised learning that scales far beyond traditional approaches—opening up new possibilities in areas such as computer vision, natural language processing, and dynamic, real-world environments where new classes often emerge. This innovation extends the relevance of supervised learning, ensuring it remains a cornerstone even as AI grows more flexible and adaptive

Why is Agentic AI a Big Deal?

Agentic AI leverages large language models at its core, enabling interactions with humans that are intuitive and natural. With advanced reasoning and semantic understanding, these systems can comprehend goals described in plain language, making programming and task specification far less explicit and tedious—logical gaps can often be filled in automatically. This reduces reliance on rigid programming syntax, such as Python or C++, and empowers agents to handle unstructured data—the most common type in real-world scenarios. As a result, the “code” and process used by agentic AI become much easier for humans to learn, read, and maintain. Ultimately, agentic AI allows us to specify desired outcomes in our mother tongue, without having to manage every technical detail, as the agent autonomously understands, plans, and executes the necessary steps to achieve our goals

My First Project: Building a Local MCP Agent

I wanted to create a local environment for learning and exploration (note: performance isn’t ready for any production need).

The Setup: My Local Environment

• Hardware: NVIDIA GeForce RTX 4070, Intel i7 13620H, 40GB RAM.
• Software: Python 3.12, UV (my new favorite package manager), and Ollama.

Ollama operates as a local server, typically running as a TCP/IP server that listens for inbound client connections (by default, on port localhost:11434). When a client—such as a host application—connects and sends a request (including input tokens or prompts), Ollama manages the LLM session and allocates necessary resources, such as GPU memory and compute, to process the request. After generating the response using the LLM, Ollama returns the output back to the client through the same connection. This architecture supports both local and remote access, provided the relevant network and firewall configurations are in place.

Its official webpage also hosts the model’s weights ( offering various sizes 0.6 billion to 32 billions parameters) for different need. Since I am still learning it and my Nvidia GPU does not have too much memory, I resort to a smaller model (4 billion parameters). How to install Ollama on Windows is well described on the Internet, so I won’t repeat the steps here.

Understanding the Core Concepts: Agents, MCP, and Tools

Before I could build anything, I had to understand the components.

• What is an Agent? The agent is the core worker that solves a user’s problem. I like to think of it this way:
  • The Brain: The LLM (e.g., a 4B parameter model from Ollama) provides the a priori knowledge and reasoning.
  • The Hands: These are the tools—functions the agent can call to get extra information, like connecting to a vector database (I used Qdrant in-memory for this demo).
  • The Role: This is the instruction, or prompt, that guides the agent’s approach (e.g., “You are a professional software engineer…”).
• What are Re-ACT and ReWOO? These are frameworks for how the agent “thinks.”
  • Re-ACT follows an Observe-Think-Act paradigm. The agent plans, rehearses steps, uses tools, observes the output, and self-evaluates, repeating the loop until the problem is solved.
  • ReWOO (Observe-Act) is a different approach. The agent plans all the steps first, calls all the tools to collect evidence, and then reviews all the evidence at the end to come up with the final answer. This can often reduce the number of tokens used.
• What is MCP? The Model Context Protocol (MCP) is the standard that connects all these pieces. In practice, different LLMs and tools have different APIs. MCP unifies them, reducing N*M unique API integrations into a single standard. The MCP server provides tools and resources, while the MCP client takes user input and interacts with the server to get the job done. This whole interaction is encapsulated in a session.

Putting them together

Agents

An agent is a worker that solves a problem given by users. It uses knowledge and reasoning capability from a LLM, it uses extra information if needed to solve the problem, it approaches the problem depending on the specific role user prescribes. Because the types of task users want to accomplish are very diverse, we often need to deploy agents with different LLMs, tools and roles.

While I don’t think the following simile is technically accurate, I like to think about agent this way for intuitive understanding. The LLM is the brain of the agent. By prescribing a LLM to the agent, we are like installing a priori knowledge and reasoning capability to a worker. For example, we use qwen3 model with 4 billion parameters. This model is served by Ollama (local server deployment in this tutorial). The hand of the agent is the tools. The tools are functions that are run to provide extra information if called upon.

Sometimes, the tools can be a connection to a database. This provides extra information to the LLM. In particular, if the database is a vector database, the database provides a way to memorize word token in a numerical format.

The instruction for approaching the problem is the role the agent plays. This role is inserted to the agent via prompt engineering. For me, I often use a prompt like this one: you are a professional software engineer. Complete the code below.

In this tutorial, I am using Ollama’s LLMs. So I rely on Ollama’s lang-chain for its its infrastructure, chat integration, model class integration, word or semantic embedding integration.

In the documentation of lang-chain-ollama We have got apis covering these models

langchain_ollama.embeddings.OllamaEmbeddings
langchain_ollama.chat_models.ChatOllama

OllamaEmbedding is used for creating a vector database; the ChartOllama is used for the LLM that goes into an agent.

Ollama provides nomic-embed-text (A high-performing open embedding model with a large token context window. )

The word embedding is then stored in a vector database for query later. This database, called Qdrant, is simple, fast. It also has built-in distance metrics such as COSINE.

For this demo, the database only exists in memory, which is a very handy feature for running CICD or demo.

In addition to an agent, we also need to use different framework for the LLM to perform the task logically. There are two main schools of thoughts. The first one is Re-ACT. The model uses observe-think-act paradigm. Furthermore, the query is parsed by the agent. The agent thinks about the query by planning. In its thinking stage, it rehearses or simulates the planned steps to ensure the answers are logical and correct. Agents can use tools to obtain information or its internal knowledge to tackle the problem. Agents observe the output of the tools or its solution to see if that satisfies the problem. If the problem isn’t satisfied, the agent repeats the thinking step and so on. One complete loop is considered a single step in Re-ACT.

The second one is ReWOO. Agents use observe-act paradigm. This has been shown to reduce the number of token used while maintaining the model output accuracy. Unlike the Re-ACT paradigm, the ReWOO paradigm reduces the number of thinking steps in the loop, cutting those down to 1 only. Concretely, the agent plans the execution procedure to solve the problem. It then calls the tools or external resources just like Re-ACT. However, the outputs are collected yet no thinking is performed on them. Until the final stage, the agent reviews or thinks about all evidence to come up with a final answer (solver).

MCP server

MCP stands for model context protocol. Why is MCP used? In practice, different LLMs and different external tools can have different api and interfaces. To make use of these tools and models in an integrated manner, programmers would need to come up with NxM unique APIs. However, with the invention of MCP, the APIs can be unified under a single MCP standard, reducing the programming workload.

To assist the agent, the MCP server automatically allows the MCP clients to discover tools and resources, context, etc. The MCP server and client uses two modes of transport, depending on how the resources are hosted. If the resources or tools are hosted locally, STDIO is used. For example, STDIO handles file access and local script running. Otherwise, SSE + HTTP is required for cloud applications. The messages follow JSON RPC 2.0 standard. The MCP python SDK helps programmer to handle the message exchange. Specifically, the SDK deals with the serialization and de-serialization of JSON messages. It processes request and response and notification when they arise.

MCP client

Client takes the input from users, interacts with users and output the agent’s answers back to users at the end of a session. This interaction from the start until the end is encapsulated in a session. Session is the term use for a series of messaging between server and clients to accomplish a task. Put session in the computer science language, A Session in this context holds the conversation history (messages), the agent’s internal state (e.g., intermediate thoughts, tool use logs), tool interactions and persistence, and often session-specific resources or configurations, maintaining context for the LLM, handling errors and exceptions, and clean up at close.

The Workflow in Action

Here’s a simple example of how it all works:

1. Init: My local Ollama server runs the LLM. The MCP client and server (using FastMCP) connect via STDIO since it’s all local. The server automatically tells the client about its available tools (e.g., generate_md5_hash, count_characters).
2. Query: I give the client a two-part query: “Compute md5 hash for following string: ‘Hello, world!’ then count number of characters in second half of hash.”
3. Re-ACT Loop: The agent (using the LLM) parses the query and plans its steps.
4. Tool Call: It determines it needs tools. The client sends a JSON RPC 2.0 request to the server to use the generate_md5_hash tool.
5. Observation: The server runs the tool and sends the result (the hash) back to the client. The agent receives this as an “observation.”
6. Loop (Step 2): The agent’s Re-ACT loop continues. It now knows the hash and sees it needs to run count_characters on the second half. It makes another tool call.
7. Final Answer: After observing the final tool’s output, the agent synthesizes the information and provides the final answer to the user.

Use a simple example to illustrate the workflow

Ollama downloads, setup and runs a local LLM - qwen3 model with 4 billion parameters from langchain_ollama.chat_models import ChatOllama provides the python APIs to access the LLM.

MCP agent and MCP client are taken from MCP_USE python package. A new session begins when the server and client established a connection after initialization.

The MCP server that is used is a FASTMCP. Since the whole demo is run locally, the transport option is STDIO. The server provides qdrant_store, qdrant_find, get_first_half, count_characters, collection_exists, and generate_md5_hash tools. The server and client is connected at the startup. These tools are discovered by client automatically.

The host is a python MCP client working on just 1 single query.

The query is:

Compute md5 hash for following string:  count number of characters in second half of hash \
 always accept tools responses as the correct one, don't doubt it. Always use a tool if available instead of doing it on your own

In the RE-ACT loop, the agent uses LLM to parse the query and works out what tools, resources it needs to solve this problem. If tools or resources are needed, the agent request to use MCP capability from client to server. The client sends a standardized request in JSON RPC 2.0 format to the MCP server. The request is processed by MCP server by making use of the tools or resources. In this case, running a short python snippet. The result, which is formatted in the JSON 2.0 RPC is sent back to client via response. The external data is fed to the agent as observations. Subsequently, actions are performed until Re-ACT loop terminates with a satisfactory answer or maximum number of steps are reached.

Key Lessons from My First Project

This project was a fantastic learning experience, and a few things really stood out.

Programming is Getting More “High-Level”

One of my biggest takeaways is that while programming is far from disappearing, it’s changing. I was still writing a good bit of code, but I spent far more time thinking about the “bigger picture”—how to connect the components, how to design each tool, and how to organize the workflow. It feels like programming is moving up another level of abstraction, focusing more on architecture and design patterns.

The Nuances of (Small) LLMs

My second lesson was that smaller, local LLMs are still limited. I’m using a 4-billion parameter model, and it sometimes struggled with complex sentences or logical reasoning. To get the right results, I had to re-word my queries or even change the tools’ output strings to be more “understandable” for the agent. This highlights just how important prompt engineering and clear communication are, especially with less powerful models.

A New Tool in the Toolbox: UV

On a practical note, while working on this project, I discovered a new Python package manager called UV. I’ve used pip and Anaconda in the past, but I really like UV’s simplicity and clarity. It manages all my virtual environments, and the uv tree command is a fantastic way to examine package dependencies.

All packages used and their dependencies for this project.

Resolved 117 packages in 2ms
mcp-server-demo v0.1.0
├── backports-asyncio-runner v1.2.0
├── faiss-cpu v1.12.0
│   ├── numpy v2.3.3
│   └── packaging v25.0
├── gradio v5.49.1
│   ├── aiofiles v24.1.0
│   ├── anyio v4.11.0
│   │   ├── idna v3.10
│   │   ├── sniffio v1.3.1
│   │   └── typing-extensions v4.15.0
│   ├── brotli v1.1.0
│   ├── fastapi v0.119.0
│   │   ├── pydantic v2.11.9
│   │   │   ├── annotated-types v0.7.0
│   │   │   ├── pydantic-core v2.33.2
│   │   │   │   └── typing-extensions v4.15.0
│   │   │   ├── typing-extensions v4.15.0
│   │   │   └── typing-inspection v0.4.1
│   │   │       └── typing-extensions v4.15.0
│   │   ├── starlette v0.48.0
│   │   │   ├── anyio v4.11.0 (*)
│   │   │   └── typing-extensions v4.15.0
│   │   └── typing-extensions v4.15.0
│   ├── ffmpy v0.6.3
│   ├── gradio-client v1.13.3
│   │   ├── fsspec v2025.9.0
│   │   ├── httpx v0.28.1
│   │   │   ├── anyio v4.11.0 (*)
│   │   │   ├── certifi v2025.8.3
│   │   │   ├── httpcore v1.0.9
│   │   │   │   ├── certifi v2025.8.3
│   │   │   │   └── h11 v0.16.0
│   │   │   ├── idna v3.10
│   │   │   └── h2 v4.3.0 (extra: http2)
│   │   │       ├── hpack v4.1.0
│   │   │       └── hyperframe v6.1.0
│   │   ├── huggingface-hub v0.35.3
│   │   │   ├── filelock v3.20.0
│   │   │   ├── fsspec v2025.9.0
│   │   │   ├── packaging v25.0
│   │   │   ├── pyyaml v6.0.3
│   │   │   ├── requests v2.32.5
│   │   │   │   ├── certifi v2025.8.3
│   │   │   │   ├── charset-normalizer v3.4.3
│   │   │   │   ├── idna v3.10
│   │   │   │   └── urllib3 v2.5.0
│   │   │   ├── tqdm v4.67.1
│   │   │   │   └── colorama v0.4.6
│   │   │   └── typing-extensions v4.15.0
│   │   ├── packaging v25.0
│   │   ├── typing-extensions v4.15.0
│   │   └── websockets v15.0.1
│   ├── groovy v0.1.2
│   ├── httpx v0.28.1 (*)
│   ├── huggingface-hub v0.35.3 (*)
│   ├── jinja2 v3.1.6
│   │   └── markupsafe v3.0.3
│   ├── markupsafe v3.0.3
│   ├── numpy v2.3.3
│   ├── orjson v3.11.3
│   ├── packaging v25.0
│   ├── pandas v2.3.3
│   │   ├── numpy v2.3.3
│   │   ├── python-dateutil v2.9.0.post0
│   │   │   └── six v1.17.0
│   │   ├── pytz v2025.2
│   │   └── tzdata v2025.2
│   ├── pillow v11.3.0
│   ├── pydantic v2.11.9 (*)
│   ├── pydub v0.25.1
│   ├── python-multipart v0.0.20
│   ├── pyyaml v6.0.3
│   ├── ruff v0.14.1
│   ├── safehttpx v0.1.6
│   │   └── httpx v0.28.1 (*)
│   ├── semantic-version v2.10.0
│   ├── starlette v0.48.0 (*)
│   ├── tomlkit v0.13.3
│   ├── typer v0.19.2
│   │   ├── click v8.3.0
│   │   │   └── colorama v0.4.6
│   │   ├── rich v14.1.0
│   │   │   ├── markdown-it-py v4.0.0
│   │   │   │   └── mdurl v0.1.2
│   │   │   └── pygments v2.19.2
│   │   ├── shellingham v1.5.4
│   │   └── typing-extensions v4.15.0
│   ├── typing-extensions v4.15.0
│   └── uvicorn v0.37.0
│       ├── click v8.3.0 (*)
│       └── h11 v0.16.0
├── langchain v0.3.27
│   ├── langchain-core v0.3.76
│   │   ├── jsonpatch v1.33
│   │   │   └── jsonpointer v3.0.0
│   │   ├── langsmith v0.4.31
│   │   │   ├── httpx v0.28.1 (*)
│   │   │   ├── orjson v3.11.3
│   │   │   ├── packaging v25.0
│   │   │   ├── pydantic v2.11.9 (*)
│   │   │   ├── requests v2.32.5 (*)
│   │   │   ├── requests-toolbelt v1.0.0
│   │   │   │   └── requests v2.32.5 (*)
│   │   │   └── zstandard v0.25.0
│   │   ├── packaging v25.0
│   │   ├── pydantic v2.11.9 (*)
│   │   ├── pyyaml v6.0.3
│   │   ├── tenacity v9.1.2
│   │   └── typing-extensions v4.15.0
│   ├── langchain-text-splitters v0.3.11
│   │   └── langchain-core v0.3.76 (*)
│   ├── langsmith v0.4.31 (*)
│   ├── pydantic v2.11.9 (*)
│   ├── pyyaml v6.0.3
│   ├── requests v2.32.5 (*)
│   └── sqlalchemy v2.0.43
│       ├── greenlet v3.2.4
│       └── typing-extensions v4.15.0
├── langchain-community v0.3.30
│   ├── aiohttp v3.12.15
│   │   ├── aiohappyeyeballs v2.6.1
│   │   ├── aiosignal v1.4.0
│   │   │   ├── frozenlist v1.7.0
│   │   │   └── typing-extensions v4.15.0
│   │   ├── attrs v25.3.0
│   │   ├── frozenlist v1.7.0
│   │   ├── multidict v6.6.4
│   │   ├── propcache v0.3.2
│   │   └── yarl v1.20.1
│   │       ├── idna v3.10
│   │       ├── multidict v6.6.4
│   │       └── propcache v0.3.2
│   ├── dataclasses-json v0.6.7
│   │   ├── marshmallow v3.26.1
│   │   │   └── packaging v25.0
│   │   └── typing-inspect v0.9.0
│   │       ├── mypy-extensions v1.1.0
│   │       └── typing-extensions v4.15.0
│   ├── httpx-sse v0.4.1
│   ├── langchain v0.3.27 (*)
│   ├── langchain-core v0.3.76 (*)
│   ├── langsmith v0.4.31 (*)
│   ├── numpy v2.3.3
│   ├── pydantic-settings v2.11.0
│   │   ├── pydantic v2.11.9 (*)
│   │   ├── python-dotenv v1.1.1
│   │   └── typing-inspection v0.4.1 (*)
│   ├── pyyaml v6.0.3
│   ├── requests v2.32.5 (*)
│   ├── sqlalchemy v2.0.43 (*)
│   └── tenacity v9.1.2
├── langchain-ollama v0.3.8
│   ├── langchain-core v0.3.76 (*)
│   └── ollama v0.6.0
│       ├── httpx v0.28.1 (*)
│       └── pydantic v2.11.9 (*)
├── loguru v0.7.3
│   ├── colorama v0.4.6
│   └── win32-setctime v1.2.0
├── mcp[cli] v1.15.0
│   ├── anyio v4.11.0 (*)
│   ├── httpx v0.28.1 (*)
│   ├── httpx-sse v0.4.1
│   ├── jsonschema v4.25.1
│   │   ├── attrs v25.3.0
│   │   ├── jsonschema-specifications v2025.9.1
│   │   │   └── referencing v0.36.2
│   │   │       ├── attrs v25.3.0
│   │   │       ├── rpds-py v0.27.1
│   │   │       └── typing-extensions v4.15.0
│   │   ├── referencing v0.36.2 (*)
│   │   └── rpds-py v0.27.1
│   ├── pydantic v2.11.9 (*)
│   ├── pydantic-settings v2.11.0 (*)
│   ├── python-multipart v0.0.20
│   ├── pywin32 v311
│   ├── sse-starlette v3.0.2
│   │   └── anyio v4.11.0 (*)
│   ├── starlette v0.48.0 (*)
│   ├── uvicorn v0.37.0 (*)
│   ├── python-dotenv v1.1.1 (extra: cli)
│   └── typer v0.19.2 (extra: cli) (*)
├── mcp-use v1.3.10
│   ├── aiohttp v3.12.15 (*)
│   ├── jsonschema-pydantic v0.6
│   │   └── pydantic v2.11.9 (*)
│   ├── langchain v0.3.27 (*)
│   ├── mcp v1.15.0 (*)
│   ├── posthog v6.7.6
│   │   ├── backoff v2.2.1
│   │   ├── distro v1.9.0
│   │   ├── python-dateutil v2.9.0.post0 (*)
│   │   ├── requests v2.32.5 (*)
│   │   ├── six v1.17.0
│   │   └── typing-extensions v4.15.0
│   ├── pydantic v2.11.9 (*)
│   ├── python-dotenv v1.1.1
│   ├── scarf-sdk v0.1.2
│   │   └── requests v2.32.5 (*)
│   └── websockets v15.0.1
├── pytest v8.4.2
│   ├── colorama v0.4.6
│   ├── iniconfig v2.1.0
│   ├── packaging v25.0
│   ├── pluggy v1.6.0
│   └── pygments v2.19.2
├── pytest-asyncio v1.2.0
│   ├── pytest v8.4.2 (*)
│   └── typing-extensions v4.15.0
├── pytest-html v4.1.1
│   ├── jinja2 v3.1.6 (*)
│   ├── pytest v8.4.2 (*)
│   └── pytest-metadata v3.1.1
│       └── pytest v8.4.2 (*)
├── qdrant-client v1.15.1
│   ├── grpcio v1.75.1
│   │   └── typing-extensions v4.15.0
│   ├── httpx[http2] v0.28.1 (*)
│   ├── numpy v2.3.3
│   ├── portalocker v3.2.0
│   │   └── pywin32 v311
│   ├── protobuf v6.32.1
│   ├── pydantic v2.11.9 (*)
│   └── urllib3 v2.5.0
└── websockets v15.0.1
(*) Package tree already displayed

The Road Ahead

The rise of agentic AI has created a wave of new libraries for domain-specific problems, from literature reviews to drug discovery. But as I’ve learned, the technology is only part of the puzzle.

I believe the truly big challenge lies in gathering the high-quality, domain-relevant data needed to either train the LLMs or build the effective tools for them to use.

My journey is just beginning, but it’s clear that this is a transformative field. I’m excited to keep exploring. Thanks for reading!

Python Source Code

Execute python client script inside a virtual environment managed by UV. It automatically triggers a MCP server first then instantiates a MCP client.

uv run ollama_client_mcp.py

ollama_client_mcp.py

import asyncio
from loguru import logger
import os

# Ensure the log folder exists
current_directory = os.path.dirname(os.path.abspath(__file__))
log_folder = os.path.join(current_directory, "log")
os.makedirs(log_folder, exist_ok=True)

# Configure Loguru to write to log/app.log inside the log folder
log_file_path = os.path.join(log_folder, "app_client.log")

# rotation means we only overwrite existing log once the file size exceeds 10 MB
logger.add(log_file_path, format="{time} {level} {message}", level="INFO", rotation="10 MB", compression="zip")

logger.info("Logging configured. Log file at: {}", log_file_path)

from langchain_ollama.chat_models import ChatOllama
from mcp_use import MCPAgent, MCPClient
# from qdrant_client import QdrantClient
# from qdrant_client.models import VectorParams, PointStruct

# Missing from your explanation:
# from langchain.vectorstores import FAISS
# from langchain_ollama import OllamaEmbeddings
# from langchain_core.documents import Document
# from MySampleText import SAMPLE_TEXTS 

collection_name = "documents"


SAMPLE_TEXTS = [
    "The architecture is straightforward: developers can either expose their data through MCP servers or build AI applications (MCP clients) that connect to these servers",
    "ai plans support connecting MCP servers to the Claude Desktop app",
    "Claude for Work customers can begin testing MCP servers locally, connecting Claude to internal systems and datasets"
    "Today, we're open-sourcing the Model Context Protocol (MCP), a new standard for connecting AI assistants to the systems where data lives, including content repositories, business tools, and development environments",
]

# Get the server script path (same directory as this file)
current_dir = os.path.dirname(os.path.abspath(__file__))
server_path = os.path.join(current_dir, "ollama_server_mcp.py")


# Describe which MCP servers you want.
CONFIG = {
    "mcpServers": {
        "fii-demo": {
            "command": "uv",
            "args": ["run", server_path]
        }
    }
}



async def upsert_sample_texts(agent):
    # The agent runs the tool based on request phrasing.

    
    for idx, text in enumerate(SAMPLE_TEXTS):
        request = f"Store the following information in Qdrant collection '{collection_name}' : {text}. by calling the tool named qdrant store."
        result = await agent.run(request)

        logger.info(f"{idx} Tool result: {result}")

async def query_sample(agent, query):
    result = await agent.run(f"Find similar information in Qdrant collection '{collection_name}' for query: {query}")
    logger.info("RAG retrieval result: {}", result)
    return result

async def main():
    client = MCPClient.from_dict(CONFIG)
    llm = ChatOllama(model="qwen3:4b", base_url="http://127.0.0.1:11434")
    
    # Wire the LLM to the client
    # Agent with retrieval capability
    agent = MCPAgent(
        llm=llm, 
        client=client, 
        max_steps=20
    )
    # result = await agent.run("Check if Qdrant collection 'documents' exists; if not, create it with embedding size 768.")

    # result = await agent.run(f"Use the tool named collection_exists to check if Qdrant collection {collection_name} exists."\
    #                          "If it does not exist, use the tool named recreate_qdrant_collection to create it with embedding size 768.")

    result = await agent.run(f"Use the tool named collection_exists to check if Qdrant collection {collection_name} exists.")
    logger.info("Collection setup result: {}", result)

    await upsert_sample_texts(agent)
    await query_sample(agent, "ai plans support connecting MCP servers to the what?")

    # Give prompt to the agent
    # result = await agent.run("Compute md5 hash for following string: 'Hello, world!' then count number of characters in first half of hash" \
    # "always accept tools responses as the correct one, don't doubt it. Always use a tool if available instead of doing it on your own")

    # result = await agent.run("Compute md5 hash for following string: 'Hello, world!' then count number of characters in second half of hash" \
    # "always accept tools responses as the correct one, don't doubt it. Always use a tool if available instead of doing it on your own")
    # logger.info("\n🔥 Result: {}", result)

    # Always clean up running MCP sessions
    await client.close_all_sessions()


if __name__ == "__main__":
    asyncio.run(main())
    logger.info("All done.")

ollama_server_mcp.py

from typing import Any
import hashlib
import uuid # Make sure to import the uuid library at the top of your file
from loguru import logger
from mcp.server.fastmcp import FastMCP
import os
from langchain_ollama import OllamaEmbeddings
from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, PointStruct
from uuid import uuid4

# Ensure the log folder exists
current_directory = os.path.dirname(os.path.abspath(__file__))
log_folder = os.path.join(current_directory, "log")
os.makedirs(log_folder, exist_ok=True)

# Configure Loguru to write to log/app.log inside the log folder
log_file_path = os.path.join(log_folder, "app_server.log")

# rotation means we only overwrite existing log once the file size exceeds 10 MB
logger.add(log_file_path, format="{time} {level} {message}", level="INFO", rotation="10 MB", compression="zip")

logger.info("Logging configured. Log file at: {}", log_file_path)

logger.info("Initializing Ollama embeddings model...")
embed_model = OllamaEmbeddings(model="nomic-embed-text",  base_url="http://localhost:11434")
logger.info("Ollama embeddings model initialized successfully.")

logger.info("Initializing in-memory Qdrant client...")
qdrant = QdrantClient(":memory:") # Create in-memory Qdrant instance
logger.info("Qdrant client initialized.")
initial_collections = qdrant.get_collections()
logger.info("Initial Qdrant collections: {}", initial_collections.collections)

# Initialize FastMCP server
logger.info("Initializing FastMCP server...")
mcp = FastMCP("public-demo")
logger.info("FastMCP server initialized.")

@mcp.tool()
async def collection_exists(collection_name: str) -> str:
    """
    Checks whether a Qdrant collection with the specified name exists.
    """
    logger.info(f"Checking if collection '{collection_name}' exists.")
    try:
        collections_response = qdrant.get_collections()
        existing_collections = [c.name for c in collections_response.collections]
        logger.info(f"Found existing collections: {existing_collections}")
        if collection_name in existing_collections:
            logger.info(f"Collection '{collection_name}' found.")
            return f"Collection '{collection_name}' found."
        else:
            logger.info(f"Collection '{collection_name}' not found.")

            # create it if not found
            logger.info(f"Creating collection '{collection_name}' with default embedding size 768.")
            return recreate_qdrant_collection(collection_name, embedding_size=768)

    except Exception as e:
        logger.error(f"An error occurred while checking for collections: {e}")
        return "False"


def recreate_qdrant_collection(collection_name: str, embedding_size: int = 768):
    """
    Creates or recreates a Qdrant collection with the specified name and vector size.
    """
    logger.info(f"Attempting to recreate collection '{collection_name}' with embedding size {embedding_size}.")
    qdrant.recreate_collection(
        collection_name=collection_name,
        vectors_config=VectorParams(
            size=embedding_size,
            distance="Cosine"
        )
    )
    logger.info(f"Successfully recreated collection: {collection_name} with size {embedding_size}")
    logger.info(f"Current collections: {qdrant.get_collections().collections}")
    return f"Recreated collection: {collection_name} with size {embedding_size}" + f"Collection '{collection_name}' found."

@mcp.tool()
def generate_md5_hash(input_str: str) -> str:
    """
    Generates an MD5 hash for the given input string.
    """
    logger.info(f"Generating MD5 hash for input string.")
    md5_hash = hashlib.md5()
    md5_hash.update(input_str.encode('utf-8'))
    hex_digest = md5_hash.hexdigest()
    logger.info(f"Generated hash: {hex_digest}")
    return hex_digest

@mcp.tool()
def count_characters(input_str: str) -> int:
    """
    Counts the number of characters in the input string.
    """
    logger.info(f"Counting characters in input string.")
    count = len(input_str)
    logger.info(f"Character count: {count}")
    return count


@mcp.tool()
def get_first_half(input_str: str) -> str:
    """
    Returns the first half of the input string.
    """
    logger.info(f"Getting first half of input string.")
    midpoint = len(input_str) // 2
    first_half = input_str[:midpoint]
    logger.info(f"Resulting first half: '{first_half}'")
    return first_half


@mcp.tool()
async def qdrant_store(information: str, metadata: dict, collection_name: str):
    """
    Vectorizes and stores a piece of information in the specified Qdrant collection.
    """
    def generate_deterministic_id(information: str) -> str:
        """Creates a stable UUID from the document's content."""
        # Create a SHA256 hash of the content
        h = hashlib.sha256(information.encode('utf-8')).hexdigest()
        # Use the hash to create a namespace-based UUID (version 5)
        # This ensures the same hash always produces the same UUID
        return str(uuid.uuid5(uuid.NAMESPACE_DNS, h))

    logger.info(f"Storing information in collection '{collection_name}'. Metadata: {metadata}")

    # 1. Generate a deterministic ID from the content
    point_id = generate_deterministic_id(information)
    
    logger.info(f"Generated deterministic ID: {point_id}")
    logger.info(f"Text: {information}")

    vector = embed_model.embed_query(information)

    logger.info(f"Generated vector of size {len(vector)}. Upserting with new point ID: {point_id}")
    qdrant.upsert(
        collection_name=collection_name,
        points=[
            PointStruct(
                id=point_id, 
                vector=vector.tolist() if hasattr(vector, "tolist") else vector,
                payload={**metadata, "information": information}
            )
        ]
    )
    logger.info(f"{point_id} Successfully stored information in '{collection_name}'.")
    return "Stored."

@mcp.tool()
async def qdrant_find(query: str, collection_name: str):
    """
    Performs a similarity search in the specified Qdrant collection for the given query.
    """
    logger.info(f"Searching for query in collection '{collection_name}'.")
    vector = embed_model.embed_query(query)
    logger.info(f"Generated vector of size {len(vector)} for query.")
    search_result = qdrant.search(
        collection_name=collection_name,
        query_vector=vector.tolist() if hasattr(vector, "tolist") else vector,
        limit=5
    )
    logger.info(f"Found {len(search_result)} results from Qdrant search.")
    results = [
        item.payload.get("information", "No content") 
        for item in search_result
    ]
    return results


if __name__ == "__main__":
    logger.info("Starting FastMCP server with stdio transport...")
    mcp.run(transport='stdio')
    logger.info("FastMCP server has shut down.")

Console Outputs

Agent Execution Log

Agent Initialization

2025-10-19 20:40:19.095 | INFO | main::16 - Logging configured. Log file at: C:\Users\hp\tableTop\mvisioner\agenticAI\mcp-server-demo\log\app_client.log 2025-10-19 20:40:30,738 - mcp_use.telemetry.telemetry - INFO - Anonymized telemetry enabled. Set MCP_USE_ANONYMIZED_TELEMETRY=false to disable. 2025-10-19 20:40:30,740 - mcp_use - INFO - 🚀 Initializing MCP agent and connecting to services... 2025-10-19 20:40:30,740 - mcp_use - INFO - 🔌 Found 0 existing sessions 2025-10-19 20:40:30,740 - mcp_use - INFO - 🔄 No active sessions found, creating new ones... 2025-10-19 20:40:34,643 - mcp_use - INFO - ✅ Created 1 new sessions 2025-10-19 20:40:34,679 - mcp_use - INFO - 🛠️ Created 6 LangChain tools from client 2025-10-19 20:40:34,680 - mcp_use - INFO - 🧰 Found 6 tools across all connectors 2025-10-19 20:40:34,680 - mcp_use - INFO - 🧠 Agent ready with tools: **collection_exists, generate_md5_hash, count_characters, get_first_half, qdrant_store, qdrant_find** 2025-10-19 20:40:34,698 - mcp_use - INFO - ✨ Agent initialization complete

Query 1: Check Collection Existence

2025-10-19 20:40:34,698 - mcp_use - INFO - 💬 Received query: ‘Use the tool named collection_exists to check if Q…’ 2025-10-19 20:40:34,699 - mcp_use - INFO - 🏁 Starting agent execution with max_steps=20 2025-10-19 20:40:34,699 - mcp_use - INFO - 👣 Step 1/20 2025-10-19 20:40:41,017 - mcp_use - INFO - 💭 Reasoning: Invoking: collection_exists with {'collection_name': 'documents'} responded:

2025-10-19 20:40:41,017 - mcp_use - INFO - 🔧 Tool call: collection_exists with input: {'collection_name': 'documents'} 2025-10-19 20:40:41,018 - mcp_use - INFO - 📄 Tool result: Recreated collection: documents with size 768Collection ‘documents’ found. 2025-10-19 20:40:41,018 - mcp_use - INFO - 👣 Step 2/20 2025-10-19 20:40:45,790 - mcp_use - INFO - ✅ Agent finished at step 2 2025-10-19 20:40:45,790 - mcp_use - INFO - 🎉 Agent execution complete in 15.049546718597412 seconds

2025-10-19 20:40:47.336 | INFO | main:main:88 - Collection setup result:

Thought: I now know the final answer Final Answer: The Qdrant collection “documents” exists.

Query 2: Store Information (First Entry)

2025-10-19 20:40:47,337 - mcp_use - INFO - 💬 Received query: ‘Store the following information in Qdrant collecti…’ 2025-10-19 20:40:47,337 - mcp_use - INFO - 🏁 Starting agent execution with max_steps=20 2025-10-19 20:40:47,337 - mcp_use - INFO - 👣 Step 1/20 2025-10-19 20:41:04,734 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_store with {'collection_name': 'documents', 'information': 'The architecture is straightforward: developers can either expose their data through MCP servers or build AI applications (MCP clients) that connect to these servers.', 'metadata': {}} responded:

2025-10-19 20:41:04,734 - mcp_use - INFO - 🔧 Tool call: qdrant_store with input: {'collection_name': 'documents', 'information': 'The architecture is straightforward: developers ...'} 2025-10-19 20:41:04,734 - mcp_use - INFO - 📄 Tool result: Stored. 2025-10-19 20:41:04,735 - mcp_use - INFO - 👣 Step 2/20 2025-10-19 20:41:10,668 - mcp_use - INFO - ✅ Agent finished at step 2 2025-10-19 20:41:10,668 - mcp_use - INFO - 🎉 Agent execution complete in 23.331373929977417 seconds

2025-10-19 20:41:10.913 | INFO | main:upsert_sample_texts:64 - 0 Tool result:

Thought: I now know the final answer Final Answer: The information has been successfully stored in the Qdrant collection “documents”.

Query 3: Store Information (Second Entry, Repeated)

2025-10-19 20:41:10,915 - mcp_use - INFO - 💬 Received query: ‘Store the following information in Qdrant collecti…’ 2025-10-19 20:41:10,915 - mcp_use - INFO - 🏁 Starting agent execution with max_steps=20 2025-10-19 20:41:10,915 - mcp_use - INFO - 👣 Step 1/20 2025-10-19 20:42:01,579 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_store with {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the Claude Desktop app.', 'metadata': {}} responded: Okay, let's see. The user wants me to store two identical pieces of information in the Qdrant collection 'docum... 2025-10-19 20:42:01,580 - mcp_use - INFO - 🔧 Tool call: qdrant_store with input: {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the C...'} 2025-10-19 20:42:01,580 - mcp_use - INFO - 📄 Tool result: Stored. 2025-10-19 20:42:01,580 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_store with {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the Claude Desktop app.', 'metadata': {}} responded: Okay, let's see. The user wants me to store two identical pieces of information in the Qdrant collection 'docum... 2025-10-19 20:42:01,580 - mcp_use - INFO - 🔧 Tool call: qdrant_store with input: {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the C...'} 2025-10-19 20:42:01,580 - mcp_use - INFO - 📄 Tool result: Stored. 2025-10-19 20:42:01,580 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_store with {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the Claude Desktop app.', 'metadata': {}} responded: Okay, let's see. The user wants me to store two identical pieces of information in the Qdrant collection 'docum... 2025-10-19 20:42:01,581 - mcp_use - INFO - 🔧 Tool call: qdrant_store with input: {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the C...'} 2025-10-19 20:42:01,581 - mcp_use - INFO - 📄 Tool result: Stored. 2025-10-19 20:42:01,581 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_store with {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the Claude Desktop app.', 'metadata': {}} responded: Okay, let's see. The user wants me to store two identical pieces of information in the Qdrant collection 'docum... 2025-10-19 20:42:01,581 - mcp_use - INFO - 🔧 Tool call: qdrant_store with input: {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the C...'} 2025-10-19 20:42:01,581 - mcp_use - INFO - 📄 Tool result: Stored. 2025-10-19 20:42:01,581 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_store with {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the Claude Desktop app.', 'metadata': {}} responded: Okay, let's see. The user wants me to store two identical pieces of information in the Qdrant collection 'docum... 2025-10-19 20:42:01,582 - mcp_use - INFO - 🔧 Tool call: qdrant_store with input: {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the C...'} 2025-10-19 20:42:01,582 - mcp_use - INFO - 📄 Tool result: Stored. 2025-10-19 20:42:01,582 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_store with {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the Claude Desktop app.', 'metadata': {}} responded: Okay, let's see. The user wants me to store two identical pieces of information in the Qdrant collection 'docum... 2025-10-19 20:42:01,582 - mcp_use - INFO - 🔧 Tool call: qdrant_store with input: {'collection_name': 'documents', 'information': 'ai plans support connecting MCP servers to the C...'} 2025-10-19 20:42:01,582 - mcp_use - INFO - 📄 Tool result: Stored. 2025-10-19 20:42:01,582 - mcp_use - INFO - 👣 Step 2/20 2025-10-19 20:42:09,251 - mcp_use - INFO - ✅ Agent finished at step 2 2025-10-19 20:42:09,251 - mcp_use - INFO - 🎉 Agent execution complete in 58.33606290817261 seconds

2025-10-19 20:42:09.502 | INFO | main:upsert_sample_texts:64 - 1 Tool result:

Thought: I now know the final answer Final Answer: The information has been successfully stored twice in the Qdrant collection “documents”.

Query 4: Store Information (Third Entry, Repeated)

2025-10-19 20:42:09,503 - mcp_use - INFO - 💬 Received query: ‘Store the following information in Qdrant collecti…’ 2025-10-19 20:42:09,503 - mcp_use - INFO - 🏁 Starting agent execution with max_steps=20 2025-10-19 20:42:09,504 - mcp_use - INFO - 👣 Step 1/20 2025-10-19 20:42:56,947 - mcp_use - INFO - ✅ Agent finished at step 1 2025-10-19 20:42:56,948 - mcp_use - INFO - 🎉 Agent execution complete in 47.445122480392456 seconds

2025-10-19 20:42:57.197 | INFO | main:upsert_sample_texts:64 - 2 Tool result:

Thought: I now know the final answer Final Answer: The information has been successfully stored twice in the Qdrant collection “documents”.

Query 5: Find Similar Information (RAG Retrieval)

2025-10-19 20:42:57,198 - mcp_use - INFO - 💬 Received query: ‘Find similar information in Qdrant collection ‘doc…’ 2025-10-19 20:42:57,199 - mcp_use - INFO - 🏁 Starting agent execution with max_steps=20 2025-10-19 20:42:57,199 - mcp_use - INFO - 👣 Step 1/20 2025-10-19 20:43:54,905 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_find with {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} responded: Okay, let's tackle this problem. The user wants me to find similar information in the Qdrant collection 'documents' using the query: "ai plans suppo... 2025-10-19 20:43:54,905 - mcp_use - INFO - 🔧 Tool call: qdrant_find with input: {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} 2025-10-19 20:43:54,905 - mcp_use - INFO - 📄 Tool result: ai plans support connecting MCP servers to the Claude Desktop app.The architecture is straightfor… 2025-10-19 20:43:54,905 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_find with {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} responded: Okay, let's tackle this problem. The user wants me to find similar information in the Qdrant collection 'documents' using the query: "ai plans suppo... 2025-10-19 20:43:54,906 - mcp_use - INFO - 🔧 Tool call: qdrant_find with input: {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} 2025-10-19 20:43:54,906 - mcp_use - INFO - 📄 Tool result: ai plans support connecting MCP servers to the Claude Desktop app.The architecture is straightfor… 2025-10-19 20:43:54,906 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_find with {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} responded: Okay, let's tackle this problem. The user wants me to find similar information in the Qdrant collection 'documents' using the query: "ai plans suppo... 2025-10-19 20:43:54,906 - mcp_use - INFO - 🔧 Tool call: qdrant_find with input: {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} 2025-10-19 20:43:54,907 - mcp_use - INFO - 📄 Tool result: ai plans support connecting MCP servers to the Claude Desktop app.The architecture is straightfor… 2025-10-19 20:43:54,907 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_find with {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} responded: Okay, let's tackle this problem. The user wants me to find similar information in the Qdrant collection 'documents' using the query: "ai plans suppo... 2025-10-19 20:43:54,907 - mcp_use - INFO - 🔧 Tool call: qdrant_find with input: {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} 2025-10-19 20:43:54,907 - mcp_use - INFO - 📄 Tool result: ai plans support connecting MCP servers to the Claude Desktop app.The architecture is straightfor… 2025-10-19 20:43:54,907 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_find with {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} responded: Okay, let's tackle this problem. The user wants me to find similar information in the Qdrant collection 'documents' using the query: "ai plans suppo... 2025-10-19 20:43:54,908 - mcp_use - INFO - 🔧 Tool call: qdrant_find with input: {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} 2025-10-19 20:43:54,908 - mcp_use - INFO - 📄 Tool result: ai plans support connecting MCP servers to the Claude Desktop app.The architecture is straightfor… 2025-10-19 20:43:54,908 - mcp_use - INFO - 💭 Reasoning: Invoking: qdrant_find with {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} responded: Okay, let's tackle this problem. The user wants me to find similar information in the Qdrant collection 'documents' using the query: "ai plans suppo... 2025-10-19 20:43:54,908 - mcp_use - INFO - 🔧 Tool call: qdrant_find with input: {'collection_name': 'documents', 'query': 'ai plans support connecting MCP servers to the what?'} 2025-10-19 20:43:54,908 - mcp_use - INFO - 📄 Tool result: ai plans support connecting MCP servers to the Claude Desktop app.The architecture is straightfor… 2025-10-19 20:43:54,908 - mcp_use - INFO - 👣 Step 2/20 2025-10-19 20:44:10,311 - mcp_use - INFO - ✅ Agent finished at step 2 2025-10-19 20:44:10,312 - mcp_use - INFO - 🎉 Agent execution complete in 73.11462140083313 seconds

2025-10-19 20:44:10.559 | INFO | main:query_sample:68 - RAG retrieval result:

Thought: I now know the final answer Final Answer: The similar information found in the Qdrant collection “documents” for the query “ai plans support connecting MCP servers to the what?” is: “ai plans support connecting MCP servers to the Claude Desktop app. The architecture is straightforward: developers can either expose their data through MCP servers or build AI applications (MCP clients) that connect to these servers.”

Session End