Wie man einen Open-Source, selbstgehosteten MCP-Server baut

Hey Leute, liebe Entwickler! Habt ihr jemals davon geträumt, euer eigenes KI-Kommandozentrum zu haben, einen Ort, an dem ihr Interaktionen zwischen verschiedenen KI-Modellen und euren Anwendungen orchestrieren könnt, und dabei eure Daten sicher und unter eurer Kontrolle behaltet? Nun, schnallt euch an, denn in diesem Artikel werden wir uns mit dem Aufbau eures eigenen, selbst gehosteten MCP-Servers mit guMCP – Gumloop's Unified Model Context Protocol – befassen.

Was genau ist das MCP, fragt ihr euch? Stellt es euch als eine universelle Sprache für KI vor. Es ist eine standardisierte Methode für verschiedene KI-Modelle und Anwendungen, um zu kommunizieren und Informationen auszutauschen. Das bedeutet, dass ihr komplexe Workflows erstellen könnt, in denen verschiedene KI-Modelle verschiedene Teile einer Aufgabe bearbeiten, und dabei alle nahtlos zusammenarbeiten. Und guMCP macht den Aufbau eures eigenen MCP-Servers unglaublich zugänglich.

💡

Bevor wir beginnen, hier ein schneller Tipp: Holt euch Apidog kostenlos! Es ist ein leistungsstarkes Tool für Entwickler, um MCP zu vereinfachen, KI-Modelle (insbesondere LLMs) zu testen und API-Tests zu optimieren. Probiert es noch heute For Free!

We’re thrilled to share that MCP support is coming soon to Apidog! 🚀

Apidog MCP Server lets you feed API docs directly to Agentic AI, supercharging your vibe coding experience! Whether you're using Cursor, Cline, or Windsurf - it'll make your dev process faster and smoother.… pic.twitter.com/ew8U38mU0K
— Apidog (@ApidogHQ) March 19, 2025

button

Ich weiß, es mag anfangs etwas entmutigend klingen, aber glaubt mir, es ist einfacher, als ihr denkt. Wir werden es in überschaubare Schritte aufteilen, sodass ihr auch dann folgen könnt, wenn ihr kein erfahrener DevOps-Guru seid. Lasst uns beginnen!

Was ist Gumloop Unified Model Context Protocol (guMCP)?

guMCP ist eine Open-Source-Implementierung des Model Context Protocol, die entwickelt wurde, um den Aufbau und die Bereitstellung eurer eigenen, selbst gehosteten MCP-Server zu erleichtern. Es bietet einen flexiblen Rahmen für die Verbindung von KI-Modellen und Anwendungen, sodass ihr leistungsstarke KI-gesteuerte Workflows erstellen könnt.

Warum selbst hosten? Selbsthosting gibt euch die vollständige Kontrolle über eure Daten und eure Infrastruktur und ist somit ideal für datenschutzsensible Anwendungen oder Situationen, in denen ihr den MCP-Server an spezifische Anforderungen anpassen müsst. Außerdem ist es eine fantastische Lerngelegenheit!

Warum einen eigenen MCP-Server erstellen?

Okay, ihr fragt euch vielleicht: "Warum sollte ich mir die Mühe machen, meinen eigenen MCP-Server zu erstellen? Gibt es nicht Cloud-basierte Lösungen, die dasselbe tun?" Das ist eine berechtigte Frage! Hier ist, warum Selbsthosting ein Game-Changer sein kann:

Datenschutz und Sicherheit: Das ist ein wichtiger Punkt. Wenn ihr selbst hostet, bleiben eure Daten auf euren Servern. Ihr seid nicht auf einen Drittanbieter angewiesen, um eure sensiblen Informationen zu schützen, was für Projekte, die mit persönlichen Daten, Finanzinformationen oder proprietären Algorithmen arbeiten, von entscheidender Bedeutung ist.
Anpassung und Kontrolle: Cloud-basierte Lösungen sind oft mit Einschränkungen verbunden. Selbsthosting ermöglicht es euch, den MCP-Server genau auf eure Bedürfnisse zuzuschneiden. Ihr könnt benutzerdefinierte Funktionen hinzufügen, euch in bestimmte APIs integrieren und die Leistung optimieren, um eure spezifischen Workflows zu optimieren.
Kosteneffizienz: Abhängig von euren Nutzungsmustern kann Selbsthosting kostengünstiger sein, als sich auf einen Cloud-Anbieter zu verlassen, insbesondere wenn ihr bereits über eine Infrastruktur und Fachkenntnisse verfügt.
Lernen und Experimentieren: Der Aufbau eures eigenen MCP-Servers ist eine fantastische Möglichkeit, mehr über KI-Infrastruktur, Netzwerke und Serveradministration zu erfahren. Es ist eine großartige Gelegenheit, eure Fähigkeiten zu erweitern und ein tieferes Verständnis dafür zu erlangen, wie diese Systeme funktionieren.

Voraussetzungen für guMCP

Bevor wir uns in den Installationsprozess stürzen, wollen wir sicherstellen, dass ihr alles habt, was ihr braucht. Keine Sorge, es ist keine lange Liste!

Python 3.11: Dieses Projekt erfordert Python 3.11 oder höher. Ihr könnt die neueste Version von der offiziellen Python-Website herunterladen.

Git: Git wird zum Klonen des Repositorys verwendet. Wenn ihr Git nicht installiert habt, könnt ihr es von der offiziellen Git-Website herunterladen.

Für Windows-Benutzer: Eine mit Bash kompatible Shell wird empfohlen. Dies könnte Git Bash (im Lieferumfang von Git für Windows enthalten) oder das Windows Subsystem for Linux (WSL) sein. Dies erleichtert das Befolgen der Befehle in diesem Tutorial.

guMCP-Installationsanleitung

Also gut, lasst uns loslegen! Befolgt diese Schritte sorgfältig, und ihr werdet euren guMCP-Server im Handumdrehen am Laufen haben.

Schritt 1: Klonen des guMCP-Repositorys

Zuerst müssen wir den guMCP-Code auf euren Rechner bringen. Öffnet euer Terminal (oder Git Bash, wenn ihr unter Windows arbeitet) und führt den folgenden Befehl aus:

git clone https://github.com/gumloop/guMCP.git
cd guMCP

Dadurch wird das guMCP-Repository von GitHub heruntergeladen und euer aktuelles Verzeichnis in den guMCP-Ordner geändert.

Schritt 2: Einrichten einer virtuellen Umgebung für guMCP

Eine virtuelle Umgebung ist wie eine Sandbox für euer Python-Projekt. Sie isoliert die Abhängigkeiten des Projekts von der Python-Installation eures Systems, verhindert Konflikte und stellt sicher, dass euer Projekt korrekt funktioniert. Dies ist Best Practice für die Python-Entwicklung.

Um eine virtuelle Umgebung zu erstellen, führt ihr die folgenden Befehle aus:

python -m venv venv

Dieser Befehl erstellt eine neue virtuelle Umgebung in einem Ordner namens venv. Jetzt müsst ihr die virtuelle Umgebung aktivieren. Der Aktivierungsbefehl hängt von eurem Betriebssystem ab:

Unter Unix/macOS:

source venv/bin/activate

Unter Windows (Eingabeaufforderung):

venv\Scripts\activate

Unter Windows (PowerShell):

.\venv\Scripts\Activate.ps1

Unter Windows (Git Bash):

source venv/Scripts/activate

Ihr wisst, dass eure virtuelle Umgebung aktiv ist, wenn ihr (venv) am Anfang eurer Eingabeaufforderung seht. Dies zeigt an, dass ihr innerhalb der isolierten Umgebung arbeitet.

Schritt 3: Installieren der guMCP-Abhängigkeiten

Da eure virtuelle Umgebung jetzt aktiv ist, könnt ihr die Abhängigkeiten des Projekts installieren. Dies sind die Bibliotheken und Pakete, auf die guMCP angewiesen ist, um korrekt zu funktionieren.

Führt den folgenden Befehl aus, um die Kernabhängigkeiten zu installieren:

pip install -r requirements.txt

Dieser Befehl verwendet pip (das Python-Paketinstallationsprogramm), um die Datei requirements.txt zu lesen und alle aufgelisteten Pakete zu installieren.

Wenn ihr plant, zum guMCP-Projekt beizutragen (was großartig ist!), solltet ihr auch die Entwicklungsabhängigkeiten installieren:

pip install -r requirements-dev.txt

Diese Abhängigkeiten werden für Tests, Linting und andere entwicklungsbezogene Aufgaben verwendet.

Schritt 4: Konfigurieren der Umgebungsvariablen für guMCP

Umgebungsvariablen werden verwendet, um Konfigurationseinstellungen zu speichern, auf die eure Anwendung zugreifen muss, z. B. API-Schlüssel, Datenbankanmeldeinformationen und andere sensible Informationen. Dadurch bleibt euer Code sauber und ihr vermeidet das Festcodieren von Geheimnissen direkt in eurer Anwendung.

guMCP verwendet eine .env-Datei, um Umgebungsvariablen zu verwalten. Um eine lokale Umgebungsvariable zu erstellen, führt ihr den folgenden Befehl aus:

cp .env.example .env

Dieser Befehl kopiert die Datei .env.example in eine neue Datei namens .env. Die Datei .env.example enthält eine Vorlage für die Umgebungsvariablen, die guMCP benötigt.

Jetzt müsst ihr die Datei .env in eurem bevorzugten Texteditor (z. B. VS Code) öffnen und die Werte nach Bedarf aktualisieren.

# Open and edit with vs code
code .env

# Open and edit in cursor
cursor .env

Die Datei .env enthält Konfigurationseinstellungen für Folgendes:

API-Schlüssel für Service-Integrationen: Wenn ihr plant, euch in Dienste von Drittanbietern wie OpenAI oder andere KI-Modellanbieter zu integrieren, müsst ihr die entsprechenden API-Schlüssel in der Datei .env angeben.
Authentifizierungseinstellungen: Ihr könnt Authentifizierungseinstellungen konfigurieren, um den Zugriff auf euren MCP-Server zu steuern. Dies kann das Einrichten von Benutzernamen, Passwörtern oder API-Schlüsseln für Clients umfassen, die mit dem Server interagieren möchten.
Serverkonfigurationsoptionen: Die Datei .env kann auch Einstellungen enthalten, die sich auf die Konfiguration des Servers beziehen, z. B. die Portnummer, auf der er lauscht, der Hostname und andere serverspezifische Parameter.
Einstellungen für die Entwicklungsumgebung: Einige Einstellungen können spezifisch für die Entwicklungsumgebung sein, z. B. Debugging-Flags oder Protokollierungsebenen.

Achtet darauf, die Datei .env sorgfältig zu überprüfen und mit den richtigen Werten für eure Umgebung zu aktualisieren. Übertragt eure .env-Datei niemals in die Versionskontrolle! Diese Datei enthält sensible Informationen, die nicht öffentlich weitergegeben werden sollten.

Verwenden von guMCP

Nachdem ihr guMCP installiert und konfiguriert habt, wollen wir sehen, wie man es verwendet! guMCP unterstützt zwei Haupttypen von Servern: SSE (Server-Sent Events)-Server und Stdio-Server. Lasst uns jeden von ihnen erkunden.

Ausführen von guMCP SSE-Servern

SSE-Server bieten eine einfache und effiziente Möglichkeit, Daten vom Server zum Client zu streamen. Im Kontext von guMCP wird dies häufig für Echtzeit-Updates und Benachrichtigungen verwendet.

guMCP stellt ein praktisches Skript bereit, um einen SSE-Entwicklungsserver lokal zu starten. Dieser Server hostet alle verfügbaren Server unter einer einzigen URL. Um den SSE-Entwicklungsserver zu starten, führt ihr den folgenden Befehl aus:

./start_sse_dev_server.sh

Dieses Skript startet den Server und gibt die URL in der Konsole aus. Standardmäßig wird der Server auf Port 8000 ausgeführt. Die URL lautet also in etwa: http://localhost:8000/simple-tools-server/local

Verwenden des Remote-MCP-Testclients

guMCP stellt auch einen Lightweight MCP-Client bereit, um eine Verbindung zu SSE-Servern herzustellen. Dieser Client ist nützlich zum Testen und Interagieren mit dem Server. Um den Client zu verwenden, führt ihr den folgenden Befehl aus:

python tests/clients/RemoteMCPTestClient.py --endpoint=http://localhost:8000/simple-tools-server/local

Ersetzt http://localhost:8000/simple-tools-server/local durch die tatsächliche URL eures SSE-Servers.

Dieser Befehl startet den MCP-Client und verbindet ihn mit dem angegebenen SSE-Server. Ihr könnt den Client dann verwenden, um Befehle an den Server zu senden und Antworten zu empfangen.

Ausführen von guMCP Stdio-Servern

Stdio-Server kommunizieren mit Clients über Standardeingabe- und -ausgabestreams. Dies ist ein traditionellerer Ansatz für die Serverkommunikation und wird häufig für Befehlszeilentools und -anwendungen verwendet.

Um einen Stdio-Server zu starten, führt ihr den folgenden Befehl aus:

python src/servers/local.py --server=simple-tools-server

Ersetzt simple-tools-server durch den Namen des Servers, den ihr ausführen möchtet.

Verwenden des guMCP Local MCP Test Clients

guMCP stellt einen Lightweight MCP-Client bereit, um Stdio-Server zu starten und eine Verbindung zu ihnen herzustellen. Um den Client zu verwenden, führt ihr den folgenden Befehl aus:

python tests/clients/LocalMCPTestClient.py --server=simple-tools-server

Ersetzt simple-tools-server durch den Namen des Servers, den ihr ausführen möchtet.

Dieser Befehl startet den MCP-Client und verbindet ihn mit dem angegebenen Stdio-Server. Ihr könnt den Client dann verwenden, um Befehle an den Server zu senden und Antworten zu empfangen.

Verstehen der guMCP-Serverkonfigurationen

Das Flag --server ist euer Schlüssel zur Auswahl, welche Tools und Funktionalitäten euer MCP-Server verfügbar macht. Stellt es euch so vor, als würdet ihr auswählen, welche Module in euer KI-Kommandozentrum geladen werden sollen. Im bereitgestellten Beispiel wird simple-tools-server verwendet, das wahrscheinlich eine grundlegende Reihe von Tools zum Testen und zur Demonstration bietet. guMCP ist jedoch modular aufgebaut, sodass ihr Serverkonfigurationen erstellen oder erweitern könnt, um spezialisiertere Funktionalitäten einzubeziehen.

Wenn ihr euch das Verzeichnis src/servers anseht, findet ihr Python-Dateien, die verschiedene Serverkonfigurationen definieren. Diese Dateien legen fest, welche Tools verfügbar sind, wie sie über das MCP verfügbar gemacht werden und welche spezifischen Abhängigkeiten sie erfordern. Durch die Untersuchung dieser Dateien könnt ihr ein Gefühl dafür bekommen, wie ihr euren Server anpassen und eure eigenen KI-gestützten Tools integrieren könnt.

Erweitern des guMCP-Toolkits: Erstellen eurer eigenen MCP-Tools

Die wahre Stärke von guMCP liegt in seiner Fähigkeit, mit euren eigenen benutzerdefinierten Tools erweitert zu werden. Stellt euch vor, ihr möchtet ein Tool erstellen, das Text mithilfe eines bestimmten KI-Modells zusammenfasst, oder eines, das mit einer bestimmten API interagiert. guMCP macht dies überraschend einfach.

Obwohl ein vollständiger Deep Dive in die Erstellung benutzerdefinierter Tools den Rahmen dieses einführenden Leitfadens sprengen würde, hier ein Vorgeschmack auf den Prozess:

Definiert euer Tool: Beginnt damit, die Funktionalität eures Tools zu umreißen. Welche Eingaben benötigt es? Welche Ausgabe erzeugt es?
Implementiert die Logik: Schreibt den Python-Code, der die gewünschte Aufgabe ausführt. Dies kann das Aufrufen der API eines KI-Modells, die Verarbeitung von Daten oder die Interaktion mit externen Diensten umfassen.
Integriert euch in guMCP: Verwendet die API von guMCP, um euer Tool zu registrieren und über das MCP zugänglich zu machen. Dies beinhaltet die Definition des Namens des Tools, der Eingabeparameter und des Ausgabeformats.
Konfiguriert den Server: Ändert eure Serverkonfigurationsdatei, um euer neues Tool einzubeziehen. Dadurch wird dem MCP-Server mitgeteilt, dass er euer Tool laden und für Clients verfügbar machen soll.

HiMCP.ai - Entdecke 1682+ MCP-Server

Durch die Erstellung eurer eigenen Tools könnt ihr guMCP an eure spezifischen Bedürfnisse anpassen und leistungsstarke KI-gestützte Workflows erstellen, die reale Probleme lösen.

Fazit: Eure Reise in die KI-Orchestrierung beginnt

Herzlichen Glückwunsch! Ihr habt erfolgreich euren eigenen, selbst gehosteten MCP-Server mit guMCP erstellt. Dies ist ein wichtiger Schritt, um das volle Potenzial der KI in euren Projekten auszuschöpfen.

Denkt daran, dies ist erst der Anfang. Erkundet die guMCP-Dokumentation, experimentiert mit verschiedenen Serverkonfigurationen und erstellt eure eigenen benutzerdefinierten Tools. Die Möglichkeiten sind endlos.

Durch das Selbsthosting eures MCP-Servers erhaltet ihr die vollständige Kontrolle über eure Daten, passt eure Workflows an und sammelt wertvolle Erfahrungen in der KI-Infrastruktur. Da sich die KI-Landschaft ständig weiterentwickelt, wird eine solide Grundlage in MCP und Selbsthosting ein wertvolles Gut sein. Also, geht hinaus und orchestriert eure KI-Träume!

button