Docker

Das Image simonclye/clye-ai-hub-gateway enthält die CLYE CLI. Es startet standardmäßig eine Sandbox, die sich mit CLYE AI verbindet. Andere Befehle (Connectoren, Share-Folder, …) brauchst du nur, wenn du den Default gezielt überschreibst.

Verwandt: Konfiguration · Sandbox · MCP-Registrierung · Filesystem-Connector · Share-Folder

Was passiert beim Start?

Der Image-Entrypoint ist fest verdrahtet:

ai-hub-container-entrypoint clye sandbox

Situation	Tatsächlicher Befehl im Container	Verbindung zu CLYE AI
`docker run … image` (ohne Extra-Args)	`… clye sandbox`	Ja – über `AI_HUB_URL` / `AI_HUB_API_KEY`
Extra-Args ohne `--entrypoint` (z. B. `--workspace /workspace`)	`… clye sandbox --workspace /workspace`	Ja – Args hängen an `sandbox`
Anderer Befehl mit `--entrypoint ai-hub-container-entrypoint` + `clye mcp clye …`	`… clye mcp clye <connector> …`	Ja – `mcp` proxyt zum Hub
Anderer Befehl mit `--entrypoint …` + `clye <connector> …` (ohne `mcp`)	nur stdio-Server	Nein – URL/Key werden ignoriert
Args ohne `--entrypoint` (z. B. `filesystem-connector …`)	`… clye sandbox filesystem-connector …`	Falsch – kein eigener Connector-Start

Kurz:

Default = Sandbox → Hub-Anbindung ist eingebaut (Sandbox).
Anderer Befehl → immer --entrypoint ai-hub-container-entrypoint und danach den vollständigen clye …-Befehl.
Stdio-Connector für den Hub → immer clye mcp clye <connector> … (MCP-Registrierung).

docker pull simonclye/clye-ai-hub-gateway:latest
docker run -e AI_HUB_URL="https://clye.ai" \
           -e AI_HUB_API_KEY="dein-api-key" \
           simonclye/clye-ai-hub-gateway:latest

https://clye.ai ist der Doku-Platzhalter; über API Daten eintragen in der oberen Leiste ersetzt du ihn in allen Beispielen (Konfiguration).

Verfügbare Tags: latest, Semver (1, 1.0, 1.0.6, …), Branch-/Timestamp-Tags.

Anderen Befehl starten

docker run --rm \
  -e AI_HUB_URL="https://clye.ai" \
  -e AI_HUB_API_KEY="dein-api-key" \
  --entrypoint ai-hub-container-entrypoint \
  simonclye/clye-ai-hub-gateway:latest \
  clye mcp clye <connector> …

--entrypoint ai-hub-container-entrypoint behält den Runtime-Wrapper (Caches, Home-Verzeichnis) und ersetzt nur den Default-sandbox.

Lokale Verzeichnisse einbinden

Ohne Volume-Mount sieht der Container nur sein eigenes Dateisystem. Lokale Ordner bindest du mit -v / --volume ein: HOST_PFAD:CONTAINER_PFAD. Im Container arbeitest du dann mit dem rechten Pfad (z. B. /workspace).

Ein Projektverzeichnis mounten (Default-Sandbox)

docker run --rm \
  -e AI_HUB_URL="https://clye.ai" \
  -e AI_HUB_API_KEY="dein-api-key" \
  -v "$PWD:/workspace" \
  -w /workspace \
  simonclye/clye-ai-hub-gateway:latest

-v "$PWD:/workspace" macht das aktuelle Host-Verzeichnis im Container unter /workspace sichtbar.
-w /workspace setzt das Arbeitsverzeichnis für Python-/Terminal-Tools.
Änderungen im Container landen direkt auf dem Host (und umgekehrt).
Kein --entrypoint nötig: der Default sandbox verbindet sich selbst mit dem Hub.

Absoluter Host-Pfad:

docker run --rm \
  -e AI_HUB_URL="https://clye.ai" \
  -e AI_HUB_API_KEY="dein-api-key" \
  -v /home/you/mein-projekt:/workspace \
  -w /workspace \
  simonclye/clye-ai-hub-gateway:latest

Sandbox mit explizitem Workspace

Zusätzliche Flags hängen an sandbox an (kein Entrypoint-Override):

docker run --rm \
  -e AI_HUB_URL="https://clye.ai" \
  -e AI_HUB_API_KEY="dein-api-key" \
  -v "$PWD:/workspace" \
  simonclye/clye-ai-hub-gateway:latest \
  --workspace /workspace

Mehrere Ordner als Filesystem-Connector

Der Filesystem-Connector ist ein stdio-MCP-Server. Für CLYE AI brauchst du mcp und den Entrypoint-Override:

docker run --rm \
  -e AI_HUB_URL="https://clye.ai" \
  -e AI_HUB_API_KEY="dein-api-key" \
  -v /home/you/frontend:/data/frontend \
  -v /home/you/backend:/data/backend \
  -v /home/you/docs:/data/docs:ro \
  --entrypoint ai-hub-container-entrypoint \
  simonclye/clye-ai-hub-gateway:latest \
  clye mcp clye filesystem-connector \
    --path /data/frontend \
    -v backend=/data/backend \
    -v docs=/data/docs \
    --permission full

Hinweise:

-v vor dem Image = Docker-Bind-Mount (Host:Container).
-v NAME=/pfad nach dem Image = benannte Roots des Filesystem-Connectors.
:ro = nur lesbar auf dem Host-Mount.
Ohne mcp startet nur stdio – der Assistent in CLYE AI sieht den Connector nicht.

Share-Folder verbindet sich selbst per WebSocket (kein mcp), braucht aber denselben Entrypoint-Override:

docker run --rm \
  -e AI_HUB_URL="https://clye.ai" \
  -e AI_HUB_API_KEY="dein-api-key" \
  -v /home/you/projekt:/data/projekt \
  --entrypoint ai-hub-container-entrypoint \
  simonclye/clye-ai-hub-gateway:latest \
  clye share-folder --path /data/projekt --name mein-projekt --permission full

Der Assistent sieht den Ordner unter /local/mein-projekt/.

Einzelne Datei (z. B. SQLite)

docker run --rm \
  -e AI_HUB_URL="https://clye.ai" \
  -e AI_HUB_API_KEY="dein-api-key" \
  -v /home/you/daten/app.db:/data/app.db \
  --entrypoint ai-hub-container-entrypoint \
  simonclye/clye-ai-hub-gateway:latest \
  clye mcp clye sqlite-connector --dbpath /data/app.db

Siehe auch SQLite.

Datenbank-Connector (z. B. PostgreSQL)

docker run --rm \
  -e AI_HUB_URL="https://clye.ai" \
  -e AI_HUB_API_KEY="dein-api-key" \
  -e POSTGRES_HOST=host.docker.internal \
  -e POSTGRES_PORT=5432 \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=geheim \
  -e POSTGRES_DB=app \
  --entrypoint ai-hub-container-entrypoint \
  simonclye/clye-ai-hub-gateway:latest \
  clye mcp clye postgres-connector

Gleiches Muster für MySQL, MSSQL, ClickHouse, Oracle, REST, ACP und andere stdio-Connectoren: immer clye mcp clye <connector> …. Siehe PostgreSQL und MCP-Registrierung.

Windows (PowerShell)

docker run --rm `
  -e AI_HUB_URL="https://clye.ai" `
  -e AI_HUB_API_KEY="dein-api-key" `
  -v "${PWD}:/workspace" `
  -w /workspace `
  simonclye/clye-ai-hub-gateway:latest

Absoluter Pfad:

docker run --rm `
  -e AI_HUB_URL="https://clye.ai" `
  -e AI_HUB_API_KEY="dein-api-key" `
  -v "C:\Users\you\mein-projekt:/workspace" `
  -w /workspace `
  simonclye/clye-ai-hub-gateway:latest

Filesystem-Connector:

docker run --rm `
  -e AI_HUB_URL="https://clye.ai" `
  -e AI_HUB_API_KEY="dein-api-key" `
  -v "C:\Users\you\projekt:/data/projekt" `
  --entrypoint ai-hub-container-entrypoint `
  simonclye/clye-ai-hub-gateway:latest `
  clye mcp clye filesystem-connector --path /data/projekt --permission full

Kurzreferenz

Docker-Flag	Beispiel	Zweck
`-v` / `--volume`	`-v "$PWD:/workspace"`	Host-Ordner in den Container legen
`-v …:ro`	`-v /docs:/data/docs:ro`	Nur-Lese-Mount
`-w` / `--workdir`	`-w /workspace`	Arbeitsverzeichnis im Container
`--entrypoint ai-hub-container-entrypoint`	siehe oben	Default-`sandbox` ersetzen, Wrapper behalten
`--rm`	`--rm`	Container nach Exit entfernen

Befehl nach dem Image	Hub-Anbindung	Wann nutzen
(keine Args) / `--workspace …`	Ja (`sandbox`)	Python + Terminal im Container
`clye mcp clye <connector> …`	Ja (`mcp`-Proxy)	DB, Filesystem, REST, ACP, …
`clye share-folder …`	Ja (WebSocket)	Ein Ordner schnell unter `/local/…`
`clye <connector> …` (ohne `mcp`)	Nein	Nur lokaler MCP-Client / Debug

Typische Container-Pfade: /workspace für Sandbox, /data/… für Connectoren. Host-Mount und CLI-Pfad müssen übereinstimmen.

Was passiert beim Start?​

Anderen Befehl starten​

Lokale Verzeichnisse einbinden​

Ein Projektverzeichnis mounten (Default-Sandbox)​

Sandbox mit explizitem Workspace​

Mehrere Ordner als Filesystem-Connector​

Share-Folder über Docker​

Einzelne Datei (z. B. SQLite)​

Datenbank-Connector (z. B. PostgreSQL)​

Windows (PowerShell)​

Kurzreferenz​

Inhalt