<div id="readability-page-1" class="page"><div><img src="https://devstarsj.github.io/assets/https://images.unsplash.com/photo-1677442135703-1787eea5ce01?w=1200&amp;q=80"><h2 id="what-is-mcp">What Is MCP?</h2>The Model Context Protocol (MCP) is an open standard introduced by Anthropic to define a universal, structured way for AI language models to communicate with external tools, data sources, and services. Think of it as a USB-C port for AI — instead of writing a custom integration for every single tool, developers define a single MCP server, and any compatible AI client can plug right in.Before MCP, connecting an LLM to external systems meant reinventing the wheel with every project: custom function schemas, bespoke JSON formats, and ad-hoc prompt engineering. MCP standardizes this entire layer.<img src="https://images.unsplash.com/photo-1620712943543-bcc4688e7485?w=900&amp;q=75" alt="MCP Architecture Diagram"> Photo by <a href="https://unsplash.com/@deepmind">DeepMind</a> on Unsplash<hr><h2 id="the-architecture">The Architecture</h2>MCP operates on a client-server model with three core components:<table><thead><tr><th>Component</th><th>Role</th></tr></thead><tbody><tr><td>MCP Host</td><td>The AI application (e.g., Claude Desktop, Cursor)</td></tr><tr><td>MCP Client</td><td>Lives inside the host; manages connections to servers</td></tr><tr><td>MCP Server</td><td>Exposes tools, resources, and prompts to clients</td></tr></tbody></table>The protocol runs over JSON-RPC 2.0 and supports multiple transports:<ul><li>stdio — for local processes (simplest, most common)</li><li>HTTP + SSE — for remote/cloud-hosted servers</li><li>WebSocket — for low-latency bidirectional streams (emerging)</li></ul><hr><h2 id="core-primitives">Core Primitives</h2>MCP defines three first-class primitives that every server can expose:<h3 id="1-tools">1. Tools</h3>Functions the AI can call to take actions or retrieve computed data.<div><pre><code>{
 "name": "search_codebase",
 "description": "Search for files or symbols in the project repository",
 "inputSchema": {
 "type": "object",
 "properties": {
 "query": { "type": "string" },
 "file_type": { "type": "string", "enum": ["ts", "py", "go", "all"] }
 },
 "required": ["query"]
 }
}
</code></pre></div><h3 id="2-resources">2. Resources</h3>Static or dynamic data the AI can read — files, database rows, API responses.<div><pre><code>{
 "uri": "file:///project/src/main.ts",
 "name": "main.ts",
 "mimeType": "text/typescript"
}
</code></pre></div><h3 id="3-prompts">3. Prompts</h3>Reusable prompt templates with parameters, designed to guide model behavior.<hr><h2 id="building-your-first-mcp-server">Building Your First MCP Server</h2>Here’s a minimal Python MCP server using the official SDK:<div><pre><code>from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
import mcp.types as types

app = Server("my-first-mcp")

@app.list_tools()
async def list_tools() -&gt; list[Tool]:
 return [
 Tool(
 name="get_weather",
 description="Get current weather for a city",
 inputSchema={
 "type": "object",
 "properties": {
 "city": {"type": "string", "description": "City name"}
 },
 "required": ["city"]
 }
 )
 ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -&gt; list[TextContent]:
 if name == "get_weather":
 city = arguments["city"]
 # In real code, call a weather API here
 return [TextContent(type="text", text=f"Sunny, 22°C in {city}")]
 raise ValueError(f"Unknown tool: {name}")

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

if __name__ == "__main__":
 import asyncio
 asyncio.run(main())
</code></pre></div>To wire it into Claude Desktop, add to <code>claude_desktop_config.json</code>:<div><pre><code>{
 "mcpServers": {
 "my-weather": {
 "command": "python",
 "args": ["/path/to/weather_server.py"]
 }
 }
}
</code></pre></div><hr><h2 id="the-mcp-ecosystem-in-2026">The MCP Ecosystem in 2026</h2>The MCP ecosystem has exploded since its launch. Today there are thousands of community-built servers:<ul><li>@modelcontextprotocol/server-filesystem — local file access</li><li>@modelcontextprotocol/server-github — GitHub API integration</li><li>mcp-server-postgres — direct Postgres queries</li><li>mcp-atlassian — Jira and Confluence</li><li>mcp-server-kubernetes — cluster management</li></ul>Major IDEs like Cursor, VS Code (Copilot), and JetBrains AI now support MCP natively, which means your MCP server can power multiple AI products without modification.<hr><table><thead><tr><th>Feature</th><th>MCP</th><th>OpenAI Functions</th><th>LangChain Tools</th></tr></thead><tbody><tr><td>Standard</td><td>Open</td><td>Proprietary</td><td>Framework-specific</td></tr><tr><td>Multi-model</td><td>✅</td><td>❌</td><td>✅ (adapter needed)</td></tr><tr><td>Remote servers</td><td>✅</td><td>❌</td><td>Partial</td></tr><tr><td>Resource access</td><td>✅</td><td>❌</td><td>❌</td></tr><tr><td>Prompt templates</td><td>✅</td><td>❌</td><td>❌</td></tr></tbody></table><hr><h2 id="security-considerations">Security Considerations</h2>With great tool access comes great responsibility. When deploying MCP servers:<ol><li>Scope permissions tightly — expose only what the AI truly needs</li><li>Validate all inputs — treat AI-generated arguments as untrusted user input</li><li>Audit tool calls — log every invocation with the originating model and session</li><li>Rate limit — prevent runaway agent loops from hammering external APIs</li><li>Never expose secrets — use environment variables, never hardcode credentials in server configs</li></ol><hr><h2 id="whats-next-for-mcp">What’s Next for MCP</h2>The roadmap for MCP in 2026 includes:<ul><li>Streaming tool responses — for long-running operations</li><li>Batch tool calls — reduce round-trips in agentic pipelines</li><li>MCP Registry — a central directory for discovering and verifying servers</li><li>OAuth 2.0 flows — standardized auth for user-delegated permissions</li><li>Multi-agent orchestration — MCP servers that themselves call other AI models</li></ul><hr><h2 id="conclusion">Conclusion</h2>MCP is quietly becoming the TCP/IP of the AI agent era. It solves the “last mile” problem of connecting powerful language models to real-world systems in a safe, standardized, and composable way. Whether you’re building a coding assistant, a customer support bot, or a fully autonomous agent pipeline, understanding MCP is no longer optional — it’s foundational.Start with a simple stdio server, connect it to Claude Desktop, and see how quickly you can make an AI genuinely useful in your own environment.<hr>References:<ul><li><a href="https://modelcontextprotocol.io/">MCP Official Docs</a></li><li><a href="https://www.anthropic.com/news/model-context-protocol">Anthropic MCP Announcement</a></li><li><a href="https://github.com/modelcontextprotocol">MCP GitHub Organization</a></li></ul> <div>이 글이 도움이 되셨다면 공감 및 광고 클릭을 부탁드립니다 :) </div></div></div>

Dev Note

What Is MCP?
The Model Context Protocol (MCP) is an open standard introduced by Anthropic to define a universal, structured way for AI language models to communicate with external tools, data sources, and services. Think of it as a USB-C port for AI — instead of writing a custom integration for every single tool, developers define a single MCP server, and any compatible AI client can plug right in.
Before MCP, connecting an LLM to external systems meant reinventing the wheel with every project: custom function schemas, bespoke JSON formats, and ad-hoc prompt engineering. MCP standardizes this entire layer.
Photo by DeepMind on Unsplash
The Architecture
MCP operates on a client-server model with three core components:
Component
      Role
    
MCP Host
      The AI application (e.g., Claude Desktop, Cursor)
    
MCP Client
      Lives inside the host; manages connections to servers
    
MCP Server
      Exposes tools, resources, and prompts to clients
    
The protocol runs over JSON-RPC 2.0 and supports multiple transports:
stdio — for local processes (simplest, most common)
HTTP + SSE — for remote/cloud-hosted servers
WebSocket — for low-latency bidirectional streams (emerging)
Core Primitives
MCP defines three first-class primitives that every server can expose:
1. Tools
Functions the AI can call to take actions or retrieve computed data.
{
  "name": "search_codebase",
  "description": "Search for files or symbols in the project repository",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "file_type": { "type": "string", "enum": ["ts", "py", "go", "all"] }
    },
    "required": ["query"]
  }
}
2. Resources
Static or dynamic data the AI can read — files, database rows, API responses.
{
  "uri": "file:///project/src/main.ts",
  "name": "main.ts",
  "mimeType": "text/typescript"
}
3. Prompts
Reusable prompt templates with parameters, designed to guide model behavior.
Building Your First MCP Server
Here’s a minimal Python MCP server using the official SDK:
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
import mcp.types as types
app = Server("my-first-mcp")
@app.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="get_weather",
            description="Get current weather for a city",
            inputSchema={
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "City name"}
                },
                "required": ["city"]
            }
        )
    ]
@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "get_weather":
        city = arguments["city"]
        # In real code, call a weather API here
        return [TextContent(type="text", text=f"Sunny, 22°C in {city}")]
    raise ValueError(f"Unknown tool: {name}")
async def main():
    async with stdio_server() as (read_stream, write_stream):
        await app.run(read_stream, write_stream, app.create_initialization_options())
if __name__ == "__main__":
    import asyncio
    asyncio.run(main())
To wire it into Claude Desktop, add to claude_desktop_config.json:
{
  "mcpServers": {
    "my-weather": {
      "command": "python",
      "args": ["/path/to/weather_server.py"]
    }
  }
}
The MCP Ecosystem in 2026
The MCP ecosystem has exploded since its launch. Today there are thousands of community-built servers:
@modelcontextprotocol/server-filesystem — local file access
@modelcontextprotocol/server-github — GitHub API integration
mcp-server-postgres — direct Postgres queries
mcp-atlassian — Jira and Confluence
mcp-server-kubernetes — cluster management
Major IDEs like Cursor, VS Code (Copilot), and JetBrains AI now support MCP natively, which means your MCP server can power multiple AI products without modification.
MCP vs. OpenAI Function Calling vs. LangChain Tools
Feature
      MCP
      OpenAI Functions
      LangChain Tools
    
Standard
      Open
      Proprietary
      Framework-specific
    
Multi-model
      ✅
      ❌
      ✅ (adapter needed)
    
Remote servers
      ✅
      ❌
      Partial
    
Resource access
      ✅
      ❌
      ❌
    
Prompt templates
      ✅
      ❌
      ❌
    
Security Considerations
With great tool access comes great responsibility. When deploying MCP servers:
Scope permissions tightly — expose only what the AI truly needs
Validate all inputs — treat AI-generated arguments as untrusted user input
Audit tool calls — log every invocation with the originating model and session
Rate limit — prevent runaway agent loops from hammering external APIs
Never expose secrets — use environment variables, never hardcode credentials in server configs
What’s Next for MCP
The roadmap for MCP in 2026 includes:
Streaming tool responses — for long-running operations
Batch tool calls — reduce round-trips in agentic pipelines
MCP Registry — a central directory for discovering and verifying servers
OAuth 2.0 flows — standardized auth for user-delegated permissions
Multi-agent orchestration — MCP servers that themselves call other AI models
Conclusion
MCP is quietly becoming the TCP/IP of the AI agent era. It solves the “last mile” problem of connecting powerful language models to real-world systems in a safe, standardized, and composable way. Whether you’re building a coding assistant, a customer support bot, or a fully autonomous agent pipeline, understanding MCP is no longer optional — it’s foundational.
Start with a simple stdio server, connect it to Claude Desktop, and see how quickly you can make an AI genuinely useful in your own environment.
References:
MCP Official Docs
Anthropic MCP Announcement
MCP GitHub Organization

MCP (Model Context Protocol): The Backbone of Modern AI Agent Integration

댓글