Model Context Protocol (MCP)

Minimal MCP server in Python using the official SDK — expose any function as an MCP tool

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 — Claude Desktop, Cursor, etc. can use it)
if __name__ == "__main__":
    mcp.run()

claude_desktop_config.json — add MCP servers here to give Claude Desktop access to tools

{
  "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"]
    }
  }
}

1. What problem does MCP solve that wasn't addressed by the standard OpenAI function calling / tool use API? (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. Anthropic recommends only using 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 (Claude, Cursor, any Claude-compatible app) can discover and use tools from any MCP server dynamically. LangChain tools require building custom server wrappers to expose as MCP, or using LangChain's own server mode.)
5. What is 'sampling' in MCP and how does it enable sophisticated agentic workflows? (Answer: MCP sampling: a server can request the AI client to run an LLM inference (a 'sampling request') as part of executing a tool. This enables recursive AI calls: an orchestrator AI uses a tool that itself calls another AI for subtask processing. Example: a document analysis MCP tool extracts text (tool action), then requests Claude to summarise each section (sampling), then compiles results. Sampling creates composable AI workflows where tools can incorporate LLM reasoning, not just deterministic code execution.)