How MCP Turns AI into a Universal Plug‑In: A Deep Dive into Model Context Protocol

What is MCP?

Model Context Protocol (MCP) is an open, consensus‑based standard that defines a universal interface for large language models (LLMs) to access local and remote resources such as files, databases, APIs, and tools. It works like a "USB‑C" for AI models, allowing a single protocol to replace fragmented, model‑specific integration code.

Architecture

MCP Host : the AI application (e.g., a chatbot or AI‑powered IDE) that initiates requests.

MCP Client : a 1:1 component inside the host that communicates with an MCP Server.

MCP Server : provides tool definitions, resource schemas, and prompts to the client.

Local Resources : files, databases, or other assets on the host machine that the server can safely access.

Remote Resources : external services reachable via APIs.

Tool selection and execution flow

When a user asks a question, the client forwards the prompt to the LLM together with a system message that lists all available tools and their JSON‑compatible descriptions. The LLM decides whether a tool is needed and, if so, emits a JSON‑formatted tool call. The client executes the tool, captures the result, and sends the original prompt plus the result back to the LLM for a final natural‑language response. Invalid or hallucinated tool calls are ignored.

# Simplified selection logic (Python‑like pseudocode)
async def start(self):
    # Initialize all MCP servers
    for server in self.servers:
        await server.initialize()
    # Gather all tools
    all_tools = []
    for server in self.servers:
        tools = await server.list_tools()
        all_tools.extend(tools)
    # Build a description string for the LLM
    tools_description = "
".join([tool.format_for_llm() for tool in all_tools])
    system_message = (
        "You are a helpful assistant with access to these tools:

"
        f"{tools_description}
"
        "Choose the appropriate tool based on the user's question. If no tool is needed, reply directly.

"
        "IMPORTANT: When you need to use a tool, respond ONLY with the exact JSON object below, nothing else:
"
        "{
"
        "    \"tool\": \"tool-name\",
"
        "    \"arguments\": {
"
        "        \"argument-name\": \"value\"
"
        "    }
"
        "}
"
    )
    messages = [{"role": "system", "content": system_message}]
    # The rest of the interaction loop is omitted for brevity

# Processing LLM response (simplified)
while True:
    messages.append({"role": "user", "content": user_input})
    llm_response = self.llm_client.get_response(messages)
    result = await self.process_llm_response(llm_response)
    if result != llm_response:  # a tool was executed
        messages.append({"role": "assistant", "content": llm_response})
        messages.append({"role": "system", "content": result})
        final_response = self.llm_client.get_response(messages)
        messages.append({"role": "assistant", "content": final_response})
    else:
        messages.append({"role": "assistant", "content": llm_response})

Python MCP Server example

The following minimal server counts and lists .txt files on the user's desktop. It demonstrates SDK setup, tool definition via the @mcp.tool() decorator, and server launch.

import os
from pathlib import Path
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Desktop TXT Counter")

@mcp.tool()
def count_desktop_txt_files() -> int:
    """Count .txt files on the desktop."""
    username = os.getenv("USER") or os.getenv("USERNAME")
    desktop_path = Path(f"/Users/{username}/Desktop")
    txt_files = list(desktop_path.glob("*.txt"))
    return len(txt_files)

@mcp.tool()
def list_desktop_txt_files() -> str:
    """List filenames of .txt files on the desktop."""
    username = os.getenv("USER") or os.getenv("USERNAME")
    desktop_path = Path(f"/Users/{username}/Desktop")
    txt_files = list(desktop_path.glob("*.txt"))
    if not txt_files:
        return "No .txt files found on desktop."
    file_list = "
".join([f"- {file.name}" for file in txt_files])
    return f"Found {len(txt_files)} .txt files on desktop:
{file_list}"

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

Setup commands

# Install uv (fast Python package manager)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Create project directory
uv init txt_counter
cd txt_counter

echo "3.11" > .python-version  # set Python version
uv venv
source .venv/bin/activate

# Install MCP SDK and httpx
uv add "mcp[cli]" httpx

# Create the server script
touch txt_counter.py
# (paste the code above into txt_counter.py)

Running and testing

Start the server in development mode: mcp dev txt_counter.py Output includes the inspector URL, e.g. http://localhost:5173, where you can manually invoke the tools. The server listens on port 3000 for proxy requests.

Debugging and reference resources

https://modelcontextprotocol.io/docs/tools/debugging

https://modelcontextprotocol.io/docs/tools/inspector

https://modelcontextprotocol.io/tutorials/building-mcp-with-llms

These guides cover detailed debugging steps, inspector usage, and best practices for building MCP servers with any LLM.