Understanding the Model Context Protocol (MCP)

If you have spent time working with LLMs like GPT or Claude, you have probably run into the limits of what they can do out of the box. They are excellent at answering questions, summarizing content, and even writing code. However, they are not well suited for tasks like fetching live stock prices, interacting with local developer tools, or performing real-time computations.

Traditionally, solving these kinds of problems meant wiring up custom function calls and writing logic to determine when and how to use them. That approach works, but it can quickly become difficult to maintain and scale.

Model Context Protocol (MCP) offers a cleaner alternative. It provides a lightweight and standardized way for language models to discover and use tools based entirely on the prompt. In this article, we will take a closer look at what MCP is, how it compares to traditional tool usage, and why it is an important upgrade for anyone building more advanced or flexible LLM-powered applications.

What Are “Tools” in LLMs?

Tools are essentially function calls that a language model can execute in order to extend its capabilities beyond its training data.

For example, suppose you want your LLM to look up live stock prices. It does not know current prices on its own, but it can call a function like search_web() or get_stock_price("AAPL"). These functions, or “tools,” are implemented in the application that wraps around the model. They are not part of the model itself, whether that is GPT, Claude, Gemini, or something else.

Here is a simple example using FastMCP:

1# stocks.py
2from fastmcp import mcp
3
4@mcp.tool()
5def get_stock_price(ticker: str) -> float:
6    # call a stock API
7    ...
1# stocks.py
2from fastmcp import mcp
3
4@mcp.tool()
5def get_stock_price(ticker: str) -> float:
6    # call a stock API
7    ...

When the model receives a prompt like “What is the latest price of AAPL?”, it can decide to call this function to get an up-to-date answer.

What Is the Model Context Protocol (MCP)?

MCP, or Model Context Protocol, is an open standard introduced by Anthropic. It defines a structured way for language models to do the following:

• Discover available tools
• Decide which ones to use
• Pass in the correct parameters
• Return the result to the user

All of this happens dynamically, based entirely on the user prompt.

Yes, it was possible to implement this manually before. MCP simply gives you a standardized and much easier way to handle it.

MCP Servers and Clients

MCP introduces two key components: servers and clients.

MCP Servers

MCP servers are simple web APIs that expose tools. Using FastMCP, you can set this up with very little code. You only need to annotate your functions with @mcp.tool() and FastMCP will handle exposing them as a server.

You can run an MCP server locally or host it remotely. Below is an example configuration for running one from your local machine:

1// mcpConfig.json
2{
3  "mcpServers": {
4    "stocks": {
5      "command": "/opt/homebrew/bin/uv",
6      "args": [
7        "--directory",
8        "/Users/michael/projects/stocks",
9        "run",
10        "stocks"
11      ]
12    }
13  }
14}
1// mcpConfig.json
2{
3  "mcpServers": {
4    "stocks": {
5      "command": "/opt/homebrew/bin/uv",
6      "args": [
7        "--directory",
8        "/Users/michael/projects/stocks",
9        "run",
10        "stocks"
11      ]
12    }
13  }
14}

MCP Clients

This is where things become more interesting. An MCP client is an application like Cursor, Claude Desktop, or VS Code that can connect to one or more MCP servers.

Important note: When we talk about “clients” here, we are referring to local applications that connect to MCP servers. This is different from the traditional client-server architecture. In this context, the client is your development environment or agent interface that interacts with your own local or remote MCP setup.

End-to-End Flow (With MCP)

Imagine typing the following into your MCP-aware development environment, such as Cursor:

“What is the latest ticker price for AAPL?”

Here is what happens behind the scenes:

1. The user sends a prompt to the LLM client.
2. The client queries all connected MCP servers to discover available tools.
3. The language model selects the appropriate tool, such as get_stock_price, and determines the correct parameters.
4. The selected tool is invoked through the MCP server.
5. The tool returns data, which the model uses to generate a complete response.
6. The user receives a response that includes real-time data pulled from the tool.

All of this happens without needing to hardcode any conditional logic to match prompts to tool calls.

Why MCP Actually Matters

While it has always been possible to implement something like this manually, MCP provides a consistent and reliable standard that saves time and reduces complexity.

Here are a few reasons it matters:

• Standardization: You no longer need to invent your own tool discovery logic.
• Reusability: Tools can be shared and reused across different applications.
• Developer Experience: You define once and use it everywhere.
• Scalability: It makes it easier to build agentic workflows and use multiple tools in combination.

You can think of this as a step up from hardcoded function calls to a plugin-style ecosystem where tools can be composed, reused, and discovered on demand.

What MCP Is Not

Just to be clear, MCP is not the following:

• It is not a plugin marketplace
• It is not hosted infrastructure
• It is not tied to any single model or provider

MCP is a protocol. It provides a common way for models, tools, and environments to communicate. Anyone can implement it, and projects like FastMCP already make it easy to get started.

Getting Started

If you want to explore MCP for yourself, here are a few helpful links:

• Model Context Protocol on GitHub
• FastMCP (Python)
• Try it out with tools like Cursor or Claude Desktop

Final Thoughts

If you have ever hacked together a few function calls to make your language model do something useful, like query a database, check the weather, or pull stock prices, you have probably felt both the power and the friction. It works, but it takes time, structure, and often a lot of glue code.

What MCP brings to the table is not magic. It is clarity. It gives me a simple and shared way to expose tools and allows language models to use them without needing a custom setup every time.

For me, this is about lowering the barrier to building practical and extensible systems with language models. Whether you are tinkering on a weekend project or building something for production, MCP makes the process a little smoother—and that makes a difference (plus the off-the-shelf ecosystem a standard enables).