Codage agentiel optimisé en fonction des coûts : Création d’un système de niveau production
Codage agentiel optimisé en termes de coûts : une solution LLM locale de niveau professionnel avec un routage LiteLLM, un cache de prompts et des points d’entrée compatibles OpenAI qui permettent de réduire les dépenses.
Ce guide reconstitue le parcours allant des matières premières à un système fonctionnel pour : le codage agentiel optimisé en termes de coûts : création d’un proxy LLM local de niveau production, une architecture multi-agents et des outils sécurisés utilisant Zoo Code, TensorX et DeepInfra. L’accent est mis sur des étapes opérationnelles, des vérifications explicites et du code que vous pouvez intégrer directement dans un dépôt sans devoir deviner l’intention derrière lui.
Résumé exécutif
Pour le résumé exécutif, définissez les entrées, le responsable de chaque étape ainsi que les critères d’achèvement avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans avoir à deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts permet d’éviter des factures inattendues lorsque le parcours passe de la démonstration à des environnements partagés. Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel d’outil.
1. Aperçu architectural : le modèle de proxy local
Pour l’1. Aperçu architectural : le modèle de proxy local, il convient de définir les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. La configuration doit être conservée en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Privilégiez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
Couche de traduction des protocoles
Pour la couche de traduction du protocole, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez conjointement le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
2. Configuration principale : Décryptage de litellm_config.yaml
Pour le niveau 2 : Configuration avancée. Explorez en profondeur le fichier litellm_config.yaml, définissez les entrées, le responsable de l’étape ainsi que les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu, sans avoir à deviner l’état caché.
Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un pipeline embrouillé.
Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
# 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"
Mécanismes critiques de configuration
Pour les mécanismes de configuration critiques, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définissez des vérifications de succès et refusez toute exécution partielle silencieuse. Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil. Pour les mécanismes de configuration critiques, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Gardez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système.
3. Modélisation des menaces et sécurité par défense en profondeur
Lorsque vous travaillez sur la section 3. Modélisation des menaces et sécurité par défense en profondeur, notez d’abord les exigences : entrées requises, signal de succès et conséquences en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez à la fois le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations apportées ultérieurement. Stockez en cache les instructions système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de problèmes.
Le schéma de vulnérabilité Open Relay
Lorsque vous travaillez sur le modèle de vulnérabilité The Open Relay, notez d’abord les exigences : entrées requises, signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé. Mémorisez les instructions système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de surconsommation.
La norme de mitigation à double couche
Lorsque vous travaillez sur la Norme de mitigation à double couche, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès et refusez toute exécution partielle silencieuse. Cachez les instructions du système stables ainsi que les schémas des outils. L’envoi répété d’un préambule identique est une cause fréquente de problèmes. Lorsque vous travaillez sur la Norme de mitigation à double couche, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Gardez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système.
# 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..."
Architecture de séparation des secrets
L’architecture de séparation des secrets fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript d’exécution idéal, un cas de défaillance et la note de rollback avant d’élargir le périmètre. Documentez en même temps le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’améliorations apportées ultérieurement. Déterminez un budget de tokens par tour et par session : les outils agents élargissent de manière importante le contexte ; des plafonds stricts empêchent que les démonstrations ne se transforment en factures inattendues.
4. Ingénierie des coûts multi-agents : Orchestrator, Scout et programmeur bon marché
- L’ingénierie des coûts multi-agents : Orchestrator, Scout et Cheap Coder fonctionnent le mieux lorsqu’ils sont considérés comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec ainsi que la note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit pointer vers une seule responsabilité plutôt que vers un processus embrouillé. Fixez des limites de tokens par tour et par session. Les outils agents élargissent lourdement le contexte ; des plafonds stricts empêchent que les démonstrations ne se transforment en factures inattendues.
Le problème de l’expansion incontrôlée du contexte par les agents
Le problème de l’expansion incontrôlée du contexte agentiel se résout le mieux lorsqu’il est considéré comme une entité mesurable. Capturez un exemple idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définites des critères de succès et refusez toute mise en œuvre partielle silencieuse. Fixez un budget de tokens par tour et par session. Les outils agents élargissent le contexte de manière agressive ; des plafonds stricts empêchent que les démonstrations ne se transforment en factures inattendues. Le problème de l’expansion incontrôlée du contexte agentiel se résout le mieux lorsqu’il est considéré comme une entité mesurable. Capturez un exemple idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Gardez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système.
La solution à trois agents
Pour la solution Tri-Agent, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie du produit, et non d’une mise en forme ultérieure. Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
Comparaison des coûts contextuels
Pour une comparaison des coûts dans le contexte, définissez les entrées, le responsable de l’étape et les critères d’arrêt avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables à des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Préférez des sorties structurées avec validation de schéma à du texte libre lorsque l’étape suivante consiste en du code ou une appel d’outil.
Déclarations de mode personnalisé (custom_modes.yaml)
Pour les déclarations de mode personnalisé (custom_modes.yaml), définitz les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définites des vérifications de succès et refusez toute exécution partielle silencieuse.
Préférez des sorties structurées avec validation de schéma plutôt que du texte libre lorsque l’étape suivante consiste en du code ou une appel à outil.
Pour les déclarations de mode personnalisé (custom_modes.yaml), définitz les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché.
Gardez la configuration en dehors du code de l’application. Les fichiers d’environnement, les stocks de secrets et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer.
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.
Instructions personnalisées d’Orchestrator
Lorsque vous travaillez sur les instructions personnalisées d’Orchestrator, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures. Mémorisez les instructions stables du système et les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de surcharge.
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. Économie du modèle et utilisation de la mise en cache des prompts
Lorsque vous travaillez sur la section 5. Économie des modèles et utilisation du cache des prompts, notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables plutôt que des scripts volumineux. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus complexe et embrouillé. Cachez les instructions du système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage.
Modèle en vedette : qwen3.8-2.4t-a95b (TensorX)
Lorsque vous travaillez sur Model Spotlight : qwen3.8-2.4t-a95b (TensorX), notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code.
Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès, et refusez les terminations partielles silencieuses.
Cachez les instructions stables du système et les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage.
La mécanique du cache des prompts
Lorsque vous travaillez sur « The Mechanics of Prompt Caching », notez d’abord les éléments essentiels : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le système passe d’un environnement de démonstration à des environnements partagés. Mémorisez les instructions du système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage.
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. Télémétrie, confidentialité et audit de l’exécution locale
Lorsque vous travaillez sur le chapitre 6 : Télémétrie, confidentialité et audit de l’exécution locale, notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans avoir à lire l’ensemble du système. Mémorisez les instructions stables du système ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage d’énergie.
Résultats de l’audit
Lors de l’analyse des résultats d’audit, notez d’abord les exigences du contrat : les données requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations apportées ultérieurement. Cachez les instructions du système stables ainsi que les schémas des outils. L’envoi répété d’un préambule identique est une cause fréquente de surcharge.
Rendre la télémétrie parfaitement sécurisée
Lorsque vous travaillez sur le renforcement de la télémétrie jusqu’au niveau zéro, notez d’abord les exigences : entrées requises, signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables plutôt que des scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé. Cachez les instructions du système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de surconsommation.
{
"telemetry.telemetryLevel": "off"
}
7. Guide pas à pas pour la configuration en production
Lorsque vous travaillez sur le guide « 7. Guide pas à pas pour la configuration de production », notez d’abord les conditions du contrat : entrées requises, signal de succès, et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès, et refusez les terminations partielles silencieuses. Cachez les instructions du système stable ainsi que les schémas des outils. L’envoi répété d’un préambule identique est une cause fréquente de problèmes.
Étape 1 : Initialisation de l’environnement
Lors de l’exécution de l’Étape 1 : Initialisation de l’environnement, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le système passe de l’environnement de démonstration à des environnements partagés. Mémorisez les instructions stables du système et les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage.
# 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
Étape 2 : Initialiser le proxy
Lorsque vous travaillez sur l’Étape 2 : Initialiser le proxy, notez d’abord les exigences du contrat : entrées requises, signal de succès, et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système. Mémorisez les instructions stables du système ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage.
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"}
Étape 3 : Configurer les profils d’extension du code Zoo
Lorsque vous travaillez sur l’Étape 3 : Configurer les profils d’extension Zoo Code, notez d’abord le contrat : les entrées requises, le signal de succès, ainsi que ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations apportées ultérieurement. Mémorisez les instructions du système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de surcharge.
Profils
Lorsque vous travaillez sur les profils, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables aux scripts volumineux. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus complexe et embrouillé. Cachez les instructions du système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de surcharge.
Étape 4 : Liens mode-profil
Lors de l’exécution de l’Étape 4 : Liaisons mode-profil, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Donnez des noms aux artefacts, définez des vérifications de succès et refusez les terminations partielles silencieuses. Cachez les instructions système stables ainsi que les schémas des outils. L’envoi répété d’un préambule identique est une cause fréquente de problèmes. Lors de l’exécution de l’Étape 4 : Liaisons mode-profil, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de garantir l’intégrité des modifications ultérieures du code. Gardez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système.
🪃 Orchestrator --> orchestrator profile
🔍 Scout --> worker profile
💸 Cheap Coder --> worker profile
Debug --> orchestrator profile
8. Guide de vérification et de dépannage
- Le guide de vérification et de dépannage fonctionne le mieux lorsqu’il est considéré comme une surface mesurable. Capturez un transcript parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours réussi et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’améliorations ultérieures. Prévoyez un budget de tokens par tour et par session. Les outils agents élargissent de manière importante le contexte ; des plafonds stricts empêchent que les démonstrations ne se transforment en factures inattendues.
Vérification des modèles actifs
Vérifier les modèles actifs fonctionne le mieux lorsqu’il est considéré comme une surface mesurable. Capturez un transcript parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’erreur doit pointer vers une seule responsabilité plutôt qu’un processus embrouillé. Fixez un budget de tokens par tour et par session. Les outils agents élargissent lourdement le contexte ; des plafonds stricts empêchent que les démonstrations ne se transforment en factures inattendues.
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
Codes d’erreur courants et solutions
Les codes d’erreur courants et leurs solutions fonctionnent le mieux lorsqu’ils sont considérés comme une surface mesurable. Capturez un exemplaire idéal, un cas d’échec et la note de réversion avant d’élargir le champ d’application. Considérez cette étape comme un contrat entre les entrées et les sorties validées. Nommez les artefacts, définites des vérifications de succès et refusez toute mise en œuvre partielle silencieuse. Fixez un budget de tokens par tour et par session. Les outils agents élargissent lourdement le contexte ; des plafonds stricts empêchent que les démonstrations ne se transforment en factures inattendues.
Erreur : HTTP 400 Base de données non connectée. / HTTP 500 Erreur interne du serveur
Erreur : HTTP 403 Clé non autorisée pour accéder au modèle
Erreur : Termination sécurisée du processus lors des redémarrages du proxy
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