Kostengünstiges agiles Programmieren – Aufbau einer Produktionsreifen Lösung
Kostengünstiges agenbasiertes Coden: Eine produktionsreife lokale LLM-Lösung mit LiteLLM-Routing, Prompt-Caching sowie OpenAI-kompatiblen Endpunkten, die die Kosten senken.
Dieser Leitfaden zeigt den Weg von Rohstoffen bis zu einem funktionsfähigen System für: Kostenoptimiertes agierendes Programmieren: Erstellung eines Produktionsreifen lokalen LLM-Proxy, Multi-Agent-Architektur sowie sichere Werkzeuge mit Zoo Code, TensorX und DeepInfra. Der Schwerpunkt liegt auf ausführbaren Schritten, expliziten Überprüfungen sowie Code, den man ohne Rätseln über die Absicht direkt in ein Repository einfügen kann.
Zusammenfassung
Für die Zusammenfassung sollten vor der Code-Änderung Eingaben, Verantwortliche für die jeweiligen Schritte sowie Abschlusskriterien definiert werden. Die Betreiber sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Zeiten sowie Kosten für Token oder Abfragen sollten neben den funktionalen Ergebnissen aufgezeichnet werden. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Prozess von einer Demo in gemeinsam genutzte Umgebungen übergeht. Bei dem nächsten Schritt, der Code oder einen Toolaufruf beinhaltet, sollten strukturierte Ausgaben mit Schema-Validierung Vorrang vor freiformiger Prosa haben.
1. Architektonischer Überblick: Das lokale Proxy-Muster
Zu 1. Architektonischer Überblick: Das lokale Proxy-Muster sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zustände schließen zu müssen. Die Konfiguration sollte außerhalb des Anwendungscode gespeichert werden. Umgebungsdateien, Geheimdatenspeicher sowie Feature-Flags sollten an einem Ort zusammengefasst sein, den die Operator überprüfen können, ohne den gesamten Ablaufverlauf durchlesen zu müssen. Wählen Sie bei dem nächsten Schritt, der ein Codeabschnitt oder einen Toolaufruf ist, strukturierte Ausgaben mit Schema-Validierung statt freier Prosa.
Protokollübersetzungsschicht
Für die Protokollübersetzungsschicht sollten vor der Codeänderung Eingaben, Verantwortliche für die jeweiligen Schritte sowie Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholungsversuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Verwenden Sie bei dem nächsten Schritt, der ein Codeabschnitt oder einen Toolaufruf ist, lieber strukturierte Ausgaben mit Schema-Validierung statt freier Prosa.
2. Hauptkonfiguration: Einführung in litellm_config.yaml
Zur zweiten Master-Konfiguration: Einen detaillierten Blick in litellm_config.yaml werfen, die Eingaben, den Verantwortlichen für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definieren. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen.
Bevorzugen Sie kleine, testbare Einheiten vor umfangreichen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Pipeline-System.
Wählen Sie bei dem nächsten Schritt, der aus Code oder einem Toolaufruf besteht, strukturierte Ausgaben mit Schema-Validierung statt freier Prosa.
# litellm_config.yaml
litellm_settings:
drop_params: true
modify_params: true
model_list:
# =========================================================================
# WILDCARD CATCH-ALL ROUTES
# Allows on-the-fly usage of any model published by TensorX or DeepInfra
# Example: tensorx/qwen/qwen3.8-2.4t-a95b
# =========================================================================
- model_name: "tensorx/*"
litellm_params:
model: "openai/*"
api_base: https://api.tensorx.ai/v1
api_key: "PLACEHOLDER_TENSORX_KEY"
use_chat_completions_api: true
- model_name: "deepinfra/*"
litellm_params:
model: "openai/*"
api_base: https://api.deepinfra.com/v1/openai
api_key: "PLACEHOLDER_DEEPINFRA_KEY"
use_chat_completions_api: true
# =========================================================================
# TENSORX NAMED SHORT ALIASES
# =========================================================================
- model_name: kimi-k3
litellm_params:
model: openai/moonshotai/kimi-k3
api_base: https://api.tensorx.ai/v1
api_key: "PLACEHOLDER_TENSORX_KEY"
use_chat_completions_api: true
- model_name: glm-5.2
litellm_params:
model: openai/z-ai/glm-5.2
api_base: https://api.tensorx.ai/v1
api_key: "PLACEHOLDER_TENSORX_KEY"
use_chat_completions_api: true
- model_name: kimi-k2.7-code
litellm_params:
model: openai/moonshotai/kimi-k2.7-code
api_base: https://api.tensorx.ai/v1
api_key: "PLACEHOLDER_TENSORX_KEY"
use_chat_completions_api: true
- model_name: glm-5.1
litellm_params:
model: openai/z-ai/glm-5.1
api_base: https://api.tensorx.ai/v1
api_key: "PLACEHOLDER_TENSORX_KEY"
use_chat_completions_api: true
# =========================================================================
# DEEPINFRA NAMED SHORT ALIASES
# =========================================================================
- model_name: deepseek-v4-pro
litellm_params:
model: openai/deepseek-ai/DeepSeek-V4-Pro
api_base: https://api.deepinfra.com/v1/openai
api_key: "PLACEHOLDER_DEEPINFRA_KEY"
use_chat_completions_api: true
- model_name: qwen3-coder-480b
litellm_params:
model: openai/Qwen/Qwen3-Coder-480B-A35B-Instruct
api_base: https://api.deepinfra.com/v1/openai
api_key: "PLACEHOLDER_DEEPINFRA_KEY"
use_chat_completions_api: true
- model_name: qwen3.6-35b
litellm_params:
model: openai/Qwen/Qwen3.6-35B-A3B
api_base: https://api.deepinfra.com/v1/openai
api_key: "PLACEHOLDER_DEEPINFRA_KEY"
use_chat_completions_api: true
- model_name: glm-4.7-flash
litellm_params:
model: openai/zai-org/GLM-4.7-Flash
api_base: https://api.deepinfra.com/v1/openai
api_key: "PLACEHOLDER_DEEPINFRA_KEY"
use_chat_completions_api: true
- model_name: nemotron-3-ultra
litellm_params:
model: openai/nvidia/Nemotron-3-Ultra
api_base: https://api.deepinfra.com/v1/openai
api_key: "PLACEHOLDER_DEEPINFRA_KEY"
use_chat_completions_api: true
# =========================================================================
# PROXY AUTHENTICATION GATEWAY
# =========================================================================
general_settings:
master_key: "PLACEHOLDER_MASTER_KEY"
Kritische Konfigurationsmechanismen
Für kritische Konfigurationsmechanismen sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Vorgänge ab. Wählen Sie bei dem nächsten Schritt Code oder einen Toolaufruf strukturierte Ausgaben mit Schema-Validierung statt freier Prosa vor. Für kritische Konfigurationsmechanismen sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf verborgene Zustände schließen zu müssen. Halten Sie die Konfiguration außerhalb des Anwendungscode. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gespeichert sein, den die Operator überprüfen können, ohne den gesamten Ablauf durchlesen zu müssen.
3. Bedrohungsmodellierung und Sicherheit durch mehrfache Absicherung
Beim Arbeiten an 3. Bedrohungsmodellierung und Sicherheit durch mehrfache Absicherung sollten Sie zunächst den Ablauf beschreiben: erforderliche Eingaben, Signal für Erfolg sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Wiederherstellungsprozess gemeinsam. Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Speichern Sie stabile Systemanweisungen sowie Tool-Schemata im Cache. Das erneute Senden identischer Voranmeldungen ist eine häufige Ursache für Ressourcenverschwendung.
Das Open Relay-Sicherheitslückenmuster
Beim Arbeiten am The Open Relay Vulnerability Pattern sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Preambles ist eine häufige Ursache für Ressourcenverschwendung.
Der Dual-Layer-Mitigation-Standard
Beim Arbeiten am Dual-Layer Mitigation Standard sollten Sie zunächst einen Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Speichern Sie stabile Systemanweisungen sowie Tool-Schemata im Cache. Das erneute Senden identischer Preambles ist eine häufige Ursache für Ressourcenverschwendung. Beim Arbeiten am Dual-Layer Mitigation Standard sollten Sie zunächst einen Vertrag aufschreiben: erforderliche Eingaben, Erfolgssignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Legen Sie die Konfiguration außerhalb des Anwendungscode ab. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreiber ohne das Durchlesen des gesamten Systems überprüfen können.
# Executable Proxy Invocation Command
LITELLM_USE_CHAT_COMPLETIONS_URL_FOR_ANTHROPIC_MESSAGES=true \
litellm --config ~/.claude/litellm_config.yaml \
--host 127.0.0.1 \
--port 4000
# Authentication Enforcement inside litellm_config.yaml
general_settings:
master_key: "sk-7i9UOL9jkji09löOIhM..."
Architektur der Geheimnisgetrennung
Die Architektur der Geheimnisgetrennung funktioniert am besten, wenn sie als messbare Größe betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Ausfallfall sowie eine Notiz zur Rücksetzung. Dokumentieren Sie gleichzeitig den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Legen Sie Budgetgrenzen pro Schritt sowie pro Sitzung fest. Agentenbasierte Tools erweitern den Kontext stark; feste Obergrenzen verhindern, dass Demonstrationen zu unerwarteten Rechnungen werden.
4. Kosteneinschätzung bei mehreren Agenten: Orchestrator, Scout und günstiger Programmierer
- Mehr-Agenten-Kostenplanung: Orchestrator, Scout und Cheap Coder funktionieren am besten, wenn sie als messbare Größen betrachtet werden. Erfassen Sie vor der Erweiterung des Umfangs ein gelungenes Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufverfahren. Legen Sie Budgetgrenzen pro Zug und pro Sitzung fest. Agentenbasierte Tools erweitern den Kontext stark; feste Obergrenzen verhindern, dass Demonstrationen zu unerwarteten Rechnungen werden.
Das Problem des kontinuierlichen Kontextwachstums bei Agenten
Das Problem des kontinuierlichen Kontextwachstums bei agilen Systemen lässt sich am besten als messbare Größe betrachten. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die relevanten Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Legen Sie Budgetgrenzen pro Turnus und pro Sitzung fest. Agierende Tools erweitern den Kontext oft aggressiv; feste Obergrenzen verhindern, dass Demonstrationen zu unerwarteten Rechnungen werden. Das Problem des kontinuierlichen Kontextwachstums bei agilen Systemen lässt sich am besten als messbare Größe betrachten. Erfassen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Bewahren Sie Konfigurationen außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher sowie Feature-Flags sollten an einem Ort gesammelt sein, den Betreuer ohne Durchsicht des gesamten Systems prüfen können.
Die Lösung mit drei Agenten
Für die Tri-Agent-Lösung sollten Eingabedaten, der Verantwortliche für den jeweiligen Schritt sowie die Abbruchkriterien vor dem Codeändern definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholungsversuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Wählen Sie bei dem nächsten Schritt, der ein Codeabschnitt oder einen Toolaufruf ist, strukturierte Ausgaben mit Schema-Validierung vor.
Vergleich der Kontextkosten
Zur Vergleich der Kosten im Kontext sollten vor dem Ändern des Codes die Eingabedaten, der Verantwortliche für den Schritt sowie die Abbruchkriterien definiert werden. Die Operator sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckte Zustände schließen zu müssen. Vorzuziehen sind kleine, testbare Einheiten statt umfangreicher Skripte. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Bei dem nächsten Schritt, der aus Code oder einem Toolaufruf besteht, sind strukturierte Ausgaben mit Schema-Validierung vor freiformiger Prosa zu bevorzugen.
Deklarationen im Custom-Modus (custom_modes.yaml)
Für Deklarationen im Custom-Modus (custom_modes.yaml) sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Operator:innen sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen.
Betrachten Sie diese Phase als Vertrag zwischen den Eingaben und den validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab.
Wählen Sie bei dem nächsten Schritt Code oder einen Toolaufruf strukturierte Ausgaben mit Schema-Validierung statt freier Prosa. Für Deklarationen im Custom-Modus (custom_modes.yaml) sollten die Eingaben, der Verantwortliche für den Schritt sowie die Abbruchkriterien vor dem Ändern des Codes definiert werden. Operator:innen sollten in der Lage sein, den Schritt von einem bekannten Checkpoint aus erneut auszuführen, ohne auf versteckten Zuständen schließen zu müssen.
Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gespeichert werden, den Operator:innen überprüfen können.
customModes:
- slug: scout
name: 🔍 Scout
roleDefinition: >-
You are a reconnaissance specialist. The orchestrator cannot read files,
so you read them on its behalf and return the smallest set of facts it
needs to write a precise implementation brief: exact paths, exact symbol
locations, and only the excerpts that matter.
whenToUse: >-
Use as the first subtask whenever the orchestrator does not already know
the exact file paths and code shape involved. Always run a scout before
delegating implementation into a codebase area that has not been mapped.
groups:
- read
customInstructions: >-
WHY YOU EXIST: Your report is pasted into the orchestrator's context,
which runs on the most expensive model in this system. Raw file dumps
read there cost many times what they cost here. Your job is to convert
a lot of cheap reading into a little expensive context.
WHAT TO RETURN: Exact repo-relative paths with line numbers. The signature
or declaration of every symbol that matters. Only excerpts directly relevant
to the task. Maximum budget: ~40 lines of total quoted code across all files.
NEVER paste full files. NEVER suggest solutions or fixes—report facts only.
- slug: cheap-coder
name: 💸 Cheap Coder
roleDefinition: >-
You are a focused implementation worker. You receive a precise,
self-contained task brief from an orchestrator and apply the smallest
correct code change that satisfies it. You do not design architecture,
you do not explore the repository on your own, and you do not invent requirements.
whenToUse: >-
Use for delegated single-purpose implementation subtasks whose target files
and intent are already named in the brief. Do not use for investigation
or architectural design.
groups:
- read
- edit
- command
customInstructions: >-
SCOPE: Work only from the files and excerpts named in your task brief.
Do not search or browse the repository to build your own picture; the
orchestrator already paid for exploration and passed you the result.
If the brief is missing a file or fact, stop and report exactly what is
missing instead of hunting for it.
EDITS: Apply the minimal diff that satisfies the brief. Preserve surrounding
style, type annotations, and conventions. Run only the single verification
command specified in the brief. If verification fails twice, stop and report.
Kundenspezifische Anweisungen für Orchestrator
Beim Arbeiten mit kundenspezifischen Anweisungen für Orchestrator sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Wiederherstellungsprozess gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlnachrichten gehören zum Produkt selbst und nicht zu späteren Optimierungen. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Präambeln ist eine häufige Ursache für Ressourcenverschwendung.
You cannot read files. Before delegating any implementation into code you have
not yet mapped, delegate a `scout` subtask first and use its report to write the
implementation brief.
Delegate implementation with new_task to `cheap-coder`, never to `code`. Every
brief must be self-contained—the worker cannot see this conversation. Include:
the exact file paths from the scout report, the excerpts the scout returned, the
precise change wanted, and the single verification command to run.
Never paste a scout report into a brief wholesale; pass only the part that
subtask needs.
After an implementation subtask reports success, do not accept its self-assessment.
Delegate a separate `scout` subtask to verify: have it confirm the changed files now
contain what was asked and report the verification command's output verbatim. Decide
on the scout's facts, not the implementer's summary.
Once the scout's verification confirms the change is correct, use
ask_followup_question to ask the user for permission to commit, and separately ask
for permission to push—approval of one is never approval of the other. If the user
approves committing, delegate to `cheap-coder` with a brief naming only the exact
relative paths of the files that actually changed to stage (never `git add .` or
`git add -A`) and the exact commit message to use: a single short line, imperative
mood, no `Co-Authored-By` trailer, no "Generated with" attribution line. Only include
a push step in that brief if the user separately approved pushing.
5. Modellökonomie und Nutzung des Prompt-Cachings
Beim Arbeiten an „5. Model Economics and Prompt Caching Leverage“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikator sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Vorlagen ist eine häufige Ursache für Ressourcenverschwendung.
Modell im Fokus: qwen3.8-2.4t-a95b (TensorX)
Beim Arbeiten mit Model Spotlight: qwen3.8-2.4t-a95b (TensorX) sollten Sie zunächst einen Vertrag aufstellen: erforderliche Eingaben, Signal für Erfolg sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben.
Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Erzeugnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab.
Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Vorlagen ist eine häufige Ursache für Ressourcenverschwendung.
Die Mechanik des Prompt-Cachings
Beim Arbeiten an „The Mechanics of Prompt Caching“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie die Laufzeiten sowie die Kosten für Tokens oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Einsatzbereich von einer Demo in gemeinsame Umgebungen wechselt. Speichern Sie stabile Systemanweisungen sowie Tool-Schemata im Cache. Das erneute Senden identischer Vorlagen ist eine häufige Ursache für unnötige Ressourcenverbrauch.
Turn 1: [System Prompt + Tool Definitions + File Map] -> Written to Cache ($2.50 / 1M)
Turn 2: [System Prompt + Tool Definitions + File Map] -> CACHE HIT ($0.63 / 1M) -> 75% Savings
Turn 3: [System Prompt + Tool Definitions + File Map] -> CACHE HIT ($0.63 / 1M) -> 75% Savings
6. Telemetrie, Privatsphäre und Prüfung der lokalen Ausführung
Beim Arbeiten an Kapitel 6 „Telemetrie, Privatsphäre und Prüfung der lokalen Ausführung“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreiber prüfen können, ohne den gesamten Code durchzulesen. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Preambles ist eine häufige Ursache für Ressourcenverschwendung.
Audit-Ergebnisse
Beim Bearbeiten von Prüfungsergebnissen sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Wiederherstellungsprozess gemeinsam. Versuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Speichern Sie stabile Systemanweisungen sowie Tool-Schemata im Cache – das erneute Senden identischer Vorlagen ist eine häufige Ursache für Ressourcenverschwendung.
Telemetrie auf Null absichern
Beim Arbeiten an der Vollständigen Absicherung der Telemetrie sollte man zunächst den Ablaufplan aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Zur Vorzugswahl gehören kleine, testbare Einheiten statt umfangreicher Skripte. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortungsbereich verweisen und nicht auf ein verworrenes Ablaufschema. Speichern Sie stabile Systemanweisungen sowie Tool-Schemata im Cache. Das erneute Senden identischer Voranmeldungen ist eine häufige Ursache für Ressourcenverschwendung.
{
"telemetry.telemetryLevel": "off"
}
7. Schritt-für-Schritt-Anleitung zur Produktionseinrichtung
Beim Bearbeiten des Leitfadens „7. Schritt-für-Schritt-Anleitung zur Produktionseinrichtung“ sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsindikatoren sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Erzeugnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Speichern Sie stabile Systemanweisungen sowie Tool-Schemata im Cache. Das erneute Senden identischer Vorlagen ist eine häufige Ursache für Ressourcenverschwendung.
Schritt 1: Initialisierung der Umgebung
Beim Bearbeiten von Schritt 1: Umgebungsinitialisierung sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Notieren Sie außerdem die Laufzeiten sowie die Kosten für Token oder Abfragen neben den funktionalen Ergebnissen. Eine frühzeitige Sichtbarkeit der Kosten verhindert überraschende Rechnungen, wenn der Einsatzbereich von einer Demo-Umgebung in gemeinsam genutzte Umgebungen wechselt. Speichern Sie stabile Systemanweisungen sowie Tool-Schemata im Cache – das erneute Senden identischer Voranmeldungen ist eine häufige Ursache für Ressourcenverbrauch.
# Start LiteLLM Proxy in foreground
alias claude-proxy='LITELLM_USE_CHAT_COMPLETIONS_URL_FOR_ANTHROPIC_MESSAGES=true litellm --config ~/.claude/litellm_config.yaml --host 127.0.0.1 --port 4000'
# Start LiteLLM Proxy in background with health check
cx-proxy-up() {
if ! ss -ltn | grep -q ":4000 "; then
echo "Starting LiteLLM Proxy on 127.0.0.1:4000..."
LITELLM_USE_CHAT_COMPLETIONS_URL_FOR_ANTHROPIC_MESSAGES=true \
nohup litellm --config ~/.claude/litellm_config.yaml --host 127.0.0.1 --port 4000 > /tmp/litellm-proxy.log 2>&1 &
# Wait for readiness endpoint
until curl -s http://127.0.0.1:4000/health/readiness | grep -q '"status":"healthy"'; do
sleep 0.5
done
echo "LiteLLM Proxy is online and healthy."
else
echo "LiteLLM Proxy is already running on port 4000."
fi
}
# CLI model catalog search tool
cx-find() {
python3 ~/.claude/cx-find.py "$@"
}
source ~/.bashrc
Schritt 2: Proxy initialisieren
Beim Bearbeiten von Schritt 2: Initialisierung des Proxys, sollten Sie zunächst den Vertrag aufschreiben – dabei sind die erforderlichen Eingaben, das Erfolgsignal sowie die Reaktion bei teilweisen Fehlern relevant. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Bewahren Sie die Konfiguration außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreiber ohne das Durchlesen des gesamten Systems überprüfen können. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Preambles ist eine häufige Ursache für Ressourcenverschwendung.
cx-proxy-up
ss -ltnp | grep :4000
# Expected output: LISTEN 0 128 127.0.0.1:4000 ...
curl -s http://127.0.0.1:4000/health/readiness
# Expected output: {"status":"healthy","db":"Not connected"}
Schritt 3: Konfigurieren der Zoo Code Extension Profiles
Beim Bearbeiten von Schritt 3: Konfigurieren der Zoo Code Extension Profiles sollten Sie zunächst den Vertrag aufschreiben – die erforderlichen Eingaben, das Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Dokumentieren Sie sowohl den erfolgreichen Ablauf als auch den Notfallweg gemeinsam. Wiederholte Versuche, menschliche Überprüfungen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Speichern Sie stabile Systemanweisungen sowie Tool-Schemata im Cache – das erneute Senden identischer Preambles ist eine häufige Ursache für Probleme.
Profile
Beim Arbeiten mit Profilen sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Ziehen Sie kleine, testbare Einheiten vor großen Skripten. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf ein verworrenes Ablaufschema. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Voranmeldungen ist eine häufige Ursache für Ressourcenverschwendung.
Schritt 4: Bindungen von Modus zu Profil
Beim Arbeiten an Schritt 4: Mode-zu-Profile-Bindungen sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgsignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Artefakte, definieren Sie Erfolgsprüfungen und lehnen Sie stille, teilweise abgeschlossene Abläufe ab. Cachen Sie stabile Systemanweisungen sowie Tool-Schemata. Das erneute Senden identischer Präambeln ist eine häufige Ursache für Ressourcenverschwendung. Beim Arbeiten an Schritt 4: Mode-zu-Profile-Bindungen sollten Sie zunächst den Vertrag aufschreiben: erforderliche Eingaben, Erfolgssignal sowie das Vorgehen bei teilweisen Fehlern. Diese Checkliste sorgt dafür, dass spätere Codeänderungen transparent bleiben. Bewahren Sie Konfigurationen außerhalb des Anwendungscode auf. Umgebungsdateien, Geheimdatenspeicher und Feature-Flags sollten an einem Ort gesammelt sein, den Betreiber ohne das Durchlesen des gesamten Systems überprüfen können.
🪃 Orchestrator --> orchestrator profile
🔍 Scout --> worker profile
💸 Cheap Coder --> worker profile
Debug --> orchestrator profile
8. Leitfaden zur Überprüfung und Fehlerbehebung
- Der Leitfaden zur Überprüfung und Fehlerbehebung funktioniert am besten, wenn er als messbarer Rahmen betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein optimales Transkript, einen Fehlerfall sowie die Notizen zur Rücksetzung. Dokumentieren Sie gleichzeitig den erfolgreichen Ablauf sowie den Wiederherstellungsprozess. Wiederholversuche, menschliche Kontrollen sowie die Handhabung von Fehlern gehören zum Produkt selbst und nicht zu späteren Optimierungen. Legen Sie Budgets für Tokens pro Turnus und pro Sitzung fest. Agentenbasierte Tools erweitern den Kontext stark; feste Obergrenzen verhindern, dass Demonstrationen zu unerwarteten Rechnungen werden.
Überprüfung aktiver Modelle
Die Überprüfung aktiver Modelle funktioniert am besten, wenn sie als messbare Struktur betrachtet wird. Erfassen Sie vor der Erweiterung des Umfangs ein gelungenes Beispiel, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Ziehen Sie kleine, testbare Einheiten vor großen Skripten vor. Wenn ein Schritt fehlschlägt, sollte der Fehler auf eine einzige Verantwortung verweisen und nicht auf einen verworrenen Ablauf. Legen Sie Budgets für Tokens pro Turnus und pro Sitzung fest. Agentenbasierte Tools erweitern den Kontext stark; feste Obergrenzen verhindern, dass Demonstrationen zu unerwarteten Rechnungen werden.
curl -si http://localhost:4000/v1/messages \
-H "Authorization: Bearer YOUR_MASTER_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "content-type: application/json" \
-d '{"model":"kimi-k3","max_tokens":16,"messages":[{"role":"user","content":"hi"}]}' \
| grep -i x-litellm
Häufige Fehlercodes und Lösungen
„Gängige Fehlercodes und Lösungen“ funktioniert am besten, wenn sie als messbarer Rahmen betrachtet werden. Erstellen Sie vor der Erweiterung des Umfangs ein „goldenes Transkript“, einen Fehlerfall sowie eine Notiz zur Rücksetzung. Betrachten Sie diese Phase als Vertrag zwischen Eingaben und validierten Ausgaben. Benennen Sie die Ergebnisse, definieren Sie Erfolgskontrollen und lehnen Sie stille, unvollständige Abschlüsse ab. Legen Sie Budgetgrenzen pro Turnus und pro Sitzung fest – agierende Tools erweitern den Kontext oft übermäßig; feste Obergrenzen verhindern, dass Demonstrationen zu unerwarteten Rechnungen werden.
Fehler: HTTP 400 Keine verbundene Datenbank. / HTTP 500 Interner Serverfehler
Fehler: HTTP 403 Schlüssel erlaubt keinen Zugriff auf das Modell
Fehler: Sicheres Beendigen des Prozesses während Neustarts des Proxys
OLD_PID=$(ss -ltnp | grep ":4000" | grep -oE "pid=[0-9]+" | cut -d= -f2 | head -1)
if [ -n "$OLD_PID" ]; then
kill "$OLD_PID"
sleep 2
ss -ltn | grep -q ":4000" || echo "Port 4000 cleared successfully."
fi