The problem MCP solves

Before MCP, every AI application had to write custom code to connect to every external service — a search API here, a database connector there, a GitHub integration elsewhere. With N AI apps and M tools, you need N×M custom integrations. MCP collapses this to N+M: each AI app implements MCP once, each tool exposes itself via MCP once, and they all work together automatically.

Adoption timeline: Anthropic released MCP in November 2024. OpenAI added native MCP support to its Agents SDK in March 2025, and Google integrated MCP into the Gemini agent stack later that year. Editors and IDEs — Cursor, Windsurf, Zed, VS Code (Copilot), Continue, Replit — and hundreds of third-party servers covering GitHub, Slack, Notion, Postgres, Google Drive, and browser automation followed. By late 2025 there were reportedly over 16,000 public MCP servers, and in December 2025 Anthropic donated the protocol's governance to the Agentic AI Foundation, a Linux Foundation project, moving MCP from a single-vendor standard to community-governed infrastructure.

MCP architecture: clients, servers, and primitives

MCP has a clean client-server architecture. The AI application hosts an MCP client that connects over stdio or HTTP/SSE to one or more MCP servers, each exposing three types of primitives:

from mcp.server.fastmcp import FastMCP

# Create an MCP server
mcp = FastMCP("My First MCP Server")

# Expose a tool — any function decorated with @mcp.tool()
# is automatically registered with the correct JSON schema
@mcp.tool()
def calculate_compound_interest(
    principal: float,
    rate: float,
    years: int,
    compound_frequency: int = 12
) -> dict:
    """
    Calculate compound interest.
    principal: Initial amount in dollars
    rate: Annual interest rate as decimal (0.05 = 5%)
    years: Number of years
    compound_frequency: Times compounded per year (12 = monthly)
    """
    amount = principal * (1 + rate / compound_frequency) ** (compound_frequency * years)
    return {
        "final_amount": round(amount, 2),
        "interest_earned": round(amount - principal, 2),
        "effective_annual_rate": round((1 + rate / compound_frequency) ** compound_frequency - 1, 4)
    }

# Run the server (connects via stdio by default — desktop AI apps and IDEs can use it)
if __name__ == "__main__":
    mcp.run()

Connecting to MCP servers: a config example

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/projects"],
      "description": "Read and write files in your projects folder"
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
    },
    "my-custom-server": {
      "command": "python",
      "args": ["/path/to/my_mcp_server.py"]
    }
  }
}

Finding MCP servers: The official MCP server registry lives at github.com/modelcontextprotocol/servers and includes first-party servers for filesystem, GitHub, Slack, PostgreSQL, Google Drive, browser automation, and many more. Community registries list thousands of additional third-party servers — vet any server's source and permissions before connecting it, since it runs with whatever access you grant it.

Practice questions

1. What problem does MCP solve that wasn't addressed by standard function calling / tool-use APIs? (Answer: Standard tool use: each AI application must implement custom integrations for each external tool — n apps × m tools = n×m integrations. MCP: universal protocol where tool servers expose a standard API (list_tools, call_tool, list_resources, read_resource). Any MCP-compatible AI client connects to any MCP server with zero custom integration. One integration per tool, works across all AI clients. Analogous to HTTP/REST making web APIs interoperable.)
2. What is the difference between MCP Tools, MCP Resources, and MCP Prompts? (Answer: MCP Tools: functions the AI can call that perform actions or retrieve dynamic data (search_database, send_email, run_code). Bidirectional — AI decides when to call. MCP Resources: static or semi-static content exposed to the AI as context (file contents, database schemas, documentation). One-directional — AI reads. MCP Prompts: reusable prompt templates that users can invoke from the client (like slash commands). The server provides the prompt structure; the AI fills it in. Each serves a different part of the context and action architecture.)
3. What are the security considerations specific to MCP deployments? (Answer: (1) Tool scope: each MCP server should have minimum necessary permissions — a search tool should not have filesystem write access. (2) Authentication: MCP servers for external services require OAuth or API key management — credentials must not be in AI context. (3) Injection via resources: an MCP resource server could return content with embedded prompt injection instructions. (4) Server trust: users connecting to third-party MCP servers grant those servers access to their AI conversations. Only use trusted/audited MCP servers.)
4. How does MCP differ from LangChain or LlamaIndex tool integrations? (Answer: LangChain/LlamaIndex tool integrations: implemented as Python code directly in the application, tightly coupled to the specific framework. Updating requires code changes and redeployment. MCP: protocol-level standard allowing runtime connection to any compatible server without code changes. An MCP-compatible client can discover and use tools from any MCP server dynamically. LangChain tools require building custom server wrappers to expose as MCP, or using a compatibility layer.)
5. Why did Anthropic transfer MCP's governance to the Agentic AI Foundation / Linux Foundation instead of keeping it as an Anthropic-owned standard? (Answer: A protocol meant to be adopted by competing AI vendors (OpenAI, Google, and others) is more credible and durable as neutral, community-governed infrastructure than as a standard controlled by one of the competitors using it — the same reason HTTP, TLS, and USB are governed by neutral standards bodies rather than a single company. Moving MCP under the Linux Foundation in December 2025 signaled that Anthropic intended MCP to be shared infrastructure for the whole industry, not a lock-in mechanism, which in turn makes third parties more willing to build servers and clients against it.)