MCP FAQ: 실무 질문에 대한 전문가 답변

# High-throughput deployment example
deployment:
  servers: 3-5 instances
  load_balancer: nginx/haproxy
  caching: Redis for frequent queries
  monitoring: Prometheus + Grafana
  rate_limiting: per-client quotas

{
  "transport": "stdio",  // Local process isolation
  "network_isolation": true,
  "firewall_rules": ["block_external_access"]
}

# Server-side permission model
class MCPServer:
    def __init__(self):
        self.capabilities = {
            "read_files": ["/safe/directory/*"],
            "write_files": ["/output/only/*"],
            "execute_commands": ["git", "npm"]  # Whitelist only
        }

# Comprehensive logging
@audit_log
def handle_request(self, request):
    log.info({
        "client_id": request.client_id,
        "operation": request.method,
        "resources": request.params.get("resources", []),
        "timestamp": datetime.utcnow(),
        "result": "success|failure"
    })

# 1. Initialize project
npm init -y
npm install @modelcontextprotocol/sdk-typescript

# 2. Create basic server
cat > server.ts << 'EOF'
import { Server } from '@modelcontextprotocol/sdk-typescript';

const server = new Server({
  name: 'my-prototype',
  version: '1.0.0'
});

server.tool('hello', 'Say hello', {
  name: { type: 'string' }
}, async (args) => {
  return `Hello, ${args.name}!`;
});

server.start();
EOF

# 3. Test immediately
npx tsx server.ts

class MCPErrorHandler:
    def handle_error(self, error):
        if isinstance(error, ValidationError):
            return self.client_error(400, "Invalid request format")
        elif isinstance(error, PermissionError):
            return self.client_error(403, "Access denied")
        elif isinstance(error, ResourceNotFound):
            return self.client_error(404, "Resource not available")
        elif isinstance(error, RateLimitExceeded):
            return self.client_error(429, "Rate limit exceeded")
        else:
            # Log for debugging, return generic error to client
            self.log_internal_error(error)
            return self.server_error(500, "Internal server error")

def test_file_access_permissions():
    server = FileSystemServer(allowed_paths=["/safe/"])
    
    # Should succeed
    result = server.read_file("/safe/document.txt")
    assert result.success
    
    # Should fail
    with pytest.raises(PermissionError):
        server.read_file("/etc/passwd")

def test_mcp_protocol_compliance():
    client = MCPClient()
    client.connect(server_url)
    
    # Test capability discovery
    capabilities = client.list_capabilities()
    assert "read_files" in capabilities
    
    # Test actual operations
    result = client.call_tool("read_file", {"path": "/test.txt"})
    assert result.status == "success"

def test_claude_integration():
    # Configure Claude with test server
    config = {
        "mcpServers": {
            "test": {"command": "python", "args": ["test_server.py"]}
        }
    }
    
    claude = ClaudeClient(config)
    response = claude.chat("Read the contents of test.txt")
    assert "file contents" in response.lower()

# Key performance indicators
metrics = {
    "request_rate": "requests/second",
    "response_time": "p50, p95, p99 latencies",
    "error_rate": "errors/total_requests",
    "connection_count": "active_connections",
    "resource_usage": "cpu, memory, disk_io",
    "business_metrics": "tools_called, files_accessed"
}

# Prometheus alerting rules
groups:
  - name: mcp_server
    rules:
      - alert: HighErrorRate
        expr: rate(mcp_errors_total[5m]) > 0.1
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "MCP server error rate is high"
      
      - alert: SlowResponseTime
        expr: histogram_quantile(0.95, rate(mcp_request_duration_seconds_bucket[5m])) > 2
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "MCP server response time is slow"

class VersionAwareServer:
    def __init__(self):
        self.supported_versions = ["1.0", "1.1", "2.0"]
        self.feature_flags = {
            "streaming": "1.1+",
            "batch_operations": "2.0+",
            "async_tools": "2.0+"
        }
    
    def handle_request(self, request):
        client_version = request.headers.get("mcp-version", "1.0")
        
        if self.supports_feature("streaming", client_version):
            return self.handle_streaming_request(request)
        else:
            return self.handle_legacy_request(request)