Build Smarter AI: Leveraging the Model Context Protocol for Dynamic Context

MCP
Page content

Summary

The evolution of technology is driven by protocols structured ways for systems to communicate and interact. The internet, APIs, and even modern databases rely on protocols to function efficiently. Similarly, as AI becomes more powerful, it needs a structured and standardized way to manage context across interactions.

Enter the Model Context Protocol (MCP) a framework designed to enhance the way AI models understand, retain, and utilize context over multiple exchanges. Large Language Models (LLMs) are powerful, but without effective context management, they can:

  • Lose track of previous conversations.
  • Provide inconsistent or redundant responses.
  • Require unnecessary reprocessing of information.

MCP solves these issues by providing a structured way to encode, retrieve, and update context dynamically. It enables AI systems to seamlessly integrate with external tools, databases, and APIs, creating smarter, more adaptable AI applications.

In this blog post, we’ll explore:
✅ What MCP is and why it matters
✅ How MCP works, including key components like context encoding and dynamic updates
✅ Technical implementation details, including JSON-RPC messaging and session management
✅ Practical examples, including how to integrate MCP with LLMs, tools, and databases

By the end, you’ll have a clear understanding of how MCP unlocks the next generation of AI interactions making them more efficient, responsive, and scalable.

Key Terms and Definitions

This post introduces several key concepts. Here’s an explanation of each:

  1. MCP (Model Context Protocol)
    A standardized framework for managing and maintaining context in AI interactions. It helps AI models remember information across multiple exchanges.
  2. Context
    Background information, user history, or external data that an AI model uses to generate relevant responses.
  3. Context Encoding
    The process of transforming complex data into a format that AI models can efficiently process and understand.
  4. Dynamic Context Management
    The ability to update and refine context in real time as interactions progress, allowing AI models to improve their understanding over time.
  5. Contextual Relevance Scoring
    A method used by AI models to determine which pieces of context are most important for generating accurate and useful responses.
  6. Context Representation
    The way contextual data is stored and transmitted, often in formats like JSON, nested dictionaries, or semantic graphs.
  7. Context Containers
    Structured repositories that store knowledge, user history, and metadata for AI applications.
  8. Message Protocols
    Rules that define how AI models and applications communicate, typically using JSON-based formats for easy data exchange.
  9. Context Layers
    Different sources of information (e.g., memory, retrieval, external APIs) that AI models use to enhance their responses.
  10. Session Management
    A system that maintains user data across interactions, ensuring continuity and personalization in AI applications.
  11. Context Injection
    The process of adding structured data (like user preferences or previous messages) into the context container.
  12. Real-Time Context Management
    The ability to modify AI context instantly without restarting interactions, allowing for adaptive AI responses.

What is the Model Context Protocol?

The Model Context Protocol is a systematic methodology for transmitting, interpreting, and maintaining contextual information during AI interactions. Traditional AI models treat each interaction as isolated. MCP changes this by providing a structured approach to store and retrieve context, enabling AI to improve over multiple exchanges.

Key Components of the Protocol:

Context Encoding

The protocol begins with a robust method of encoding contextual information. This involves transforming complex, multi-dimensional contextual data into a standardized format that AI models can efficiently process and interpret.

  • How Context Encoding is Used in MCP
    1. When an interaction starts → MCP encodes relevant context (user preferences, previous messages).
    1. When a user sends a query → MCP retrieves the encoded context.
    1. When the model generates a response → It updates the context encoding for the next interaction.

Dynamic Context Management

Unlike static context frameworks, the Model Context Protocol allows for dynamic updating and refinement of contextual understanding. As an interaction progresses, the context can be incrementally modified, enriched, and recalibrated.

Contextual Relevance Scoring

Is a mechanism used to evaluate and prioritize different pieces of context when generating responses. This ensures that the most relevant information is given more weight, leading to more accurate and context-aware AI interactions.

How Contextual Relevance Scoring Works in MCP

  1. Extracting Context Sources
    • MCP gathers context from multiple sources, such as user history, memory layers, retrieval systems, API responses, and stored metadata.
  2. Scoring Context Elements
    • Each piece of context is assigned a relevance score based on factors like:
      • Recency (Newer information is often more relevant.)
      • Semantic Similarity (How closely the context matches the current query.)
      • Usage Frequency (How often a piece of context has been referenced in past interactions.)
      • Explicit Importance (Some data may have a predefined priority.)
  3. Weighted Context Selection
    • The MCP model uses the scores to determine which pieces of context should be included, excluded, or prioritized in a given interaction.
    • Lower-scoring context elements may be discarded or de-emphasized to prevent irrelevant or outdated information from influencing the response.
  4. Adaptive Relevance Updating
    • As the conversation evolves, the scoring adjusts dynamically.
    • Context that was relevant at the start of an interaction may become less important over time, while new inputs may take precedence.
    • MCP continuously refines the context pool to optimize accuracy.

Example of Contextual Relevance Scoring in Action

Scenario: AI Assistant Answering User Questions

Imagine a customer support chatbot using MCP. The user asks:

“What’s the status of my order?”

The system evaluates multiple context sources:

  • Recent user messages (e.g., “I placed an order yesterday”) → High Relevance
  • Order history API response (e.g., “Order #1234 shipped today”) → Very High Relevance
  • General FAQ on shipping policies → Low Relevance
  • Older order details from last month → Very Low Relevance (Discarded)

The highest-scoring context elements (order history and recent messages) are selected, ensuring the AI provides an accurate and context-aware response.

Why use the MCP

One of the biggest challenges in using LLMs is efficiently managing context the background knowledge, user history, or external data that an AI model relies on to generate relevant responses.

Without a structured protocol, context management can become ad-hoc, inefficient, and difficult to scale. MCP addresses this by:

  • Providing standardized communication between applications and models.
  • Improving context persistence, reducing redundant information exchange.
  • Enhancing modularity, allowing models to interact with various data sources seamlessly.
  • Enabling real-time updates to model context without needing to restart the interaction.

Additionally, MCP helps you build agents and complex workflows on top of LLMs. LLMs frequently need to integrate with data and tools, and MCP provides:

  • A growing list of pre-built integrations that your LLM can directly plug into
  • Flexibility to switch between LLM providers and vendors
  • Best practices for securing your data within your infrastructure.
  • A process and guidelines on how to build tools for interaction with LLM’s.

mcp

Technical Details of MCP

Base Protocol

The Model Context Protocol (MCP) follows a structured and extensible protocol for managing AI interactions. At its core, it supports:

1. JSON-RPC Message Format

  • MCP uses JSON-RPC 2.0 as the primary communication format between clients and servers.
  • JSON-RPC is a lightweight, stateless protocol that allows remote procedure calls (RPCs) to be executed over a structured message format.
  • Implementation:
    • Clients send requests to MCP servers in JSON format.
    • The server processes the request, executes the corresponding function, and returns a JSON response.
    • Requests can be synchronous or asynchronous.

Example JSON-RPC Request in MCP:

{
  "jsonrpc": "2.0",
  "method": "get_context",
  "params": {"session_id": "user123"},
  "id": 1
}

Example JSON-RPC Response:

{
  "jsonrpc": "2.0",
  "result": {"context": "User prefers sci-fi movies"},
  "id": 1
}

2. Stateful Connections

  • MCP supports stateful interactions, meaning it maintains session context across multiple exchanges.
  • It does this by:
    • Tracking session IDs to persist user context.
    • Storing context in memory or external databases (e.g., Redis, PostgreSQL).
    • Dynamically updating context as interactions progress.

Implementation:

  • The server assigns a session ID to each user.
  • Context containers store session-specific data.
  • When a client sends a new request, the server retrieves stored context and updates it as needed.

Example of a Stateful Session:

  1. User asks: “What’s my last query?”
  2. Server retrieves session history and responds.
  3. User asks another question, and the context remains persistent.

3. Server and Client Capability Negotiation

  • MCP allows clients and servers to negotiate capabilities dynamically, ensuring compatibility.
  • When a client connects, it can request available features from the server.
  • The server returns a list of supported features, and the client can choose which ones to use.

Example Implementation:

  • Client requests available server features:
{
  "jsonrpc": "2.0",
  "method": "list_features",
  "id": 2
}
  • Server responds with available features:
{
  "jsonrpc": "2.0",
  "result": {
    "features": ["resources", "prompts", "tools", "sampling"]
  },
  "id": 2
}

MCP Features

MCP servers can provide different functionalities to clients:

1. Resources: Context and Data

  • Resources are structured containers that store context, user history, and data for AI models.
  • Servers provide access to:
    • User-specific context (e.g., preferences, previous interactions).
    • External knowledge sources (e.g., APIs, databases).

Implementation:

  • MCP servers define resource endpoints using JSON-RPC.
  • Clients can store and retrieve resources dynamically.

Example: Store user preference as a resource

{
  "jsonrpc": "2.0",
  "method": "store_resource",
  "params": {"key": "user_pref", "value": "likes sci-fi"},
  "id": 3
}

2. Prompts: Templated Messages and Workflows

  • Prompts are predefined templates used for AI interactions.
  • Servers can store reusable prompts for AI models.
  • Workflows can be multi-step AI interactions.

Implementation:

  • MCP provides a prompt method to register, retrieve, and execute prompts.

Example: Retrieve a stored prompt

{
  "jsonrpc": "2.0",
  "method": "get_prompt",
  "params": {"name": "weather_request"},
  "id": 4
}

3. Tools: Functions for AI Execution

  • MCP allows servers to define functions (tools) that AI models can call during execution.
  • These tools can:
    • Query databases
    • Fetch API data
    • Perform calculations

Implementation:

  • MCP servers define tools as callable functions.
  • LLMs can invoke tools during a conversation.

Example of a Tool Definition in MCP:

@mcp.tool()
def get_weather(city: str) -> str:
    """Fetch weather data for a given city."""
    return f"The weather in {city} is sunny."

Client Features in MCP

MCP clients can provide additional features to servers:

1. Sampling: Recursive AI Interactions

  • Clients can automate AI interactions, making decisions based on sampled outputs.
  • Useful for multi-step AI reasoning.

Implementation:

  • Clients request a sampled response, where the server provides multiple possible outputs.

Example:

{
  "jsonrpc": "2.0",
  "method": "sample_response",
  "params": {"prompt": "Suggest a vacation destination"},
  "id": 5
}
  • Server returns multiple response options:
{
  "jsonrpc": "2.0",
  "result": {
    "samples": ["Paris", "Tokyo", "New York"]
  },
  "id": 5
}

Additional Utilities in MCP

MCP also includes various utility features for robustness.

1. Configuration

  • Clients and servers can exchange configurations dynamically.
  • Supports:
    • Model selection (e.g., “Use GPT-4 or Claude?”)
    • Context length limits
    • API rate limits

Example:

{
  "jsonrpc": "2.0",
  "method": "set_config",
  "params": {"max_context_length": 2048},
  "id": 6
}

2. Progress Tracking

  • MCP allows tracking of long-running processes.
  • Useful for asynchronous API calls.

Example:

{
  "jsonrpc": "2.0",
  "method": "track_progress",
  "params": {"task_id": "1234"},
  "id": 7
}

3. Cancellation

  • MCP supports cancelling ongoing tasks.
  • Clients can send a cancellation request, and the server will stop execution.

Example:

{
  "jsonrpc": "2.0",
  "method": "cancel_task",
  "params": {"task_id": "1234"},
  "id": 8
}

4. Error Reporting

  • MCP includes standardized error messages for debugging.

Example: Error Response

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32600,
    "message": "Invalid request format."
  },
  "id": null
}

5. Logging

  • MCP servers log interactions for analysis and debugging.
  • Logs track:
    • User queries
    • Context updates
    • LLM decisions

Example: Logging an interaction

{
  "jsonrpc": "2.0",
  "method": "log_event",
  "params": {"event": "User asked about weather."},
  "id": 9
}

How MCP Works

Core Components

MCP operates on a simple yet powerful framework that includes:

  1. Context Containers

    • Act as structured repositories for knowledge, history, and metadata.
    • Can store user messages, API calls, documents, and session data.

  2. Message Protocols

    • Define the communication between clients (users/applications) and models.
    • Typically JSON-based for easy parsing.

  3. Context Layers

    • Allow models to reference different context sources dynamically.
    • Examples include memory layers, retrieval layers, and external API layers.

  4. Session Management

    • Enables persistent memory across interactions.
    • Supports time-sensitive data retention policies.

MCP Workflow

Here’s how MCP typically operates in a real-world scenario:

  1. Initialization: The system initializes a context container when a user session begins.
  2. Context Injection: Relevant structured data (e.g., user preferences, recent interactions) is added.
  3. Query Handling: The model processes queries using both new inputs and stored context.
  4. Context Update: After generating a response, the model updates the container with new knowledge.
  5. Response Generation: The refined response, informed by both static and dynamic context, is sent back to the user.

Practical Example: Create and test an Echo Application

Step 1: Create the server

A structured JSON format is used to store context:

pip install mcp mcp[cli]

from mcp.server.fastmcp import FastMCP

# create the server
mcp = FastMCP("Echo")

# Echo resource 
# Defines an MCP resource that listens for requests in the format: echo://your_message
# When accessed, it returns the message with "Resource echo: " added.
@mcp.resource("echo://{message}")
def echo_resource(message: str) -> str:
    """Echo a message as a resource"""
    return f"Resource echo: {message}"

# Define a tool which is a callable function. 
# This tool takes a message as input and returns "Tool echo: message".
@mcp.tool()
def echo_tool(message: str) -> str:
    """Echo a message as a tool"""
    return f"Tool echo: {message}"

# Defines a prompt function which formats the input as a request.
# Instead of just returning the message, it asks the AI model to process it.
@mcp.prompt()
def echo_prompt(message: str) -> str:
    """Create an echo prompt"""
    return f"Please process this message: {message}"

How These Pieces Work Together

Feature Purpose Example Input Example Output
Resource Retrieves stored data via URL-style requests echo://Hi "Resource echo: Hi"
Tool Performs a function (used in AI workflows) echo_tool("Hi") "Tool echo: Hi"
Prompt Formats the message as an AI query prompt echo_prompt("Hi") "Please process this message: Hi"

Step 2: Run the echo server

We can use the mcp cli with the dev flag to test the server

mcp dev .\echo_server.py

🔍 MCP Inspector is up and running at http://localhost:5173 🚀

Step 3: Testing the Server

If you open a browser at http://localhost:5173 you will be able to test the server.

    1. Connect to the server

MCP Connect

    1. Open the Tools page and send a message
    • List the tools, if none are showing. In this case there will be just the echo tool
    • Enter a message and click the Run Tool button.

MCP Tool

4. Config for tool

{
    "mcpServers": {
        "weather": {
            "command": "uv",
            "args": [
                "--directory",
                "C:\\ABSOLUTE\\PATH\\TO\\PARENT\\FOLDER\\echo_server",
                "run",
                "echo_server.py"
            ]
        }
    }
}

MCP Servers

There is a large list of MCP servers here MCP Servers

These include servers for

  • PostgreSQL
  • Brave Search
  • Git
  • Neo4j
  • Slack

and many more.

Ollama interacting with sqlite

In this example, we demonstrate how MCP can bridge a local LLM (Ollama with qwen2.5) with an SQLite database (chinook.db). This allows the LLM to query and retrieve information from the database, enabling more informed and accurate responses.

Step 1 : Install mcphost

To do this I need to install a bridge application: mcphost.

To install this first install go: Go install.

Then using go we install the bridge application:

go install github.com/mark3labs/mcphost@latest

Next we need a server we can host. We can use docker or we can use a local one. For this post I am going to use

  • Ollama to communicate with a local LLM.
  • qwen2.5 as the local LLM model.
  • SQLite MCP Server as the mcp server.

Step 2. The Database

The first thing we need is an sqlite database to browse.

I am going to use chinook. It is a music database.

You can download a copy from here chinook

Step 3. The model

To get the model use ollama to pull it.

ollama pull qwen2.5

Step 4. The mcp config file

This is a JSON file. Save it in the same directory as your chinook.db file.

{
    "mcpServers": {
      "sqlite": {
        "command": "uvx",
        "args": [
          "mcp-server-sqlite",
          "--db-path",
          "./chinook.db"
        ]
      },
      "filesystem": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-filesystem",
          "/tmp"
        ]
      }
    }
  }

This JSON file configures two servers

    1. SQLite MCP Server: Interacts with an SQLite database (chinook.db).
    1. Filesystem MCP Server: Allows interaction with a file system (/tmp directory).

Step 5. Start the MCP host application

mcphost -m ollama:qwen2.5 --config mcp.json

2025/03/05 18:10:55 INFO Model loaded provider=ollama model=qwen2.5
2025/03/05 18:10:55 INFO Initializing server... name=filesystem
2025/03/05 18:10:57 INFO Initializing server... name=sqlite
2025/03/05 18:10:58 INFO Server connected name=filesystem
2025/03/05 18:10:58 INFO Server connected name=sqlite
2025/03/05 18:10:58 INFO Tools loaded server=sqlite count=6
2025/03/05 18:10:58 INFO Tools loaded server=filesystem count=11

Step 6. Querying the database with the model through MCP and the sqlite server

If we look at the docs for the Server we can see some of the supported commands

Sqlite MCP Docs

  • read_query: Execute SELECT queries to read data from the database
  • write_query: Execute INSERT, UPDATE, or DELETE queries
  • list_tables: Get a list of all tables in the database
  • create_table: Create new tables in the database
  • describe_table: View schema information for a specific table

Step 7. Example calls and results

list_tables

list_tables

2025/03/05 18:19:49 INFO 🔧 Using tool name=sqlite__list_tables

  Assistant:


  The following tables are present in the database:

  • Album
  • Artist
  ...

describe_table

describe_table Artist

  The Artist table in the database has the following schema:

  • ArtistId (INTEGER, Primary Key): This column is an integer and serves as the primary key for the table.
  • Name (NVARCHAR(120), Nullable): This column can store up to 120 characters and does not have to contain a value.

  This table appears to be used to store artist names with each entry having a unique identifier.

read_query

read_query SELECT * FROM Artist

2025/03/05 18:39:04 INFO 🔧 Using tool name=sqlite__read_query

  Assistant:


  Based on the provided list of music groups and artists from the tool's response, here are some recommendations for live music events you might be interested in:

  1. Calexico - They often perform a mix of indie rock, Americana, and folk elements. Their live shows tend to feature complex arrangements and dynamic
  performances.
  ...

References

Code examples

You can find the code examples used in the post and more here:

mcp-examples