> ## Documentation Index
> Fetch the complete documentation index at: https://veniceai-mintlify-d2fddb8a.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Claude Code

> Konfigurieren Sie die Claude Code CLI so, dass Anthropic-Claude-Opus- und -Sonnet-Anfragen über Venice laufen — für private, nutzungsbasierte Coding-Agent-Inferenz.

[Claude Code](https://docs.anthropic.com/en/docs/claude-code) ist Anthropics CLI-Tool für agentisches Coden. Diese Anleitung zeigt dir, wie du es über Venice AI betreibst, um Claude Opus 4.5/4.6 und Sonnet 4.5/4.6 pro Token zu bezahlen.

<CardGroup cols={3}>
  <Card title="Pay Per Token" icon="coins">
    Kein Abo. Zahle nur, was du nutzt
  </Card>

  <Card title="Claude-Modelle" icon="microchip">
    Zugriff auf Opus 4.5/4.6 und Sonnet 4.5/4.6 über Venice
  </Card>

  <Card title="Prompt Caching" icon="bolt">
    Venice-Caching funktioniert zusammen mit Claude Code
  </Card>
</CardGroup>

## Warum du einen Router brauchst

Claude Code verbindet sich standardmäßig direkt mit Anthropics API. Um es mit Venice zu verwenden, brauchst du [claude-code-router](https://github.com/musistudio/claude-code-router), einen quelloffenen lokalen Proxy, der:

<Steps>
  <Step title="abfängt" icon="hand">
    fängt ausgehende Requests von Claude Code ab, bevor sie Anthropic erreichen
  </Step>

  <Step title="transformiert" icon="arrows-rotate">
    wandelt das Request-Format um und mappt Modell-IDs (z. B. `claude-opus-4-5`)
  </Step>

  <Step title="umleitet" icon="route">
    leitet die Requests an Venice unter `api.venice.ai/api/v1/chat/completions` weiter
  </Step>
</Steps>

***

## Voraussetzungen

<CardGroup cols={3}>
  <Card title="Venice-Konto" icon="user" href="https://venice.ai/settings/api">
    Mit API-Credits
  </Card>

  <Card title="Node.js" icon="node-js" href="https://nodejs.org/">
    v18 oder höher
  </Card>

  <Card title="Claude Code" icon="terminal" href="https://docs.anthropic.com/en/docs/claude-code">
    Per npm installiert
  </Card>
</CardGroup>

***

## Einrichtung

<Steps>
  <Step title="Claude Code installieren">
    Falls noch nicht geschehen, installiere Anthropics Claude Code CLI:

    ```bash theme={null}
    npm install -g @anthropic-ai/claude-code
    ```
  </Step>

  <Step title="Router installieren">
    ```bash theme={null}
    npm install -g @musistudio/claude-code-router
    ```
  </Step>

  <Step title="API-Schlüssel erstellen">
    Erstelle einen Schlüssel unter [venice.ai/settings/api](https://venice.ai/settings/api). Du fügst ihn im nächsten Schritt direkt in die Konfigurationsdatei ein.
  </Step>

  <Step title="Konfiguration erstellen">
    Erstelle das Konfigurationsverzeichnis:

    ```bash theme={null}
    mkdir -p ~/.claude-code-router
    ```

    Erstelle dann `~/.claude-code-router/config.json` mit deinem bevorzugten Editor:

    ```bash theme={null}
    # Mit nano
    nano ~/.claude-code-router/config.json

    # Oder mit VS Code
    code ~/.claude-code-router/config.json
    ```

    Füge die folgende Konfiguration ein:

    ```json theme={null}
    {
      "APIKEY": "",
      "LOG": true,
      "LOG_LEVEL": "info",
      "API_TIMEOUT_MS": 600000,
      "HOST": "127.0.0.1",
      "Providers": [
        {
          "name": "venice",
          "api_base_url": "https://api.venice.ai/api/v1/chat/completions",
          "api_key": "your-venice-api-key-here",
          "models": [
            "claude-opus-4-5",
            "claude-sonnet-4-5",
            "claude-opus-4-6",
            "claude-opus-4-6-fast",
            "claude-sonnet-4-6"
          ],
          "transformer": {
            "use": ["anthropic"]
          }
        }
      ],
      "Router": {
        "default": "venice,claude-opus-4-5",
        "think": "venice,claude-opus-4-5",
        "background": "venice,claude-opus-4-5",
        "longContext": "venice,claude-opus-4-5",
        "longContextThreshold": 100000
      }
    }
    ```

    <Note>
      Wenn du `config.json` änderst, während der Router läuft, starte ihn mit `ccr restart` neu, um die Änderungen anzuwenden.
    </Note>
  </Step>

  <Step title="Starten">
    Starte den Router, dann Claude Code:

    ```bash theme={null}
    ccr start
    ccr code
    ```

    Oder verwende die Aktivierungsmethode:

    ```bash theme={null}
    eval "$(ccr activate)" && claude
    ```
  </Step>
</Steps>

***

## Unterstützte Modelle

| Modell               | Venice-ID              | Geeignet für                              |
| -------------------- | ---------------------- | ----------------------------------------- |
| Claude Opus 4.5      | `claude-opus-4-5`      | Komplexes Reasoning, große Refactorings   |
| Claude Sonnet 4.5    | `claude-sonnet-4-5`    | Schnelle Iteration, Alltags-Coding        |
| Claude Opus 4.6      | `claude-opus-4-6`      | Komplexes Reasoning, große Refactorings   |
| Claude Opus 4.6 Fast | `claude-opus-4-6-fast` | Komplexes Reasoning mit geringerer Latenz |
| Claude Sonnet 4.6    | `claude-sonnet-4-6`    | Schnelle Iteration, Alltags-Coding        |

<Info>
  Claude Code ist für Claude-Modelle optimiert. Andere über Venice verfügbare Modelle (GPT, DeepSeek, Grok usw.) funktionieren möglicherweise, aber wir können keine gleichwertige Erfahrung garantieren, da Claude Code auf Claude-spezifische Funktionen wie Extended Thinking setzt. Für andere Modelle erwäge die Nutzung der [Standard-API](/api-reference/endpoint/chat/completions) von Venice.
</Info>

***

## Router-Funktionen

Der Router bietet mehrere nützliche Funktionen über das einfache Routing hinaus:

<AccordionGroup>
  <Accordion title="Modelle on the fly wechseln">
    Verwende den Befehl `/model` innerhalb von Claude Code, um Modelle ohne Neustart zu wechseln:

    ```
    /model venice,claude-sonnet-4-5
    ```

    Nützlich, wenn du Opus für komplexe Aufgaben und Sonnet für schnelle Iterationen verwenden möchtest.
  </Accordion>

  <Accordion title="Visuelle Konfiguration im UI-Modus">
    Lieber eine GUI? Starte den webbasierten Konfigurations-Editor:

    ```bash theme={null}
    ccr ui
    ```

    Damit öffnet sich eine Browser-Oberfläche zum Bearbeiten deiner `config.json`, ohne die Datei direkt anzufassen.
  </Accordion>

  <Accordion title="Router-Szenarien erklärt">
    Der `Router`-Abschnitt der Konfiguration steuert, welches Modell unterschiedliche Aufgabentypen bearbeitet:

    | Szenario      | Wann es verwendet wird                                                   |
    | ------------- | ------------------------------------------------------------------------ |
    | `default`     | Allgemeine Anfragen                                                      |
    | `think`       | Reasoning-intensive Aufgaben (Plan-Modus)                                |
    | `background`  | Hintergrund-Operationen                                                  |
    | `longContext` | Wenn der Kontext den Wert `longContextThreshold` an Tokens überschreitet |

    Du kannst unterschiedliche Szenarien an unterschiedliche Modelle routen. Zum Beispiel Sonnet für Hintergrund-Aufgaben verwenden, um Kosten zu sparen.
  </Accordion>

  <Accordion title="Debugging mit Logs">
    Wenn etwas nicht funktioniert, prüfe die Logs:

    ```bash theme={null}
    # Server-Logs (HTTP, API-Aufrufe)
    ~/.claude-code-router/logs/ccr-*.log

    # Application-Logs (Routing-Entscheidungen)
    ~/.claude-code-router/claude-code-router.log
    ```

    Setze `"LOG_LEVEL": "debug"` in deiner Konfiguration für ausführlichere Ausgaben.
  </Accordion>
</AccordionGroup>

***

## Caching-Verhalten

Venice [Prompt Caching](/guides/features/prompt-caching) funktioniert zusammen mit Claude Codes nativen Cache-Markern. Venice erkennt automatisch, wenn Claude Code `cache_control`-Felder sendet, und passt seine Caching-Strategie entsprechend an.

| Szenario                     | Cache-TTL | Wer steuert          |
| ---------------------------- | --------- | -------------------- |
| Default (empfohlen)          | 5 Minuten | Claude Code + Venice |
| Mit `cleancache`-Transformer | 1 Stunde  | Nur Venice           |

<AccordionGroup>
  <Accordion title="Wann KEIN cleancache (die meisten Nutzer)">
    Die Standardkonfiguration lässt beide Systeme kooperieren:

    * Claude Code sendet seine nativen `cache_control`-Marker
    * Venice fügt Caching mit einer TTL von 5 Minuten hinzu
    * Beide Systeme teilen sich das 4-Block-Cache-Limit

    Das funktioniert gut für aktive Coding-Sessions, in denen du häufige Anfragen stellst.
  </Accordion>

  <Accordion title="Wann cleancache verwenden">
    Füge `cleancache` zum Transformer hinzu, wenn du:

    * Fehler wegen des 4-Block-Cache-Limits bekommst
    * Seltsames Caching-Verhalten erlebst
    * Venices 1-Stunden-TTL für längere Sessions bevorzugst

    ```json theme={null}
    "transformer": {
      "use": ["anthropic", "cleancache"]
    }
    ```

    Damit werden Claude Codes Cache-Marker entfernt, und Venice erhält die volle Kontrolle mit längerer TTL.
  </Accordion>
</AccordionGroup>

***

## Ressourcen

<CardGroup cols={2}>
  <Card title="Venice API Docs" icon="book" href="/api-reference/api-spec">
    Vollständige API-Referenz
  </Card>

  <Card title="claude-code-router" icon="github" href="https://github.com/musistudio/claude-code-router">
    Quellcode und Issues
  </Card>
</CardGroup>