Without MCP (N x M integrations):

  Claude ──── Custom ──── GitHub
  Claude ──── Custom ──── Slack
  Claude ──── Custom ──── Database
  GPT-4  ──── Custom ──── GitHub
  GPT-4  ──── Custom ──── Slack
  GPT-4  ──── Custom ──── Database
  Gemini ──── Custom ──── GitHub
  Gemini ──── Custom ──── Slack
  Gemini ──── Custom ──── Database

  3 models x 3 tools = 9 custom integrations

With MCP (N + M integrations):

  Claude ─┐                ┌── GitHub MCP Server
  GPT-4  ─┤── MCP ─────────┤── Slack MCP Server
  Gemini ─┘   Protocol     └── Database MCP Server

  3 models + 3 tools = 6 implementations (via shared protocol)

┌─────────────────────────────────────────────────────────────┐
│                        MCP Host                              │
│              (Claude Desktop, VS Code, IDE)                  │
│                                                              │
│  ┌────────────────────────────────────────────────────────┐  │
│  │                    MCP Client                           │  │
│  │          (manages server connections)                    │  │
│  └──────────┬──────────────┬──────────────┬───────────────┘  │
│             │              │              │                   │
└─────────────┼──────────────┼──────────────┼──────────────────┘
              │              │              │
    ┌─────────▼───┐  ┌──────▼──────┐  ┌───▼──────────┐
    │ MCP Server  │  │ MCP Server  │  │ MCP Server   │
    │ (Database)  │  │ (GitHub)    │  │ (Slack)      │
    └──────┬──────┘  └──────┬──────┘  └──────┬───────┘
           │                │                │
    ┌──────▼──────┐  ┌──────▼──────┐  ┌──────▼───────┐
    │  PostgreSQL │  │  GitHub API │  │  Slack API   │
    └─────────────┘  └─────────────┘  └──────────────┘

@server.list_resources()
async def list_resources():
    return [
        Resource(
            uri="db://schema/users",
            name="Users Table Schema",
            description="Schema definition for the users table",
            mimeType="application/json"
        )
    ]

@server.read_resource()
async def read_resource(uri: str):
    if uri == "db://schema/users":
        schema = await get_table_schema("users")
        return schema

@server.list_tools()
async def list_tools():
    return [
        Tool(
            name="query_database",
            description="Execute a read-only SQL query against the database",
            inputSchema={
                "type": "object",
                "properties": {
                    "sql": {
                        "type": "string",
                        "description": "The SQL query to execute (SELECT only)"
                    }
                },
                "required": ["sql"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "query_database":
        sql = arguments["sql"]
        if not sql.strip().upper().startswith("SELECT"):
            return TextContent(text="Error: Only SELECT queries are allowed.")
        results = await execute_query(sql)
        return TextContent(text=json.dumps(results, indent=2))

@server.list_prompts()
async def list_prompts():
    return [
        Prompt(
            name="analyze_table",
            description="Analyze a database table and provide insights",
            arguments=[
                PromptArgument(
                    name="table_name",
                    description="Name of the table to analyze",
                    required=True
                )
            ]
        )
    ]

@server.get_prompt()
async def get_prompt(name: str, arguments: dict):
    if name == "analyze_table":
        table = arguments["table_name"]
        return GetPromptResult(
            messages=[
                PromptMessage(
                    role="user",
                    content=TextContent(
                        text=f"Analyze the '{table}' table. Read its schema, "
                             f"run exploratory queries, and report findings."
                    )
                )
            ]
        )

# my_server.py
import json
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Resource, Tool, TextContent

server = Server("demo-server")


@server.list_resources()
async def list_resources():
    return [
        Resource(
            uri="info://server",
            name="Server Info",
            description="Information about this MCP server",
            mimeType="text/plain"
        )
    ]


@server.read_resource()
async def read_resource(uri: str):
    if uri == "info://server":
        return "Demo MCP server with a calculator tool."
    raise ValueError(f"Unknown resource: {uri}")


@server.list_tools()
async def list_tools():
    return [
        Tool(
            name="add_numbers",
            description="Add two numbers together",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number", "description": "First number"},
                    "b": {"type": "number", "description": "Second number"}
                },
                "required": ["a", "b"]
            }
        )
    ]


@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "add_numbers":
        result = arguments["a"] + arguments["b"]
        return [TextContent(type="text", text=f"Result: {result}")]
    raise ValueError(f"Unknown tool: {name}")


async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream)


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

pip install mcp[cli]
python my_server.py

{
  "mcpServers": {
    "demo": {
      "command": "python",
      "args": ["/path/to/my_server.py"]
    }
  }
}