> ## Documentation Index
> Fetch the complete documentation index at: https://docs.venice.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Venice CLI

> Die offizielle Venice-Kommandozeilenschnittstelle bringt Chat, Websuche, Bildgenerierung, TTS, Transkription, Video und Embeddings in dein Terminal – mit optionaler Ende-zu-Ende-Verschlüsselung.

Die [Venice CLI](https://github.com/veniceai/venice-cli) ist die offizielle Kommandozeilenschnittstelle für Venice. Chatte mit KI-Modellen, generiere Bilder, wandle Text in Sprache um, transkribiere Audio, erzeuge Videos und mehr – alles direkt im Terminal, mit optionaler Ende-zu-Ende-Verschlüsselung.

<Card title="GitHub: veniceai/venice-cli" icon="github" href="https://github.com/veniceai/venice-cli">
  Veröffentlicht als [`veniceai-cli`](https://www.npmjs.com/package/veniceai-cli) auf npm. MIT-Lizenz.
</Card>

<CardGroup cols={3}>
  <Card title="Datenschutz zuerst" icon="lock">
    Optionale E2EE- und TEE-Attestation. Keine Telemetrie, kein Browser-Tracking.
  </Card>

  <Card title="Jede Modalität" icon="layer-group">
    Chat, Suche, Bild, Upscale, TTS, Transkription, Video und Embeddings
  </Card>

  <Card title="Skriptfähig" icon="terminal">
    JSON- und Raw-Ausgabe, Piping von stdin und Shell-Completions für bash, zsh, fish
  </Card>
</CardGroup>

## Schnellstart

<Steps>
  <Step title="CLI installieren">
    Global mit npm installieren:

    ```bash theme={"system"}
    npm install -g veniceai-cli
    ```

    Oder ohne Installation ausführen:

    ```bash theme={"system"}
    npx veniceai-cli chat 'Hello, world!'
    ```
  </Step>

  <Step title="Venice API-Schlüssel besorgen">
    Erstelle einen unter [venice.ai/settings/api](https://venice.ai/settings/api). Schritt-für-Schritt-Anleitung im [API-Schlüssel-Guide](/guides/getting-started/generating-api-key).
  </Step>

  <Step title="Schlüssel konfigurieren">
    Führe das interaktive Setup aus und füge deinen Schlüssel ein, wenn du dazu aufgefordert wirst – so taucht er nie in deiner Shell-History oder Prozessliste auf:

    ```bash theme={"system"}
    venice config init
    ```

    Oder verwende stattdessen eine Umgebungsvariable:

    ```bash theme={"system"}
    export VENICE_API_KEY=YOUR_API_KEY
    ```
  </Step>

  <Step title="Loschatten">
    ```bash theme={"system"}
    venice chat "What is the meaning of life?"
    ```
  </Step>
</Steps>

<Note>
  Erfordert Node.js 18.0.0 oder höher. `VENICE_API_KEY` überschreibt jeden Wert aus der Konfigurationsdatei.
</Note>

## Befehle

| Befehl                                | Was er tut                                                              |
| ------------------------------------- | ----------------------------------------------------------------------- |
| `venice chat <prompt>`                | Chatte mit jedem Venice-Textmodell, mit Tools, Characters und Streaming |
| `venice search <query>`               | Websuche mit KI-Synthese und optionalen Zitaten                         |
| `venice image <prompt>`               | Bild aus einem Textprompt generieren                                    |
| `venice upscale <file>`               | Bestehendes Bild bis zu 4× hochskalieren                                |
| `venice tts <text>`                   | Text-to-Speech mit über 35 Stimmen                                      |
| `venice transcribe <file>`            | Speech-to-Text mit optionalen Zeitstempeln                              |
| `venice video <subcommand>`           | KI-generierte Videos in die Queue stellen, abfragen und herunterladen   |
| `venice embeddings <text>`            | Embedding-Vektoren generieren                                           |
| `venice models`                       | Live-Modellkatalog auflisten und filtern                                |
| `venice tee <subcommand>`             | TEE-Attestation abrufen und verifizieren                                |
| `venice config <subcommand>`          | API-Schlüssel und Defaults verwalten                                    |
| `venice history <subcommand>`         | Konversationen auflisten, anzeigen, exportieren oder löschen            |
| `venice usage`                        | Token-Verbrauch über die Zeit anzeigen                                  |
| `venice characters` / `venice voices` | Integrierte Personas und TTS-Stimmen auflisten                          |
| `venice completions <shell>`          | Shell-Completions generieren                                            |

### Chat

```bash theme={"system"}
# Basic chat
venice chat "Explain quantum computing in simple terms"

# Use a specific model and system prompt
venice chat -m deepseek-v3.2 -s "You are a helpful coding assistant" "Write fizzbuzz in Python"

# Continue the previous conversation
venice chat --continue "What about the next step?"

# Function calling with built-in tools
venice chat -t calculator,datetime "What's 25 * 4.5, and what day is it?"

# JSON output for scripting
venice chat -f json "List 3 colors" | jq '.content'
```

Gängige Chat-Optionen:

| Option                   | Beschreibung                                             |
| ------------------------ | -------------------------------------------------------- |
| `-m, --model <model>`    | Zu verwendendes Modell (Default: `kimi-k2-5`)            |
| `-s, --system <prompt>`  | System-Prompt                                            |
| `-c, --character <name>` | Character-Persona                                        |
| `-t, --tools <tools>`    | Kommagetrennte Liste integrierter Tools                  |
| `--continue`             | Letzte Konversation fortsetzen                           |
| `--web-search`           | Websuche für aktuelle Informationen aktivieren           |
| `--no-stream`            | Streaming-Ausgabe deaktivieren                           |
| `-f, --format <format>`  | Ausgabeformat (`pretty`, `json`, `markdown`, `raw`)      |
| `--e2ee` / `--no-e2ee`   | Ende-zu-Ende-Verschlüsselung erzwingen oder deaktivieren |
| `--tee-verify`           | TEE-Attestation-Details anzeigen                         |
| `-q, --quiet`            | E2EE/TEE-Statusmeldungen ausblenden                      |

### Websuche

```bash theme={"system"}
venice search "Latest developments in fusion energy"
venice search -n 10 --citations "Best practices for TypeScript"
venice search --scrape "Company research on Anthropic"
```

### Bildgenerierung & Upscaling

```bash theme={"system"}
# Generate and save an image
venice image -o sunset.png "A serene mountain lake at sunset"

# Custom dimensions and model
venice image -w 1024 -h 768 -m flux-1-dev "Landscape photograph"

# Upscale an existing image 4×
venice upscale photo.jpg -s 4 -o photo_4x.jpg
```

### Text-to-Speech & Transkription

```bash theme={"system"}
# Speak with a specific voice
venice tts -v bf_emma -o greeting.mp3 "Good morning, everyone!"

# Pipe text in from stdin
echo "Text to speak" | venice tts -o output.mp3

# Transcribe audio with timestamps
venice transcribe -t recording.mp3

# Choose a model and language hint
venice transcribe -m openai/whisper-large-v3 -l es spanish_audio.mp3
```

### Videogenerierung

Videogenerierung läuft asynchron (queue-basiert).

```bash theme={"system"}
# Queue a text-to-video generation
venice video generate -m veo3-fast-text-to-video "Cinematic sunset over mountains"

# Image-to-video with a reference image
venice video generate -m wan-2.6-image-to-video -i photo.jpg "The scene comes alive"

# Poll until done, then download
venice video status -w <queue_id>
venice video retrieve <queue_id> -o my_video.mp4

# List available video models
venice video models
```

### Modelle & Embeddings

```bash theme={"system"}
# List and filter the catalog
venice models -t image
venice models --privacy
venice models --e2ee

# Generate embeddings
venice embeddings -o vectors.json "Text to embed"
```

### Konfiguration

```bash theme={"system"}
# Interactive setup
venice config init

# Set and inspect values
venice config set default_model kimi-k2-5
venice config get default_model
venice config show
venice config path
```

| Schlüssel             | Beschreibung                           |
| --------------------- | -------------------------------------- |
| `api_key`             | Dein Venice API-Schlüssel              |
| `default_model`       | Default-Chatmodell                     |
| `default_image_model` | Default-Bildgenerierungsmodell         |
| `default_voice`       | Default-TTS-Stimme                     |
| `output_format`       | Default-Ausgabeformat                  |
| `show_usage`          | Token-Verbrauch nach Anfragen anzeigen |

## Datenschutz: E2EE & TEE

Die Venice CLI ist für Datenschutz gebaut. Sie versendet keine Telemetrie, speichert deinen API-Schlüssel lokal mit eingeschränkten Berechtigungen und unterstützt Venices Confidential-Compute-Modelle.

* **Ende-zu-Ende-Verschlüsselung (E2EE)**: Nachrichten werden clientseitig verschlüsselt und nur innerhalb der TEE entschlüsselt, sodass Venice deine Daten nicht lesen kann. Die CLI aktiviert E2EE automatisch, wenn ein Modell die Fähigkeit ankündigt, und erzeugt pro Session ein ephemeres Schlüsselpaar (ECDH + AES-GCM).
* **TEE-Attestation**: Kryptografisch verifizieren, dass ein Modell in einer sicheren Enklave läuft, bevor Daten gesendet werden.

```bash theme={"system"}
# Discover confidential-compute models
venice models --e2ee
venice models --tee

# Chat with E2EE (auto-enabled for capable models)
venice chat -m <e2ee-capable-model> "Your private message here"

# TEE-only mode: verify attestation without encryption
venice chat -m <e2ee-capable-model> --no-e2ee "TEE verified, not encrypted"

# Fetch and verify attestation directly
venice tee attestation <model>
venice tee verify <model>
```

<Note>
  Der E2EE-Modus deaktiviert Tools und Websuche, um die Ende-zu-Ende-Verschlüsselung zu erhalten.
</Note>

## Ausgabeformate

| Format     | Anwendungsfall                                                     |
| ---------- | ------------------------------------------------------------------ |
| `pretty`   | Farbige, formatierte Ausgabe für die interaktive Nutzung (Default) |
| `json`     | Maschinenlesbares JSON für Skripting und Piping                    |
| `markdown` | Markdown-formatierte Ausgabe für Dokumentation                     |
| `raw`      | Reiner Text ohne Formatierung, für Pipes                           |

Die CLI erkennt automatisch, wenn die Ausgabe gepipet wird, und wechselt auf `raw`.

```bash theme={"system"}
venice chat -f json "List items" | jq '.'
venice chat "Generate code" | pbcopy
```

## Ressourcen

<CardGroup cols={2}>
  <Card title="GitHub" icon="github" href="https://github.com/veniceai/venice-cli">
    Quellcode, Issues und Releases
  </Card>

  <Card title="npm" icon="npm" href="https://www.npmjs.com/package/veniceai-cli">
    `veniceai-cli`
  </Card>

  <Card title="Venice MCP Server" icon="plug" href="/guides/integrations/venice-mcp">
    Stellt dieselben Venice-Tools jedem MCP-Host bereit
  </Card>

  <Card title="Venice API-Referenz" icon="book" href="/api-reference/api-spec">
    Vollständige Endpoint- und Parameter-Dokumentation
  </Card>
</CardGroup>