Crear un Servidor MCP Remoto en un VPS con Python y FastAPI

La mayoría de los ejemplos de MCP usan stdio para comunicarse localmente. Pero, ¿qué pasa si quieres que tu IA acceda a herramientas pesadas o bases de datos que viven en un servidor remoto (VPS)?

En este tutorial, crearemos un Servidor MCP Remoto usando Python y FastAPI con soporte para SSE (Server-Sent Events), el estándar para transporte remoto en MCP.

Requisitos

Un servidor VPS (Ubuntu 22.04 recomendado).
Python 3.10+.
Una dirección IP pública o dominio.

Paso 1: Estructura del Proyecto

Crea una carpeta nueva y configura un entorno virtual:

mkdir mcp-remote-server
cd mcp-remote-server
python3 -m venv venv
source venv/bin/activate

Paso 2: Instalación de Dependencias

Necesitaremos mcp (el SDK oficial), fastapi y uvicorn.

pip install mcp fastapi uvicorn[standard]

Paso 3: El Código del Servidor (`server.py`)

Este script define un servidor simple que expone una herramienta para sumar números (como prueba) y configura los endpoints SSE necesarios.

from fastapi import FastAPI
from mcp.server.fastapi import FcpServer
from mcp.server.fastapi import FastMCP

# Inicializamos la aplicación FastMCP
# Esta clase wrapper facilita la integración con FastAPI
mcp = FastMCP("Mi Servidor Remoto")

@mcp.tool()
def sumar_numeros(a: int, b: int) -> int:
    """Suma dos números. Útil para pruebas de conexión."""
    return a + b

@mcp.resource("config://app-version")
def get_version() -> str:
    """Devuelve la versión actual de la app remota."""
    return "v1.0.0-remote"

# FastMCP ya incluye internamente el manejo de rutas SSE,
# pero si necesitamos personalizarlo, podemos montar la app así:
# (FastMCP se encarga de crear la app FastAPI subyacente si no se la pasamos)

Nota: El SDK de Python para MCP (mcp) está evolucionando rápidamente. La clase FastMCP simplifica mucho la creación de servidores sobre FastAPI comparado con la implementación manual de rutas /sse y /messages.

Paso 4: Ejecutar el Servidor

Ejecuta el servidor con Uvicorn escuchando en todas las interfaces (0.0.0.0) para que sea accesible desde fuera.

uvicorn server:mcp.run --host 0.0.0.0 --port 8000

En producción, deberías usar Nginx como proxy inverso y asegurar la conexión con SSL (HTTPS).

Paso 5: Conectar desde el Cliente (Claude Desktop)

Para conectar tu Claude Desktop local a este servidor remoto, edita tu archivo de configuración claude_desktop_config.json:

{
  "mcpServers": {
    "mi-vps-remoto": {
      "command": "", 
      "url": "http://TU_IP_VPS:8000/sse",
      "transport": "sse" 
    }
  }
}

¡Ojo! Claude Desktop actualmente soporta primariamente stdio. El soporte para sse directo en la configuración de usuario está en desarrollo activo.

Una alternativa común es usar un “puente” local: un pequeño script en tu máquina que se conecta al SSE remoto y lo retransmite a Claude por Stdio.

El Puente (Bridge) Local

Si Claude no conecta directamente por URL, crea este script client.py en tu máquina local:

import asyncio
from mcp.client.sse import sse_client
from mcp.client.stdio import stdio_client

async def run():
    async with sse_client("http://TU_IP_VPS:8000/sse") as (read, write):
        async with stdio_client(read, write):
            pass # Mantiene la conexión abierta

if __name__ == "__main__":
    asyncio.run(run())

Y configura Claude para ejecutar este script:

"mi-vps-remoto": {
  "command": "python",
  "args": ["/ruta/a/client.py"]
}

¡Listo! Ahora tu IA local tiene poderes en la nube.