Cómo crear un servidor MCP desde cero con Python

Los clientes de IA como Claude y Cursor son fantásticos para escribir código y analizar texto, pero tal y como vienen de fábrica, básicamente van a ciegas. No pueden ver tus datos ni usar tus herramientas sin ayuda. El Protocolo de Contexto del Modelo (MCP) es el puente. Un servidor MCP le da a un cliente de IA nuevas capacidades, como llamar a una API o leer un archivo.

En esta guía, vas a crear un servidor MCP desde cero en Python. Usarás FastMCP, el framework de Python más habitual para esta tarea. Aprenderás a conectar el servidor a Claude y a Cursor. Después, implementarás el servidor en un servidor en producción, para que un cliente de IA pueda acceder a él desde cualquier lugar.

El código completo es breve. Puedes terminar la compilación local en unos 20 minutos.

¿Qué es un servidor MCP?

El Protocolo de Contexto de Modelo es un estándar abierto. Anthropic lo lanzó a finales de 2024. Define una forma común para que los clientes de IA se comuniquen con sistemas externos.

Un servidor MCP es un programa pequeño. Se sitúa entre un cliente de IA y un sistema que te pertenece. El cliente de IA envía una solicitud. El servidor realiza la tarea y devuelve un resultado.

Un servidor MCP le ofrece al cliente de IA tres cosas:

• Herramientas. Acciones que puede realizar el cliente. Por ejemplo, comprobar el estado de una página web.
• Recursos. Datos que el cliente puede consultar. Por ejemplo, una lista de archivos.
• Indicaciones. Instrucciones ya preparadas que el cliente puede reutilizar.

La ventaja es la estandarización. Escribes el servidor una sola vez. Después, cualquier cliente de IA que admita MCP puede utilizarlo. No tienes que escribir una integración personalizada para cada cliente.

Lo que vamos a crear hoy

Para ver cómo encaja todo esto, vamos a crear un servidor llamado «Site Health Checker». Es lo bastante sencillo como para hacerlo de una sola vez, pero abarca los tres pilares de la especificación MCP.

El servidor le envía al cliente de IA:

• Una herramienta llamada «check_site». Te dice el código de estado HTTP y el tiempo de respuesta de una URL.
• Una herramienta llamada «check_ssl». Te dice cuántos días faltan para que caduque el certificado SSL de una URL.
• Un recurso «monitored_sites». Muestra la lista de sitios que estás supervisando.
• Una solicitud «health_report». Le pide al cliente un breve resumen del estado.

Al final, le haces a Claude una pregunta en lenguaje sencillo. Claude ejecuta tu herramienta y te da una respuesta.

Requisitos

previos
. Necesitas lo siguiente antes de empezar:

• Python 3.10 o una versión posterior.
• El gestor de paquetes pip o uv. En esta guía se usa uv.
• Un cliente de IA compatible con MCP. En esta guía se usan Claude Desktop y Cursor.
• Conocimientos básicos de Python.

Para comprobar tu versión de Python, ejecuta este comando:

bash

python3 --version

Cómo funciona un servidor MCP

Antes de escribir código, conoce sus componentes. MCP tiene tres componentes:

1. El host y el cliente. Se trata de la aplicación de IA, como Claude Desktop. Es la que inicia y controla la conexión.
2. El servidor. Este es tu programa. Proporciona las herramientas, los recursos y las indicaciones.
3. Los mensajes. El cliente y el servidor se envían mensajes en formato JSON-RPC.

Primero, el cliente y el servidor establecen una conexión. El cliente le pregunta al servidor qué puede hacer. El servidor le envía su lista de herramientas, recursos y indicaciones. A continuación, el cliente puede acceder a ellos.

El transporte es el canal por el que circulan los mensajes. Hay dos tipos de transporte habituales:

• stdio. El cliente inicia el servidor como un proceso local. Los dos programas se comunican a través de la entrada y salida estándar. Usa stdio para el desarrollo local.
• HTTP. El servidor se ejecuta como un servicio web. El cliente se conecta a través de una red. Usa HTTP para un servidor remoto o compartido.

Empiezas con stdio. Más adelante, cambias a HTTP para la implementación remota.

Configura el servidor con FastMCP

FastMCP se encarga del trabajo duro por ti. Gestiona el protocolo, el establecimiento de conexión y el formato de los mensajes. Tú escribes funciones sencillas en Python. FastMCP las convierte en herramientas, recursos y mensajes de ayuda.

Paso 1. Crea el proyecto

Crea una carpeta para el proyecto. A continuación, entra en ella.

bash

mkdir site-health-mcp
cd
site-health-mcp

Paso 2. Instala los paquetes

Instala FastMCP y la biblioteca HTTP.

bash

uv init
uv add fastmcp httpx

Paso 3. Crea el archivo del servidor

Crea un archivo llamado server.py. Añade las líneas de importación y el objeto del servidor.

python

from fastmcp import FastMCP
import httpx
import ssl
import socket
from datetime import datetime, timezone
from urllib.parse import urlparse
mcp = FastMCP("Site Health Checker")

La línea FastMCP(«Site Health Checker») crea el servidor. El texto es el nombre del servidor. El cliente de IA muestra este nombre al usuario.

Paso 4. Añade la primera herramienta

Una herramienta es una función de Python con el decorador @mcp.tool. Añade la herramienta check_site debajo del objeto server.

python

@mcp.tool
def check_site(url:str) ->dict:
    """Get the HTTP status code and the response time for a URL."""
    start = datetime.now(timezone.utc)
    response = httpx.get(url, timeout=10.0, follow_redirects=True)
    elapsed = (datetime.now(timezone.utc) - start).total_seconds()
    return{
        "url": url,
        "status_code": response.status_code,
        "ok": response.is_success,
        "response_time_seconds":round(elapsed,3),
    }

Hay tres partes importantes en esta función:

• El decorador @mcp.tool registra la función como una herramienta.
• La cadena de documentación le dice al cliente de IA qué hace la herramienta. Escríbela con cuidado. El cliente la lee para decidir cuándo usar la herramienta.
• Las indicaciones de tipo (url: str y -> dict) le dicen al cliente cuáles son la entrada y la salida. FastMCP construye el esquema de la herramienta a partir de ellas.

Paso 5. Añade la segunda herramienta

Añade una segunda herramienta que compruebe el certificado SSL.

python

@mcp.tool
def check_ssl(url:str) -> dict:
    
"""Get the number of days until the SSL certificate of a URL expires."""
    
hostname = urlparse(url).hostname
context = ssl.create_default_context()
with socket.create_connection((hostname,443), timeout=10.0)as
sock:
with context.wrap_socket(sock, server_hostname=hostname)as
secure_sock:
            certificate = secure_sock.getpeercert()
    expiry = datetime.strptime(certificate["notAfter"],"%b %d %H:%M:%S %Y %Z")
    days_left = (expiry - datetime.utcnow()).days
    return{
        "url": url,
        "ssl_expiry": certificate["notAfter"],
        "days_left": days_left,
    }

Esta herramienta abre una conexión segura con el sitio. Lee el certificado. A continuación, devuelve el número de días que faltan para que caduque el certificado.

Paso 6. Añade un recurso

Un recurso son datos de solo lectura. El cliente de IA los lee, pero no ejecuta ninguna acción. Añade un recurso que muestre la lista de sitios supervisados.

python

MONITORED_SITES = [
    
"https://www.cloudways.com",
"https://www.digitalocean.com",
]
@mcp.resource("sites://monitored")
def monitored_sites() ->list[str]:
    """The list of sites that you monitor."""
    return MONITORED_SITES

El decorador @mcp.resource necesita un URI. El URI es la dirección del recurso. En este caso es sites://monitored. El cliente usa el URI para solicitar los datos.

Paso 7. Añade un «prompt»

. Un «prompt» es una instrucción reutilizable. Evita que el usuario tenga que escribir la misma solicitud cada vez. Añade un «prompt» que pida un informe de estado.

python

@mcp.prompt
def health_report(url:str) ->str:
    """Make a prompt that asks the AI client for a health report of a site."""
    return(
        f"Check the HTTP status and the SSL expiry for {url}. "
        "Then give a short health summary."
    )

Paso 8. Añade el comando de ejecución

Añade las últimas líneas al archivo. Estas líneas inician el servidor.

python

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

La llamada a mcp.run() inicia el servidor con el transporte stdio. Este es el transporte adecuado para uso local.

Paso 9. Ejecuta el servidor

Inicia el servidor desde la terminal.

bash

uv run server.py

Ahora el servidor está a la espera de un cliente. No muestra mucho en pantalla, porque se comunica a través de stdio. Esto es normal. Detén el servidor con Ctrl + C.

Ya tienes tu servidor listo. El siguiente paso es conectar un cliente de IA.

Conecta el servidor a un cliente de IA

Ahora conectas el servidor a Claude Desktop y Cursor. El cliente de IA inicia el servidor por ti. No tienes que ejecutar el servidor manualmente.

Conéctate a Claude Desktop

FastMCP puede generar la configuración de Claude Desktop por ti. Ejecuta este comando:

bash

fastmcp install claude-desktop server.py

Este comando añade tu servidor al archivo de configuración de Claude Desktop. Si prefieres editar el archivo a mano, ábrelo en una de estas ubicaciones:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

Añade tu servidor al archivo. Usa la ruta absoluta a tu proyecto.

json

{
  "mcpServers": {
    "site-health": {
      "command":"uv",
      "args": ["run","--directory",
"/absolute/path/to/site-health-mcp","server.py"]
    }
  }
}

Guarda el archivo. Después, cierra y vuelve a abrir Claude Desktop. Claude Desktop solo lee el archivo al iniciarse.

Ahora prueba el servidor. Escribe esta solicitud en Claude Desktop:

text

Check the health of https://www.cloudways.com

Claude ejecuta tu herramienta «check_site». Primero te pide tu autorización. Acepta la llamada. Claude te devuelve el código de estado y el tiempo de respuesta.

Conéctate a Cursor

Cursor también es compatible con servidores MCP. Abre la configuración de Cursor y busca la sección MCP. O edita directamente el archivo de configuración en ~/.cursor/mcp.json.

Añade los mismos datos del servidor:

json

{
  "mcpServers": {
    "site-health": {
      "command":"uv",
      "args": ["run","--directory",
"/absolute/path/to/site-health-mcp","server.py"]
    }
  }
}

Guarda el archivo. Cursor carga el servidor. Ahora ya puedes hacerle a Cursor las mismas preguntas sobre el estado del servidor.

Implementar el servidor MCP en un host remoto

Un servidor stdio se ejecuta en tu propio ordenador. Solo tu propio cliente de IA puede utilizarlo. Para compartir el servidor, debes implementarlo en un host remoto. De este modo, cualquier cliente podrá acceder a él a través de la red.

PRECAUCIÓN: Hay un servidor MCP remoto expuesto a la red. No pongas en marcha un servidor sin autenticación para que sea de acceso público. Una herramienta podría llevar a cabo acciones reales. Protege el servidor antes de hacerlo público. Lee más en «¿Es seguro dejar que la IA gestione tus servidores?».

Paso 1. Cambia el transporte a HTTP

Cambia las últimas líneas de server.py. Usa el transporte HTTP en lugar de stdio.

python

if __name__ =="__main__":
    mcp.run(transport="http", host="0.0.0.0", port=8000)

El valor host=»0.0.0.0″ hace que el servidor acepte conexiones desde la red. El valor port=8000 establece el puerto. Ahora el servidor ofrece un punto final HTTP. FastMCP muestra la URL completa al iniciarse.

Paso 2. Copia los archivos al servidor

Conéctate a tu servidor remoto mediante SSH. En esta guía se utiliza un Droplet de DigitalOcean, ya que te ofrece acceso completo como root. Encontrarás la dirección IP en el panel de control del Droplet.

bash

ssh your-user@your-server-ip

Copia los archivos de tu proyecto al servidor. A continuación, entra en la carpeta del proyecto.

Paso 3. Instala los paquetes en el servidor

Instala uv en el servidor si aún no lo tienes. A continuación, instala los paquetes del proyecto.

bash

uv add fastmcp httpx

Paso 4. Mantén el servidor en marcha

Un comando normal se detiene cuando cierras la sesión SSH. Un servidor de producción debe estar siempre en marcha. Usa systemd para mantenerlo en marcha. systemd inicia el servidor, lo reinicia tras un fallo y lo vuelve a iniciar tras un reinicio del sistema.

Primero, busca la ruta completa a « uv »:

bash

which uv 

A continuación, crea un archivo de servicio en /etc/systemd/system/site-health.service. Usa tu propio nombre de usuario, la ruta del proyecto y la ruta de uv.

ini
[Unit]
Description=Site Health MCP Server
After=network.target
[Service]
User=your-user
WorkingDirectory=/home/your-user/site-health-mcp
ExecStart=/home/your-user/.local/bin/uv run server.py
Restart=always
[Install]
WantedBy=multi-user.target

A continuación, inicia el servicio y actívalo para que se ejecute al arrancar el sistema:

bash
sudo systemctl daemon-reload
sudo systemctl enable site-health
sudo systemctl start site-health

Comprueba que el servicio esté en marcha:

bash
sudo systemctl status site-health

Paso 5. Expone el servidor de forma segura

El servidor se ejecuta en un puerto del host. Para uso público, coloca el servidor detrás de un proxy inverso. El proxy inverso añade un certificado HTTPS y un nombre de dominio limpio. Dirige el dominio al puerto del servidor.

El punto final queda así:

texto

https://your-domain.com/mcp

Paso 6. Conecta un cliente a la URL en producción

Ahora conecta Cursor al servidor en producción. Usa el campo «url» en lugar de un comando local.

json

{
  "mcpServers": {
    "site-health": {
      "url":"https://your-domain.com/mcp"
    }
  }
}

Guarda el archivo. Cursor se conecta a tu servidor en producción. Las herramientas funcionan igual que antes, pero ahora el servidor se ejecuta en la nube.

Probar y depurar el servidor

FastMCP incluye una herramienta de prueba llamada MCP Inspector. Te ofrece una página web para probar tu servidor sin necesidad de un cliente de IA. Ejecuta este comando:

bash

fastmcp dev server.py

El comando abre el MCP Inspector en tu navegador. En el Inspector, puedes:

• Ver la lista de herramientas, recursos y indicaciones.
• Ejecutar una herramienta con datos de prueba.
• Leer el resultado.

Usa el Inspector para detectar problemas desde el principio. Es más rápido que una prueba a través de un cliente de IA completo.

Próximos pasos

Has creado un servidor MCP que funciona, lo has conectado a dos clientes de IA y lo has implementado en un servidor en producción. Para ir un paso más allá, prueba estas tareas:

• Añade autenticación. Protege el servidor remoto con un token antes de ponerlo a disposición del público.
• Añade más herramientas. Dota al servidor de nuevas capacidades, como una comprobación de DNS o un informe de uso del disco.
• Añade la gestión de errores. Muestra un mensaje claro cuando un sitio no funcione o una URL sea incorrecta.

También puedes saltarte la configuración y usar un servidor MCP gestionado. Para la gestión del alojamiento, el servidor MCP de Cloudways conecta tu cliente de IA a tu cuenta de Cloudways. Gestionas servidores y aplicaciones en un lenguaje sencillo, sin necesidad de una configuración personalizada. Es una buena opción cuando lo que quieres es el resultado, pero no el mantenimiento. Para verlo en acción, lee el plan de gestión de agencias MCP.