Skip to content

From Skeptic to Believer: Unpacking the Model Context Protocol

I’ll admit it , when I first heard about the Model Context Protocol (MCP), my eyes nearly rolled out of my head. Having worn the data scientist hat for over a decade, I’ve watched plenty of hyped frameworks come and go. But curiosity got the better of me. I dug in, tried it out, and well, I was pleasantly surprised. It turns out MCP actually is useful!

Condensed mini‑blog from my piece on the Model Context Protocol (MCP). Read full article on Medium.

MCP in one breath

It’s a protocol, not a framework. Think USB‑C for LLM apps.

  • Host: your LLM application (chatbot, editor plugin, desktop app). The decider.
  • Client: the in‑app component that speaks MCP to servers. The messenger.
  • Server: exposes Resources (read‑only data), Tools (actions), and Prompts (reusable templates). The do‑er.

One server can power many apps; one app can connect to many servers. No model/vendor lock‑in.

The three primitives (with bite‑sized code)

1) Resources — "GET me context"

Read‑only handles to data you want the model to see.

from mcp.server.fastmcp import FastMCP
mcp = FastMCP("My App")

@mcp.resource("config://app")
def get_config() -> str:
    return "App configuration here"

@mcp.resource("users://{user_id}/profile")
def get_user_profile(user_id: str) -> str:
    return f"Profile data for user {user_id}"

Use for configs, user metadata, document contents, preloaded business context.

2) Tools — "Do the thing"

Side‑effectful actions or computations (sync/async).

import httpx
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("My App")

@mcp.tool()
def calculate_bmi(weight_kg: float, height_m: float) -> float:
    return weight_kg / (height_m ** 2)

@mcp.tool()
async def fetch_weather(city: str) -> str:
    async with httpx.AsyncClient() as client:
        r = await client.get(f"https://api.weather.com/{city}")
        return r.text

Great for API calls, business logic, CRUD, automation.

3) Prompts — "Stop rewriting templates"

Server‑defined, reusable prompt patterns.

from mcp.server.fastmcp import FastMCP
from mcp.server.fastmcp.prompts import base
mcp = FastMCP("My App")

@mcp.prompt()
def review_code(code: str) -> str:
    return f"Please review this code:\n\n{code}"

@mcp.prompt()
def debug_error(error: str) -> list[base.Message]:
    return [
        base.UserMessage("I'm seeing this error:"),
        base.UserMessage(error),
        base.AssistantMessage("I'll help debug that. What have you tried so far?"),
    ]

Handy for code review, support workflows, query templates, standardized outputs.

A practical build: wrap an MLflow model with MCP

Goal: expose a wine‑quality predictor (served via MLflow) to any MCP‑compatible host (e.g., Claude Desktop).

Tool: predict_wine_quality

# server.py
@mcp.tool(name="predict_wine_quality", description="Predict wine quality using MLflow API")
async def predict_wine_quality(inputs: list[list[float]], columns: list[str]) -> list[float]:
    payload = {"dataframe_split": {"data": inputs, "columns": columns}}
    async with httpx.AsyncClient() as client:
        resp = await client.post(MLFLOW_URL, json=payload)
    return resp.json()["predictions"]

Resource: example payload to guide users

@mcp.resource(
    uri="wine://example",
    name="wine_quality_example",
    description="Example wine quality inputs and outputs",
    mime_type="application/json",
)
def get_input_example() -> str:
    import json
    return json.dumps({
        "columns": [
            "fixed acidity", "volatile acidity", "citric acid", "residual sugar",
            "chlorides", "free sulfur dioxide", "total sulfur dioxide",
            "density", "pH", "sulphates", "alcohol"
        ],
        "data": [
            [7.4, 0.7, 0, 1.9, 0.076, 11, 34, 0.9978, 3.51, 0.56, 9.4],
            [7.8, 0.88, 0, 2.6, 0.098, 25, 67, 0.9968, 3.2, 0.68, 9.8]
        ]
    }, indent=2)

Prompt: tidy the output for chat

@mcp.prompt(name="format_predictions", description="Format wine quality predictions for chatbot")
def format_predictions(predictions: list[float]) -> str:
    formatted = "\n".join(f"- Sample {i+1}: **{s:.2f}/10**" for i, s in enumerate(predictions))
    return f"## Predicted Wine Quality Scores\n\n{formatted}"

Dev UX: test, containerize, connect

Local dev & inspector

mcp dev src/mcp_server_mlflow/server.py

Containerize it (recommended)

FROM python:3.11-slim-bookworm
WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential curl git && rm -rf /var/lib/apt/lists/*
COPY pyproject.toml uv.lock README.md ./
COPY src/ ./src/
RUN pip install uv && uv venv && uv sync
RUN useradd -ms /bin/bash appuser
USER appuser
ENV PATH="/app/.venv/bin:$PATH"
ENV MLFLOW_URL="http://host.docker.internal:1234/invocations"
ENTRYPOINT ["mcp-server-mlflow"]

Build it:

docker build -t mcp/wine .

Wire it to Claude Desktop (or any MCP host)

Option A — Docker:

{
  "mcpServers": {
    "My Wine Quality Server (docker)": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "--init", "mcp/wine"]
    }
  }
}

Option B — uv:

{
  "mcpServers": {
    "My Wine Quality Server (uv)": {
      "command": "uv",
      "args": ["--directory", "/PATH/TO/PROJECT", "run", "mcp-server-mlflow"]
    }
  }
}

When MCP shines (and when it’s overkill)

Use MCP when:

  • You have multiple apps/agents that need the same tools/data/prompts.
  • You want model‑agnostic integrations (swap providers without rewiring).
  • Teams should share capabilities via a common, versionable interface.

Skip MCP when:

  • It’s a one‑off script with a single hardcoded API call.
  • There’s no reuse across apps or teammates.

Takeaways

  • MCP standardizes how LLM apps access resources, tools, and prompts.
  • It trades brittle per‑app glue for composable, reusable, portable servers.
  • The Python SDK + mcp dev + Docker make it straightforward to ship.

Wrap‑up

I started a skeptic. After wiring a real MLflow model through MCP and dropping it into a chat host, I’m… converted. If your LLM features are stuck in “autocomplete” mode, MCP is the cleanest path I’ve seen to make them world‑aware without bespoke spaghetti.

📖 Read the Full Article

Article Preview

From Skeptic to Believer: Unpacking the Model Context Protocol

MCP is a powerful open protocol that lets LLM apps connect to tools and data sources in a standardized, plug-and-play way—kind of like REST for AI.

📖 Full article available on Medium