Tutorial de Fastapi-MCP para principiantes y expertos

¿Alguna vez te has opuesto con una situación en la que querías que tu chatbot use una utensilio y luego responda? Suena complicado, ¡verdad! Pero ahora, MCP (Protocolo de contexto del maniquí) Le ofrece una forma de integrar su LLM a herramientas externas fácilmente y el LLM podrá usar esas herramientas en todos los sentidos. En este tutorial, nos sumergiremos en el proceso de convertir una aplicación web simple hecha con FastAPI, alimentado por un servidor MCP, utilizando el FastAPI-MCP.

Fastapi con MCP

Fastapi es una utensilio muy simple integrada en Python que lo ayuda a crear aplicaciones web utilizando API. Está diseñado para ser practicable de usar y rápido al mismo tiempo. Piense en Fastapi como un camarero inteligente que toma su pedido (solicitudes HTTP), va a la cocina (saco de datos/servidor) y luego toma su pedido (salida) y luego se lo muestra. Es una gran utensilio para construir backends web, servicios para aplicaciones móviles, etc.

MCP es un protocolo en serie extenso de Anthrope que proporciona una funcionalidad para que el LLMS se comunique con fuentes y herramientas de datos externas. Piense en MCP como un kit de herramientas que proporciona la utensilio adecuada para la tarea dada. Estaríamos usando MCP para crear un servidor.

Ahora, ¿qué pasa si estas funcionalidades se dan a su LLM? ¡Hará que tu vida sea mucho más practicable! Es por eso que Fastapi para la integración de MCP ayuda mucho. Fastapi Se encarga de los servicios de diferentes fuentes y MCP se encarga del contexto de su LLM. Al usar FastAPI con MCP Server, podemos obtener llegada a cada utensilio implementada en la web y utilizarla como una utensilio LLM y hacer que los LLM hagan nuestro trabajo de guisa más eficaz.

En la imagen de hacia lo alto, podemos ver que hay un servidor MCP que está conectado a un punto final API. Este punto final API puede ser un punto final de Fastapi o cualquier otro servicio API de terceros apto en Internet.

¿Qué es Fastapi-MCP?

FastAPI-MCP es una utensilio que le permite convertir cualquier aplicación de Fastapi en alguna utensilio que LLMS como Chatgpt o Claude puede entender y usar fácilmente. Al usar FastAPI-MCP, puede envolver sus puntos finales de Fastapi de tal guisa que se convertirán en una utensilio de enchufe y reproducción en un ecosistema de IA que utiliza LLM.

Si desea entender cómo trabajar con MCP, lea este artículo sobre ¿Cómo usar MCP?

¿Qué API se pueden convertir en MCP usando FastAPI-MCP?

Con FastAPI-MCP, cualquier punto final de Fastapi se puede convertir en una utensilio MCP para LLM. Estos puntos finales deben incluir:

• Obtenga puntos finales: Convertido en posibles de MCP.
• Anunciar, poner, eliminar puntos finales: Convertido en herramientas MCP.
• Funciones de utilidad personalizadas: Se puede unir como herramientas adicionales de MCP

Fastapi-MCP es una biblioteca muy practicable de usar que descubre y convierte automáticamente estos puntos finales en MCP. Incluso conserva el esquema, así como la documentación de estas API.

Práctico usando Fastapi-MCP

Veamos un ejemplo simple sobre cómo convertir un punto final de Fastapi en un servidor MCP. En primer superficie, crearemos un punto final de Fastapi y luego avanzaremos para convertirlo en un Servidor MCP usando fastapi-mcp.

Configuración de Fastapi

1. Instale las dependencias

Haga que su sistema sea compatible instalando las dependencias requeridas.

pip install fastapi fastapi_mcp uvicorn mcp-proxy

2. Importar las dependencias requeridas

Haga un nuevo archivo con el nombre ‘main.py’, luego valor las siguientes dependencias en el interior de él.

from fastapi import FastAPI, HTTPException, Query

import httpx

from fastapi_mcp import FastApiMCP

3. Defina la aplicación Fastapi

Definamos una aplicación Fastapi con el nombre «API de actualizaciones meteorológicas».

app = FastAPI(title="Weather Updates API")

4. Definición de las rutas y funciones

Ahora, definiremos las rutas de nuestra aplicación, que denotarán qué punto final ejecutará qué función. Aquí, estamos haciendo una aplicación de puesta al día del clima usando clima.gov API (gratuitamente), que no requiere ninguna esencia API. Solo necesitamos apalear el https://api.weather.gov/points/{lathhth, {lon} con el valencia correcto de extensión y distancia.

Definimos una función get_weather que tomará un nombre o código de estado como argumento y luego encontramos las coordenadas correspondientes en el diccionario City_Coordinates y luego alcanzará la URL saco con esas coordenadas.

# Predefined latitude and longitude for major cities (for simplicity)
# In a production app, you could use a geocoding service like Nominatim or Google Geocoding API
CITY_COORDINATES = {
   "Los Angeles": {"lat": 34.0522, "lon": -118.2437},
   "San Francisco": {"lat": 37.7749, "lon": -122.4194},
   "San Diego": {"lat": 32.7157, "lon": -117.1611},
   "New York": {"lat": 40.7128, "lon": -74.0060},
   "Chicago": {"lat": 41.8781, "lon": -87.6298},
   # Add more cities as needed
}


@app.get("/weather")
async def get_weather(
   stateCode: str = Query(..., description="State code (e.g., 'CA' for California)"),
   city: str = Query(..., description="City name (e.g., 'Los Angeles')")
):
   """
   Retrieve today's weather from the National Weather Service API based on city and state
   """
   # Get coordinates (latitude, longitude) for the given city
   if city not in CITY_COORDINATES:
       raise HTTPException(
           status_code=404,
           detail=f"City '{city}' not found in predefined list. Please use another city."
       )
  
   coordinates = CITY_COORDINATES(city)
   lat, lon = coordinates("lat"), coordinates("lon")
  
   # URL for the NWS API Gridpoints endpoint
   base_url = f"https://api.weather.gov/points/{lat},{lon}"
  
   try:
       async with httpx.AsyncClient() as client:
           # First, get the gridpoint information for the given location
           gridpoint_response = await client.get(base_url)
           gridpoint_response.raise_for_status()
           gridpoint_data = gridpoint_response.json()
          
           # Retrieve the forecast data using the gridpoint information
           forecast_url = gridpoint_data("properties")("forecast")
           forecast_response = await client.get(forecast_url)
           forecast_response.raise_for_status()
           forecast_data = forecast_response.json()


           # Returning today's forecast
           today_weather = forecast_data("properties")("periods")(0)
           return {
               "city": city,
               "state": stateCode,
               "date": today_weather("startTime"),
               "temperature": today_weather("temperature"),
               "temperatureUnit": today_weather("temperatureUnit"),
               "forecast": today_weather("detailedForecast"),
           }
  
   except httpx.HTTPStatusError as e:
       raise HTTPException(
           status_code=e.response.status_code,
           detail=f"NWS API error: {e.response.text}"
       )
   except Exception as e:
       raise HTTPException(
           status_code=500,
           detail=f"Internal server error: {str(e)}"
       )

5. Configurar el servidor MCP

Convirtamos esta aplicación Fastapi en MCP ahora usando la biblioteca FastAPI-MCP. Este proceso es muy simple, solo necesitamos unir algunas líneas y el FastAPI-MCP convierte automáticamente los puntos finales en herramientas MCP y detecta su esquema y documentación fácilmente.

mcp = FastApiMCP(
   app,
   name="Weather Updates API",
   description="API for retrieving today's weather from weather.gov",
)
mcp.mount() 

6. Comenzando la aplicación

Ahora, agregue lo subsiguiente al final de su Pitón archivo.

if __name__ == "__main__":
   import uvicorn
   uvicorn.run(app, host="0.0.0.0", port=8000) 

Y vaya a Terminal y ejecute el archivo Main.py.

python main.py 

Ahora su aplicación Fastapi debería comenzar en localhost con éxito.

Configuración del cursor

Configuremos el IDE del cursor para probar nuestro servidor MCP.

1. Descargar cursor desde aquí https://www.cursor.com/downloads.
2. Instálelo, regístrese y llegue a la pantalla de inicio.

3. Ahora ve al Archivo Desde la mostrador de herramientas del encabezado. y haga clic en Preferencias Y luego en Configuración del cursor.

4. Desde la configuración del cursor, haga clic en MCP.

5. En la pestaña MCP, haga clic en Amplificar nuevo servidor MCP completo.
   Abrirá un mcp.json archivo. Pegue el subsiguiente código en él y guarde el archivo.

{
   "mcpServers": {
     "National Park Service": {
         "command": "mcp-proxy",
         "args": ("http://127.0.0.1:8000/mcp")
     }
   }
}

6. De envés en la configuración del cursor, debería ver lo subsiguiente:

Si está viendo esto en su pantalla, eso significa que su servidor se ejecuta correctamente y está conectado al IDE cursor. Si muestra algunos errores, intente usar el Reanudar clavija en la ángulo derecha.

Hemos configurado con éxito el servidor MCP en el IDE del cursor. Ahora, probemos el servidor.

Prueba del servidor MCP

Nuestro servidor MCP puede recuperar las actualizaciones meteorológicas. Solo tenemos que preguntarle al cursor IDE para la puesta al día del clima en cualquier ubicación, y lo obtendrá para nosotros usando el servidor MCP.

Consulta: «Por confianza dime cuál es el clima de hoy en San Diego«

Consulta: «¿El clima de Nueva York?«

Podemos ver en las horizontes que nuestro servidor MCP funciona admisiblemente. Solo necesitamos pedir los detalles del clima, decidirá por sí solo si usar el servidor MCP o no. En la segunda salida preguntamos vagamente «¿clima de Nueva York?» Fue capaz de realizar el contexto de la consulta en función de nuestro aviso antecedente, y utilizó las herramientas MCP apropiadas para objetar.

Conclusión

MCP permite LLMS Para aumentar sus capacidades de respuesta dando llegada a herramientas externas y Fastapi ofrece una guisa practicable de hacerlo. En esta dirección completa, combinamos ambas tecnologías utilizando la biblioteca FastAPI-MCP. Utilizando esta biblioteca, podemos convertir cualquier API en servidor MCP, lo que ayudará a los agentes LLMS y AI a obtener la información más nuevo de las API. No habrá obligación de especificar una utensilio personalizada para cada tarea nueva. MCP con Fastapi se encargará de todo automáticamente. La Revolución en el LLM fue presentada por la inclusión de MCP, y ahora, Fastapi emparejado con MCP está revolucionando la forma en que LLM está accediendo a estas herramientas.