MCP Client and Server: Complete Guide for Modern AI Development

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

class MCPClientManager {
  private client: Client;
  private transport: StdioClientTransport;

  async initialize(serverCommand: string, serverArgs: string[]) {
    // Create transport layer for server communication
    this.transport = new StdioClientTransport({
      command: serverCommand,
      args: serverArgs
    });

    // Initialize MCP client with transport
    this.client = new Client({
      name: "my-mcp-client",
      version: "1.0.0"
    }, {
      capabilities: {
        tools: true,
        resources: true,
        prompts: true
      }
    });

    // Connect to the MCP server
    await this.client.connect(this.transport);
    console.log("MCP client connected successfully");

    // Discover server capabilities
    const serverCapabilities = await this.client.listTools();
    console.log("Available tools:", serverCapabilities);
  }

  async invokeTool(toolName: string, args: Record) {
    try {
      const result = await this.client.callTool({
        name: toolName,
        arguments: args
      });
      return result;
    } catch (error) {
      console.error(`Tool invocation failed: ${error.message}`);
      throw error;
    }
  }

  async disconnect() {
    await this.client.close();
    console.log("MCP client disconnected");
  }
}

// Usage example
const mcpClient = new MCPClientManager();
await mcpClient.initialize("node", ["./server.js"]);
const response = await mcpClient.invokeTool("searchDatabase", { 
  query: "users", 
  limit: 10 
});

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

class ResilientMCPClient {
  private client: Client;
  private maxRetries: number = 3;
  private baseDelay: number = 1000;

  async callToolWithRetry(
    toolName: string, 
    args: Record,
    attempt: number = 0
  ): Promise {
    try {
      return await this.client.callTool({ name: toolName, arguments: args });
    } catch (error) {
      if (attempt >= this.maxRetries) {
        throw new Error(`Tool call failed after ${this.maxRetries} attempts`);
      }

      // Exponential backoff: 1s, 2s, 4s
      const delay = this.baseDelay * Math.pow(2, attempt);
      console.log(`Retry attempt ${attempt + 1} after ${delay}ms`);
      
      await new Promise(resolve => setTimeout(resolve, delay));
      return this.callToolWithRetry(toolName, args, attempt + 1);
    }
  }

  async listAvailableResources(): Promise {
    const resources = await this.client.listResources();
    return resources.resources.map(r => r.uri);
  }

  async subscribeToResourceUpdates(resourceUri: string) {
    // Subscribe to real-time resource changes
    this.client.setNotificationHandler({
      async onResourceUpdated(notification) {
        console.log(`Resource updated: ${notification.uri}`);
        // Handle resource updates in your application
      }
    });
  }
}

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

class DatabaseMCPServer {
  private server: Server;

  constructor() {
    this.server = new Server({
      name: "database-mcp-server",
      version: "1.0.0"
    }, {
      capabilities: {
        tools: true,
        resources: true
      }
    });

    this.setupTools();
    this.setupResources();
  }

  private setupTools() {
    // Register database query tool
    this.server.setRequestHandler("tools/list", async () => ({
      tools: [{
        name: "query_database",
        description: "Execute SQL queries on the database",
        inputSchema: {
          type: "object",
          properties: {
            tableName: {
              type: "string",
              description: "Name of the table"
            }
          },
          required: ["tableName"]
        }
      }]
    }));

    // Handle tool execution requests
    this.server.setRequestHandler("tools/call", async (request) => {
      const { name, arguments: args } = request.params;

      if (name === "query_database") {
        return await this.executeQuery(args.query, args.params);
      } else if (name === "get_table_schema") {
        return await this.getTableSchema(args.tableName);
      }

      throw new Error(`Unknown tool: ${name}`);
    });
  }

  private setupResources() {
    // Register database tables as resources
    this.server.setRequestHandler("resources/list", async () => ({
      resources: [{
        uri: "db://tables/users",
        name: "Users Table",
        description: "User account information",
        mimeType: "application/json"
      }, {
        uri: "db://tables/products",
        name: "Products Table",
        description: "Product catalog data",
        mimeType: "application/json"
      }]
    }));
  }

  private async executeQuery(query: string, params: any[] = []) {
    // Implement actual database query logic here
    console.log(`Executing query: ${query}`);
    return {
      content: [{
        type: "text",
        text: JSON.stringify({ 
          success: true, 
          rows: [], 
          rowCount: 0 
        })
      }]
    };
  }

  private async getTableSchema(tableName: string) {
    // Return table schema information
    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          table: tableName,
          columns: [
            { name: "id", type: "integer", primaryKey: true },
            { name: "name", type: "varchar", nullable: false }
          ]
        })
      }]
    };
  }

  async start() {
    const transport = new StdioServerTransport();
    await this.server.connect(transport);
    console.log("Database MCP Server running");
  }
}

// Start the server
const server = new DatabaseMCPServer();
await server.start();

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import crypto from "crypto";

class SecureMCPServer {
  private server: Server;
  private apiKeys: Map;
  private requestCounts: Map;

  constructor() {
    this.server = new Server({
      name: "secure-mcp-server",
      version: "1.0.0"
    }, {
      capabilities: { tools: true }
    });

    this.apiKeys = new Map();
    this.requestCounts = new Map();
    this.initializeAuthentication();
  }

  private initializeAuthentication() {
    // Middleware to validate API keys
    this.server.setRequestHandler("tools/call", async (request, extra) => {
      const apiKey = extra?.meta?.apiKey;
      
      if (!apiKey || !this.apiKeys.has(apiKey)) {
        throw new Error("Invalid or missing API key");
      }

      // Check rate limiting
      if (!this.checkRateLimit(apiKey)) {
        throw new Error("Rate limit exceeded");
      }

      // Validate permissions for requested tool
      const { name } = request.params;
      const keyData = this.apiKeys.get(apiKey);
      
      if (!keyData.permissions.includes(name)) {
        throw new Error(`Permission denied for tool: ${name}`);
      }

      // Input validation
      this.validateInput(request.params);

      // Execute the tool
      return await this.executeTool(request.params);
    });
  }

  private checkRateLimit(apiKey: string): boolean {
    const now = Date.now();
    const keyData = this.apiKeys.get(apiKey);
    let requestData = this.requestCounts.get(apiKey);

    // Reset counter if window expired
    if (!requestData || now > requestData.resetTime) {
      requestData = { count: 0, resetTime: now + 3600000 }; // 1 hour
      this.requestCounts.set(apiKey, requestData);
    }

    if (requestData.count >= keyData.rateLimit) {
      return false;
    }

    requestData.count++;
    return true;
  }

  private validateInput(params: any) {
    // Implement schema validation
    if (params.arguments?.query) {
      // Prevent SQL injection
      const dangerousPatterns = /(\bDROP\b|\bDELETE\b|\bUPDATE\b)/gi;
      if (dangerousPatterns.test(params.arguments.query)) {
        throw new Error("Potentially dangerous query detected");
      }
    }

    // Sanitize string inputs
    Object.keys(params.arguments || {}).forEach(key => {
      if (typeof params.arguments[key] === 'string') {
        params.arguments[key] = params.arguments[key].trim();
      }
    });
  }

  registerApiKey(key: string, permissions: string[], rateLimit: number = 100) {
    this.apiKeys.set(key, { permissions, rateLimit });
  }

  private async executeTool(params: any) {
    // Tool execution logic with proper error handling
    try {
      // Implement tool logic
      return { content: [{ type: "text", text: "Success" }] };
    } catch (error) {
      console.error(`Tool execution error: ${error.message}`);
      throw new Error("Internal server error");
    }
  }
}

// Initialize with API key
const secureServer = new SecureMCPServer();
secureServer.registerApiKey(
  "sk_live_abc123", 
  ["query_database", "get_schema"], 
  1000
);

// Server-side: Sending progress updates
class StreamingMCPServer {
  private server: Server;

  setupLongRunningTool() {
    this.server.setRequestHandler("tools/call", async (request) => {
      if (request.params.name === "process_large_file") {
        const totalSteps = 100;
        
        for (let step = 0; step <= totalSteps; step += 10) {
          // Send progress notification
          await this.server.sendNotification({
            method: "notifications/progress",
            params: {
              progressToken: request.params._meta?.progressToken,
              progress: step,
              total: totalSteps,
              message: `Processing: ${step}% complete`
            }
          });

          // Simulate work
          await new Promise(resolve => setTimeout(resolve, 1000));
        }

        return {
          content: [{
            type: "text",
            text: "File processing complete"
          }]
        };
      }
    });
  }
}

// Client-side: Handling progress updates
class StreamingMCPClient {
  private client: Client;

  async processWithProgress(filename: string) {
    // Set up progress handler
    this.client.setNotificationHandler({
      async onProgress(notification) {
        const { progress, total, message } = notification.params;
        console.log(`Progress: ${progress}/${total} - ${message}`);
        // Update UI progress bar
        this.updateProgressBar(progress / total * 100);
      }
    });

    // Call tool with progress token
    const result = await this.client.callTool({
      name: "process_large_file",
      arguments: { filename },
      _meta: { progressToken: crypto.randomUUID() }
    });

    return result;
  }

  private updateProgressBar(percentage: number) {
    // Update application UI
    console.log(`[${('='.repeat(percentage / 2))}${' '.repeat(50 - percentage / 2)}] ${percentage}%`);
  }
}

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import fs from "fs/promises";
import path from "path";

class FileSystemMCPServer {
  private server: Server;
  private allowedPaths: string[];

  constructor(allowedPaths: string[]) {
    this.allowedPaths = allowedPaths;
    this.server = new Server({
      name: "filesystem-mcp-server",
      version: "1.0.0"
    }, {
      capabilities: { tools: true, resources: true }
    });

    this.setupFileSystemTools();
  }

  private setupFileSystemTools() {
    this.server.setRequestHandler("tools/list", async () => ({
      tools: [{
        name: "read_file",
        description: "Read contents of a file",
        inputSchema: {
          type: "object",
          properties: {
            path: { type: "string", description: "File path to read" }
          },
          required: ["path"]
        }
      }, {
        name: "list_directory",
        description: "List files in a directory",
        inputSchema: {
          type: "object",
          properties: {
            path: { type: "string", description: "Directory path" }
          },
          required: ["path"]
        }
      }, {
        name: "write_file",
        description: "Write content to a file",
        inputSchema: {
          type: "object",
          properties: {
            path: { type: "string" },
            content: { type: "string" }
          },
          required: ["path", "content"]
        }
      }]
    }));

    this.server.setRequestHandler("tools/call", async (request) => {
      const { name, arguments: args } = request.params;
      
      // Validate path is within allowed directories
      const normalizedPath = path.normalize(args.path);
      const isAllowed = this.allowedPaths.some(allowed => 
        normalizedPath.startsWith(path.normalize(allowed))
      );

      if (!isAllowed) {
        throw new Error("Access denied: Path outside allowed directories");
      }

      switch (name) {
        case "read_file":
          return await this.readFile(args.path);
        case "list_directory":
          return await this.listDirectory(args.path);
        case "write_file":
          return await this.writeFile(args.path, args.content);
        default:
          throw new Error(`Unknown tool: ${name}`);
      }
    });
  }

  private async readFile(filePath: string) {
    try {
      const content = await fs.readFile(filePath, 'utf-8');
      return {
        content: [{
          type: "text",
          text: content
        }]
      };
    } catch (error) {
      throw new Error(`Failed to read file: ${error.message}`);
    }
  }

  private async listDirectory(dirPath: string) {
    try {
      const files = await fs.readdir(dirPath, { withFileTypes: true });
      const fileList = files.map(f => ({
        name: f.name,
        type: f.isDirectory() ? 'directory' : 'file',
        path: path.join(dirPath, f.name)
      }));

      return {
        content: [{
          type: "text",
          text: JSON.stringify(fileList, null, 2)
        }]
      };
    } catch (error) {
      throw new Error(`Failed to list directory: ${error.message}`);
    }
  }

  private async writeFile(filePath: string, content: string) {
    try {
      await fs.writeFile(filePath, content, 'utf-8');
      return {
        content: [{
          type: "text",
          text: `File written successfully: ${filePath}`
        }]
      };
    } catch (error) {
      throw new Error(`Failed to write file: ${error.message}`);
    }
  }
}

// Initialize with allowed project directories
const fsServer = new FileSystemMCPServer([
  '/home/user/projects',
  '/var/www/html'
]);

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

class CachedMCPClient {
  private client: Client;
  private cache: Map;
  private cacheTTL: number = 300000; // 5 minutes

  constructor() {
    this.cache = new Map();
  }

  async getTools(forceRefresh: boolean = false): Promise {
    const cacheKey = 'tools:list';
    
    if (!forceRefresh && this.cache.has(cacheKey)) {
      const cached = this.cache.get(cacheKey);
      if (Date.now() - cached.timestamp < this.cacheTTL) {
        console.log('Returning cached tools');
        return cached.data;
      }
    }

    // Cache miss or expired - fetch from server
    const tools = await this.client.listTools();
    this.cache.set(cacheKey, {
      data: tools.tools,
      timestamp: Date.now()
    });

    return tools.tools;
  }

  async getResourceWithCache(uri: string): Promise {
    const cacheKey = `resource:${uri}`;
    
    if (this.cache.has(cacheKey)) {
      const cached = this.cache.get(cacheKey);
      if (Date.now() - cached.timestamp < this.cacheTTL) {
        return cached.data;
      }
    }

    const resource = await this.client.readResource({ uri });
    this.cache.set(cacheKey, {
      data: resource,
      timestamp: Date.now()
    });

    return resource;
  }

  clearCache(pattern?: string) {
    if (pattern) {
      // Clear specific cache entries
      for (const key of this.cache.keys()) {
        if (key.includes(pattern)) {
          this.cache.delete(key);
        }
      }
    } else {
      // Clear entire cache
      this.cache.clear();
    }
  }

  // Subscribe to resource updates to invalidate cache
  setupCacheInvalidation() {
    this.client.setNotificationHandler({
      async onResourceUpdated(notification) {
        console.log(`Cache invalidated for: ${notification.uri}`);
        this.clearCache(notification.uri);
      }
    });
  }
}

import { v4 as uuidv4 } from 'uuid';

class MCPLogger {
  private serviceName: string;
  private logLevel: 'debug' | 'info' | 'warn' | 'error';

  constructor(serviceName: string, logLevel = 'info') {
    this.serviceName = serviceName;
    this.logLevel = logLevel;
  }

  private formatLog(level: string, message: string, metadata: any = {}) {
    return JSON.stringify({
      timestamp: new Date().toISOString(),
      service: this.serviceName,
      level,
      message,
      traceId: metadata.traceId || 'unknown',
      ...metadata
    });
  }

  info(message: string, metadata?: any) {
    console.log(this.formatLog('INFO', message, metadata));
  }

  error(message: string, error: Error, metadata?: any) {
    console.error(this.formatLog('ERROR', message, {
      ...metadata,
      errorMessage: error.message,
      errorStack: error.stack
    }));
  }

  debug(message: string, metadata?: any) {
    if (this.logLevel === 'debug') {
      console.log(this.formatLog('DEBUG', message, metadata));
    }
  }
}

// Usage in MCP Server
class MonitoredMCPServer {
  private server: Server;
  private logger: MCPLogger;

  constructor() {
    this.logger = new MCPLogger('mcp-server');
    this.setupMonitoring();
  }

  private setupMonitoring() {
    this.server.setRequestHandler("tools/call", async (request) => {
      const traceId = uuidv4();
      const startTime = Date.now();

      this.logger.info('Tool invocation started', {
        traceId,
        toolName: request.params.name,
        arguments: request.params.arguments
      });

      try {
        const result = await this.executeTool(request.params);
        const duration = Date.now() - startTime;

        this.logger.info('Tool invocation completed', {
          traceId,
          toolName: request.params.name,
          duration,
          success: true
        });

        return result;
      } catch (error) {
        const duration = Date.now() - startTime;

        this.logger.error('Tool invocation failed', error, {
          traceId,
          toolName: request.params.name,
          duration,
          success: false
        });

        throw error;
      }
    });
  }

  private async executeTool(params: any) {
    // Tool execution logic
    return { content: [{ type: "text", text: "Success" }] };
  }
}

import { Server, Client } from "@modelcontextprotocol/sdk";

class MCPGatewayServer {
  private gateway: Server;
  private backendClients: Map;
  private toolRegistry: Map; // tool -> server mapping

  constructor() {
    this.gateway = new Server({
      name: "mcp-gateway",
      version: "1.0.0"
    }, {
      capabilities: { tools: true, resources: true }
    });

    this.backendClients = new Map();
    this.toolRegistry = new Map();
  }

  async registerBackendServer(name: string, client: Client) {
    // Connect to backend server
    this.backendClients.set(name, client);

    // Discover its capabilities
    const tools = await client.listTools();
    tools.tools.forEach(tool => {
      // Prefix tool names with server name to avoid conflicts
      const qualifiedName = `${name}.${tool.name}`;
      this.toolRegistry.set(qualifiedName, name);
    });

    console.log(`Registered backend server: ${name} with ${tools.tools.length} tools`);
  }

  setupGatewayHandlers() {
    // Aggregate tools from all backend servers
    this.gateway.setRequestHandler("tools/list", async () => {
      const allTools = [];

      for (const [serverName, client] of this.backendClients) {
        const tools = await client.listTools();
        tools.tools.forEach(tool => {
          allTools.push({
            ...tool,
            name: `${serverName}.${tool.name}`,
            description: `[${serverName}] ${tool.description}`
          });
        });
      }

      return { tools: allTools };
    });

    // Route tool calls to appropriate backend
    this.gateway.setRequestHandler("tools/call", async (request) => {
      const { name, arguments: args } = request.params;
      
      // Determine which backend server handles this tool
      const serverName = this.toolRegistry.get(name);
      if (!serverName) {
        throw new Error(`Unknown tool: ${name}`);
      }

      const client = this.backendClients.get(serverName);
      
      // Remove server prefix from tool name
      const actualToolName = name.substring(serverName.length + 1);

      // Forward request to backend server
      console.log(`Routing ${actualToolName} to backend: ${serverName}`);
      return await client.callTool({
        name: actualToolName,
        arguments: args
      });
    });
  }

  async start() {
    await this.setupGatewayHandlers();
    console.log("Gateway server ready");
  }
}

// Usage
const gateway = new MCPGatewayServer();

// Register multiple backend servers
const dbClient = new Client(/* database server config */);
const fsClient = new Client(/* filesystem server config */);
const apiClient = new Client(/* API integration server config */);

await gateway.registerBackendServer("database", dbClient);
await gateway.registerBackendServer("filesystem", fsClient);
await gateway.registerBackendServer("external-api", apiClient);

await gateway.start();

enum CircuitState {
  CLOSED,  // Normal operation
  OPEN,    // Failing, reject requests
  HALF_OPEN // Testing recovery
}

class CircuitBreaker {
  private state: CircuitState = CircuitState.CLOSED;
  private failureCount: number = 0;
  private lastFailureTime: number = 0;
  private successCount: number = 0;

  constructor(
    private threshold: number = 5,
    private timeout: number = 60000,
    private halfOpenRequests: number = 3
  ) {}

  async execute(operation: () => Promise): Promise {
    if (this.state === CircuitState.OPEN) {
      if (Date.now() - this.lastFailureTime > this.timeout) {
        console.log('Circuit breaker: Attempting recovery (HALF_OPEN)');
        this.state = CircuitState.HALF_OPEN;
        this.successCount = 0;
      } else {
        throw new Error('Circuit breaker is OPEN');
      }
    }

    try {
      const result = await operation();
      this.onSuccess();
      return result;
    } catch (error) {
      this.onFailure();
      throw error;
    }
  }

  private onSuccess() {
    this.failureCount = 0;

    if (this.state === CircuitState.HALF_OPEN) {
      this.successCount++;
      if (this.successCount >= this.halfOpenRequests) {
        console.log('Circuit breaker: Recovered (CLOSED)');
        this.state = CircuitState.CLOSED;
      }
    }
  }

  private onFailure() {
    this.failureCount++;
    this.lastFailureTime = Date.now();

    if (this.failureCount >= this.threshold) {
      console.log('Circuit breaker: Threshold exceeded (OPEN)');
      this.state = CircuitState.OPEN;
    }
  }

  getState(): CircuitState {
    return this.state;
  }
}

class ResilientMCPClient {
  private client: Client;
  private circuitBreaker: CircuitBreaker;

  constructor() {
    this.circuitBreaker = new CircuitBreaker(5, 60000, 3);
  }

  async callTool(name: string, args: any) {
    return await this.circuitBreaker.execute(async () => {
      return await this.client.callTool({ name, arguments: args });
    });
  }

  getCircuitState(): string {
    const state = this.circuitBreaker.getState();
    return CircuitState[state];
  }
}

import { describe, it, expect, beforeEach } from 'vitest';
import { Server } from '@modelcontextprotocol/sdk/server/index.js';

describe('MCP Server Tests', () => {
  let server: Server;

  beforeEach(() => {
    server = new Server({
      name: "test-server",
      version: "1.0.0"
    }, {
      capabilities: { tools: true }
    });

    // Register test tool
    server.setRequestHandler("tools/list", async () => ({
      tools: [{
        name: "calculate",
        description: "Perform calculation",
        inputSchema: {
          type: "object",
          properties: {
            operation: { type: "string", enum: ["add", "multiply"] },
            a: { type: "number" },
            b: { type: "number" }
          },
          required: ["operation", "a", "b"]
        }
      }]
    }));

    server.setRequestHandler("tools/call", async (request) => {
      const { operation, a, b } = request.params.arguments;
      
      let result;
      if (operation === "add") {
        result = a + b;
      } else if (operation === "multiply") {
        result = a * b;
      } else {
        throw new Error(`Unknown operation: ${operation}`);
      }

      return {
        content: [{ type: "text", text: String(result) }]
      };
    });
  });

  it('should list available tools', async () => {
    const response = await server.request({
      method: "tools/list",
      params: {}
    });

    expect(response.tools).toHaveLength(1);
    expect(response.tools[0].name).toBe("calculate");
  });

  it('should execute addition correctly', async () => {
    const response = await server.request({
      method: "tools/call",
      params: {
        name: "calculate",
        arguments: { operation: "add", a: 5, b: 3 }
      }
    });

    expect(response.content[0].text).toBe("8");
  });

  it('should execute multiplication correctly', async () => {
    const response = await server.request({
      method: "tools/call",
      params: {
        name: "calculate",
        arguments: { operation: "multiply", a: 4, b: 7 }
      }
    });

    expect(response.content[0].text).toBe("28");
  });

  it('should handle invalid operations', async () => {
    await expect(
      server.request({
        method: "tools/call",
        params: {
          name: "calculate",
          arguments: { operation: "divide", a: 10, b: 2 }
        }
      })
    ).rejects.toThrow("Unknown operation");
  });
});

# Dockerfile for MCP Server
FROM node:20-alpine

WORKDIR /app

# Install dependencies
COPY package*.json ./
RUN npm ci --production

# Copy application code
COPY src/ ./src/
COPY tsconfig.json ./

# Build TypeScript
RUN npm run build

# Create non-root user
RUN addgroup -g 1001 mcpserver && \
    adduser -D -u 1001 -G mcpserver mcpserver

USER mcpserver

# Expose health check endpoint (if using HTTP transport)
EXPOSE 3000

# Set environment variables
ENV NODE_ENV=production
ENV LOG_LEVEL=info

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD node healthcheck.js

# Start MCP server
CMD ["node", "dist/server.js"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mcp-server
  labels:
    app: mcp-server
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mcp-server
  template:
    metadata:
      labels:
        app: mcp-server
    spec:
      containers:
      - name: mcp-server
        image: your-registry/mcp-server:latest
        ports:
        - containerPort: 3000
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: mcp-secrets
              key: database-url
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 15
          periodSeconds: 20
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: mcp-server-service
spec:
  selector:
    app: mcp-server
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: LoadBalancer