Zum Hauptinhalt springen

CLYE CLI

Die CLYE CLI (Befehl: clye) ist ein Kommandozeilen-Tool, um dich mit einer CLYE-AI-Instanz zu verbinden und typische Aufgaben ohne UI zu erledigen. Der Installer legt zusätzlich die Aliase ai-hub-cli und ai-hub an.

Stand dieser Seite: basiert auf der offiziellen CLI-Doku unter https://ai-hub-cli.s3.de.io.cloud.ovh.net/index.html

Was du mit der CLI machen kannst​

  • Verbindung zu deiner CLYE-AI-Instanz herstellen und verfügbare MCP-Tools anzeigen (connect, tools)
  • Tools aufrufen und Parameter als JSON übergeben (call)
  • Workspace-Dateien auflisten und herunterladen (files …)
  • Workspaces als Dateisystem mounten (FUSE) (mount)
  • Lokale MCP-Server starten (z. B. Python-/Terminal-Executor) und mit CLYE AI registrieren (mcp …)
  • Connectoren als MCP Server betreiben: Datenbanken, REST (OpenAPI), Dateisystem

Installation​

Schnellinstallation (Linux/macOS)​

curl -fsSL https://ai-hub-cli.s3.de.io.cloud.ovh.net/install.sh | sh

Der Installer erkennt OS/Architektur, lädt das passende Binary und installiert es so, dass es im PATH gefunden wird.

Schnellinstallation (Windows PowerShell)​

irm https://ai-hub-cli.s3.de.io.cloud.ovh.net/install.ps1 | iex

Hinweise:

  • Installation nach %LOCALAPPDATA%\clye und Aufnahme in den User-PATH (ohne Admin-Rechte).
  • Wenn du in cmd.exe arbeitest, rufe PowerShell auf und nutze denselben Installer.

Manuell herunterladen​

Direkte Downloads (ohne Installer):

Konfiguration & Authentifizierung​

Die meisten Befehle, die mit CLYE AI sprechen, benötigen:

  • AI_HUB_URL (Basis-URL deiner Instanz)
  • AI_HUB_API_KEY (API Key)

Du kannst beides über eine .env im aktuellen Verzeichnis setzen (wird automatisch geladen) oder per Environment-Variablen.

Environment-Variablen setzen​

Linux/macOS:

export AI_HUB_URL="https://clye.ai"
export AI_HUB_API_KEY="your-api-key-here"

Windows PowerShell:

$env:AI_HUB_URL = "https://clye.ai"
$env:AI_HUB_API_KEY = "your-api-key-here"

Windows cmd:

set AI_HUB_URL=https://clye.ai
set AI_HUB_API_KEY=your-api-key-here

Alternativ: Flags​

Flags überschreiben Variablen für den jeweiligen Aufruf:

clye --url "https://clye.ai" --api-key "your-api-key-here" [command]

Globale Flags​

  • --self-update: prüft beim Start auf eine neuere Version
  • --self-update-interval: Intervall (Default 1h, z. B. 30m, 2h)

Erste Schritte​

1) Verbindung testen​

clye connect

Das verbindet sich mit dem MCP-Endpunkt (…/api/mcp), initialisiert wenn möglich, und zeigt verfügbare Tools an.

2) Tools anzeigen und aufrufen​

clye tools
clye tools --json

clye call my_tool --params '{"key":"value"}'

3) Workspace-Dateien​

clye files list <workspace-id>
clye files get <workspace-id> <file-id>
clye files download <workspace-id> <file-id> <output-path>

4) Workspace mounten (FUSE)​

Linux/macOS:

clye mount <workspace-id> /mnt/aihub

Windows:

clye mount <workspace-id> M:

Voraussetzungen:

Update der CLI​

clye update

Optional kannst du die Download-Quelle überschreiben:

  • Env: AI_HUB_CLI_S3_URL
  • Flag: --s3-url

Default ist der Bucket dieser Doku: https://ai-hub-cli.s3.de.io.cloud.ovh.net.

Lokale MCP-Executors (stdio)​

Diese Subcommands starten lokale MCP Server (stdio), nützlich für Tests oder um sie mit AI Hub zu registrieren.

  • clye python-executor (Tool: execute_python)
  • clye terminal-executor (Tool: execute_terminal)
  • clye combined-executor (beide Tools)

Zusätzlich:

  • clye acp-connector: Bridge zum Agent Client Protocol (ACP) über stdio (für CLYE AI: clye mcp clye acp-connector …)

Direkt ausführen: python-run & terminal-run​

clye python-run 'print(1 + 1)'

clye terminal-run "echo hello"
clye terminal-run --background "npm run dev"
clye terminal-run --working-dir /path/to/repo "ls -la"

Datenbank-Connectoren (MCP)​

Jeder Connector stellt ein Tool execute_sql bereit. Konfiguration geht über Flags oder Environment-Variablen (Flags gewinnen).

important

Wenn du einen Connector für CLYE AI verwenden willst, starte nicht nur den Connector selbst, sondern immer den Wrapper davor.

  • ✅ Mit CLYE AI verbunden: clye mcp clye postgres-connector ...
  • ⚠️ Nur lokal als MCP-Server gestartet: clye postgres-connector ...

Das gilt genauso für mysql-connector, sqlite-connector, filesystem-connector, rest-connector und acp-connector.

  • clye sqlite-connector
  • clye postgres-connector
  • clye mysql-connector
  • clye mssql-connector
  • clye clickhouse-connector
  • clye oracle-connector (benötigt Oracle Instant Client; Builds ohne CGO können Oracle ggf. nicht enthalten)

REST-Connector (OpenAPI → MCP Tools)​

Exponiert Endpunkte aus einer OpenAPI-3.0-Spezifikation als MCP Tools.

clye mcp clye rest-connector --spec openapi.json --base-url https://api.example.com

Auth-Beispiele:

# Bearer Token
clye mcp clye rest-connector --spec openapi.json --base-url https://api.example.com \
  --api-key YOUR_API_KEY

# Custom Header (API Key)
clye mcp clye rest-connector --spec openapi.json --base-url https://api.example.com \
  --api-key YOUR_API_KEY --api-key-header X-API-Key

MCP-Registrierung mit CLYE AI​

Lokalen MCP Server registrieren (stdio)​

# Wichtig: Der Connector ist ein **STDIO MCP-Server**.
# Damit CLYE AI ihn nutzen kann, muss `clye mcp` den eigentlichen Connector starten.
clye mcp clye postgres-connector --host localhost --port 5432 --user postgres --password mypass

# Beispiel: MySQL
clye mcp clye mysql-connector --host localhost --port 3306 --user root --password mypass --dbname mydb
tipp

Für die Anbindung an CLYE AI reicht es nicht, nur den Connector zu starten.

  • ✅ Richtig (CLYE AI ↔ STDIO MCP): clye mcp clye mysql-connector …
  • ⚠️ Startet nur lokal als MCP-Server (ohne CLYE AI): clye mysql-connector …
  • ❌ Funktioniert nicht (Subcommand fehlt so): clye mcp mysql-connector …

Merksatz: clye mcp verbindet/registriert, der Connector danach ist das eigentliche MCP-Programm (stdio).

Remote HTTP MCP (streamable HTTP)​

clye mcp https://remote-mcp-server.example.com/mcp
clye mcp --mcp-header "Authorization: Bearer your-token-here" https://remote-mcp-server.example.com/mcp

Nach einer erfolgreichen Registrierung erscheint der angebundene Server in CLYE wieder zuverlässig unter Einstellungen → MCP-Server. Auch nach einem Deploy reicht bei bereits verbundenen Gateways normalerweise der nächste Reconnect; ein zusätzlicher manueller Neustart der laufenden CLI ist dafür in diesem Fall in der Regel nicht nötig.

Docker​

Das Image startet standardmäßig eine Sandbox mit Hub-Anbindung:

ai-hub-container-entrypoint clye sandbox

Andere Befehle (Connectoren) brauchen Entrypoint-Override und meist mcp:

--entrypoint ai-hub-container-entrypoint … clye mcp clye <connector> …

Vollständige Erklärung und Beispiele: Docker.

docker pull simonclye/clye-ai-hub-gateway:latest

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

Wofür ist das praktisch? (Use Cases)​

1) Datenbanken sicher für CLYE/AI Hub verfügbar machen (MCP)​

Wenn du einen lokalen oder privaten Datenbankzugang hast (z. B. PostgreSQL in deinem Netzwerk), kannst du ihn per CLI als MCP-Server starten. Dadurch können MCP-fähige Clients (inkl. CLYE AI) über ein Tool wie execute_sql darauf zugreifen.

Beispiele:

# PostgreSQL für CLYE AI bereitstellen
clye mcp clye postgres-connector --host localhost --port 5432 --user postgres --password mypass --dbname mydb

# MySQL für CLYE AI bereitstellen
clye mcp clye mysql-connector --host localhost --port 3306 --user root --password mypass --dbname mydb

2) Lokale Ordner als MCP-Ressourcen bereitstellen (Dateisystem-Connector)​

Damit kannst du einen oder mehrere Ordner als Ressourcen (filesystem://…) und File-Tools bereitstellen (lesen/suchen; optional schreiben).

# Read-only (Default) – mit CLYE AI verbunden
clye mcp clye filesystem-connector --path /home/you/project

# Vollzugriff (schreiben/löschen/verschieben)
clye mcp clye filesystem-connector --path /home/you/project --permission full

# Zusätzliche Ordner per Named Volumes
clye mcp clye filesystem-connector \
  --path /home/you/monorepo \
  -v frontend=/home/you/frontend-app \
  -v backend=/home/you/backend-api

Hinweis: Mit --tools … kannst du die bereitgestellten Operationen auf eine Allowlist begrenzen. Ohne mcp startet nur der lokale stdio-Server – AI_HUB_URL greift dann nicht.

3) Lokale Coding-Agents an CLYE AI anbinden (ACP)​

Mit acp-connector kannst du lokale Agenten (z. B. Coding Agents) über ACP (Agent Client Protocol) per stdio anbinden.

clye mcp clye acp-connector --acp-agents-config /path/to/agents.json

Format der Config (Beispiel):

{
  "agents": [
    {
      "id": "my-agent",
      "command": "node",
      "args": ["/path/to/agent.js"],
      "description": "Lokaler Coding Agent"
    }
  ]
}

4) Tasks in CLYE AI abarbeiten (Worker-Workflow)​

Die CLI hat ein eigenes task-Subcommand. Damit können Worker-Prozesse Tasks aus einer Queue holen, starten, Fortschritt melden und abschließen.

Wichtig:

  • AI_HUB_TASK_ID (oder --task-id) setzt den „aktuellen Task-Kontext".
  • task next wartet und claimt den nächsten Task für diesen Worker.

Beispiele:

# Nächsten Task holen (optional mit Timeout)
clye task next --timeout-ms 60000

# Task starten
clye task start <task-id>

# Fortschritt melden
clye task progress <task-id> --percent 30

# Erfolgreich abschließen
clye task complete <task-id>

# Oder als fehlgeschlagen markieren
clye task fail <task-id> --message "Build fehlgeschlagen"

5) Schnelles Debugging: Code/Kommandos ausführen​

Ohne MCP-Client kannst du die gleichen Engines direkt nutzen:

clye python-run "print(1 + 1)"
clye terminal-run "ls -la"

Befehlsübersicht (aus clye --help)​

Diese Befehle sind aktuell in der CLI verfügbar:

  • connect: Verbindung testen und Tools anzeigen
  • tools: Tool-Liste aus CLYE AI (optional --json)
  • call: Tool aufrufen (Parameter via --params als JSON)
  • files: Workspace-Dateien: list, get, download
  • mount: Workspace per FUSE mounten
  • mcp: MCP-Server mit CLYE AI verbinden (lokal per stdio oder remote per HTTP)
  • sandbox: Embedded „combined executor" als Sandbox registrieren (mit Persistenz)
  • python-executor, terminal-executor, combined-executor: lokale MCP Executors
  • python-run, terminal-run: direkte Wrapper (ohne MCP Client)
  • filesystem-connector: Ordner als MCP Ressourcen + File-Tools
  • DB-Connectoren: postgres-connector, mysql-connector, mssql-connector, clickhouse-connector, sqlite-connector, oracle-connector
  • rest-connector: OpenAPI → MCP Tools
  • acp-connector: ACP Bridge zu lokalen Agents
  • task: Tasks erstellen/holen/claimen/starten/fortschritt/abschließen
  • test-mcp-server / test-mcp-app-server: lokale Test-Server
  • test-mcp-server: MCP Server prüfen (stdio oder streamable HTTP)
  • update: CLI aktualisieren
  • completion: Shell Autocomplete Scripts

Inhalt