Model Context Protocol

Model Context Protocol

Your agent doesn’t know what it doesn’t know.

MCP is how you teach it.

The Brief

You’re packing for a trip. You open Cursor and ask:

"what's the weather in Colombo right now?"

The agent is fast. It’s confident. It’s about to be wrong.

Attempt 1 — Ask the Agent

You type the obvious thing. The agent answers immediately.

> what's the weather in Colombo right now?

It's currently around 29°C and partly cloudy in Colombo,
with humidity near 80% — typical for this time of year.

Confident. Specific. Useful-sounding.

Now open your weather app.

Why Did That Happen?

The LLM was trained on public text — months or years ago.

The Pattern

Anything that lives outside the weights is invisible to the model.

Every one of these is a place the agent will hallucinate if you ask.

The Pivot

We don’t need a smarter model. We need to hand the model a way to look things up.

1. Expose a real source as a tool

   Wrap a weather API in something the agent can call.

2. Speak a protocol the agent understands

   So any agent — Cursor, Claude, Copilot — can use it.

3. Let the agent decide when to call it

   No prompt engineering. The agent picks the tool by name and description.

That protocol is MCP — the Model Context Protocol.

What Is MCP?

An open protocol that connects AI agents to tools and data — over a standard interface.

The Shape of the Fix

┌──────────┐    MCP     ┌─────────────┐   HTTP   ┌──────────────┐
│  Cursor  │ ─────────▶ │ Weather MCP │ ──────▶  │ open-meteo   │
│ (client) │            │ Server      │          │  (free API)  │
└──────────┘            │ get_weather │          └──────────────┘
                        └─────────────┘

The MCP server is yours. It knows how to talk to the weather API. It tells the agent: “I have a tool called get_weather. Give me a city, I’ll give you the current conditions.”

The agent now has a way to look up instead of guessing.

Build the MCP Server

The Python SDK makes this almost trivial. One file. One tool. No API key — open-meteo is free.

pip install mcp httpx

# weather_server.py
import httpx
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("weather")

@mcp.tool()
def get_weather(city: str) -> dict:
    """Get the current weather for a city.
    Returns temperature in Celsius, wind speed, and a condition code."""
    geo = httpx.get(
        "https://geocoding-api.open-meteo.com/v1/search",
        params={"name": city, "count": 1},
    ).json()
    if not geo.get("results"):
        return {"error": f"City not found: {city}"}

    lat, lon = geo["results"][0]["latitude"], geo["results"][0]["longitude"]
    now = httpx.get(
        "https://api.open-meteo.com/v1/forecast",
        params={"latitude": lat, "longitude": lon, "current_weather": True},
    ).json()["current_weather"]

    return {
        "city":        city,
        "temperature": now["temperature"],
        "wind_kph":    now["windspeed"],
        "condition":   now["weathercode"],
    }

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

Wire It Into Cursor

Cursor reads MCP servers from a config file. One entry per server.

// ~/.cursor/mcp.json
{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": ["/path/to/weather_server.py"]
    }
  }
}

Restart Cursor. The weather server shows up under MCP Tools. The agent now sees get_weather in its toolbox.

Attempt 2 — Ask Again

Same question. Same model. Different result.

> what's the weather in Colombo right now?

[calling tool: weather.get_weather(city="Colombo")]

Currently in Colombo: 24°C, wind 18 km/h, condition code 63
(moderate rain). Pack an umbrella.

The agent didn’t guess. It noticed the question was about current weather, found a tool whose description matched, called it, and used the result.

What Just Happened

1. Tool discovery

   On startup, Cursor asked the MCP server “what can you do?” The server replied with the tool list and descriptions.

2. Intent matching

   When the user asked about Colombo weather, the agent matched the question against tool descriptions and picked get_weather.

3. Invocation

   The agent called the tool with city="Colombo". The MCP server hit the weather API and returned structured JSON.

4. Grounded answer

   The agent answered using the tool’s response — not its imagination.

What MCP Buys You

Beyond One Tool

get_weather is the first rung. The same server can grow.

Same pattern for any source the model can’t reach: Jira, GitHub, Postgres, your feature flags, your deploy pipeline.

The Takeaways

What’s Next