🔌 Building with MCP

How plugins and connectors work under the hood — from installing pre-built ones in Cowork to building your own

MCP (Model Context Protocol) is the open standard that powers Claude's plugin system. Every time Cowork connects to Gmail, Slack, or any other service, it's using MCP under the hood. You can install pre-built connectors with one click or build your own.

• → Cowork plugins are MCP servers — they connect Claude to external tools
• → Architecture: Host (Cowork/Claude Desktop) → Client → Server (your tool)
• → Pre-built connectors exist for Gmail, Slack, Google Drive, GitHub, and 50+ more
• → Developers can build custom MCP servers in Python or TypeScript
• → One standard protocol means one connector works everywhere Claude runs

MCP is to AI what USB was to peripherals. Before USB, every device needed its own connector. MCP creates one standard protocol so any AI can talk to any tool. The ecosystem already has 50+ pre-built servers with over 80,000 GitHub stars.

When you install a Gmail plugin in Cowork, what is actually happening under the hood?

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/directory"]
    }
  }
}

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your-token"
      }
    }
  }
}

Restart Claude Desktop and you'll see a hammer icon indicating MCP tools are available. In Claude Code, servers activate automatically when you open a project with an .mcp.json file.

pip install mcp

from mcp.server import Server
from mcp.types import Tool, TextContent
import mcp.server.stdio

server = Server("weather")

@server.list_tools()
async def list_tools():
    return [
        Tool(
            name="get_weather",
            description="Get current weather for a city. Returns temperature and conditions.",
            inputSchema={
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name"}
                },
                "required": ["city"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "get_weather":
        city = arguments["city"]
        # Your weather API logic here
        return [TextContent(type="text", text=f"Weather in {city}: 72°F, Sunny")]

async def main():
    async with mcp.server.stdio.stdio_server() as (read, write):
        await server.run(read, write)

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

The description field is how Claude decides when to use your tool. A vague description like 'does weather stuff' means Claude won't know when to call it. Be specific: 'Get current weather for a city. Returns temperature in Fahrenheit and sky conditions.'