MCP 개념

┌─────────────────────────────────────────────────────────┐
│  MCP의 핵심 가치                                          │
├─────────────────────────────────────────────────────────┤
│  1. 표준화: 모든 데이터 소스에 일관된 인터페이스 제공      │
│  2. 확장성: 새로운 도구와 리소스를 쉽게 추가              │
│  3. 재사용성: 한 번 작성한 서버를 여러 클라이언트에서 사용 │
│  4. 분리: 데이터 제공자와 AI 모델의 독립적 개발           │
└─────────────────────────────────────────────────────────┘

// 1. 파일 시스템 접근
"프로젝트 src/ 디렉토리의 모든 TypeScript 파일을 분석해줘"
→ MCP 파일시스템 서버가 파일 목록과 내용 제공

// 2. 데이터베이스 쿼리
"지난 30일간 매출 상위 10개 제품을 보여줘"
→ MCP PostgreSQL 서버가 데이터베이스 쿼리 실행

// 3. API 통합
"GitHub에서 open 상태인 이슈 중 'bug' 레이블이 있는 것들을 찾아줘"
→ MCP GitHub 서버가 GitHub API 호출

// 4. 도구 실행
"이 Python 코드를 실행하고 결과를 보여줘"
→ MCP 실행 환경 서버가 코드 실행

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

// 클라이언트 생성
const client = new Client({
  name: "my-ai-client",
  version: "1.0.0"
}, {
  capabilities: {
    tools: {}
  }
});

// 서버에 연결 (stdio 전송)
const transport = new StdioClientTransport({
  command: "python",
  args: ["server.py"]
});

await client.connect(transport);

// 사용 가능한 도구 목록 조회
const tools = await client.listTools();
console.log(tools);

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

# 서버 생성
server = Server("my-mcp-server")

# 도구 등록
@server.tool()
async def read_file(path: str) -> str:
    """파일 내용을 읽습니다."""
    with open(path, 'r') as f:
        return f.read()

# 서버 실행
async def main():
    async with stdio_server() as streams:
        await server.run(
            streams[0],
            streams[1],
            server.create_initialization_options()
        )

// Function Calling 방식
const response = await anthropic.messages.create({
  model: "claude-4-5",
  messages: [{ role: "user", content: "파일 읽어줘" }],
  tools: [{
    name: "read_file",
    description: "파일을 읽습니다",
    input_schema: {
      type: "object",
      properties: {
        path: { type: "string" }
      }
    }
  }]
});

// 도구 실행은 클라이언트가 직접 처리
if (response.stop_reason === "tool_use") {
  const result = await readFile(toolUse.input.path);
  // 결과를 다시 Claude에게 전달...
}

// ─────────────────────────────────────

// MCP 방식
const client = new MCPClient();
await client.connect(fileSystemServer);

// 도구 목록은 서버에서 자동 제공
const tools = await client.listTools();

// 도구 실행도 서버가 처리
const result = await client.callTool("read_file", {
  path: "/path/to/file"
});

// 직접 API 통합 (각 클라이언트에서 반복)
class GitHubIntegration {
  constructor(token) {
    this.token = token;
  }

  async listIssues(repo) {
    const response = await fetch(`https://api.github.com/repos/${repo}/issues`, {
      headers: { Authorization: `token ${this.token}` }
    });
    return response.json();
  }

  // 수십 개의 메서드...
}

// ─────────────────────────────────────

// MCP 방식 (한 번만 작성, 모든 클라이언트에서 재사용)
const githubServer = await client.connect("github-mcp-server");

// 모든 GitHub 기능을 표준 인터페이스로 사용
const issues = await client.callTool("github_list_issues", {
  repo: "anthropics/anthropic-sdk-python"
});

// 요청 메시지
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "read_file",
    "arguments": {
      "path": "/home/user/example.txt"
    }
  }
}

// 응답 메시지
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "Hello, MCP!"
      }
    ]
  }
}

// 에러 응답
{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32602,
    "message": "Invalid params",
    "data": {
      "details": "File not found"
    }
  }
}

// initialize 요청
{
  "jsonrpc": "2.0",
  "id": 0,
  "method": "initialize",
  "params": {
    "protocolVersion": "2024-11-05",
    "clientInfo": {
      "name": "Claude Desktop",
      "version": "1.0.0"
    },
    "capabilities": {
      "tools": {}
    }
  }
}

// initialize 응답
{
  "jsonrpc": "2.0",
  "id": 0,
  "result": {
    "protocolVersion": "2024-11-05",
    "serverInfo": {
      "name": "filesystem-server",
      "version": "1.0.0"
    },
    "capabilities": {
      "tools": {},
      "resources": {}
    }
  }
}

// tools/list - 도구 목록 조회
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list"
}

// 응답
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "read_file",
        "description": "파일 내용을 읽습니다",
        "inputSchema": {
          "type": "object",
          "properties": {
            "path": {
              "type": "string",
              "description": "파일 경로"
            }
          },
          "required": ["path"]
        }
      }
    ]
  }
}

// tools/call - 도구 실행
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "read_file",
    "arguments": {
      "path": "/etc/hosts"
    }
  }
}

// resources/list - 리소스 목록
{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "resources/list"
}

// resources/read - 리소스 읽기
{
  "jsonrpc": "2.0",
  "id": 4,
  "method": "resources/read",
  "params": {
    "uri": "file:///path/to/document.txt"
  }
}

// prompts/list - 프롬프트 목록
{
  "jsonrpc": "2.0",
  "id": 5,
  "method": "prompts/list"
}

// prompts/get - 프롬프트 가져오기
{
  "jsonrpc": "2.0",
  "id": 6,
  "method": "prompts/get",
  "params": {
    "name": "code-review",
    "arguments": {
      "language": "python"
    }
  }
}

import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

// Python 서버 실행
const transport = new StdioClientTransport({
  command: "python",
  args: ["-m", "mcp_server_filesystem"],
  env: {
    ...process.env,
    "PYTHONPATH": "/path/to/server"
  }
});

await client.connect(transport);

import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";

// 원격 서버 연결
const transport = new SSEClientTransport(
  new URL("https://mcp-server.example.com/sse")
);

await client.connect(transport);

@server.tool()
async def calculate(expression: str) -> str:
    """수학 표현식을 계산합니다.

    Args:
        expression: 계산할 수학 표현식 (예: "2 + 2")

    Returns:
        계산 결과
    """
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"에러: {e}"

@server.resource("file://{path}")
async def read_file_resource(path: str) -> str:
    """파일을 리소스로 제공합니다."""
    with open(path, 'r') as f:
        return f.read()

@server.prompt()
async def code_review_prompt(language: str, code: str) -> str:
    """코드 리뷰 프롬프트를 생성합니다."""
    return f"""다음 {language} 코드를 리뷰해주세요:

```{language}
{code}
```

다음 관점에서 검토해주세요:
1. 코드 품질
2. 성능
3. 보안
4. 베스트 프랙티스
"""

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

async function main() {
  // 1. 클라이언트 생성
  const client = new Client({
    name: "example-client",
    version: "1.0.0"
  }, {
    capabilities: {
      tools: {}
    }
  });

  // 2. 전송 계층 설정
  const transport = new StdioClientTransport({
    command: "python",
    args: ["server.py"]
  });

  try {
    // 3. 연결 및 초기화
    await client.connect(transport);
    console.log("연결 성공!");

    // 4. 작업 수행
    const tools = await client.listTools();
    console.log("사용 가능한 도구:", tools);

    const result = await client.callTool("read_file", {
      path: "/etc/hosts"
    });
    console.log("결과:", result);

  } finally {
    // 5. 종료
    await client.close();
    console.log("연결 종료");
  }
}

main().catch(console.error);

{
  "capabilities": {
    "tools": {},                    // 도구 호출 지원
    "resources": {
      "subscribe": true          // 리소스 변경 구독
    },
    "prompts": {},                  // 프롬프트 사용 지원
    "sampling": {}                  // 샘플링 요청 수신 (서버→클라이언트)
  }
}

{
  "capabilities": {
    "tools": {
      "listChanged": true        // 도구 목록 변경 알림
    },
    "resources": {
      "subscribe": true,         // 리소스 구독 지원
      "listChanged": true        // 리소스 목록 변경 알림
    },
    "prompts": {
      "listChanged": true        // 프롬프트 목록 변경 알림
    },
    "logging": {}                   // 로그 메시지 전송
  }
}

from mcp.server import McpError

@server.tool()
async def read_file(path: str) -> str:
    if not os.path.exists(path):
        raise McpError(
            code=-32001,
            message="File not found",
            data={"path": path}
        )

    with open(path, 'r') as f:
        return f.read()

try {
  const result = await client.callTool("read_file", {
    path: "/nonexistent.txt"
  });
} catch (error) {
  if (error.code === -32001) {
    console.error("파일을 찾을 수 없습니다:", error.data.path);
  } else {
    console.error("예상치 못한 오류:", error.message);
  }
}