MCP-Server in Python – Alles, was ich am ersten Tag gewusst hätte, hätte ich gewusst.

Einführung

Als Entwickler, der mit großen Sprachmodellen (LLMs) arbeitet, habe ich in den letzten Wochen mit Model Context Protocol (MCP) Servern experimentiert. Trotz des Hypes fand ich es anfangs schwierig, das Konzept zu verstehen, einen Server aufzubauen oder zu begreifen, wie es meinen Arbeitsablauf verbessern könnte. Diese Erfahrung ist vielen Entwicklern wahrscheinlich vertraut, die Schwierigkeiten haben, LLMs mit externen Tools und Datenquellen zu integrieren, was ihre Fähigkeit einschränkt, Aufgaben über die Textgenerierung hinaus auszuführen.

Nachdem ich Stunden damit verbracht habe, Dokumentationen zu lesen, Videos anzuschauen und durch Ausprobieren zu lernen, habe ich erfolgreich eine Handvoll benutzerdefinierter Server erstellt. Diese Server ermöglichen nun Aufgaben wie das Abfragen von Datenbanken, das Versenden von E-Mails und SMS sowie das Bereitstellen von Anwendungen auf DigitalOcean – alles nahtlos integriert in Cursor und Claude Desktop. Diese Integration löst das Problem, dass LLMs auf die Textgenerierung beschränkt sind, indem sie eine standardisierte Möglichkeit bietet, sie mit externen Tools und Datenquellen zu verbinden, was sie letztendlich leistungsfähiger und nützlicher macht.

Was Sie lernen werden

• Warum MCP wichtig ist.
• Wie man einen Python MCP-Server einrichtet.
• Wie man es in Cursor und Claude Desktop anschließt.
• Wie man ein einfaches SQLite-Abfrage-Tool schreibt.
• Wie man alles End-to-End testet.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie folgende Dinge haben:

• Python 3.7+ auf Ihrem System installiert.
• SQLite (mit einer community.db Datei).
• Cursor Pro und Claude Desktop.
• Ein Terminal (macOS/Linux) oder PowerShell/CMD (Windows).

Was ist MCP und warum brauchen wir es?

Große Sprachmodelle (LLMs) wie GPT oder Claude sind erstaunlich darin, Texte zu generieren, aber im Kern sagen sie nur das nächste Token in einer Sequenz voraus. Sie können von sich aus keine Dateien abrufen, keine Datenbank abfragen oder eigenständig reale Aktionen auslösen. Sie brauchen eine Brücke zur Außenwelt.

Das Model Context Protocol (MCP) ist ein offenes Protokoll, das standardisiert, wie Anwendungen Kontext an LLMs bereitstellen. Man kann es sich wie einen USB-C-Anschluss für KI-Anwendungen vorstellen: Genau wie USB-C einen universellen Weg bietet, um Ihre Geräte mit einer Vielzahl von Peripheriegeräten zu verbinden, bietet MCP eine standardisierte Verbindung für LLMs, um auf Datenquellen und externe Werkzeuge zuzugreifen. Kurz gesagt, gibt MCP Ihren LLMs die Fähigkeit, nicht nur zu chatten, sondern auch tatsächlich Dinge zu tun und mit der Welt außerhalb zu interagieren.

Wie die Teile zusammenpassen

Stell dir vor, du chattest mit einem LLM in einer Anwendung wie Cursor oder Claude Desktop - diese Anwendung ist dein Host. Es ist die Schnittstelle, die du siehst und mit der du interagierst.

Unter der Haube enthält jeder Host einen MCP Client, ein Stück Software, das das MCP-Protokoll spricht und weiß, wie man Anfragen an MCP-Server weiterleitet.

Aber hier wird es interessant - während das LLM (ob es sich um Claude, GPT oder ein anderes Modell handelt) großartig darin ist, Text zu generieren, kann es von sich aus keine SQLite-Datenbank abfragen, keine E-Mail senden oder eine SMS-API anrufen. Hier kommt der MCP-Server ins Spiel.

So funktioniert es Schritt für Schritt:

1. Sie senden eine Anfrage an das LLM in Ihrer Host-Anwendung (z. B. „Listen Sie die besten Chatter auf.“).

2. Das LLM (Kunde) verarbeitet Ihren Text und prüft, ob ein MCP-Tool für diese Anfrage verfügbar ist.

3. Wenn ein relevantes Tool konfiguriert ist, leitet der MCP-Client die Anfrage über das MCP-Protokoll an einen MCP-Server weiter.

4. Der MCP-Server führt die angeforderte Aufgabe aus:

   1. Es kann eine lokale Datenquelle abfragen, wie Ihre SQLite-Datenbank.
   2. Oder es kann Remote-Dienste anrufen, wie eine E-Mail- oder SMS-API.

5. Der Server gibt die Ergebnisse an den MCP-Client zurück, der sie an das LLM weiterleitet.

6. Das LLM formatiert dann diese Ergebnisse und präsentiert sie Ihnen in der Host-Anwendung.

Kurz gesagt, der Host stellt die Benutzeroberfläche bereit, der Client leitet Anfragen weiter, und der Server übernimmt die schwere Arbeit - er verbindet die Sprachfähigkeiten Ihrer KI mit realen Daten und Aktionen.

Unten ist ein vereinfachtes Diagramm, das zeigt, wie diese Komponenten interagieren:

Alles im Diagramm läuft auf deinem Computer. Deine Host-App (Cursor oder Claude Desktop) zeigt einfach auf den MCP-Server, den du lokal ausführst. Dieser Server kann mit deiner SQLite-Datenbank sprechen oder E-Mail/SMS-APIs aufrufen.

Erstellen Sie Ihren ersten MCP-Server

Lass uns einen lokalen MCP-Server in Python erstellen, der eine SQLite-Datenbank nach den aktivsten Chattern in einer Community abfragt. Du wirst mit deinem LLM in Cursor oder Claude Desktop chatten, und der Server wird die Datenbankarbeiten übernehmen.

Schritt 1 - Richten Sie Ihre Umgebung ein

• Erstellen Sie eine virtuelle Umgebung:

python -m venv mcp-env
source mcp-env/bin/activate  # For Windows: mcp-env\Scripts\activate

• Installieren Sie das MCP Python SDK:

pip install mcp

Schritt 2 - Greifen Sie auf die Beispieldatenbank zu

Lade community.db herunter (es enthält eine Tabelle mit Chatteilnehmern und Beispiel Daten).

Schritt 3: Schreiben Sie Ihren MCP-Server

Erstellen Sie eine Datei mit dem Namen sqlite-server.py und fügen Sie den folgenden Code ein:

sqlite-server.py
from mcp.server.fastmcp import FastMCP
import sqlite3

Initialize the MCP server with a friendly name
mcp = FastMCP("Community Chatters")

Define a tool to fetch the top chatters from the SQLite database
@mcp.tool()
def get_top_chatters():
    """Retrieve the top chatters sorted by number of messages."""
    # Connect to the SQLite database
    conn = sqlite3.connect('community.db')
    cursor = conn.cursor()
    
    # Execute the query to fetch chatters sorted by messages
    cursor.execute("SELECT name, messages FROM chatters ORDER BY messages DESC")
    results = cursor.fetchall()
    conn.close()
    
    # Format the results as a list of dictionaries
    chatters = [{"name": name, "messages": messages} for name, messages in results]
    return chatters

Run the MCP server locally
if __name__ == '__main__':
    mcp.run()

Dieser einfache Server definiert ein Werkzeug, get_top_chatters, das sich mit Ihrer SQLite-Datenbank verbindet, die sortierten Daten abruft und sie in einem leicht lesbaren Format zurückgibt.

Hinzufügen Ihres MCP-Servers zu Cursor

Sobald Ihr MCP-Server eingerichtet ist, besteht der nächste Schritt darin, ihn zu Ihrem Cursor-Client hinzuzufügen. So gehen Sie vor:

• Öffnen Sie Cursor → Einstellungen → MCP (erfordert Cursor Pro).

• Klicken Sie auf „Neuen globalen MCP-Server hinzufügen“, um die Konfigurationsdatei des MCP-Servers zu öffnen, die sich unter ~/.cursor/mcp.json befindet.

  

• Aktualisieren Sie die Datei mit den Details zu Ihrem Server. Diese Konfiguration weist Cursor an, Ihren lokalen MCP-Server auszuführen, wann immer Informationen über die Chatteilnehmer abgerufen werden müssen.

{
  "mcpServers": {
    "sqlite-server": {
      "command": "/path/to/your/project/venv/bin/python",
      "args": [
        "/path/to/your/project/sqlite-server.py"
      ],
      "description": "A simple MCP server to query top chatters from a community database"
    }
  }
}

• Speichern und zu den MCP-Einstellungen zurückkehren.
• Überprüfen Sie, ob Ihr Server und sein Tool aufgeführt sind. Sie sollten einen grünen Punkt neben dem Server sehen.

Testen Ihres MCP-Servers in Cursor

Nachdem dein Server zu Cursor hinzugefügt wurde, ist es Zeit, ihn zu testen:

1. Öffne einen Chat in Cursor und stelle eine Frage, wie zum Beispiel: „Wie viele Chatter sind in der Datenbank?“

   

2. Das LLM wird erkennen, dass es eine Aufgabe ausführen muss, die es nicht alleine bewältigen kann.

3. Ein Hinweis wird erscheinen, der um Ihre Erlaubnis bittet, das Tool auszuführen. Genehmigen Sie die Anfrage.

4. Der MCP-Server wird die SQLite-Datenbank abfragen, die Daten abrufen und sie zurücksenden. Die KI wird die Informationen dann im Chat präsentieren.

Wenn alles korrekt eingerichtet ist, sollten Sie die Anzahl der Chatter zusammen mit den Namen und Nachrichtenanzahlen angezeigt bekommen, was bestätigt, dass das Tool wie erwartet funktioniert.

Hinzufügen Ihres MCP-Servers zu Claude Desktop

Sie können Ihren MCP-Server auch mit Claude Desktop integrieren. So geht's:

• Öffnen Sie Claude Desktop → Einstellungen → Entwickler → Konfiguration bearbeiten.
• Fügen Sie denselben Serverblock zu claude_desktop_config.json hinzu
• Speichern, schließen und Claude Desktop erneut öffnen. Dieses Aktualisieren stellt sicher, dass die neue Konfiguration übernommen wird.

{
  "servers": [
    {
      "name": "Community Chatters Server",
      "command": "python",
      "args": ["server.py"],
      "description": "A simple MCP server to query top chatters from a community database"
    }
  ]
}

• Überprüfen Sie in den Einstellungen von Claude Desktop, ob der MCP-Server aufgeführt ist, und prüfen Sie, ob Sie ein Werkzeugsymbol im Chatfenster sehen, das anzeigt, dass externe Tools verbunden sind. Ein Klick auf dieses Symbol sollte weitere Details anzeigen.

  

Testen Ihres MCP-Servers in Claude Desktop

Jetzt, da Ihr Server zu Claude Desktop hinzugefügt wurde, lassen Sie uns ihn testen:

1. Öffnen Sie einen Chat in Claude Desktop und stellen Sie eine Frage wie: „Zeig mir die Liste der besten Chatter.“ Claude Desktop wird erkennen, dass die Anfrage ein externes Tool erfordert.

   

2. Es wird eine Eingabeaufforderung erscheinen, die um Ihre Erlaubnis bittet, das MCP-Tool auszuführen. Genehmigen Sie die Eingabeaufforderung.

3. Überprüfen Sie die Ausgabe: Der MCP-Server wird die Anfrage verarbeiten, die SQLite-Datenbank abfragen und die Daten zurückgeben, die dann von Claude Desktop angezeigt werden.

Dies zeigt, dass Ihr MCP-Server von zwei verschiedenen Host-Anwendungen - Cursor und Claude Desktop - zugänglich ist, wodurch sowohl GPT als auch Claude auf externe Daten für ihre Antworten zugreifen können.

Häufig gestellte Fragen

Was ist der Zweck des MCP-Servers in diesem Tutorial?

Der MCP-Server ist so konzipiert, dass er die SQLite-Datenbank abfragt und die Anzahl der Chatter, ihre Namen und die Nachrichtenanzahl an die Client-Anwendung, wie Cursor oder Claude Desktop, bereitstellt. Dies ermöglicht es der Client-Anwendung, die aktivsten Chatter in der Community anzuzeigen, was die Benutzererfahrung verbessert und wertvolle Einblicke bietet. Weitere Informationen zu den Funktionen des MCP-Servers finden Sie in der MCP-Server-Dokumentation.

Wie integriere ich meinen MCP-Server mit Claude Desktop?

Um Ihren MCP-Server mit Claude Desktop zu integrieren, müssen Sie den Serverblock zu claude_desktop_config.json hinzufügen, speichern, schließen und Claude Desktop erneut öffnen. Dadurch wird sichergestellt, dass die neue Konfiguration übernommen wird. Für eine Schritt-für-Schritt-Anleitung zur Integration Ihres MCP-Servers mit Claude Desktop, lesen Sie das Claude Desktop Integrationshandbuch.

Was ist die Bedeutung des MCP-Ökosystems?

Das MCP-Ökosystem überbrückt die Kluft zwischen großen Sprachmodellen (LLMs) und externen Datenquellen, wodurch die Integration externer Daten in KI-Antworten ermöglicht wird. Diese Integration ermöglicht genauere und informativere Antworten von KI-Modellen, wodurch sie in verschiedenen Anwendungen effektiver werden. Für ein tieferes Verständnis des MCP-Ökosystems und seiner Bedeutung, siehe die Übersicht über das MCP-Ökosystem.

Kann ich dieses Tutorial als Ausgangspunkt für fortgeschrittene MCP-Anwendungen verwenden?

Ja, dieses Tutorial bietet eine Grundlage für den Aufbau fortgeschrittener MCP-Anwendungen, wie das Versenden von E-Mails und SMS-Benachrichtigungen, das Bereitstellen von MCP-Servern auf Cloud-Plattformen und mehr. Die Fähigkeiten und Kenntnisse, die aus diesem Tutorial gewonnen werden, können auf eine Vielzahl von MCP-Anwendungen angewendet werden, wodurch es ein ausgezeichnetes Sprungbrett für weitere Erkundungen darstellt. Für Inspiration und Anleitung zum Bau fortgeschrittener MCP-Anwendungen konsultieren Sie die MCP-Anwendungsbeispiele.

Schlussfolgerung

In diesem umfassenden Tutorial haben wir MCP kennengelernt, eine standardisierte Schnittstelle, die die Lücke zwischen großen Sprachmodellen (LLMs) und externen Datenquellen überbrückt. Wir haben auch die Bedeutung von MCP, sein Ökosystem und den Prozess zum Aufbau eines grundlegenden MCP-Servers mit Python und SQLite gelernt.

Durch dieses Tutorial haben Sie praktische Erfahrungen im Einrichten einer virtuellen Umgebung, der Nutzung einer vorhandenen Datenbank, dem Erstellen eines minimalen MCP-Servers und der Integration mit einer Client-Anwendung wie Cursor gesammelt. Dieser Erfolg markiert den Beginn Ihrer MCP-Entwicklungsreise.

Wenn wir nach vorne blicken, sind die Möglichkeiten grenzenlos. Sie können fortschrittliche MCP-Anwendungen erstellen, wie das Versenden von E-Mails und SMS-Benachrichtigungen, das Bereitstellen von MCP-Servern auf Cloud-Plattformen wie DigitalOcean und mehr. Das MCP-Ökosystem ist riesig, und die Möglichkeiten zur Innovation sind unbegrenzt.

Wir hoffen, dass dieses Tutorial Sie inspiriert hat, weiterhin über MCP und dessen Anwendungen zu lernen. Viel Spaß beim Programmieren!