> ## Documentation Index > Fetch the complete documentation index at: https://docs.tokenlab.sh/llms.txt > Use this file to discover all available pages before exploring further. # Bonnes pratiques > Optimisez votre utilisation de l’API TokenLab pour le coût, les performances et la fiabilité ## Sélection du modèle Choisir le bon modèle peut avoir un impact significatif sur le coût et la qualité. ### Recommandations par type de tâche | Tâche | Modèles recommandés | Justification | | ------------------------------ | ------------------------------------------------- | ----------------------------------- | | **Questions-réponses simples** | `gpt-5-mini`, `gemini-3.5-flash` | Rapide, peu coûteux, suffisant | | **Raisonnement complexe** | `gpt-5.4`, `claude-opus-4-6`, `deepseek-r1` | Meilleure logique et planification | | **Codage** | `claude-sonnet-4-6`, `gpt-4o`, `deepseek-v3-2` | Optimisé pour le code | | **Écriture créative** | `claude-sonnet-4-6`, `gpt-4o` | Meilleure qualité rédactionnelle | | **Vision/Images** | `gpt-4o`, `claude-sonnet-4-6`, `gemini-3.5-flash` | Prise en charge native de la vision | | **Contexte long** | `gemini-2.5-pro`, `claude-sonnet-4-6` | Fenêtres de 1M+ token | | **Sensible au coût** | `gpt-5-mini`, `gemini-3.5-flash`, `deepseek-v3-2` | Meilleur rapport qualité-prix | ### Niveaux de coût ``` $$$$ Premium: gpt-5.4, claude-opus-4-6 $$$ Standard: claude-sonnet-4-6, gpt-4o $$ Budget: gpt-5-mini, gemini-3.5-flash $ Economy: deepseek-v3-2, deepseek-r1 ``` ## Optimisation des coûts ### 1. Utilisez d’abord des modèles plus petits ```python theme={null} def smart_query(question: str, complexity: str = "auto"): """Use cheaper models for simple tasks.""" if complexity == "simple": model = "gpt-5-mini" elif complexity == "complex": model = "gpt-4o" else: # Start cheap, escalate if needed model = "gpt-5-mini" response = client.chat.completions.create( model=model, messages=[{"role": "user", "content": question}] ) return response ``` ### 2. Définissez `max_tokens` Définissez toujours une limite `max_tokens` raisonnable : ```python theme={null} # ❌ Bad: No limit, could generate thousands of tokens response = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": "Summarize this article"}] ) # ✅ Good: Limit response length response = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": "Summarize this article"}], max_tokens=500 # Reasonable limit for a summary ) ``` ### 3. Optimisez les prompts ```python theme={null} # ❌ Verbose prompt (more input tokens) prompt = """ I would like you to please help me by analyzing the following text and providing a comprehensive summary of the main points. Please be thorough but also concise in your response. The text is as follows: {text} """ # ✅ Concise prompt (fewer tokens) prompt = "Summarize the key points:\n{text}" ``` ### 4. Regroupez les requêtes similaires ```python theme={null} # ❌ Many small requests for question in questions: response = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": question}] ) # ✅ Fewer larger requests combined_prompt = "\n".join([f"{i+1}. {q}" for i, q in enumerate(questions)]) response = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": f"Answer each question:\n{combined_prompt}"}] ) ``` ## Optimisation des performances ### 5. Utilisez le streaming pour l’UX Le streaming améliore les performances perçues : ```python theme={null} stream = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": "Write a long essay"}], stream=True ) for chunk in stream: if chunk.choices[0].delta.content: print(chunk.choices[0].delta.content, end="", flush=True) ``` ### 6. Choisissez des modèles rapides pour un usage interactif | Cas d’usage | Recommandé | Latence | | -------------------------- | -------------------------------- | ------------------------------ | | Interface de chat | `gpt-5-mini`, `gemini-3.5-flash` | \~200ms jusqu’au premier token | | Complétion d’onglet | `claude-haiku-4-5` | \~150ms jusqu’au premier token | | Traitement en arrière-plan | `gpt-4o`, `claude-sonnet-4-6` | \~500ms jusqu’au premier token | ### 7. Définissez des timeouts ```python theme={null} client = OpenAI( api_key="sk-your-key", base_url="https://api.tokenlab.sh/v1", timeout=60.0 # 60 second timeout ) ``` ## Fiabilité ### 8. Implémentez des retries ```python theme={null} import time from openai import RateLimitError, APIError def chat_with_retry(messages, max_retries=3): for attempt in range(max_retries): try: return client.chat.completions.create( model="gpt-4o", messages=messages ) except RateLimitError: wait = 2 ** attempt print(f"Rate limited, waiting {wait}s...") time.sleep(wait) except APIError as e: if attempt == max_retries - 1: raise time.sleep(1) raise Exception("Max retries exceeded") ``` ### 9. Gérez les erreurs proprement ```python theme={null} from openai import APIError, AuthenticationError, RateLimitError try: response = client.chat.completions.create(...) except AuthenticationError: # Check API key notify_admin("Invalid API key") except RateLimitError: # Queue for later or use backup add_to_queue(request) except APIError as e: if e.status_code == 402: notify_admin("Balance low") elif e.status_code >= 500: # Server error, retry later schedule_retry(request) ``` ### 10. Utilisez des modèles de secours ```python theme={null} FALLBACK_CHAIN = ["gpt-4o", "claude-sonnet-4-6", "gemini-3.5-flash"] def chat_with_fallback(messages): for model in FALLBACK_CHAIN: try: return client.chat.completions.create( model=model, messages=messages ) except APIError: continue raise Exception("All models failed") ``` ## Sécurité ### 11. Protégez les clés API ```python theme={null} # ❌ Never hardcode keys client = OpenAI(api_key="sk-abc123...") # ✅ Use environment variables import os client = OpenAI(api_key=os.environ["TOKENLAB_API_KEY"]) ``` ### 12. Validez les entrées utilisateur ```python theme={null} def validate_message(content: str) -> bool: """Validate user input before sending to API.""" if len(content) > 100000: raise ValueError("Message too long") # Add other validation as needed return True ``` ### 13. Définissez des limites pour les clés API Créez des clés API distinctes avec des limites de dépenses pour : * Développement/tests * Production * Différentes applications ## Monitoring ### 14. Suivez l’utilisation Vérifiez régulièrement votre tableau de bord pour : * L’utilisation des token par modèle * La répartition des coûts * Les taux de succès du cache * Les taux d’erreur ### 15. Journalisez les métriques importantes ```python theme={null} import logging response = client.chat.completions.create(...) logging.info({ "model": response.model, "prompt_tokens": response.usage.prompt_tokens, "completion_tokens": response.usage.completion_tokens, "total_tokens": response.usage.total_tokens, }) ``` ### 16. Configurez des alertes Configurez des alertes de solde faible dans votre tableau de bord pour éviter toute interruption de service. ## Checklist * [ ] Utilisation du modèle approprié pour chaque tâche * [ ] Définition de limites `max_tokens` * [ ] Prompts concis * [ ] Mise en cache activée lorsque pertinent * [ ] Regroupement des requêtes similaires * [ ] Streaming pour une UX interactive * [ ] Modèles rapides pour un usage en temps réel * [ ] Timeouts configurés * [ ] Logique de retry implémentée * [ ] Gestion des erreurs en place * [ ] Modèles de secours configurés * [ ] Clés API dans des variables d’environnement * [ ] Validation des entrées * [ ] Clés séparées pour dev/prod * [ ] Limites de dépenses définies