What is the Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is an open specification for secure, streamable communication and tooling integration between Language Model clients and servers. It enables language models and their helper agents to share context and resources efficiently—across different platforms, tools, and workflows.

MCP defines conventions for sharing prompts, resources, and agent workflows, making it a pivotal piece in building modular, composable AI agent systems.

Key Design Features

Standardized Context Exchange: Facilitate structured communication between models, agents, and tools.
Extensible Tooling: Integrate file systems, fetchers, and custom tools with LLM agents.
Transport Flexibility: Works over streamable HTTP and stdio (standard input/output), making integrations simple and universal.
Clear Lifecycle and Security: Policy-driven authentication and flexible session management.

For architectural deep-dives and developer documentation, see:

MCP Transport Layer

MCP is intentionally simple but powerful. The protocol defines how agents and servers communicate, supporting two primary transport mechanisms:

Streamable HTTP: Sends/receives context and events as a real-time data stream over HTTP.
Stdio (Standard Input/Output): Enables agents and tools to communicate via terminal pipes, enabling local rapid prototyping or composable scripts in any language.

See: Transports Documentation

Example MCP Servers and Clients

You can browse live lists and open source examples of MCP-compatible clients and servers here:

Step-by-Step: Using Fast Agent with MCP

Here’s how to set up a working MCP Agent (Fast Agent) from scratch:

1. Create & Activate a Virtual Environment, Install Dependencies

uv venv
.venv\Scripts\activate
uv pip install fast-agent-mcp
fast-agent setup

2. Configure your API Key

Edit fastagent.secrets.yaml and add your LLM provider’s key. For OpenAI, see: Get API key

api_key: sk-... # Your OpenAI key

3. Set Up your LLM provider

Define the provider and set up the model in your configuration (see Fast Agent docs).

4. Register Servers (Tools) with the Client

Update your configuration to add MCP servers—these are your agent’s tools!

servers = ["filesystem", "fetch"]

5. Run Your Agent

uv run agent.py

Example Usage & Workflows

You can define agents and workflows with Fast Agent like this:

from mcp_agent.core.fastagent import FastAgent

fast = FastAgent("Agent Example")

@fast.agent(
    instruction="Given an object, respond only with an estimate of its size.",
    servers=["filesystem", "fetch"]
)
async def main():
    async with fast.run() as agent:
        await agent()

if __name__ == "__main__":
    import asyncio
    asyncio.run(main())

To run:

uv run agent.py --model sonnet

Agents and workflows can be chained, use parallel executions, or include human input. See the official Fast Agent example workflows and MCP client/server lists.

🚦 Quick Guide: How Model Context Protocol (MCP) Works