The Fragmentation Problem in AI Tooling

Every major AI assistant — Claude, GPT-4, Gemini — has its own way of calling tools. If you want your application to work with multiple models, you end up writing adapters for each one. Custom function schemas here, a different JSON format there, proprietary webhooks everywhere.

This is the same problem the web solved with HTTP, or databases with SQL. We needed a standard. Enter Model Context Protocol (MCP).

Photo by Lars Kienle on Unsplash

What Is MCP?

Model Context Protocol is an open standard originally developed by Anthropic and now adopted across the industry. It defines a uniform way for AI models to:

• Discover what tools and resources are available
• Call those tools with structured inputs
• Receive structured results back

Think of it as a universal remote for AI capabilities. Instead of hard-coding integrations, you expose a MCP server, and any compliant AI client can talk to it.

Core Concepts

Architecture Deep Dive

MCP uses a client-server architecture over a local stdio transport or HTTP/SSE for remote servers.

// Tool definition example
{
  "name": "get_weather",
  "description": "Get current weather for a location",
  "inputSchema": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "City and country, e.g. Seoul, Korea"
      }
    },
    "required": ["location"]
  }
}

When a model decides to call a tool, it sends a tools/call request to the MCP server. The server executes the logic and returns a structured result. Simple, predictable, portable.

Building Your First MCP Server

The official SDKs make this straightforward. Here’s a minimal Python server:

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

server = Server("my-tools")

@server.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="fetch_data",
            description="Fetch data from internal API",
            inputSchema={
                "type": "object",
                "properties": {
                    "endpoint": {"type": "string"},
                    "params": {"type": "object"}
                },
                "required": ["endpoint"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "fetch_data":
        # Your actual logic here
        endpoint = arguments["endpoint"]
        params = arguments.get("params", {})
        result = await my_api_client.get(endpoint, params=params)
        return [types.TextContent(type="text", text=str(result))]

async def main():
    async with stdio_server() as streams:
        await server.run(*streams, server.create_initialization_options())

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

TypeScript/Node.js support is equally mature, and community SDKs exist for Go, Rust, and Java.

The Ecosystem in 2026

The MCP ecosystem has exploded. Notable servers available today:

• GitHub MCP Server — repo management, PRs, issues
• Postgres MCP Server — natural language SQL queries
• Filesystem Server — read/write local files with sandboxing
• Brave Search Server — web search integration
• Slack/Discord servers — message reading and sending
• Docker MCP Toolkit — container management

Most cloud providers now ship official MCP servers for their services. AWS, GCP, and Azure all have first-party servers covering their major APIs.

Security Considerations

MCP’s power comes with responsibility. Key security patterns:

1. Principle of Least Privilege Scope each MCP server to only what the AI needs. Don’t give a writing assistant database write access.

2. Input Validation Always validate and sanitize tool inputs server-side. The model might be confused or manipulated into sending unexpected values.

3. Tool Confirmation for Destructive Operations For writes, deletes, or external communications, implement a confirmation step or use a separate “preview” tool before a “confirm” tool.

4. Audit Logging Log every tool call with context. When something goes wrong, you need to know what the model was doing.

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    logger.info(f"Tool called: {name}", extra={
        "tool": name,
        "arguments": arguments,
        "timestamp": datetime.utcnow().isoformat()
    })
    # ... execute tool

MCP vs Function Calling

You might wonder: how does MCP differ from OpenAI’s function calling or Anthropic’s tool use?

Function calling is model-specific. You define functions in the API request, and the model’s response includes a function call. Everything is baked into the LLM API.

MCP is infrastructure-level. You define servers independently of any model. The same MCP server can serve Claude, GPT-4, Gemini, or any future model. It’s the difference between a custom integration and a protocol.

When to Use MCP

MCP shines when:

• You’re building multi-model applications and want portability
• You have existing internal tools you want to expose to AI
• You need team-shared capabilities (one server, many AI users)
• You want observability into what AI agents are doing

Stick with native function calling when:

• You’re building a single-model prototype
• You need ultra-low latency (local stdio transport adds some overhead)
• Your tools are highly model-specific

The Road Ahead

MCP is on track to become the foundational plumbing of AI-powered software, much like REST became the default for web APIs. The recent 1.0 spec release brought:

• Streaming tool results for long-running operations
• Tool annotations for UI hints and grouping
• OAuth 2.0 support for remote server authentication
• Elicitation — servers can ask the user for additional information

With VS Code, JetBrains, and major AI coding assistants all supporting MCP natively, the network effects are compounding. If you’re building AI tooling in 2026, MCP is no longer optional — it’s the table stakes.

Getting Started

• MCP Spec — Official specification
• MCP Python SDK
• MCP TypeScript SDK
• Awesome MCP Servers — Community server list

Start by wrapping one of your internal APIs as an MCP server. Once you see how cleanly it plugs into any AI workflow, you’ll never go back to custom integrations.

이 글이 도움이 되셨다면 공감 및 광고 클릭을 부탁드립니다 :)