Cómo Crear un Servidor MCP con TypeScript y Python: Guía Práctica

mkdir mcp-servidor-ts
cd mcp-servidor-ts
npm init -y

npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node

{
  "name": "mcp-servidor-ts",
  "version": "1.0.0",
  "type": "module",
  "main": "build/index.js",
  "scripts": {
    "build": "tsc"
  }
}

{
  "compilerOptions": {
    "target": "ES2022",
    "module": "Node16",
    "moduleResolution": "Node16",
    "outDir": "./build",
    "rootDir": "./src",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*"]
}

# Inicializar el proyecto e instalar dependencias
uv init mcp-servidor-python
cd mcp-servidor-python
uv venv
source .venv/bin/activate  # En Windows: .venv\Scripts\activate

uv add "mcp[cli]"

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// 1. Inicialización de la instancia del servidor MCP
const server = new McpServer({
  name: "servidor-metricas-ts",
  version: "1.0.0",
});

// 2. Definición de una Tool (Acción con parámetros validados por Zod)
server.registerTool(
  "obtener_rendimiento",
  {
    description: "Obtiene el porcentaje de uso de CPU y memoria de un servidor remoto.",
    inputSchema: z.object({
      servidorId: z.string().describe("Identificador único del servidor (ej. srv-01)"),
    }),
  },
  async ({ servidorId }) => {
    // Registro de logs seguro enviado a stderr
    console.error(`[INFO] Consultando métricas para: ${servidorId}`);

    // Respuesta estructurada requerida por el protocolo
    return {
      content: [
        {
          type: "text",
          text: `Servidor ${servidorId}: Uso de CPU al 42%, Memoria al 68%. Estado: Saludable.`,
        },
      ],
    };
  }
);

// 3. Definición de un Resource (Datos de solo lectura)
server.registerResource(
  "politica_alerta",
  "config://politica-alerta",
  {
    name: "Política de Alertas",
    description: "Límites estipulados para el disparo de alertas de infraestructura.",
    mimeType: "text/plain",
  },
  async (uri) => ({
    contents: [
      {
        uri: uri.href,
        text: "Límite crítico CPU: 90%. Límite crítico Memoria: 85% sostenido por 5 min.",
      },
    ],
  })
);

// 4. Definición de un Prompt (Plantilla de usuario)
server.registerPrompt(
  "diagnosticar_servidor",
  {
    description: "Genera un análisis guiado sobre la salud del servidor.",
    args: {
      servidorId: z.string().describe("ID del servidor a revisar"),
    },
  },
  ({ servidorId }) => ({
    messages: [
      {
        role: "user",
        content: {
          type: "text",
          text: `Por favor analiza las métricas del servidor ${servidorId}, verifica si excede la politica_alerta y recomienda acciones.`,
        },
      },
    ],
  })
);

// 5. Conexión e inicio del transporte STDIO
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("Servidor MCP TypeScript ejecutándose en STDIO");
}

main().catch((error) => {
  console.error("Error fatal en main():", error);
  process.exit(1);
});

npx tsc

import logging
from typing import Any
from mcp.server.fastmcp import FastMCP

# Configuración de logs dirigidos strictly a stderr
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("servidor-python")

# 1. Inicialización de la instancia del servidor MCP con FastMCP
mcp = FastMCP("servidor-metricas-py")

# 2. Definición de Tool mediante decoradores sintácticos
@mcp.tool()
def obtener_rendimiento(servidor_id: str) -> str:
    """Obtiene el porcentaje de uso de CPU y memoria de un servidor remoto.

    Args:
        servidor_id: Identificador único del servidor (ej. srv-01)
    """
    logger.error(f"[INFO] Consultando servidor Python: {servidor_id}")
    return f"Servidor {servidor_id} (Py): Uso de CPU al 38%, Memoria al 55%. Estado: Óptimo."

# 3. Definición de Resource (Lectura de contexto estático)
@mcp.resource("config://politica-alerta")
def obtener_politica() -> str:
    """Devuelve las políticas de alerta predeterminadas del sistema."""
    return "Regla Py: Notificar si el uso de disco supera el 95%."

# 4. Definición de Prompt reutilizable
@mcp.prompt("reporte_rapido")
def plantilla_reporte(servidor_id: str) -> str:
    """Plantilla para solicitar un informe ejecutivo rápido."""
    return f"Genera un resumen ejecutivo de un párrafo sobre el estado actual de {servidor_id}."

# 5. Punto de entrada para ejecución en transporte STDIO
if __name__ == "__main__":
    mcp.run(transport="stdio")

# Para el servidor Python
uv run mcp dev servidor.py

# Para el servidor TypeScript
npx @modelcontextprotocol/inspector node build/index.js

{
  "mcpServers": {
    "metricas-ts": {
      "command": "node",
      "args": [
        "/RUTA/ABSOLUTA/A/mcp-servidor-ts/build/index.js"
      ]
    },
    "metricas-python": {
      "command": "uv",
      "args": [
        "--directory",
        "/RUTA/ABSOLUTA/A/mcp-servidor-python",
        "run",
        "servidor.py"
      ]
    }
  }
}