<div id="readability-page-1" class="page"><div><img src="https://devstarsj.github.io/assets/https://images.unsplash.com/photo-1558494949-ef010cbdcc31?w=1920&amp;q=80">Every AI application needs to connect to external tools—databases, APIs, file systems. Until now, each integration was custom. Model Context Protocol (MCP) changes that with a universal standard.<img src="https://images.unsplash.com/photo-1558494949-ef010cbdcc31?w=800&amp;q=80" alt="Network connections"> Photo by <a href="https://unsplash.com/@jordanharrison">Jordan Harrison</a> on Unsplash<h2 id="the-integration-problem">The Integration Problem</h2>Before MCP, connecting an LLM to tools looked like this:<div><pre><code>Your App → Custom Code → Tool A
 → Different Code → Tool B 
 → More Code → Tool C
</code></pre></div>Every tool needed custom integration. Every AI platform did it differently.<h2 id="what-is-mcp">What is MCP?</h2>Model Context Protocol is an open standard that defines how LLMs communicate with external tools and data sources. Think of it as USB-C for AI—one connector, universal compatibility.<img src="https://images.unsplash.com/photo-1518770660439-4636190af475?w=800&amp;q=80" alt="Standardization"> Photo by <a href="https://unsplash.com/@alexkixa">Alexandre Debiève</a> on Unsplash<h3 id="core-concepts">Core Concepts</h3>MCP Server: Exposes tools/resources to AI MCP Client: The AI application that connects Transport: How they communicate (stdio, HTTP)<div><pre><code>AI App (Client) ←→ MCP Protocol ←→ MCP Server ←→ Database/API/Tool
</code></pre></div><h2 id="building-an-mcp-server">Building an MCP Server</h2>Let’s create a simple MCP server that provides weather data:<div><pre><code>import { Server } from "@modelcontextprotocol/sdk/server";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio";

const server = new Server({
 name: "weather-server",
 version: "1.0.0"
}, {
 capabilities: {
 tools: {}
 }
});

// Define the tool
server.setRequestHandler("tools/list", async () =&gt; ({
 tools: [{
 name: "get_weather",
 description: "Get current weather for a city",
 inputSchema: {
 type: "object",
 properties: {
 city: { type: "string", description: "City name" }
 },
 required: ["city"]
 }
 }]
}));

// Handle tool calls
server.setRequestHandler("tools/call", async (request) =&gt; {
 if (request.params.name === "get_weather") {
 const city = request.params.arguments.city;
 const weather = await fetchWeather(city);
 return {
 content: [{
 type: "text",
 text: JSON.stringify(weather)
 }]
 };
 }
});

// Start server
const transport = new StdioServerTransport();
await server.connect(transport);
</code></pre></div>MCP defines two types of capabilities:<h3 id="tools">Tools</h3>Functions the AI can call:<div><pre><code>{
 name: "send_email",
 description: "Send an email",
 inputSchema: { /* params */ }
}
</code></pre></div><h3 id="resources">Resources</h3>Data the AI can read:<div><pre><code>{
 uri: "file:///path/to/document.md",
 name: "Project README",
 mimeType: "text/markdown"
}
</code></pre></div><h2 id="connecting-mcp-to-claude">Connecting MCP to Claude</h2>Claude Desktop and Claude Code natively support MCP. Configuration is simple:<div><pre><code>// claude_desktop_config.json
{
 "mcpServers": {
 "weather": {
 "command": "node",
 "args": ["./weather-server.js"]
 },
 "database": {
 "command": "python",
 "args": ["./db-server.py"],
 "env": {
 "DATABASE_URL": "postgres://..."
 }
 }
 }
}
</code></pre></div>Now Claude can query weather and databases without custom code in your app.<h2 id="real-world-mcp-servers">Real-World MCP Servers</h2>The ecosystem is growing fast:<table><thead><tr><th>Server</th><th>Purpose</th></tr></thead><tbody><tr><td><code>@modelcontextprotocol/server-filesystem</code></td><td>File operations</td></tr><tr><td><code>@modelcontextprotocol/server-github</code></td><td>GitHub API</td></tr><tr><td><code>@modelcontextprotocol/server-postgres</code></td><td>Database queries</td></tr><tr><td><code>@modelcontextprotocol/server-brave-search</code></td><td>Web search</td></tr><tr><td><code>@modelcontextprotocol/server-slack</code></td><td>Slack integration</td></tr></tbody></table><h2 id="building-a-database-mcp-server">Building a Database MCP Server</h2>Here’s a more practical example—a PostgreSQL server:<div><pre><code>from mcp.server import Server
from mcp.server.stdio import stdio_server
import asyncpg

server = Server("postgres-mcp")

@server.tool()
async def query_database(sql: str) -&gt; str:
 """Execute a read-only SQL query"""
 if not sql.strip().upper().startswith("SELECT"):
 return "Error: Only SELECT queries allowed"
 
 conn = await asyncpg.connect(DATABASE_URL)
 try:
 rows = await conn.fetch(sql)
 return json.dumps([dict(r) for r in rows])
 finally:
 await conn.close()

@server.tool()
async def list_tables() -&gt; str:
 """List all tables in the database"""
 return await query_database(
 "SELECT table_name FROM information_schema.tables "
 "WHERE table_schema = 'public'"
 )

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

asyncio.run(main())
</code></pre></div><h2 id="security-considerations">Security Considerations</h2>MCP servers have access to sensitive systems. Be careful:<h3 id="1-principle-of-least-privilege">1. Principle of Least Privilege</h3><div><pre><code># Bad: Full database access
@server.tool()
async def execute_sql(sql: str): ...

# Good: Scoped read-only access
@server.tool()
async def get_user_orders(user_id: int): ...
</code></pre></div><h3 id="2-input-validation">2. Input Validation</h3><div><pre><code>@server.tool()
async def read_file(path: str) -&gt; str:
 # Prevent path traversal
 safe_path = Path(ALLOWED_DIR) / Path(path).name
 if not safe_path.is_relative_to(ALLOWED_DIR):
 raise ValueError("Access denied")
 return safe_path.read_text()
</code></pre></div><h3 id="3-rate-limiting">3. Rate Limiting</h3><div><pre><code>from limits import RateLimiter

limiter = RateLimiter(calls=100, period=60)

@server.tool()
async def web_search(query: str):
 if not limiter.allow():
 return "Rate limited. Try again later."
 ...
</code></pre></div><h2 id="mcp-vs-function-calling">MCP vs Function Calling</h2>How does MCP compare to OpenAI’s function calling?<table><thead><tr><th>Aspect</th><th>Function Calling</th><th>MCP</th></tr></thead><tbody><tr><td>Scope</td><td>Single API call</td><td>Full server</td></tr><tr><td>Discovery</td><td>Defined per request</td><td>Server advertises</td></tr><tr><td>State</td><td>Stateless</td><td>Can maintain state</td></tr><tr><td>Standard</td><td>Vendor-specific</td><td>Open protocol</td></tr></tbody></table>MCP is higher-level—it’s about servers that provide multiple tools, not individual function definitions.<h2 id="the-future-of-mcp">The Future of MCP</h2>As MCP adoption grows:<ol><li>Marketplace of servers - Install capabilities like npm packages</li><li>Cross-platform compatibility - Write once, use with any MCP client</li><li>Composable AI systems - Chain servers together</li></ol><div><pre><code># Future: Installing AI capabilities
mcp install weather database github slack
claude --with-mcp="weather,database,github"
</code></pre></div><h2 id="getting-started">Getting Started</h2><ol><li>Use existing servers: Check <a href="https://github.com/modelcontextprotocol/servers">github.com/modelcontextprotocol/servers</a></li><li>Build custom servers: Use the TypeScript or Python SDK</li><li>Configure Claude: Add servers to your config</li></ol>MCP makes AI integrations portable, reusable, and standardized. If you’re building AI applications, it’s worth learning.<hr>MCP is still evolving. Watch the spec and join the community to shape its future. <div>이 글이 도움이 되셨다면 공감 및 광고 클릭을 부탁드립니다 :) </div></div></div>

Dev Note

Every AI application needs to connect to external tools—databases, APIs, file systems. Until now, each integration was custom. Model Context Protocol (MCP) changes that with a universal standard.
Photo by Jordan Harrison on Unsplash
The Integration Problem
Before MCP, connecting an LLM to tools looked like this:
Your App → Custom Code → Tool A
        → Different Code → Tool B  
        → More Code → Tool C
Every tool needed custom integration. Every AI platform did it differently.
What is MCP?
Model Context Protocol is an open standard that defines how LLMs communicate with external tools and data sources. Think of it as USB-C for AI—one connector, universal compatibility.
Photo by Alexandre Debiève on Unsplash
Core Concepts
MCP Server: Exposes tools/resources to AI
MCP Client: The AI application that connects
Transport: How they communicate (stdio, HTTP)
AI App (Client) ←→ MCP Protocol ←→ MCP Server ←→ Database/API/Tool
Building an MCP Server
Let’s create a simple MCP server that provides weather data:
import { Server } from "@modelcontextprotocol/sdk/server";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio";
const server = new Server({
  name: "weather-server",
  version: "1.0.0"
}, {
  capabilities: {
    tools: {}
  }
});
// Define the tool
server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "get_weather",
    description: "Get current weather for a city",
    inputSchema: {
      type: "object",
      properties: {
        city: { type: "string", description: "City name" }
      },
      required: ["city"]
    }
  }]
}));
// Handle tool calls
server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "get_weather") {
    const city = request.params.arguments.city;
    const weather = await fetchWeather(city);
    return {
      content: [{
        type: "text",
        text: JSON.stringify(weather)
      }]
    };
  }
});
// Start server
const transport = new StdioServerTransport();
await server.connect(transport);
MCP Resources vs Tools
MCP defines two types of capabilities:
Tools
Functions the AI can call:
{
  name: "send_email",
  description: "Send an email",
  inputSchema: { /* params */ }
}
Resources
Data the AI can read:
{
  uri: "file:///path/to/document.md",
  name: "Project README",
  mimeType: "text/markdown"
}
Connecting MCP to Claude
Claude Desktop and Claude Code natively support MCP. Configuration is simple:
// claude_desktop_config.json
{
  "mcpServers": {
    "weather": {
      "command": "node",
      "args": ["./weather-server.js"]
    },
    "database": {
      "command": "python",
      "args": ["./db-server.py"],
      "env": {
        "DATABASE_URL": "postgres://..."
      }
    }
  }
}
Now Claude can query weather and databases without custom code in your app.
Real-World MCP Servers
The ecosystem is growing fast:
Server
      Purpose
    
@modelcontextprotocol/server-filesystem
      File operations
    
@modelcontextprotocol/server-github
      GitHub API
    
@modelcontextprotocol/server-postgres
      Database queries
    
@modelcontextprotocol/server-brave-search
      Web search
    
@modelcontextprotocol/server-slack
      Slack integration
    
Building a Database MCP Server
Here’s a more practical example—a PostgreSQL server:
from mcp.server import Server
from mcp.server.stdio import stdio_server
import asyncpg
server = Server("postgres-mcp")
@server.tool()
async def query_database(sql: str) -> str:
    """Execute a read-only SQL query"""
    if not sql.strip().upper().startswith("SELECT"):
        return "Error: Only SELECT queries allowed"
    
    conn = await asyncpg.connect(DATABASE_URL)
    try:
        rows = await conn.fetch(sql)
        return json.dumps([dict(r) for r in rows])
    finally:
        await conn.close()
@server.tool()
async def list_tables() -> str:
    """List all tables in the database"""
    return await query_database(
        "SELECT table_name FROM information_schema.tables "
        "WHERE table_schema = 'public'"
    )
async def main():
    async with stdio_server() as (read, write):
        await server.run(read, write)
asyncio.run(main())
Security Considerations
MCP servers have access to sensitive systems. Be careful:
1. Principle of Least Privilege
# Bad: Full database access
@server.tool()
async def execute_sql(sql: str): ...
# Good: Scoped read-only access
@server.tool()
async def get_user_orders(user_id: int): ...
2. Input Validation
@server.tool()
async def read_file(path: str) -> str:
    # Prevent path traversal
    safe_path = Path(ALLOWED_DIR) / Path(path).name
    if not safe_path.is_relative_to(ALLOWED_DIR):
        raise ValueError("Access denied")
    return safe_path.read_text()
3. Rate Limiting
from limits import RateLimiter
limiter = RateLimiter(calls=100, period=60)
@server.tool()
async def web_search(query: str):
    if not limiter.allow():
        return "Rate limited. Try again later."
    ...
MCP vs Function Calling
How does MCP compare to OpenAI’s function calling?
Aspect
      Function Calling
      MCP
    
Scope
      Single API call
      Full server
    
Discovery
      Defined per request
      Server advertises
    
State
      Stateless
      Can maintain state
    
Standard
      Vendor-specific
      Open protocol
    
MCP is higher-level—it’s about servers that provide multiple tools, not individual function definitions.
The Future of MCP
As MCP adoption grows:
Marketplace of servers - Install capabilities like npm packages
Cross-platform compatibility - Write once, use with any MCP client
Composable AI systems - Chain servers together
# Future: Installing AI capabilities
mcp install weather database github slack
claude --with-mcp="weather,database,github"
Getting Started
Use existing servers: Check github.com/modelcontextprotocol/servers
Build custom servers: Use the TypeScript or Python SDK
Configure Claude: Add servers to your config
MCP makes AI integrations portable, reusable, and standardized. If you’re building AI applications, it’s worth learning.
MCP is still evolving. Watch the spec and join the community to shape its future.

Model Context Protocol (MCP): The USB-C of AI Integrations

댓글