Fastapi-MCP-Tutorial für Anfänger und Experten

Sind Sie jemals auf eine State of affairs gestoßen, in der Sie wollten, dass Ihr Chatbot ein Software verwendet und dann antwortet? Klingt kompliziert, richtig! Aber jetzt, MCP (Modellkontextprotokoll) Bietet Ihnen eine Möglichkeit, Ihre LLM einfach in externe Instruments zu integrieren, und das LLM kann diese Instruments in jeder Hinsicht verwenden. In diesem Tutorial werden wir in den Prozess des Konvertierens einer einfachen Net-App eingehen, die mit Fastapi, die von einem MCP-Server mithilfe des FastAPI-MCP betrieben wird, konvertieren.

Fastapi mit MCP

Fastapi ist ein sehr einfaches Software in Python, mit dem Sie Webanwendungen mit APIs erstellen können. Es ist so konzipiert, dass es gleichzeitig einfach zu bedienen und schnell zu bedienen ist. Stellen Sie sich Fastapi als einen intelligenten Kellner vor, der Ihre Bestellung aufnimmt (HTTP -Anfragen), geht in die Küche (Datenbank/Server) und dann Ihre Bestellung (Ausgabe) und zeigt ihn dann an. Es ist ein großartiges Software zum Erstellen von Net -Backends, Diensten für cellular Apps usw.

MCP ist ein offenes Standardprotokoll von Anthropic, das den LLMs eine Funktionalität bietet, mit externen Datenquellen und Instruments zu kommunizieren. Stellen Sie sich MCP als Toolkit vor, das das richtige Werkzeug für die angegebene Aufgabe bietet. Wir verwenden MCP zum Erstellen eines Servers.

Was ist nun, wenn diese Funktionen Ihrem LLM gegeben werden? Es wird Ihr Leben viel einfacher machen! Deshalb hilft Fastapi to MCP Integration sehr. Fastapi kümmert sich um die Dienste aus verschiedenen Quellen und MCP kümmert sich um den Kontext Ihres LLM. Durch die Verwendung von Fastapi mit MCP Server können wir auf jedes über das Net bereitgestellte Software zugreifen und dies als LLM -Software nutzen und die LLMs unsere Arbeit effizienter erledigen.

Im obigen Bild können wir sehen, dass es einen MCP -Server gibt, der mit einem API -Endpunkt verbunden ist. Dieser API -Endpunkt kann ein Fastapi -Endpunkt oder ein anderer API -Dienst von Drittanbietern sein, der im Web verfügbar ist.

Was ist Fastapi-MCP?

Fastapi-MCP ist ein Software, mit dem Sie jede Fastapi-Anwendung in ein Software umwandeln können, das LLMs mögen Chatgpt oder Claude kann leicht verstehen und verwenden. Durch die Verwendung von Fastapi-MCP können Sie Ihre Fastapi-Endpunkte so einwickeln, dass sie in einem AI-Ökosystem ein Plug-and-Play-Software mit LLMs werden.

Wenn Sie wissen möchten, wie man mit MCP arbeitet, lesen Sie diesen Artikel über Wie benutze ich MCP?

Welche APIs kann mit Fastapi-MCP in MCP konvertiert werden?

Bei Fastapi-MCP kann jeder FastAPI-Endpunkt in ein MCP-Software für LLMs konvertiert werden. Diese Endpunkte sollten enthalten:

• Endpunkte erhalten: In MCP -Ressourcen umgewandelt.
• Put up, setzen, Endpunkte löschen: In MCP -Instruments umgewandelt.
• Benutzerdefinierte Dienstprogrammfunktionen: Kann als zusätzliche MCP -Instruments hinzugefügt werden

Fastapi-MCP ist eine sehr benutzerfreundliche Bibliothek, die diese Endpunkte automatisch entdeckt und in MCP umwandelt. Es bewahrt auch das Schema sowie die Dokumentation dieser APIs.

Praktisch mit Fastapi-MCP

Schauen wir uns ein einfaches Beispiel zum Umwandeln eines Fastapi -Endpunkts in einen MCP -Server an. Zuerst erstellen wir einen Fastapi -Endpunkt und bewegen uns dann in eine Umwandlung in a MCP -Server Verwendung fastapi-mcp.

Fastapi konfigurieren

1. Installieren Sie die Abhängigkeiten

Machen Sie Ihr System kompatibel, indem Sie die erforderlichen Abhängigkeiten installieren.

pip set up fastapi fastapi_mcp uvicorn mcp-proxy

2. Importieren Sie die erforderlichen Abhängigkeiten

Erstellen Sie eine neue Datei mit dem Namen ‚predominant.py‘ und importieren Sie die folgenden Abhängigkeiten darin.

from fastapi import FastAPI, HTTPException, Question

import httpx

from fastapi_mcp import FastApiMCP

3. Definieren Sie die Fastapi -App

Definieren wir eine Fastapi -App mit dem Namen „Climate Updates API“.

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

4. Definieren der Routen und Funktionen

Jetzt werden wir die Routen für unsere App definieren, die bezeichnen, welcher Endpunkt die Funktion ausführen wird. Hier erstellen wir eine Wetter -Replace -App mithilfe wetter.gov API (frei), für die kein API -Schlüssel erforderlich ist. Wir müssen nur die treffen https://api.climate.gov/factors/erlat}, {lon} mit dem richtigen Wert von Breitengrad und Längengrad.

Wir haben eine Get_Weather -Funktion definiert, die einen Staatsnamen oder Code als Argument nimmt und dann die entsprechenden Koordinaten im Wörterbuch von City_Coordinaten ermittelt und dann mit diesen Koordinaten die Foundation -URL geschlagen hat.

# Predefined latitude and longitude for main cities (for simplicity)
# In a manufacturing app, you can 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 extra cities as wanted
}


@app.get("/climate")
async def get_weather(
   stateCode: str = Question(..., description="State code (e.g., 'CA' for California)"),
   metropolis: str = Question(..., description="Metropolis identify (e.g., 'Los Angeles')")
):
   """
   Retrieve right this moment's climate from the Nationwide Climate Service API based mostly on metropolis and state
   """
   # Get coordinates (latitude, longitude) for the given metropolis
   if metropolis not in CITY_COORDINATES:
       elevate HTTPException(
           status_code=404,
           element=f"Metropolis '{metropolis}' not present in predefined record. Please use one other metropolis."
       )
  
   coordinates = CITY_COORDINATES(metropolis)
   lat, lon = coordinates("lat"), coordinates("lon")
  
   # URL for the NWS API Gridpoints endpoint
   base_url = f"https://api.climate.gov/factors/{lat},{lon}"
  
   strive:
       async with httpx.AsyncClient() as consumer:
           # First, get the gridpoint data for the given location
           gridpoint_response = await consumer.get(base_url)
           gridpoint_response.raise_for_status()
           gridpoint_data = gridpoint_response.json()
          
           # Retrieve the forecast knowledge utilizing the gridpoint data
           forecast_url = gridpoint_data("properties")("forecast")
           forecast_response = await consumer.get(forecast_url)
           forecast_response.raise_for_status()
           forecast_data = forecast_response.json()


           # Returning right this moment's forecast
           today_weather = forecast_data("properties")("durations")(0)
           return {
               "metropolis": metropolis,
               "state": stateCode,
               "date": today_weather("startTime"),
               "temperature": today_weather("temperature"),
               "temperatureUnit": today_weather("temperatureUnit"),
               "forecast": today_weather("detailedForecast"),
           }
  
   besides httpx.HTTPStatusError as e:
       elevate HTTPException(
           status_code=e.response.status_code,
           element=f"NWS API error: {e.response.textual content}"
       )
   besides Exception as e:
       elevate HTTPException(
           status_code=500,
           element=f"Inside server error: {str(e)}"
       )

5. MCP Server einrichten

Konvertieren wir diese Fastapi-App jetzt mit der Fastapi-MCP-Bibliothek in MCP. Dieser Vorgang ist sehr einfach, wir müssen nur ein paar Zeilen von FastAPI-MCP hinzufügen, um die Endpunkte automatisch in MCP-Instruments umzuwandeln und sein Schema und die Dokumentation leicht zu erkennen.

mcp = FastApiMCP(
   app,
   identify="Climate Updates API",
   description="API for retrieving right this moment's climate from climate.gov",
)
mcp.mount() 

6. Starten Sie die App

Fügen Sie nun Folgendes am Ende Ihrer hinzu Python Datei.

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

Und gehen Sie zum Terminal und führen Sie die Essential.Py -Datei aus.

python predominant.py 

Jetzt sollte Ihre Fastapi -App in Localhost erfolgreich beginnen.

Cursor konfigurieren

Konfigurieren wir die Cursor -IDE zum Testen unseres MCP -Servers.

1. Obtain Cursor von hier https://www.cursor.com/downloads.
2. Installieren Sie es, melden Sie sich an und gelangen Sie zum Startbildschirm.

3. Jetzt geh zum Datei Aus der Header -Symbolleiste. und klicken Sie auf Vorlieben und dann weiter Cursoreinstellungen.

4. Klicken Sie aus den Cursoreinstellungen auf MCP.

5. Klicken Sie auf der Registerkarte MCP auf Fügen Sie einen neuen globalen MCP -Server hinzu.
   Es wird a öffnen McP.json Datei. Fügen Sie den folgenden Code ein und speichern Sie die Datei.

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

6. Zurück bei den Cursoreinstellungen sollten Sie Folgendes sehen:

Wenn Sie dies auf Ihrem Bildschirm sehen, bedeutet dies, dass Ihr Server erfolgreich ausgeführt und mit dem verbunden ist Cursor IDE. Wenn es einige Fehler anzeigt, versuchen Sie es mit dem neu starten Style in der rechten Ecke.

Wir haben den MCP -Server erfolgreich in der Cursor -IDE eingerichtet. Lassen Sie uns nun den Server testen.

Testen des MCP -Servers

Unser MCP -Server kann die Wetteraktualisierungen abrufen. Wir müssen nur die Cursor -IDE nach dem Wetter -Replace an jedem Ort bitten, und es wird dies für uns mit dem MCP -Server abrufen.

Abfrage: “Bitte sagen Sie mir, was das heutige Wetter in San Diego ist”

Abfrage: “New Yorker Wetter?”

Wir können aus den Ausgängen sehen, dass unser MCP -Server intestine funktioniert. Wir müssen nur nach den Wetterdaten fragen, und entscheidet für sich, ob MCP Server verwendet werden soll oder nicht. In der zweiten Ausgabe fragten wir vage „New Yorker Wetter?“ Es struggle in der Lage, den Kontext der Abfrage basierend auf unserer vorherigen Eingabeaufforderung zu erkennen, und verwendete die entsprechenden MCP -Instruments, um zu beantworten.

Abschluss

MCP erlaubt Llms Um ihre Antwortkapazitäten zu erhöhen, indem Sie Zugriff auf externe Instruments erhalten, und Fastapi bietet eine einfache Möglichkeit, dies zu tun. In diesem umfassenden Leitfaden haben wir beide Technologien mit der Fastapi-MCP-Bibliothek kombiniert. Mit dieser Bibliothek können wir jede API in MCP -Server umwandeln, wodurch die LLM- und AI -Agenten helfen, die neuesten Informationen von den APIs zu erhalten. Für jede neue Aufgabe muss kein benutzerdefiniertes Software definiert werden. MCP mit Fastapi kümmert sich automatisch um alles. Die Revolution in den LLMs wurde durch die Einführung von MCP gebracht, und jetzt revolutioniert Fastapi mit MCP die Artwork und Weise, wie LLMs auf diese Instruments zugreifen.

Harsh Mishra ist ein KI/ML -Ingenieur, der mehr Zeit damit verbringt, mit großen Sprachmodellen zu sprechen als mit tatsächlichen Menschen. Leidenschaft über Genai, NLP und Maschinen schlauer (damit sie ihn noch nicht ersetzen). Wenn er Fashions nicht optimiert, optimiert er wahrscheinlich seine Kaffeeaufnahme. 🚀☕