MCP Fundamentals for Building AI Agents/

...

/

What Is MCP?

What Is MCP?

Learn how MCP bridges agents and tools together.

We'll cover the following...

Imagine deploying an advanced AI agent in your clinic. It would connect to databases, access apps, and trigger workflows, appearing to be the ideal assistant on paper.

But there’s a problem.

  • When you ask for a patient’s latest lab results or treatment history, the agent often fails to coherently retrieve and synthesize information from multiple sources.

  • The agent may respond using only the information visible at a single step. Critical context can be lost due to the absence of a consistent protocol governing how information flows between memory, tools, and reasoning steps.

  • Even when the agent has access to the necessary tools, it may make decisions based on incomplete context, lose track of prior steps, or offer plausible—but inaccurate—recommendations, unanchored in patient-specific data.

That’s why simply adding agentic capabilities isn’t enough. Without a Model Context Protocol (MCP), your agent can’t reliably stitch together the right information across steps, keep context consistent, or coordinate complex tasks. MCP ensures that relevant data flows smoothly between actions, tools, and the language model. It transforms a set of loosely connected skills into a unified, intelligent system capable of end-to-end reasoning and execution.

Life before MCP

Consider the experience of an AI developer in early 2024.

You’re building a smart application to help users schedule meetings, extract customer insights, or automate business workflows. You integrate a language model—it responds fluently.

Then a user asks:

“What were our sales numbers yesterday?”
“Schedule a Zoom call for next Thursday.”
“Summarize our latest bug reports.”

These requests need live data, real actions, and up-to-date context. But to connect your AI to real-world tools and data, you find yourself:

  • Writing custom code for every API.

  • Wrestling with different authentication schemes.

  • Worrying about giving too much access (or not enough).

  • Fixing things every time the API changes or a new tool is added.

It’s like building a new, hand-crafted adapter for every device in your house. And if you want your app to work with another AI provider, get ready to do it again.

There had to be a better way.

MCP: The “USB-C for AI”

In late 2024, researchers and engineers at Anthropic and across the open-source community decided: enough was enough. They’d seen every AI developer waste time re-inventing the same brittle integrations.
Their question:

“What if connecting AI to external data and tools was as easy as plugging in a USB-C cable?”

That vision led to the creation of the Model Context Protocol (MCP), an open standard for connecting AI models to real-time data, tools, and services through a single, universal interface.

Press + to interact
Before MCP vs. after MCP
Before MCP vs. after MCP

No more hand-crafted adapters for every API, no more code rewrites for every new integration.
Just “plug in” your data source or tool as an MCP server, and any MCP-compatible AI agent can use it securely and consistently.

Why do we need MCP?

Let’s put the problem side-by-side:

  • Fragmented integrations: Every tool, database, or API needed custom code. Upgrading or swapping one out would require a major refactor.

  • Isolation: AI models couldn’t fetch live data, so answers quickly became stale or incomplete. (Remember the “smartphone with no network?”)

  • Security and permissions: Every integration risked overexposing data, with fragile permission systems.

  • Vendor lock-in: Each AI provider had their own function-calling or plugin standard—switching meant rewriting everything.

How does MCP fix this?

Let’s return to our medical AI agent in Dr. Lee’s clinic.

Before MCP:
Dr. Lee uses a medical AI agent to assist with patient care. Each time she queries lab results, the agent accesses a single source, without maintaining continuity. Follow-up queries fail to incorporate earlier context. Integrations are piecemeal. Adding new tools requires more custom code and creates new failure points.

With MCP:
Now, Dr. Lee’s clinic adopts MCP. Each data source—lab reports, EHRs, clinical notes—is exposed via a standardized server. The agent accesses all relevant information through a unified interface and maintains full conversational context. Security controls ensure that only authorized data is accessible. Onboarding new tools becomes seamless. The agent becomes a true collaborator, grounded in current, patient-specific data.

The medical AI agent with MCP is a true clinical collaborator, always working with complete, current patient context.

Where does MCP fit in the AI stack?

MCP sits between your LLM-based agent and external systems—tools, APIs, and data sources. It standardizes communication regardless of whether you use RAG, plug-ins, or custom function calling. MCP doesn’t replace these approaches—it complements them, offering a modular, consistent, and scalable bridge layer.

Press + to interact
MCP as the bridge layer in the AI stack
MCP as the bridge layer in the AI stack

How does MCP work?

Let’s demystify with a real-world scenario:

Meet Alex—the AI developer. Alex is building a productivity assistant.
He wants it to:

  • Summarize the latest sales report (from a file server).

  • Schedule meetings (through a calendar API).

  • File bug reports (via a ticketing system).

With MCP:

  1. Alex spins up MCP servers for the file system, calendar, and ticketing APIs.

  2. His AI app acts as an MCP client, discovering what each server can do (“list_tools”, “list_resources”, etc.).

  3. When a user requests a summary, the AI pulls the document from the file server resource.

  4. To schedule a meeting, it calls a calendar tool.

  5. Filing a bug uses a prompt template for ticket creation.

Press + to interact
How does MCP work?
How does MCP work?

All through one standard protocol. No more one-off integrations are needed, no matter which AI model powers the agent.

Security, performance, and scalability

These building blocks have design benefits for real-world systems, especially around security and scale.

  • Security: Let’s revisit the AI medical agent. With MCP, the clinic can limit the AI’s access: it can view lab results and medication lists, but not sensitive mental health records or billing information. If the AI tries to access something it shouldn’t, MCP blocks the request and logs it for review. The clinic admins have full control over what the AI can and cannot see or do.

  • Performance and scalability: As the clinic grows, the agentic assistant must connect to more tools. For example, maybe a new radiology system or a second clinic’s patient database is needed. With MCP, integrating these new sources is as easy as plugging them in; the assistant can immediately discover and use them without a full rewrite or redeployment. If another department wants to use the same AI assistant, they can connect their data with minimal setup. There is no need to reinvent the wheel for each new integration.

  • Production-ready: Suppose the clinic wants to deploy the medical AI assistant in a scalable, cloud-based environment. MCP servers can be run in a serverless setup, storing session and connection info in Redis. Now, if the clinic opens more branches or if usage spikes during flu season, the system seamlessly scales. There will be no single point of failure, single-client bottleneck, or big ops headaches.

Comparing REST, function calling, and MCP

Let’s appreciate the power of MCP with a real-world scenario. Suppose your AI agent needs to schedule a meeting in the user’s calendar.

Direct REST API integration

Your agent (or backend) must know the calendar service’s API. It manually crafts HTTP requests, manages authentication tokens, parses responses, and handles errors. Every API is different, so every integration is custom.

Press + to interact
import requests
# Custom code for Google Calendar API
def schedule_meeting(start, end, participants, description, auth_token):
    url = "https://www.googleapis.com/calendar/v3/calendars/primary/events"
    headers = {"Authorization": f"Bearer {auth_token}"}
    data = {
        "start": {"dateTime": start},
        "end": {"dateTime": end},
        "attendees": [{"email": p} for p in participants],
        "description": description,
    }
    response = requests.post(url, headers=headers, json=data)
    return response.json()

When relying on custom integration code for each provider, the developer must handle authentication, error handling, and request formatting differently for every service, which can lead to increased complexity and maintenance. As a result, scaling becomes a major challenge; adding new calendar APIs or services often requires rewriting significant portions of your codebase, making it difficult to keep up with new tools or evolving requirements.

Vendor-specific function calling

LLM vendors (like OpenAI or Anthropic) let the developer “register” a set of functions that the model can invoke, but the format for describing and calling functions is different for each vendor. Below is a sample format for OpenAI function calling:

Press + to interact
{
  "functions": [
    {
      "name": "schedule_meeting",
      "description": "Schedules a calendar event",
      "parameters": {
        "type": "object",
        "properties": {
          "start": {"type": "string"},
          "end": {"type": "string"},
          "participants": {"type": "array", "items": {"type": "string"}},
          "description": {"type": "string"}
        }
      }
    }
  ]
}

The developer must still write backend code to perform the actions, even with declarative function interfaces. Changing vendors can require re-describing functions and potentially reworking input and output formats. Additionally, these functions are often closely tied to a specific agent environment, making portability and flexibility more challenging.

The MCP way

With MCP, the developer simply provides an MCP server that exposes a schedule_event tool, using a standard schema. Any agent or platform that speaks MCP can instantly discover and use it. no vendor lock-in, no custom glue code, and no rewriting for each new agent or service is required!

Press + to interact
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("Calendar Server")
@mcp.tool()
def schedule_event(start: str, end: str, participants: list, description: str) -> str:
    # Implementation to schedule the meeting (could wrap Google, Outlook, etc.)
    return "Event created with ID XYZ"

With MCP, the developer moves from custom wiring and “integration hell” to a standardized world where any AI agent can instantly discover and use new tools, resources, and workflows.

Think about your last integration project:
How much code did you write for auth, data formatting, or error handling?
How much could you save now and in the future if every new capability were just “plug and play”?

Case study: How MCP transformed integration?

Priya is building a virtual assistant at a fast-paced tech firm. Her use cases include querying sales data, coordinating cross-platform calendars, and summarizing bug reports.

The challenge (Before MCP):
She wrote and maintained custom integrations for each API. Authentication differed. Data formats were inconsistent. Updates were painful. Switching agents required starting over.

The solution (With MCP):
Priya now exposes each resource as an MCP server, and her assistant acts as an MCP client. Tools are discoverable, secure, and modular. Integration becomes reusable and maintainable—no more vendor lock-in, no more brittle connectors.

Questions

  • Why does MCP fundamentally change Priya’s workflow compared to traditional REST APIs and vendor-specific function calling?

Notepad

  • What advantages does MCP offer regarding standardization, modularity, and reusability?

Notepad