# Kimi Code CLI einrichten

> **Zuletzt geprüft**: 2026-10-13 · 📄 Laut offizieller Dokumentation (Kimi Code CLI 2.1.1)

## Auf einen Blick

| Punkt | Details |
|---|---|
| Verfügbare Modelle | Claude ✅ (`type = "anthropic"`) · GPT ✅ · Chinesische Modelle ✅ (`type = "openai"`) · Gemini ❌ (QCode führt die Gemini-Familie nicht; bitte Claude, GPT oder ein chinesisches Modell verwenden) |
| Protokoll & Base URL | Anthropic Messages: `https://api.qcode.cc/api` · OpenAI Chat Completions: `https://api.qcode.cc/openai/v1` |
| Wo eingerichtet wird | `~/.kimi-code/config.toml` — je Protokoll eine Tabelle `[providers.<name>]`, je Modell ein Eintrag `[models.<alias>]` |
| Offizielle Dokumentation | [moonshotai.github.io/kimi-code](https://moonshotai.github.io/kimi-code/en/) |

[Kimi Code CLI](https://github.com/MoonshotAI/kimi-code) ist der Coding-Agent von Moonshot AI, der im Terminal läuft. Die Dokumentation nennt drei Wege, an ein Modell zu kommen: Anmeldung mit einem Klick beim verwalteten Kimi-Code-Dienst, „connecting Claude with an Anthropic API key, or connecting third-party inference services via the OpenAI-compatible protocol“. Die beiden letzten sind genau die Endpoints, die QCode bereitstellt — mit einem QCode-Schlüssel sind Claude, GPT und die chinesischen Familien in demselben Werkzeug abgedeckt. Der Stand bei Erstellung dieser Seite ist 2.1.1 (2026-09-24).

## Welches Protokoll

Das Feld `type` in der Tabelle `[providers.<name>]` bestimmt, welche Protokollimplementierung verwendet wird. Die offizielle Referenz listet sechs Werte — `kimi`, `anthropic`, `openai`, `openai_responses`, `google-genai`, `vertexai` — Sie brauchen davon zwei.

| Gewünschte Modelle | `type` | `base_url` |
|---|---|---|
| `claude-sonnet-5`, `claude-opus-5`, `claude-haiku-5-5` | `anthropic` | `https://api.qcode.cc/api` |
| `gpt-6.1-sol`, `gpt-6-sol` sowie die chinesischen Familien | `openai` | `https://api.qcode.cc/openai/v1` |

🔴 **Richten Sie Claude-Modelle niemals auf den OpenAI-kompatiblen Endpoint.** QCode bedient die Claude-Familie ausschließlich über Anthropic Messages; eine `claude-*`-Kennung, die an `https://api.qcode.cc/openai/v1` geht, wird abgelehnt. Die beiden Endpoints sind nicht austauschbar — siehe [Endpoints und API-Pfade](/docs/getting-started/endpoints-and-api-paths).

Tragen Sie die Base URL genau wie in der Tabelle ein: enden Sie bei `/api` bzw. `/openai/v1`, hängen Sie **weder** `/v1/messages` noch `/chat/completions` an, und setzen Sie **keinen** abschließenden Slash.

## Installation

Offiziell gibt es zwei Wege: das Installationsskript (empfohlen, weil kein vorinstalliertes Node.js nötig ist) und die globale Installation per npm.

```sh
# macOS / Linux
curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash

# Windows (PowerShell)
irm https://code.kimi.com/kimi-code/install.ps1 | iex

# npm — prüfen Sie die Laufzeit vorher mit: node --version
npm install -g @moonshot-ai/kimi-code
```

Für den npm-Weg ist **Node.js 22.19.0 oder neuer erforderlich**. Das Skript lädt die neueste Version, prüft die Prüfsumme und legt die ausführbare Datei `kimi` in Ihrem `PATH` ab. Prüfen Sie die Verfügbarkeit des Programms, wechseln Sie in Ihr Projektverzeichnis und starten Sie `kimi`, um die interaktive Oberfläche zu öffnen:

```sh
kimi --version
cd your-project
kimi
```

## Claude konfigurieren (`type = "anthropic"`)

Zugangsdaten werden ausschließlich aus der Konfigurationsdatei gelesen. Die Dokumentation ist eindeutig: Die CLI „does **not** fall back to shell environment variables automatically: running `export KIMI_API_KEY` in the terminal does not give any provider its key“. Der Schlüssel steht also entweder in der Datei, oder `api_key_env` nennt eine Variable, die die CLI bei jeder Anfrage neu liest.

```toml
# ~/.kimi-code/config.toml
default_model = "claude-sonnet-5"

[providers.qcode]
type = "anthropic"
base_url = "https://api.qcode.cc/api"
api_key_env = "QCODE_API_KEY"

[models."claude-sonnet-5"]
provider = "qcode"
model = "claude-sonnet-5"
max_context_size = 262144
```

```sh
export QCODE_API_KEY=cr_your_qcode_key
```

`qcode` ist nur der Provider-Name, den Sie vergeben haben; jeder Eintrag `[models.<alias>]` verweist über das Pflichtfeld `provider` darauf. Wenn Sie keine Umgebungsvariable anlegen möchten, ersetzen Sie `api_key_env` durch `api_key = "cr_your_qcode_key"`. Die Dokumentation merkt an, dass dieser Wert im Klartext in der Datei steht, und `api_key` sowie `api_key_env` schließen einander aus — setzen Sie genau eines von beiden.

| Feld | Tabelle | Eintrag |
|---|---|---|
| `type` | providers | `anthropic`, laut Dokumentation „For connecting to the Claude API“ |
| `base_url` | providers | `https://api.qcode.cc/api`; ohne Angabe gilt die Anthropic-SDK-Vorgabe |
| `api_key` / `api_key_env` | providers | der Schlüssel selbst oder der Name der Variable mit dem Schlüssel |
| `custom_headers` | providers | optionale Tabelle mit zusätzlichen HTTP-Headern für jede Anfrage |
| `provider` | models | Pflicht — der oben definierte Provider-Name |
| `model` | models | Pflicht — die an den Server gesendete Modellkennung, z. B. `claude-sonnet-5` |
| `max_context_size` | models | Pflicht, mindestens 1 Token — die `262144` im obigen Beispiel ist ein Platzhalter; tragen Sie die Kontextlänge des Modells ein, das Sie tatsächlich nutzen |
| `max_output_size` | models | optional, Ausgabeobergrenze (entspricht `max_tokens`); derzeit liest nur der Provider `anthropic` sie |

> **Festland-China**: Der Anthropic-Endpoint antwortet auch auf `https://asia.qcode.cc/api` und `https://us.qcode.cc/api` — derselbe Schlüssel, Sie tauschen nur den Host in `base_url`.
> **Fähigkeiten**: Standard-Claude-Namen aktivieren Vision, Tool Use und Thinking automatisch. Ein Modellname, den die CLI nicht kennt, braucht ein explizites `capabilities` in `[models.<alias>]` (`thinking`, `image_in`, `tool_use` …); solche Tags werden nur ergänzt, nie entfernt.

## GPT und chinesische Modelle konfigurieren (`type = "openai"`)

Dieselbe Datei, der andere Endpoint. Zum Typ `openai` steht in der Dokumentation: „For connecting to the OpenAI Chat Completions protocol, as well as any third-party service compatible with that protocol (override `base_url` as needed)“. Der eingebaute Standardwert ist `https://api.openai.com/v1` — erst das überschriebene `base_url` macht daraus eine Verbindung zu QCode.

```toml
[providers.qcode-openai]
type = "openai"
base_url = "https://api.qcode.cc/openai/v1"
api_key_env = "QCODE_API_KEY"

[models."gpt-6.1-sol"]
provider = "qcode-openai"
model = "gpt-6.1-sol"
max_context_size = 262144

[models."deepseek-v4.1-flash"]
provider = "qcode-openai"
model = "deepseek-v4.1-flash"
max_context_size = 262144

[models."qwen3.8-max"]
provider = "qcode-openai"
model = "qwen3.8-max"
max_context_size = 262144
```

- **Namen mit Punkt in Anführungszeichen setzen.** `gpt-6.1-sol` und `qwen3.8-max` schreiben Sie als `[models."qwen3.8-max"]`; ohne Anführungszeichen deutet TOML den Punkt als Trenner verschachtelter Tabellen. Feldnamen selbst sind durchgängig snake_case (`default_model`, `max_context_size`).
- Die Zahlen oben sind Platzhalter für ein Pflichtfeld. Die tatsächliche Kontextlänge entnehmen Sie der Spezifikation des jeweiligen Modells. Abgerechnet wird pro Token; die Preise je Modell stehen auf [qcode.cc/models](https://qcode.cc/models).
- Beide Provider können in ein und derselben Konfiguration stehen. Die Modellwahl pro Sitzung erledigt `-m <alias>` (Startoptionen stehen über der Datei, gelten aber nur für diesen Start), im TUI wechseln Sie über `/model`. `default_model` muss einer der definierten Aliase sein.
- Reasoning-Ausgabe: Bei Reasoning-Modellen Dritter übernimmt die CLI die `reasoning_content`-Verarbeitung und die `reasoning_effort`-Injektion von selbst. Liefert Ihr Gateway den Inhalt unter einem unüblichen Feldnamen, setzen Sie `reasoning_key` beim Modell-Alias.
- Weitere Kennungen für diesen Endpoint finden Sie bei [Chinesische Modelle](/docs/usage/cn-models). `claude-*`-Kennungen funktionieren hier **nicht**.

## Verbindung überprüfen

Vorab die Dateien prüfen, ohne das TUI zu starten:

```sh
kimi doctor
kimi doctor config
```

`kimi doctor` führt „Validate `config.toml` and `tui.toml` without starting the TUI or modifying either file“ aus und beendet sich mit Code `0`, wenn alle geprüften Dateien gültig oder übersprungen sind, und mit `1`, wenn eine fehlt oder ungültig ist. Der dokumentierte Prüfumfang sind diese beiden Dateien; dass der Befehl die Erreichbarkeit des Endpoints testet, steht in der Dokumentation nicht.

Danach sehen Sie, was die CLI tatsächlich registriert hat:

```sh
kimi provider list
```

Geben Sie anschließend `/provider` im TUI ein: Der interaktive Provider-Manager zeigt die konfigurierten Provider und erlaubt, sie hinzuzufügen oder zu entfernen. `kimi provider` ist das nichtinteraktive Gegenstück für Skripte und CI.

Zum Schluss der direkte Request gegen den Endpoint (bitte eigenen Schlüssel einsetzen):

```bash
KEY="cr_your_qcode_key"
curl -X POST https://api.qcode.cc/api/v1/messages \
  -H "x-api-key: $KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-5","max_tokens":32,"messages":[{"role":"user","content":"ping"}]}'
```

Diese Seite wurde nach der Dokumentation erstellt; **die obigen Anfragen wurden mit keinem echten Schlüssel ausgeführt**, daher wird hier kein Statuscode versprochen. Der JSON-Fehlertext unterscheidet die drei Ursachen: falscher Pfad, falscher Schlüssel, Modell auf diesem Endpoint nicht verfügbar.

> Die Dokumentation beschreibt außerdem einen Abkürzungsweg über einen Drittanbieter-Katalog: `kimi provider catalog add anthropic --api-key sk-ant-... --default-model claude-opus-4-7`. Dabei liefert der Katalog Protokolltyp, Base URL und Modelliste, und `--base-url` überschreibt den Endpoint (`--default-model` schreibt `default_model` als `<providerId>/<modelId>`). Die Kennung in diesem Beispiel stammt aus dem öffentlichen Katalog, nicht aus QCode; ob QCode dort gelistet ist, wurde auf dieser Seite nicht geprüft, deshalb empfiehlt sie den TOML-Weg oben.

## Fehlerbehebung und bekannte Einschränkungen

| Symptom | Was die Dokumentation sagt | Vorgehen |
|---|---|---|
| Start bricht ab, weil einem Provider Zugangsdaten fehlen | Reihenfolge: `api_key` oder `api_key_env` (genau eines), dann der Schlüssel in der Tabelle `[providers.<name>.env]`, und wenn alles fehlt, schlägt der Start mit einer Fehlermeldung fehl | Die üblichen Schlüsselnamen für diesen Typ sind `ANTHROPIC_API_KEY` und `ANTHROPIC_BASE_URL`, notiert in `[providers.qcode.env]` — das sind Schlüssel der Datei, keine Suche in der Shell. Beim `/models`-Abgleich fällt ein Provider mit leerer Variable allein aus, ohne die anderen zu stören |
| `export ANTHROPIC_API_KEY=…` scheint wirkungslos | Shell-Variablen sind kein allgemeiner Rückfallpfad; in die Shell schauen nur `api_key_env` des Providers und die Familie `KIMI_MODEL_*` | Nutzen Sie `api_key_env`. `KIMI_MODEL_PROVIDER_TYPE` akzeptiert `kimi`, `anthropic`, `openai`; mit gesetztem `KIMI_MODEL_NAME` baut die CLI einen provisorischen Provider im Speicher, der beim Neustart verschwindet |
| Änderungen an der Datei greifen nicht | Startoptionen haben Vorrang vor der Datei und gelten nur für diese Sitzung; die Datei wird beim Start gelesen | Starten Sie `kimi` neu oder führen Sie `/reload` aus, um die aktuelle `config.toml` anzuwenden |
| Konfigurationsfehler oder nicht gefundener Alias, wenn ein Alias mit Punkt ohne Anführungszeichen steht | `default_model` muss in `models` definiert sein, und ein Alias mit Punkt ohne Anführungszeichen wird zur verschachtelten Tabelle | Setzen Sie den Alias in Anführungszeichen: `[models."qwen3.8-max"]` |
| 404 oder Fehler beim Pfad | Wie ein Drittanbieter-Gateway den Pfad zusammenstellt, dazu schweigt die Dokumentation | `base_url` endet auf `/api` (Claude) bzw. `/openai/v1` (GPT und chinesische Modelle): ohne Abschluss-Slash und ohne von Hand ergänzten API-Pfad |
| Claude wird vom Provider `openai` abgelehnt | — | QCode bedient die Claude-Familie auf diesem Endpoint nicht; zurück zu `type = "anthropic"` |
| Verschiedene Projekte brauchen verschiedene Endpoints | Einen projektbezogenen Konfigurationsmechanismus gibt es nicht — die CLI liest genau eine Benutzerdatei, und wohin Sie sie auch verlegen, ihr Name bleibt `config.toml` | Richten Sie `KIMI_CODE_HOME` vor dem Start auf ein eigenes Datenverzeichnis je Projekt |

Über das Werkzeug selbst hinaus:

- **Gemini**: Kimi Code hat den Typ `google-genai` für den direkten Zugriff auf die Google-Gemini-API, aber QCode führt die Gemini-Familie nicht. Bitte verwenden Sie Claude, GPT oder ein chinesisches Modell.
- **luna**: QCode führt `gpt-6-luna` und `gpt-5.6-luna` nicht; nehmen Sie eine andere GPT-Kennung wie `gpt-6.1-sol`, `gpt-6-sol` oder `gpt-5.6-terra`.
- `max_output_size` liest nur der Provider `anthropic`, eine Ausgabeobergrenze auf einem `openai`-Alias bewirkt also nichts.
- Welches Modell für welche Aufgabe geeignet ist, steht in [Modellauswahl](/docs/usage/model-selection); liegt der Fehler außerhalb dieses Werkzeugs, arbeiten Sie die [Fehlerbehebung](/docs/reference/troubleshooting) durch.

## Weiteres

- [Endpoints und API-Pfade](/docs/getting-started/endpoints-and-api-paths) — Protokoll im Vergleich zur Modellfamilie
- [Kompatibilität der Werkzeuge](/docs/ide/tool-compatibility) — welches Werkzeug welchen Endpoint nutzt
- [Chinesische Modelle](/docs/usage/cn-models) — Kennungen und Pfade des OpenAI-Endpoints
- [Modellauswahl](/docs/usage/model-selection) — das Modell zur Aufgabe
- [OpenCode einrichten](/docs/ide/opencode) — ein weiteres Terminal-Werkzeug auf denselben beiden Endpoints