DeepSeek-Reasonix Einsteigerleitfaden: ein kostengünstiger KI-Programmieragent

Projektübersicht

DeepSeek-Reasonix ist ein terminalorientierter KI-Coding-Agent. Er ist nicht einfach nur eine Chat-CLI, sondern organisiert Modell, Tools, Plugins, Projektkontext und Genehmigungsabläufe zu einer konfigurierbaren lokalen Agent-Engine.

Seine drei Kernmerkmale sind: Erstens ist er standardmäßig auf lange Sitzungen mit DeepSeek optimiert und legt besonderen Wert auf Prefix Cache, damit die Token-Kosten bei fortlaufenden Entwicklungsaufgaben niedriger bleiben; zweitens sind Provider, Modelle, Tools und Plugins in reasonix.toml definiert und nicht hart im Programm codiert; drittens wird er als einzelne Go-Binärdatei ausgeliefert, sodass CLI/TUI, Desktop-Client und VS-Code-Erweiterung dieselbe Reasonix-Engine wiederverwenden können.

In diesem Artikel bauen wir gemeinsam eine minimale Praxisumgebung auf: Reasonix installieren, den DeepSeek-API-Key konfigurieren, Projektanweisungen initialisieren, eine Code-Änderungsaufgabe ausführen und anschließend ein OpenAI-kompatibles Gateway anbinden. Am Ende wirst du wissen: Wann es sinnvoll ist, DeepSeek direkt zu verwenden, und wann es komfortabler ist, Defapi als einheitliche Schnittstelle einzusetzen.

Schwierigkeitsgrad: Mittel | Dauer: 20–40 Minuten | Ergebnis: DeepSeek-Reasonix zum Laufen bringen und verstehen, wie konfigurationsgetriebene Steuerung, Projektanweisungen, Zwei-Modell-Zusammenarbeit und die Anbindung kostengünstiger Schnittstellen funktionieren

Zielgruppe

• Entwickler, die mit DeepSeek einen kostengünstigen Programmier-Agenten aufbauen möchten
• Ingenieure, die häufig im Terminal Code ändern und sich einen lokalen KI-Assistenten wünschen
• Personen, die KI-Agenten in Team-Codebasen integrieren möchten, dabei aber die Token-Kosten im Blick behalten
• Nutzer, die bereits Claude Code, Codex oder OpenClaw verwendet haben und das DeepSeek-Ökosystem vergleichen möchten

Kernabhängigkeiten und Umgebung

Vollständiger Projektstrukturbaum

Wir bereiten ein minimales Demo-Projekt vor:

reasonix-agent-demo/
├── .env.example
├── reasonix.toml
├── REASONIX.md
├── tasks/
│   └── bugfix.md
└── demo-app/
    ├── package.json
    └── src/
        └── price.ts

1. Reasonix CLI installieren

Der einfachste Weg ist die Installation über npm:

npm i -g reasonix

Installation überprüfen:

reasonix --version

Wenn du macOS verwendest, kannst du auch Homebrew nutzen:

brew install esengine/reasonix/reasonix

Windows-Nutzern wird empfohlen, PowerShell oder Windows Terminal zu verwenden:

npm i -g reasonix
reasonix --version

2. DeepSeek API Key konfigurieren

Lege zunächst ein Demo-Verzeichnis an:

mkdir reasonix-agent-demo
cd reasonix-agent-demo

Bereite .env.example vor:

DEEPSEEK_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxx
DEFAPI_API_KEY=defapi_xxxxxxxxxxxxxxxxxxxxx

Kopiere es als lokale Umgebungsdatei:

cp .env.example .env

PowerShell-Variante:

Copy-Item .env.example .env

Trage anschließend deinen eigenen DeepSeek API Key ein.

3. Setup ausführen und die Erstkonfiguration abschließen

Führe jetzt den Initialisierungsbefehl aus:

reasonix setup

Folge den Hinweisen und wähle Provider und Modell aus. DeepSeek-Reasonix ist standardmäßig auf DeepSeek ausgerichtet, daher können wir zuerst den DeepSeek-Provider wählen und dann ein Modell, das sich gut für alltägliche Programmieraufgaben eignet.

Nach der Konfiguration startest du eine interaktive Sitzung:

reasonix

Du kannst zunächst eine einfache Frage stellen:

Bitte erkläre, welche Dateien sich aktuell im Projektverzeichnis befinden, und wo du empfehlen würdest, mit der Initialisierung zu beginnen.

Wenn Reasonix korrekt antwortet, ist die Kette aus CLI, Modell und API-Key erfolgreich verbunden.

4. reasonix.toml anlegen und den Provider fixieren

Damit die Konfiguration reproduzierbar bleibt, schreiben wir die zentralen Einstellungen in reasonix.toml:

default_model = "deepseek"
language = "zh"

[ui]
theme = "auto"

[agent]
temperature = 0.0
reasoning_language = "zh"
soft_compact_ratio = 0.5
tool_result_snip_ratio = 0.6
compact_ratio = 0.8
compact_force_ratio = 0.9

[[providers]]
name = "deepseek"
kind = "openai"
base_url = "https://api.deepseek.com"
models = ["deepseek-v4-flash", "deepseek-v4-pro"]
default = "deepseek-v4-flash"
api_key_env = "DEEPSEEK_API_KEY"
context_window = 1000000
effort = "high"

[environment]
enabled = true

Dabei sind einige Punkte besonders wichtig:

• default_model verweist auf den Provider-Namen; später kann innerhalb des Providers das Standardmodell gewechselt werden.
• temperature = 0.0 eignet sich besser für Code-Änderungsaufgaben, da die Ausgabe stabiler wird.
• context_window reserviert genügend Platz für lange Sitzungen.
• soft_compact_ratio und compact_ratio machen die Kontextpflege besser steuerbar.

Lade die Umgebungsvariablen beim Start explizit:

export $(grep -v '^#' .env | xargs)
reasonix

PowerShell kann so aussehen:

Get-Content .env | ForEach-Object {
  if ($_ -match "^(.*?)=(.*)$") {
    [Environment]::SetEnvironmentVariable($matches[1], $matches[2], "Process")
  }
}
reasonix

5. Mit /init Projektanweisungen generieren

Bei Codeaufgaben ist es für den Agenten am schwierigsten, wenn die Projektregeln jedes Mal neu erklärt werden müssen. Reasonix unterstützt im interaktiven Modus:

/init

Dadurch wird anhand des aktuellen Projekts eine Projektanweisung erzeugt. Wir können sie auch manuell als REASONIX.md anlegen:

# Reasonix Projektanweisungen

## Projektziel

Dies ist ein minimales Beispielprojekt zur Validierung des Reasonix-Programmier-Agenten.

## Entwicklungsregeln

- Vor Änderungen am Code zuerst den Plan erläutern.
- Wichtige Funktionen mit chinesischen Kommentaren versehen.
- Nach Abschluss der Änderung die Projekttests ausführen.
- Kein Git-Commit, sofern der Nutzer es nicht ausdrücklich verlangt.

## Häufige Befehle

```bash
npm test

> [!TIP]
> Je stabiler die Projektanweisungen sind, desto leichter trifft DeepSeek den Prefix Cache. Schreibe nicht täglich wechselnde Aufgabendetails in die dauerhaften Anweisungen, sondern lege sie besser in separaten Aufgabendateien ab.

## 6. Eine echte Codeaufgabe vorbereiten

Wir erstellen ein minimales TypeScript-Projekt:

```bash
mkdir -p demo-app/src tasks
cd demo-app
npm init -y
npm i -D typescript tsx
npx tsc --init
cd ..

Neue Datei demo-app/src/price.ts:

export type PriceInput = {
  amount: number;
  discountRate?: number;
};

export function calculateFinalPrice(input: PriceInput): number {
  const discount = input.discountRate || 0;
  return input.amount * (1 - discount);
}

Diese Funktion hat ein typisches Problem: discountRate wird nicht auf Grenzen geprüft; bei Eingabe von 1.5 entsteht ein negativer Preis.

Neue Datei tasks/bugfix.md:

# Aufgabe: Grenzproblem bei der Preisberechnung beheben

Bitte ändere `demo-app/src/price.ts`:

1. `amount` muss größer oder gleich 0 sein.
2. `discountRate` hat standardmäßig den Wert 0.
3. `discountRate` darf nur zwischen 0 und 1 liegen.
4. Füge `calculateFinalPrice` einen chinesischen Kommentar hinzu.
5. Ergänze einen Minimaltest oder ein ausführbares Prüfskript.

Nun lassen wir Reasonix die Aufgabe ausführen:

reasonix run "Lies tasks/bugfix.md und setze die dort beschriebene Codeänderung um."

Du wirst sehen, wie Reasonix die Aufgabe liest, Dateien prüft, einen Änderungsvorschlag macht und dann mit Tools Code schreibt. Genau darin unterscheidet sich ein Coding Agent von einem normalen Chatbot: Er erklärt nicht nur ein Problem, sondern geht ins Projekt und ändert Dateien.

7. Planner/Executor-Zwei-Modellmodus konfigurieren

Der Ein-Modell-Modus erledigt bereits viele Aufgaben, aber komplexe Anforderungen brauchen oft zuerst Planung und dann Ausführung. Reasonix unterstützt in der Konfiguration die Trennung von Planner und Executor:

[agent]
temperature = 0.0
planner_model = "deepseek-pro"
reasoning_language = "zh"

[[providers]]
name = "deepseek"
kind = "openai"
base_url = "https://api.deepseek.com"
models = ["deepseek-v4-flash", "deepseek-v4-pro"]
default = "deepseek-v4-flash"
api_key_env = "DEEPSEEK_API_KEY"
context_window = 1000000
effort = "high"

[[providers]]
name = "deepseek-pro"
kind = "openai"
base_url = "https://api.deepseek.com"
model = "deepseek-v4-pro"
api_key_env = "DEEPSEEK_API_KEY"
context_window = 1000000
effort = "high"

Eine praktische Kombination ist:

So lassen sich Kosten kontrollieren und gleichzeitig wird bei wichtigen Schritten ein stärkeres Modell für die Bewertung eingesetzt.

8. Defapi-kompatible Schnittstelle anbinden

Die Provider von Reasonix sind konfigurationsgetrieben. Solange der Ziel-Dienst eine OpenAI-artige Schnittstelle unterstützt, kann er als Provider eingebunden werden. Das eignet sich sehr gut für Defapi.

Der Vorteil von Defapi ist, dass der Preis meist nur etwa halb so hoch ist wie beim Originalanbieter, und die Modelle weitgehend mit den folgenden Protokollen kompatibel sind:

• v1/chat/completions
• v1/messages
• v1beta/models/

Wir können in reasonix.toml einen zusätzlichen Defapi-Provider anlegen:

[[providers]]
name = "defapi-claude"
kind = "openai"
base_url = "https://api.defapi.org/api/v1"
model = "anthropic/claude-sonnet-4.5"
api_key_env = "DEFAPI_API_KEY"
context_window = 200000

Danach das Standardmodell umschalten:

default_model = "defapi-claude"

Oder du behältst DeepSeek als Standard-Executor und nutzt das starke Modell auf Defapi als Planner:

default_model = "deepseek"

[agent]
planner_model = "defapi-claude"
temperature = 0.0

[[providers]]
name = "deepseek"
kind = "openai"
base_url = "https://api.deepseek.com"
models = ["deepseek-v4-flash", "deepseek-v4-pro"]
default = "deepseek-v4-flash"
api_key_env = "DEEPSEEK_API_KEY"
context_window = 1000000
effort = "high"

[[providers]]
name = "defapi-claude"
kind = "openai"
base_url = "https://api.defapi.org/api/v1"
model = "anthropic/claude-sonnet-4.5"
api_key_env = "DEFAPI_API_KEY"
context_window = 200000

Diese Kombination eignet sich sehr gut für die Praxis: Standardaufgaben laufen über DeepSeek und halten die Kosten niedrig, während komplexe Planung oder Code-Review über das starke Modell auf Defapi erfolgt. Auf Provider-Ebene vereinheitlicht, muss Reasonix keinen neuen Code für jeden Modellanbieter schreiben.

9. Eine vollständige Validierung durchführen

Jetzt machen wir eine vollständige Prüfung:

reasonix run "Prüfe die Implementierung von demo-app/src/price.ts und erkläre, ob es noch Grenzprobleme gibt."

Anschließend lassen wir eine Aufgabe ausführen, die näher an der echten Arbeit ist:

reasonix run "Bitte füge demo-app einen npm test-Befehl hinzu und verwende ein Minimal-Skript, um die drei Szenarien normaler Preis, Rabatt und ungültiger Rabatt für calculateFinalPrice zu prüfen."

Zum Schluss die Git-Änderungen ansehen:

git diff

Wenn du siehst, dass Reasonix Code geändert, Tests ergänzt und die Gründe für die Änderungen erklärt hat, dann läuft dieser minimale Agent-Workflow bereits erfolgreich.

Häufige Probleme beheben

1. Der Befehl reasonix wird nicht gefunden

Prüfe zuerst das globale npm-Verzeichnis:

npm config get prefix
npm bin -g

Falls npm bin -g nicht verfügbar ist, kannst du alternativ verwenden:

npm root -g

Nachdem du das globale Installationsverzeichnis gefunden hast, füge das entsprechende Ausführungsverzeichnis zu PATH hinzu. Windows-Nutzer müssen das Terminal meist neu öffnen.

2. Keine Berechtigung für die globale npm-Installation

Unter macOS/Linux solltest du nicht einfach sudo verwenden. Stattdessen kannst du das globale npm-Verzeichnis in das Benutzerverzeichnis verschieben:

mkdir -p ~/.npm-global
npm config set prefix ~/.npm-global
export PATH="$HOME/.npm-global/bin:$PATH"
npm i -g reasonix

Danach solltest du die PATH-Konfiguration in die Startdatei deiner Shell schreiben.

3. Der DeepSeek API Key wird nicht wirksam

Prüfe zuerst, ob die Umgebungsvariable vorhanden ist:

echo "$DEEPSEEK_API_KEY"

PowerShell:

$env:DEEPSEEK_API_KEY

Wenn die Ausgabe leer ist, wurde .env in diesem Terminal nicht geladen. Du kannst sie zunächst manuell setzen:

export DEEPSEEK_API_KEY="sk-xxxxxxxxxxxxxxxx"
reasonix

4. reasonix.toml wird nicht gelesen

Reasonix liest die Konfiguration normalerweise in der Reihenfolge „Befehlsparameter, Konfiguration im aktuellen Verzeichnis, globale Benutzerkonfiguration, eingebaute Standardwerte“. Stelle zuerst sicher, dass du im Projektstamm arbeitest:

pwd
ls reasonix.toml

Dann ausführen:

reasonix run "Bitte nenne das aktuell verwendete Modell und den Provider."

Wenn die Ausgabe nicht zur Konfiguration passt, prüfe zuerst, ob Befehlszeilenparameter oder globale Konfiguration die Konfiguration im aktuellen Verzeichnis überschreiben.

5. Das Modell antwortet langsam oder die Kosten sind zu hoch

Teile die Aufgabe zuerst kleiner auf:

reasonix run "Lies nur demo-app/src/price.ts und ändere noch nichts; nenne zunächst die potenziellen Probleme."

Danach die Änderung:

reasonix run "Ändere nur demo-app/src/price.ts basierend auf den eben genannten Problemen."

In langen Sitzungen begünstigen stabile Projektanweisungen und wenig veränderte Aufgabendefinitionen einen besseren Cache-Treffer. Bei komplexen Aufgaben kannst du den Planner/Executor-Zwei-Modellmodus aktivieren und das teurere Modell nur in der Planungsphase einsetzen.

6. Der Agent ändert Dateien ohne Freigabe

Prüfe den aktuellen Arbeitsmodus. In interaktiven Sitzungen kann man auf einen vorsichtigeren Modus umschalten und vor Tool-Aufrufen eine Bestätigung verlangen. Für Teamprojekte empfiehlt es sich, standardmäßig Genehmigungen zu aktivieren und nicht direkt in einen unbeaufsichtigten automatischen Änderungsmodus zu wechseln.

Du kannst Reasonix zunächst nur lesen lassen:

reasonix run "Nur analysieren, nichts ändern: Bitte prüfe die Probleme in demo-app/src/price.ts."

Nach Bestätigung des Plans erst die Änderung ausführen.

7. Chinesische Zeichendarstellung ist im Windows-Terminal fehlerhaft

Unter PowerShell kannst du zuerst UTF-8 einstellen:

chcp 65001
$OutputEncoding = [System.Text.Encoding]::UTF8

Wenn die Ausgabe weiterhin fehlerhaft ist, wird die Nutzung von Windows Terminal empfohlen. Stelle außerdem sicher, dass Editor, Terminal und Git UTF-8 verwenden.

Weiterführende Lektüre / nächste Schritte

• Reasonix Desktop-Client nutzen, um den terminalbasierten Agent-Workflow in eine grafische Oberfläche zu verlagern.
• VS-Code-Erweiterung installieren, damit Reasonix den Editor-Kontext liest und Tool-Freigaben behandelt.
• MCP-kompatible Plugins konfigurieren, um interne Skripte, Datenbankabfragen und Dokumentensuche in den Agenten einzubinden.
• Sub-Agenten für Aufgaben wie review, security_review oder research einsetzen.
• Reasonix in einen OpenClaw-Workflow integrieren, damit der Chat-Einstieg echte Codeaufgaben auslöst.
• Defapi mit v1/chat/completions oder v1/messages anbinden, um DeepSeek-, Claude- und Gemini-Modellanbieter zentral zu verwalten.