drasticstatic Arbeitskopie — Wird vom Fortuna-Handelssystem verwendet. Dies ist ein unabhängiges Repository, das aus einem lokalen Klon von hummingbot/mcp erstellt wurde. Upstream wird als Remote für freiwillige Vergleiche nachverfolgt — Änderungen werden vor der Anwendung überprüft.

# Check for upstream updates (review before applying)
git fetch upstream && git log upstream/main --oneline

MCP Hummingbot Server

Ein MCP-Server (Model Context Protocol), der es Claude und Gemini CLI ermöglicht, mit Hummingbot für den automatisierten Kryptowährungshandel über mehrere Börsen hinweg zu interagieren.

Installation & Konfiguration

Option 1: Verwendung von uv (Empfohlen für die Entwicklung)

1. uv installieren (falls noch nicht installiert):

   curl -LsSf https://astral.sh/uv/install.sh | sh

2. Klonen und Abhängigkeiten installieren:

   git clone https://github.com/hummingbot/mcp
   cd mcp
   uv sync

3. Eine .env-Datei erstellen:

   cp .env.example .env

4. Die .env-Datei bearbeiten mit Ihren Hummingbot-API-Zugangsdaten:

   HUMMINGBOT_API_URL=http://localhost:8000
   HUMMINGBOT_USERNAME=admin
   HUMMINGBOT_PASSWORD=admin

5. In Claude Code oder Gemini CLI konfigurieren:

   {
     "mcpServers": {
       "hummingbot-mcp": {
         "type": "stdio",
         "command": "uv",
         "args": [
           "--directory",
           "/path/to/mcp",
           "run",
           "main.py"
         ]
       }
     }
   }

   Hinweis: Stellen Sie sicher, dass Sie /path/to/mcp durch den tatsächlichen Pfad zu Ihrem MCP-Verzeichnis ersetzen.

Option 2: Verwendung von Docker (Empfohlen für die Produktion)

1. Eine .env-Datei erstellen:

   touch .env

2. Die .env-Datei bearbeiten mit Ihren Hummingbot-API-Zugangsdaten:

   HUMMINGBOT_API_URL=http://localhost:8000
   HUMMINGBOT_USERNAME=admin
   HUMMINGBOT_PASSWORD=admin

   Wichtig: Wenn Sie den MCP-Server in Docker ausführen und eine Verbindung zu einer Hummingbot-API auf Ihrem Host herstellen:

   • Linux: Verwenden Sie --network host (siehe unten), damit der Container auf localhost:8000 zugreifen kann.

   • Mac/Windows: Ändern Sie HUMMINGBOT_API_URL in http://host.docker.internal:8000.

3. Das Docker-Image abrufen:

   docker pull hummingbot/hummingbot-mcp:latest

4. In Claude Code oder Gemini CLI konfigurieren:

   Für Linux (unter Verwendung von --network host):

   {
     "mcpServers": {
       "hummingbot-mcp": {
         "type": "stdio",
         "command": "docker",
         "args": [
           "run",
           "--rm",
           "-i",
           "--network",
           "host",
           "--env-file",
           "/path/to/mcp/.env",
           "-v",
           "$HOME/.hummingbot_mcp:/root/.hummingbot_mcp",
           "hummingbot/hummingbot-mcp:latest"
         ]
       }
     }
   }

   Für Mac/Windows:

   {
     "mcpServers": {
       "hummingbot-mcp": {
         "type": "stdio",
         "command": "docker",
         "args": [
           "run",
           "--rm",
           "-i",
           "--env-file",
           "/path/to/mcp/.env",
           "-v",
           "$HOME/.hummingbot_mcp:/root/.hummingbot_mcp",
           "hummingbot/hummingbot-mcp:latest"
         ]
       }
     }
   }

   (Denken Sie daran, HUMMINGBOT_API_URL=http://host.docker.internal:8000 in Ihrer .env-Datei festzulegen)

   Hinweis: Stellen Sie sicher, dass Sie /path/to/mcp durch den tatsächlichen Pfad zu Ihrem MCP-Verzeichnis ersetzen.

Cloud-Bereitstellung mit Docker Compose

Für die Cloud-Bereitstellung, bei der sowohl die Hummingbot-API als auch der MCP-Server auf demselben Server laufen:

1. Eine .env-Datei erstellen:

   touch .env

2. Die .env-Datei bearbeiten mit Ihren Hummingbot-API-Zugangsdaten:

   HUMMINGBOT_API_URL=http://localhost:8000
   HUMMINGBOT_USERNAME=admin
   HUMMINGBOT_PASSWORD=admin

3. Eine docker-compose.yml erstellen:

   services:
     hummingbot-api:
       container_name: hummingbot-api
       image: hummingbot/hummingbot-api:latest
       ports:
         - "8000:8000"
       volumes:
         - ./bots:/hummingbot-api/bots
         - /var/run/docker.sock:/var/run/docker.sock
       environment:
         - USERNAME=admin
         - PASSWORD=admin
         - BROKER_HOST=emqx
         - DATABASE_URL=postgresql+asyncpg://hbot:hummingbot-api@postgres:5432/hummingbot_api
       networks:
         - emqx-bridge
       depends_on:
         - postgres
   
     mcp-server:
       container_name: hummingbot-mcp
       image: hummingbot/hummingbot-mcp:latest
       stdin_open: true
       tty: true
       env_file:
         - .env
       environment:
         - HUMMINGBOT_API_URL=http://hummingbot-api:8000
       depends_on:
         - hummingbot-api
       networks:
         - emqx-bridge
   
     # Include other services from hummingbot-api docker-compose.yml as needed
     emqx:
       container_name: hummingbot-broker
       image: emqx:5
       restart: unless-stopped
       environment:
         - EMQX_NAME=emqx
         - EMQX_HOST=node1.emqx.local
         - EMQX_CLUSTER__DISCOVERY_STRATEGY=static
         - EMQX_CLUSTER__STATIC__SEEDS=[emqx@node1.emqx.local]
         - EMQX_LOADED_PLUGINS="emqx_recon,emqx_retainer,emqx_management,emqx_dashboard"
       volumes:
         - emqx-data:/opt/emqx/data
         - emqx-log:/opt/emqx/log
         - emqx-etc:/opt/emqx/etc
       ports:
         - "1883:1883"
         - "8883:8883"
         - "8083:8083"
         - "8084:8084"
         - "8081:8081"
         - "18083:18083"
         - "61613:61613"
       networks:
         emqx-bridge:
           aliases:
             - node1.emqx.local
       healthcheck:
         test: [ "CMD", "/opt/emqx/bin/emqx_ctl", "status" ]
         interval: 5s
         timeout: 25s
         retries: 5
   
     postgres:
       container_name: hummingbot-postgres
       image: postgres:15
       restart: unless-stopped
       environment:
         - POSTGRES_DB=hummingbot_api
         - POSTGRES_USER=hbot
         - POSTGRES_PASSWORD=hummingbot-api
       volumes:
         - postgres-data:/var/lib/postgresql/data
       ports:
         - "5432:5432"
       networks:
         - emqx-bridge
       healthcheck:
         test: ["CMD-SHELL", "pg_isready -U hbot -d hummingbot_api"]
         interval: 10s
         timeout: 5s
         retries: 5
   
   networks:
     emqx-bridge:
       driver: bridge
   
   volumes:
     emqx-data: { }
     emqx-log: { }
     emqx-etc: { }
     postgres-data: { }

4. Bereitstellen:

   docker compose up -d

5. In Claude Code oder Gemini CLI konfigurieren, um eine Verbindung zum bestehenden Container herzustellen:

   {
     "mcpServers": {
       "hummingbot-mcp": {
         "type": "stdio",
         "command": "docker",
         "args": [
           "exec",
           "-i",
           "hummingbot-mcp",
           "uv",
           "run",
           "main.py"
         ]
       }
     }
   }

   Hinweis: Ersetzen Sie hummingbot-mcp durch Ihren tatsächlichen Containernamen. Sie können den Containernamen finden, indem Sie Folgendes ausführen:

   docker ps

Related MCP server: ai-trader

Serverkonfiguration

Beim ersten Start erstellt der Server eine Standardkonfiguration aus Umgebungsvariablen (oder verwendet http://localhost:8000 mit Standard-Zugangsdaten). Die Konfiguration wird in ~/.hummingbot_mcp/server.yml gespeichert.

Verwendung des configure_server-Tools

# Show the current server configuration
configure_server()

# Update the host and port
configure_server(host="192.168.1.100", port=8001)

# Update credentials
configure_server(username="admin", password="secure_password")

# Update everything at once
configure_server(
    name="production",
    host="prod-server",
    port=8000,
    username="admin",
    password="secure_password"
)

Nur die bereitgestellten Parameter werden geändert; weggelassene Parameter behalten ihre aktuellen Werte bei. Der Client verbindet sich nach jeder Aktualisierung automatisch neu.

Umgebungsvariablen

Die folgenden Umgebungsvariablen können in Ihrer .env-Datei für den MCP-Server festgelegt werden:

Hinweis: Verwenden Sie nach der Ersteinrichtung das configure_server-Tool, um die Serververbindung zu aktualisieren. Umgebungsvariablen werden nur verwendet, um die anfängliche Standardkonfiguration zu erstellen.

Anforderungen

• Python 3.11+

• Laufender Hummingbot-API-Server

• Gültige Hummingbot-API-Zugangsdaten

Verfügbare Tools

Der MCP-Server bietet Tools für:

Serververwaltung

• configure_server: Anzeigen oder Aktualisieren der aktiven Hummingbot-API-Serververbindung

  • Keine Parameter: Aktuelle Serverkonfiguration anzeigen

  • Beliebige Parameter: Aktualisieren und neu verbinden

  • Die Konfiguration bleibt in ~/.hummingbot_mcp/server.yml erhalten

Handels- & Kontoverwaltung

• Kontoverwaltung und Connector-Einrichtung

• Portfolio-Salden und -Verteilung

• Auftragserteilung und -verwaltung

• Positionsverwaltung

• Marktdaten (Preise, Orderbücher, Kerzen)

• Finanzierungssätze

• Bot-Bereitstellung und -verwaltung

• Controller-Konfiguration

Entwicklung

Um den Server im Entwicklungsmodus auszuführen:

uv run main.py

Um Tests auszuführen:

uv run pytest

Fehlerbehebung

Der MCP-Server bietet jetzt umfassende Fehlermeldungen, um bei der Diagnose von Verbindungs- und Authentifizierungsproblemen zu helfen:

Verbindungsfehler

Wenn Sie Fehlermeldungen sehen wie:

• ❌ Cannot reach Hummingbot API at <url> - Der API-Server läuft nicht oder ist nicht erreichbar

• ❌ Authentication failed when connecting to Hummingbot API - Falscher Benutzername oder falsches Passwort

• ❌ Failed to connect to Hummingbot API - Allgemeiner Verbindungsfehler

Die Fehlermeldungen enthalten:

• Die genaue verwendete URL

• Ihren konfigurierten Benutzernamen (Passwort ist maskiert)

• Spezifische Vorschläge zur Behebung des Problems

• Verweise auf Tools wie configure_server

Häufige Lösungen

1. API läuft nicht:

   • Stellen Sie sicher, dass Ihr Hummingbot-API-Server läuft

   • Überprüfen Sie, ob die API unter der konfigurierten URL erreichbar ist

2. Falsche Zugangsdaten:

   • Verwenden Sie das configure_server-Tool, um die Server-Zugangsdaten zu aktualisieren

   • Oder überprüfen Sie Ihre .env-Dateikonfiguration

3. Falsche URL:

   • Verwenden Sie das configure_server-Tool, um die Server-URL zu aktualisieren

   • Verwenden Sie für Docker auf Mac/Windows host.docker.internal anstelle von localhost

4. Docker-Netzwerkprobleme:

   • Verwenden Sie unter Linux --network host in Ihrer Docker-Konfiguration

   • Verwenden Sie unter Mac/Windows host.docker.internal:8000 als API-URL

Fehlerprävention

Der MCP-Server wird:

• Nicht wiederholen bei Authentifizierungsfehlern (401-Fehler) - er teilt Ihnen sofort mit, dass die Zugangsdaten falsch sind

• Wiederholen bei Verbindungsfehlern mit hilfreichen Nachrichten darüber, was möglicherweise falsch ist

• Kontext bereitstellen, ob Sie in Docker ausführen, und entsprechende Korrekturen vorschlagen

• Sie zu den richtigen Tools (configure_server) führen, um Probleme zu beheben