Model Context Protocol

Model Context Protocol (MCP) is an open standard from Anthropic that defines how AI models connect to external tools, data sources, and services. Before MCP, every team building an AI application had to write custom integrations for every external system they wanted their model to access — a database connector for one app, a file reader for another, a search tool for a third, none of them reusable across tools. MCP solves this by defining a common protocol: build an MCP server once, and any compliant LLM client can connect to it and use its capabilities. The model sees a consistent interface regardless of what system sits on the other end.

The analogy Anthropic uses is the USB standard for peripherals. Before USB, every peripheral needed a custom connector. After USB, you could plug anything into anything. MCP plays the same role for AI tools: it replaces a tangle of per-application integrations with a single protocol that works everywhere.

What does MCP do?

MCP defines how a client (an LLM application, like Claude Desktop or Cursor) and a server (a program that exposes capabilities) discover and communicate with each other. The protocol is built around three primitives:

Tools are functions the LLM can call to take action or retrieve data. A tool might query a database, search the web, call an API, or execute code. When the LLM decides to use a tool, it sends a structured request to the server; the server executes the function and returns the result.

Resources are data sources the LLM can read. Unlike tools, resources are passive — they expose data (files, database records, API responses) that the LLM can include in its context without invoking a function. A resource might be a specific document, the contents of a directory, or a live API feed.

Prompts are reusable prompt templates that the server exposes to the client. They are pre-built instruction sets — for example, a “summarise this document” prompt that the user can invoke from any client that supports the server.

Together, these three primitives cover most of what an AI system needs to interact with external systems: the ability to take actions (Tools), read data (Resources), and apply consistent instructions (Prompts).

Who uses MCP?

MCP is used by AI engineers and developers building tools and applications that need LLMs to interact with external systems. The two main groups are server builders and client builders.

Server builders are teams or individuals who expose a system’s capabilities as MCP tools. A company might build an MCP server for their internal documentation system so that any employee using Claude Desktop or Cursor can query it directly. Open-source maintainers build and publish servers for common services — GitHub, Slack, Google Drive, PostgreSQL, and hundreds of others are available on public registries.

Client builders are the developers integrating MCP support into LLM applications. Claude Desktop, Cursor, Cline, Continue, and VS Code Copilot Chat all support MCP natively. If you are building your own agent application, you add MCP client support and your users immediately get access to the entire ecosystem of published MCP servers.

End users are the beneficiaries: they connect servers from the registry to their preferred LLM client and get capabilities (web browsing, calendar access, database queries) without the AI application having to build each integration from scratch.

MCP use cases

AI assistant with database access. An engineer connects a Postgres MCP server to Claude Desktop. They can now ask Claude questions like “how many new users signed up last week?” and Claude executes the appropriate SQL query against the production database, reads the result, and answers in plain English — without the engineer writing any query manually.

Agent with file system tools. A coding agent in Cursor connects to an MCP server that exposes the local file system as resources. The agent can read source files, write changes, and check directory listings as part of its reasoning loop — all through the same MCP interface, regardless of which OS or file system the project is on.

Multi-client tool library. A company builds internal MCP servers for their document management system, their CRM, and their support ticket platform. Every engineer using Claude, Cursor, or a custom internal LLM interface can connect these servers and access internal data in their preferred tool without the IT team building separate integrations for each.

Custom agent with MCP tools. A developer building an autonomous research agent uses the MCP Python SDK to connect their agent to a web search server, an arXiv server, and a note-taking server. The agent calls these tools during its reasoning loop without hardcoding each integration — new servers can be added later without changing the agent code.

Is MCP free?

Yes. MCP is an open standard released by Anthropic under the MIT licence. The protocol specification, reference SDKs, and official documentation are all freely available. There is no managed service or paid tier — you implement MCP in your own code, using the SDKs to build servers and clients. The only costs are your own infrastructure and the API calls your application makes to whatever LLM it uses.

How to get started with MCP

The fastest way to experience MCP is to install Claude Desktop and connect a published server from the registry. The official quickstart at modelcontextprotocol.io walks through connecting the filesystem MCP server to Claude Desktop in about five minutes.

To build your own server in Python, install FastMCP:

pip install fastmcp

A minimal server looks like this:

from fastmcp import FastMCP

mcp = FastMCP("my-server")

@mcp.tool()
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    # your implementation here
    return f"Weather for {city}: 22°C, partly cloudy"

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

Point any MCP client at this server and the get_weather tool becomes available to the LLM. The MCP documentation at modelcontextprotocol.io covers transports, authentication, resource schemas, and prompt definitions in detail. The BuildrLabs Agentic AI Bootcamp includes a module on building custom MCP servers as part of the production agentic systems curriculum.

BuildrLabs is an AI engineering academy in Colombo, Sri Lanka. The Agentic AI Bootcamp covers MCP server development as a core module — students build custom servers that connect their capstone agents to real external systems. Learn more at buildrlabs.ai.