FastMCP - Framework de Python para la Construcción Rápida de Servidores y Clientes MCP

Resumen del Proyecto

FastMCP es un framework de Python de alto nivel para construir servidores y clientes del Protocolo de Contexto del Modelo (MCP), diseñado para permitir a los desarrolladores crear herramientas, exponer recursos, definir prompts y conectar componentes de forma rápida y concisa. Este proyecto, desarrollado y mantenido por el usuario de GitHub jlowin, se ha convertido en una parte importante del ecosistema MCP.

¿Por qué elegir FastMCP?

Aunque el protocolo MCP es potente, su implementación requiere una gran cantidad de código boilerplate: configuración del servidor, manejadores de protocolo, tipos de contenido, gestión de errores, etc. FastMCP se encarga de todos los detalles complejos del protocolo y la gestión del servidor, permitiéndole centrarse en la creación de excelentes herramientas.

Los objetivos de diseño de FastMCP son:

• 🚀 Rápido: Una interfaz de alto nivel significa menos código y un desarrollo más rápido.
• 🍀 Sencillo: Construye servidores MCP con la mínima cantidad de código boilerplate.
• 🐍 Pythonic: Se siente natural para los desarrolladores de Python.
• 🔍 Completo: Proporciona una implementación completa de la especificación central de MCP, compatible con servidores y clientes.

Características Principales

Funcionalidades Básicas

• Cree servidores con decoradores intuitivos, con un mínimo de código boilerplate.
• Proxy de servidores existentes para modificar la configuración o el transporte.
• Combine servidores en aplicaciones complejas.
• Genere servidores a partir de especificaciones OpenAPI u objetos FastAPI.
• Interactúe programáticamente con servidores MCP.
• Conéctese a cualquier servidor MCP utilizando cualquier protocolo de transporte.
• Pruebe servidores sin intervención manual.
• Aproveche las funciones centrales de MCP, como el muestreo LLM.

Evolución de la Versión

¡FastMCP 1.0 hizo que la construcción de servidores MCP fuera tan sencilla que ahora forma parte del SDK oficial de Python del Protocolo de Contexto del Modelo!

FastMCP 2.0 se basa en esto introduciendo varias características nuevas:

• Funciones avanzadas como el proxy y la combinación de servidores MCP.
• Generación automática de servidores a partir de especificaciones OpenAPI u objetos FastAPI.
• Introducción de funciones de cliente, como el muestreo LLM.

Instalación

Se recomienda utilizar uv para instalar FastMCP:

uv pip install fastmcp

Instalación para desarrollo:

git clone https://github.com/jlowin/fastmcp.git
cd fastmcp

uv sync

Ejemplo de Inicio Rápido

Ejemplo de Servidor Básico

# server.py
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 get_greeting(name: str) -> str:
    """Get a personalized greeting"""
    return f"Hello, {name}!"

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

Instalar en Claude Desktop:

fastmcp install server.py

Explicación Detallada de los Conceptos Clave

1. Instancia FastMCP

Representa el objeto central de la aplicación MCP, gestionando las conexiones, los detalles del protocolo y el enrutamiento:

from fastmcp import FastMCP


mcp = FastMCP("My App")


mcp = FastMCP("My App", dependencies=["pandas", "numpy"])

2. Herramientas (Tools)

Permiten a los LLM realizar operaciones ejecutando funciones de Python, adecuadas para cálculos, llamadas a API externas o efectos secundarios:

import httpx
from pydantic import BaseModel

class UserInfo(BaseModel):
    user_id: int
    notify: bool = False

@mcp.tool()
async def send_notification(user: UserInfo, message: str) -> dict:
    """Sends a notification to a user if requested."""
    if user.notify:

        print(f"Notifying user {user.user_id}: {message}")
        return {"status": "sent", "user_id": user.user_id}
    return {"status": "skipped", "user_id": user.user_id}

@mcp.tool()
def get_stock_price(ticker: str) -> float:
    """Gets the current price for a stock ticker."""

    prices = {"AAPL": 180.50, "GOOG": 140.20}
    return prices.get(ticker.upper(), 0.0)

3. Recursos (Resources)

Exponen datos a los LLM, proporcionando principalmente información sin realizar cálculos significativos o efectos secundarios:

@mcp.resource("config://app-version")
def get_app_version() -> str:
    """Returns the application version."""
    return "v2.1.0"


@mcp.resource("db://users/{user_id}/email")
async def get_user_email(user_id: str) -> str:
    """Retrieves the email address for a given user ID."""

    emails = {"123": "alice@example.com", "456": "bob@example.com"}
    return emails.get(user_id, "not_found@example.com")

4. Prompts

Definen plantillas o patrones de interacción reutilizables:

from fastmcp.prompts.base import UserMessage, AssistantMessage

@mcp.prompt()
def ask_review(code_snippet: str) -> str:
    """Generates a standard code review request."""
    return f"Please review the following code snippet for potential bugs and style issues:\n```python\n{code_snippet}\n```"

@mcp.prompt()
def debug_session_start(error_message: str) -> list[Message]:
    """Initiates a debugging help session."""
    return [
        UserMessage(f"I encountered an error:\n{error_message}"),
        AssistantMessage("Okay, I can help with that. Can you provide the full traceback and tell me what you were trying to do?")
    ]

Funciones Avanzadas

1. Servidor Proxy

Cree un servidor FastMCP que actúe como intermediario, haciendo proxy de las peticiones a otro endpoint MCP:

import asyncio
from fastmcp import FastMCP, Client
from fastmcp.client.transports import PythonStdioTransport


proxy_client = Client(
    transport=PythonStdioTransport('path/to/original_stdio_server.py'),
)


proxy = FastMCP.from_client(proxy_client, name="Stdio-to-SSE Proxy")

if __name__ == "__main__":
    proxy.run(transport='sse')

2. Composición de Servidores

Construya grandes aplicaciones MCP creando servidores FastMCP modulares y "montándolos" en un servidor padre:

from fastmcp import FastMCP


weather_mcp = FastMCP("Weather Service")

@weather_mcp.tool()
def get_forecast(city: str):
    return f"Sunny in {city}"


news_mcp = FastMCP("News Service")

@news_mcp.tool()
def fetch_headlines():
    return ["Big news!", "Other news"]


mcp = FastMCP("Composite")
mcp.mount("weather", weather_mcp) 
mcp.mount("news", news_mcp)        

3. Generación de Servidores a partir de APIs

Genere automáticamente servidores FastMCP a partir de APIs Web existentes:

from fastapi import FastAPI
from fastmcp import FastMCP


fastapi_app = FastAPI(title="My Existing API")

@fastapi_app.get("/status")
def get_status():
    return {"status": "running"}


mcp_server = FastMCP.from_fastapi(fastapi_app)

4. Funcionalidad de Cliente

Interactúe con cualquier servidor MCP:

from fastmcp import Client

async with Client("path/to/server") as client:

    result = await client.call_tool("weather", {"location": "San Francisco"})
    print(result)
    

    res = await client.read_resource("db://users/123/profile")
    print(res)

Ejecutar el Servidor

Modo de Desarrollo

fastmcp dev your_server_file.py

Instalación en Producción

fastmcp install your_server_file.py

Ejecución Directa

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

Proyectos de Ejemplo

El proyecto contiene varios archivos de ejemplo:

• simple_echo.py: Herramientas, recursos y prompts básicos.
• complex_inputs.py: Utiliza modelos Pydantic como entrada de herramientas.
• mount_example.py: Monta múltiples servidores FastMCP.
• sampling.py: Utiliza la finalización LLM en un servidor MCP.
• screenshot.py: Herramienta que devuelve objetos Image.
• text_me.py: Herramienta que interactúa con una API externa.
• memory.py: Ejemplo complejo con interacción con la base de datos.

Guía de Contribución

FastMCP agradece las contribuciones de la comunidad:

Requisitos del Entorno

• Python 3.10+
• Gestor de paquetes uv

Configuración de Desarrollo

git clone https://github.com/jlowin/fastmcp.git && cd fastmcp
uv venv && uv sync

Pruebas

uv run pytest -vv

Calidad del Código

Utilice ruff y pre-commit:

pre-commit install
pre-commit run --all-files

Significado del Proyecto

FastMCP llena el vacío entre la implementación del protocolo MCP y el desarrollo de aplicaciones reales, permitiendo a los desarrolladores:

1. Prototipar e implementar rápidamente servidores MCP.
2. Integrar fácilmente APIs y fuentes de datos existentes.
3. Construir arquitecturas de aplicaciones de IA modulares y escalables.
4. Centrarse en la lógica de negocio en lugar de los detalles de la implementación del protocolo.