FastMCP y el SDK oficial de MCP para Python ya comparten una capa de protocolo, pero no una API. Este artículo los pone frente a frente en importaciones, autenticación, composición, pruebas, tamaño de instalación y costos de migración, para que elijas el adecuado para tu próximo servidor MCP.
Pegas from mcp.server.fastmcp import FastMCP de un tutorial en un proyecto nuevo, lo ejecutas y Python te responde con un ModuleNotFoundError. Tu configuración no tiene nada de malo. El SDK oficial cambió el nombre de esa clase, el proyecto independiente FastMCP siguió su propio camino y las dos bibliotecas ahora comparten nombre, una capa de protocolo y muchos desarrolladores confundidos.
Aquí va la respuesta corta. A octubre de 2026, el paquete oficial mcp está en 2.3.0 y el paquete independiente fastmcp en 4.0.11. Elige FastMCP cuando quieras composición de servidores, proxy, importación de OpenAPI, proveedores de autenticación integrados y un cliente de pruebas en proceso. Elige el SDK oficial de MCP cuando quieras el árbol de dependencias más pequeño, control directo sobre las primitivas del protocolo y ningún framework extra entre tu código y la especificación.
💡 Veredicto rápido: Si estás creando un servidor de Model Context Protocol que usarán usuarios reales y no lo tienes claro, empieza con FastMCP. En un servidor sencillo, pasar más adelante al SDK oficial es una edición de cinco minutos. Ir en sentido contrario implica reconstruir funciones que FastMCP te daba de serie.
Jeremiah Lowin creó FastMCP para que escribir un servidor MCP se sintiera como escribir una función normal de Python. Esa API de alto nivel fue tan buena que el SDK oficial de Python de Anthropic la incorporó en 2024 como FastMCP 1.0, en mcp.server.fastmcp. El proyecto independiente nunca se detuvo. Siguió publicando versiones con su propio nombre de paquete, llegó a la versión 3.0 GA el 18 de febrero de 2026 y se trasladó desde una cuenta personal de GitHub al repositorio de PrefectHQ/fastmcp cuando Prefect lo adoptó como infraestructura central.
Hoy lo mantienen Jeremiah Lowin y Nate Nowack bajo la licencia Apache-2.0. El proyecto afirma que impulsa cerca del 70 % de los servidores MCP en todos los lenguajes, una cifra autodeclarada que conviene tomar con cautela.
El SDK v2 oficializó la separación. La clase FastMCP incluida ahora es MCPServer, y la ruta de importación antigua se eliminó por completo:
# SDK v1 (bundled FastMCP, gone in v2)
from mcp.server.fastmcp import FastMCP
# SDK v2
from mcp.server import MCPServer
# Standalone FastMCP
from fastmcp import FastMCP
Si todavía necesitas el comportamiento antiguo, la línea v1 está en modo de mantenimiento. Instálala con uv add "mcp[cli]<2".
No tienes que elegir entre dos implementaciones rivales del protocolo. FastMCP 4 se basa en la misma capa de protocolo del SDK v2, así que la pregunta real es cuánto framework quieres colocar encima.
Así se comparan ambas en los aspectos que deciden la mayoría de los proyectos:
| Función | SDK oficial de MCP 2.3.0 | FastMCP 4.0.11 |
|---|---|---|
| Instalación | uv add "mcp[cli]" | uv add fastmcp |
| Clase del servidor | MCPServer | FastMCP |
| Importación | from mcp.server import MCPServer | from fastmcp import FastMCP |
| Versión de Python | 3.10+ | 3.10+ |
| Transportes | stdio, Streamable HTTP, SSE | stdio, HTTP, SSE |
| Estilo de decoradores | Solo @mcp.tool() | @mcp.tool o @mcp.tool() |
| Composición de servidores | No incluida | Montar servidores dentro de otros |
| Proxy a otros servidores | No incluido | Incluido |
| OpenAPI a herramientas | No incluido | OpenAPIProvider |
| Configuración de autenticación | Tres ajustes separados | Un proveedor auth= (JWT, OAuth, GitHub, Google) |
| Observabilidad | OpenTelemetry nativo | Hooks de middleware |
| Tamaño instalado | Unos 41 MB, 36 paquetes | Unos 65 MB, 66 paquetes |
| Mantenido por | El proyecto MCP | Prefect |
Las cifras de tamaño de instalación proceden de una prueba comparativa publicada el 5 de octubre de 2026, así que tus números variarán según la plataforma y los extras.
El código de los primeros pasos es casi idéntico. En ambas bibliotecas, las anotaciones de tipo se convierten en JSON Schema y las docstrings en descripciones de herramientas. Esta es la versión del SDK oficial:
from mcp.server import MCPServer
mcp = MCPServer("Demo")
@mcp.tool()
def add(a: int, b: int) -> int:
"""Add two numbers."""
return a + b
@mcp.resource("greeting://{name}")
def greeting(name: str) -> str:
"""Greet someone by name."""
return f"Hello, {name}!"
Y la versión de FastMCP:
from fastmcp import FastMCP
mcp = FastMCP("Demo")
@mcp.tool
def add(a: int, b: int) -> int:
"""Add two numbers."""
return a + b
@mcp.resource("greeting://{name}")
def greeting(name: str) -> str:
"""Greet someone by name."""
return f"Hello, {name}!"
if __name__ == "__main__":
mcp.run()
Con el extra cli del SDK puedes probar la primera usando mcp dev server.py. La segunda se ejecuta con un simple python server.py.
La mayoría de los errores de migración vienen de detalles como estos:
MCPServer del SDK requiere @mcp.tool(). Un @mcp.tool sin paréntesis provoca un TypeError. FastMCP acepta ambas formas."streamable-http". FastMCP lo llama "http".run().ctx.mcp_server en el SDK se convierte en ctx.fastmcp en FastMCP, y ctx.log(level, data) se convierte en ctx.log(message, level=...).El paquete oficial es la instalación más pequeña. En las mediciones de octubre de 2026, mcp 2.3.0 trajo 36 paquetes y unos 41 MB al site-packages, mientras que fastmcp 4.0.11 trajo 66 paquetes y unos 65 MB. Esa diferencia es el precio de los extras: proveedores de autenticación, herramientas de OpenAPI, proxy y la biblioteca cliente.
Por qué importa en la práctica:
El tiempo de importación en frío es un argumento más débil. Las mismas mediciones variaron mucho entre ejecuciones en una misma máquina, así que no elijas una biblioteca por unos cientos de milisegundos de arranque.
El SDK oficial mantiene una clase Server de bajo nivel junto a la amigable MCPServer. En la v2, cada manejador sigue una sola forma, async (ctx, params) -> result, sin decoradores y sin envoltura automática:
from mcp.server import Server, ServerRequestContext
from mcp.types import CallToolRequestParams, CallToolResult, TextContent
async def call_tool(ctx: ServerRequestContext, params: CallToolRequestParams) -> CallToolResult:
return CallToolResult(content=[TextContent(type="text", text="ok")])
server = Server("Bookshop", on_call_tool=call_tool)
Tú escribes el manejo de las solicitudes, lo que implica más código y más control. El SDK v2 también añade herramientas a nivel de protocolo, a las que llegas de forma más directa aquí:
Resolve y Elicit: un parámetro de herramienta que rellena una función que escribes, invisible para el modelo, y que puede detenerse y hacerle una pregunta al usuario a mitad de la llamada.Client de primera clase: from mcp import Client negocia la conexión por ti, sin ClientSession anidado ni inicialización manual.cache_hints en el servidor y soporte de caché en el cliente.La revisión del protocolo 2026-07-28 elimina el handshake initialize y los ID de sesión en Streamable HTTP, de modo que un balanceador de carga sencillo puede repartir solicitudes entre réplicas sin estado. Ambas bibliotecas se apoyan en la misma capa de protocolo, pero es en el SDK donde la configuras directamente.
La propuesta de FastMCP es sencilla: lo que de todos modos acabas escribiendo alrededor de un servidor, pero ya hecho.
FastMCP puede montar un servidor dentro de otro, de modo que un servidor de weather y un servidor de billing pueden vivir en módulos separados y aparecer aun así como un solo endpoint con prefijos de ruta. También puede hacer de proxy de un servidor MCP de terceros, lo que te permite envolver un servidor existente con tu propia autenticación. El SDK oficial no incluye ninguna de las dos funciones como característica integrada.
La versión 3.0 reconstruyó esto alrededor de los proveedores. Las herramientas ya no tienen que vivir en un solo archivo: un FileSystemProvider las encuentra en un directorio y las recarga cuando cambian.
Si tu empresa ya tiene una API REST, OpenAPIProvider convierte una especificación OpenAPI o una aplicación FastAPI en herramientas MCP sin tener que reescribir cada endpoint a mano.
La autenticación recibe el mismo tratamiento. FastMCP reúne los tres parámetros separados del SDK (token_verifier, auth_server_provider y auth=AuthSettings) en un único proveedor auth=, con soporte integrado para JWT, OAuth, GitHub y Google. Añadir el inicio de sesión con GitHub pasa a ser una cuestión de configuración en lugar de un proyecto de fin de semana. Las herramientas también pueden pedir ayuda al LLM del cliente mediante ctx.sample().
El Client de FastMCP acepta directamente un objeto servidor, así que la prueba se ejecuta en proceso, sin puertos, sin subprocesos y sin tiempos de espera inestables:
import asyncio
from fastmcp import Client, FastMCP
mcp = FastMCP("Demo")
@mcp.tool
def add(a: int, b: int) -> int:
return a + b
async def main():
async with Client(mcp) as client:
result = await client.call_tool("add", {"a": 2, "b": 3})
print(result.data) # 5
asyncio.run(main())
Las pruebas en proceso son una de las ventajas que destacan las notas de migración del propio FastMCP, y facilitan construir una suite de pytest rápida.
Ninguna de las dos opciones es gratuita. Ambas traen una factura que llega más tarde. Los equipos que eligen FastMCP pagan con versiones que cambian con frecuencia y un número mayor de dependencias, y los que eligen el SDK pagan con el código que escriben ellos mismos.
FastMCP pasó de la 3.0 GA de febrero de 2026 a la 4.0.11 en octubre, así que espera que las versiones principales lleguen rápido. Fija el rango en el archivo de proyecto, por ejemplo fastmcp>=4,<5, y lee las notas de la versión antes de cada actualización.
También instala unos 30 paquetes más que el SDK. Prefect vende una plataforma alojada, Horizon, para el despliegue y el control de acceso. La biblioteca en sí es Apache-2.0 y funciona en cualquier lugar donde puedas ejecutar Python.
Si estás actualizando un servidor v1, reserva tiempo de verdad. Las notas de la versión 2 enumeran estos cambios incompatibles:
mcp[ws]).McpError ahora es MCPError, y una MCPError lanzada dentro de una herramienta se convierte en un error de protocolo que el modelo nunca ve.mount_path ya no existe.httpx a httpx2.
Olvídate de buscar funciones y compara tu situación con esta tabla:
| Tu situación | Elige |
|---|---|
| Envolver una API REST existente o una aplicación FastAPI | FastMCP |
| Combinar varios servidores detrás de un solo endpoint | FastMCP |
| Añadir inicio de sesión con GitHub, Google u OAuth | FastMCP |
| Revisión estricta de dependencias en un entorno muy restringido | SDK oficial |
| Comportamiento de protocolo personalizado a nivel de manejador | SDK oficial |
| Prototipo de fin de semana con una sola herramienta | Cualquiera |
Imagina un equipo de tres personas que quiere que un asistente de IA lea su API interna de pedidos. Con una especificación OpenAPI ya disponible, OpenAPIProvider elimina la mayor parte del trabajo endpoint por endpoint, y el único proveedor auth= gestiona el inicio de sesión de la empresa. Ahora imagina un equipo de plataforma que construye una pasarela auditada y que debe superar una revisión estricta de dependencias. Ese equipo se decanta por el SDK y gana los manejadores de bajo nivel que necesita. Ningún equipo se equivocó. Partieron de restricciones distintas.
auth= en lugar de tres.@mcp.tool, más corto, y las pruebas rápidas en proceso.Resolve o Elicit directamente desde el paquete base.Las dos bibliotecas comparten una capa de protocolo, así que pasar de una a otra es sobre todo un trabajo mecánico. Ir del SDK a FastMCP tiene este aspecto:
- from mcp.server import MCPServer
+ from fastmcp import FastMCP
- mcp = MCPServer("orders")
+ mcp = FastMCP("orders")
- @mcp.tool()
+ @mcp.tool
Luego cambia "streamable-http" por "http" en tu llamada a run(), renombra ctx.mcp_server a ctx.fastmcp y une tus tres ajustes de autenticación en un solo proveedor. Si vas en sentido contrario, deshaz esos cambios y prevé sustituir la composición, el proxy y la importación de OpenAPI por código propio.
Ejecuta tus pruebas después de cada paso. Si las escribiste con un cliente en proceso, toda la comprobación tarda solo unos segundos.
Un servidor MCP solo es tan útil como lo que hay detrás de sus herramientas. Picasso IA ofrece un conector MCP y una API para desarrolladores de generación de imágenes, edición de imágenes y generación de video, de modo que un cliente como Claude Desktop puede crear recursos visuales a través de herramientas que nunca tuviste que construir. Esos trabajos son asíncronos: envías uno y luego consultas el resultado. Ese patrón de enviar y consultar también sirve para tus propios servidores, con una herramienta que devuelve un ID de trabajo y una segunda que comprueba su estado.
Puedes pedirle a un LLM que escriba el primer borrador de cualquiera de las dos versiones. Esta es la ruta rápida con Claude Sonnet 5, un modelo pensado para tareas de programación:
low para ediciones rápidas, o súbelo para un error complejo que afecte a varios archivos.Pide ambas versiones en una sola solicitud y compara tú mismo las diferencias. Si quieres una segunda opinión sobre el código, GPT 5.6 Sol está pensado para tareas de programación complejas y sirve bien como revisor.
Cuando tu servidor esté en marcha, dale algo divertido que hacer. Abre Picasso IA, prueba los modelos de imagen y de video y mira qué producen unos cuantos prompts bien escritos. Después conecta tu herramienta favorita a tu propio servidor MCP y deja que tu próximo proyecto cree sus propios recursos visuales. Tu primera imagen está a un prompt de distancia.
Elige tu idioma
