Model Context Protocol (MCP): Connect Claude to Any Tool

Every Claude agent you build needs tools. In the examples throughout this series, those tools were custom Python functions you wrote — a weather lookup, a search wrapper, a database query. That works, but it means writing integration code for every system your agent needs to connect to. Connecting to Slack, GitHub, PostgreSQL, Google Drive, and five other tools means writing five separate tool definitions and integration layers.

The Model Context Protocol (MCP) is Anthropic's answer to this integration problem. It is an open standard that defines a universal way for AI models to connect to tools, data sources, and services. Any system that implements the MCP server specification can be used by any MCP-compatible AI client — including Claude — without writing custom integration code every time.

What MCP Actually Is

MCP is a client-server protocol. The architecture has three components:

MCP Hosts: Applications that contain the AI model. Claude Desktop, Claude.ai, and your custom application are MCP hosts
MCP Clients: The component inside the host that connects to MCP servers and manages the protocol communication
MCP Servers: Standalone processes that expose tools, resources, and prompts to AI models. A GitHub MCP server exposes tools like create_issue and list_pull_requests. A PostgreSQL MCP server exposes tools like run_query and list_tables

The critical insight: the MCP server and the host application are decoupled. The GitHub MCP server does not know or care whether Claude Desktop, a custom Python agent, or another AI model is connecting to it. And your Claude agent does not need to know how GitHub's API works — it just calls the tools the MCP server exposes.

MCP is Like a Universal Plug for AI Tools

A useful mental model: MCP is like a USB standard for AI tool connections. Before USB, every peripheral needed a different connector. USB gave you one standard port that works with any device. MCP gives AI models one standard connection mechanism that works with any tool server. As the MCP ecosystem grows, Claude can connect to hundreds of pre-built integrations without any custom code.

The MCP Ecosystem

Anthropic and the developer community have published MCP servers for a growing list of systems. Notable examples:

File system: Read and write local files within a configured directory
GitHub: List repos, read files, create issues, manage pull requests
PostgreSQL: Query databases, list schemas, execute read-only SQL
Slack: Post messages, read channel history, manage conversations
Google Drive: Read and search Google Drive files
Brave Search: Real-time web search through Brave's search API
Puppeteer: Browser automation for web scraping and testing
SQLite: Query and analyse SQLite databases

The full list of Anthropic-maintained MCP servers is available at github.com/modelcontextprotocol/servers.

Using MCP in Claude Desktop

The simplest way to use MCP is through Claude Desktop, which includes a built-in MCP client. You configure servers in a JSON configuration file.

json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/yourname/documents"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your_token_here"
      }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your_brave_api_key"
      }
    }
  }
}

This configuration file is placed at:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

After saving the configuration and restarting Claude Desktop, Claude can see and use the tools provided by each configured server.

Using MCP in Your Python Applications

For programmatic use, the Python mcp SDK lets your application act as an MCP client:

python

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
import anthropic

anthropic_client = anthropic.Anthropic()

async def run_claude_with_mcp(user_message: str):
    """Run Claude with an MCP server providing tools."""
    
    # Connect to the filesystem MCP server
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "@modelcontextprotocol/server-filesystem", "/tmp/workspace"]
    )
    
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            # List available tools from the MCP server
            tools_response = await session.list_tools()
            
            # Convert MCP tool format to Anthropic tool format
            tools = [
                {
                    "name": tool.name,
                    "description": tool.description,
                    "input_schema": tool.inputSchema
                }
                for tool in tools_response.tools
            ]
            
            messages = [{"role": "user", "content": user_message}]
            
            # Agent loop with MCP tool execution
            while True:
                response = anthropic_client.messages.create(
                    model="claude-sonnet-4-6",
                    max_tokens=4096,
                    tools=tools,
                    messages=messages
                )
                
                if response.stop_reason == "end_turn":
                    return response.content[0].text
                
                tool_results = []
                for block in response.content:
                    if block.type == "tool_use":
                        # Execute the tool via MCP
                        mcp_result = await session.call_tool(
                            block.name,
                            block.input
                        )
                        
                        tool_results.append({
                            "type": "tool_result",
                            "tool_use_id": block.id,
                            "content": str(mcp_result.content)
                        })
                
                messages.append({"role": "assistant", "content": response.content})
                messages.append({"role": "user", "content": tool_results})

# Run the agent
result = asyncio.run(run_claude_with_mcp(
    "List the files in the workspace directory and summarise what each one is for."
))
print(result)

MCP Resources and Prompts

Beyond tools, MCP servers can expose two additional capability types:

Resources

Resources are data sources that can be read into Claude's context. A PostgreSQL MCP server might expose each database table as a resource. A file system server exposes individual files as resources. Claude can request specific resources to include in its context window.

python

# List available resources from an MCP server
resources = await session.list_resources()

# Read a specific resource
resource_content = await session.read_resource("file:///workspace/README.md")

Prompts

MCP servers can expose pre-built prompt templates — reusable system prompt patterns that guide Claude for specific tasks within that server's domain.

python

# List available prompts
prompts = await session.list_prompts()

# Get a specific prompt template
prompt = await session.get_prompt("code_review", {"language": "python"})

Use Existing MCP Servers Before Building Custom Ones

Before writing a custom tool integration, check whether an MCP server already exists for the system you need to connect to. The MCP ecosystem is growing rapidly — GitHub, Slack, databases, search engines, file systems, and many more are already covered by production-ready servers maintained by Anthropic and the community. Using an existing server saves significant development time and gives you a tested, maintained integration.

Building a Custom MCP Server

When an existing server does not cover your needs, you can build your own. The MCP Python SDK makes this straightforward:

python

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types

server = Server("my-custom-server")

@server.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="get_customer",
            description="Retrieve customer data by customer ID from the internal CRM",
            inputSchema={
                "type": "object",
                "properties": {
                    "customer_id": {
                        "type": "string",
                        "description": "The unique customer ID"
                    }
                },
                "required": ["customer_id"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    if name == "get_customer":
        customer_id = arguments["customer_id"]
        # Query your actual database here
        result = {"id": customer_id, "name": "Example Customer", "status": "active"}
        return [types.TextContent(type="text", text=str(result))]
    
    raise ValueError(f"Unknown tool: {name}")

# Start the server
asyncio.run(stdio_server(server))

Summary

MCP transforms Claude agent development by providing a standardised way to connect to any tool, data source, or service. Instead of writing bespoke integration code for every system, you configure MCP servers and Claude can immediately use their capabilities.

Key points:

MCP is an open standard — any AI model and any service can implement it
Use Claude Desktop configuration for personal productivity with MCP servers
Use the Python MCP SDK for programmatic agent applications
Check the existing server ecosystem before building custom servers
MCP servers expose tools, resources, and prompts — all three can be used in Claude agents

Next: one of the most important cost-saving techniques in the Claude API — Prompt Caching with Claude: Cut API Costs by Up to 90%.

This post is part of the Anthropic AI Tutorial Series. Previous post: The Agentic Loop: How Claude Reasons, Acts, and Self-Corrects.