Utiliser des modèles gratuits sans sacrifier la qualité

# Un seul endpoint, tous les modèles
curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "meta-llama/llama-3.3-70b-instruct:free",
    "messages": [{"role": "user", "content": "Explique-moi le machine learning"}]
  }'

from groq import Groq

client = Groq(api_key="gsk_...")

response = client.chat.completions.create(
    model="llama-3.3-70b-versatile",
    messages=[{"role": "user", "content": "Bonjour !"}],
    temperature=0.7,
    max_tokens=1024
)

print(response.choices[0].message.content)
# Réponse en moins de 500ms pour la plupart des requêtes !

import google.generativeai as genai

genai.configure(api_key="AIza...")

model = genai.GenerativeModel("gemini-2.5-flash")
response = model.generate_content("Résume ce document de 200 pages...")

print(response.text)

from cerebras.cloud.sdk import Cerebras

client = Cerebras(api_key="csk-...")

response = client.chat.completions.create(
    model="llama-3.3-70b",
    messages=[{"role": "user", "content": "Bonjour !"}]
)

# Réponse quasi-instantanée
print(response.choices[0].message.content)

Requête utilisateur
    │
    ▼
┌─────────────┐     Rate limit?     ┌──────────────┐     Rate limit?     ┌─────────────┐
│  Groq Free  │ ──────────────────▶ │  Cerebras    │ ──────────────────▶ │  OpenRouter  │
│  (gratuit)  │                     │  (gratuit)   │                     │  (gratuit)   │
└─────────────┘                     └──────────────┘                     └─────────────┘
                                                                               │
                                                                          Rate limit?
                                                                               │
                                                                               ▼
                                                                    ┌──────────────────┐
                                                                    │  Claude Sonnet   │
                                                                    │  (payant, filet) │
                                                                    └──────────────────┘

import time
import httpx
from dataclasses import dataclass
from typing import Optional

@dataclass
class Provider:
    name: str
    base_url: str
    api_key: str
    model: str
    max_retries: int = 1
    timeout: float = 30.0
    is_free: bool = True

class ModelManager:
    """Gère une chaîne de fallback entre providers LLM."""

    def __init__(self, providers: list[Provider]):
        self.providers = providers
        self._rate_limited: dict[str, float] = {}  # provider -> retry_after timestamp

    def _is_available(self, provider: Provider) -> bool:
        """Vérifie si un provider n'est pas en rate limit."""
        if provider.name in self._rate_limited:
            if time.time() < self._rate_limited[provider.name]:
                return False
            del self._rate_limited[provider.name]
        return True

    def _mark_rate_limited(self, provider: Provider, retry_after: int = 60):
        """Marque un provider comme temporairement indisponible."""
        self._rate_limited[provider.name] = time.time() + retry_after

    async def complete(
        self,
        messages: list[dict],
        temperature: float = 0.7,
        max_tokens: int = 2048
    ) -> Optional[dict]:
        """Envoie une requête en essayant chaque provider de la chaîne."""

        for provider in self.providers:
            if not self._is_available(provider):
                continue

            try:
                async with httpx.AsyncClient(timeout=provider.timeout) as client:
                    response = await client.post(
                        f"{provider.base_url}/chat/completions",
                        headers={
                            "Authorization": f"Bearer {provider.api_key}",
                            "Content-Type": "application/json"
                        },
                        json={
                            "model": provider.model,
                            "messages": messages,
                            "temperature": temperature,
                            "max_tokens": max_tokens
                        }
                    )

                    if response.status_code == 429:
                        # Rate limited - marquer et passer au suivant
                        retry_after = int(response.headers.get("retry-after", 60))
                        self._mark_rate_limited(provider, retry_after)
                        print(f"⚠️ {provider.name} rate limited, retry dans {retry_after}s")
                        continue

                    if response.status_code == 200:
                        data = response.json()
                        # Ajouter des métadonnées sur le provider utilisé
                        data["_provider"] = provider.name
                        data["_is_free"] = provider.is_free
                        return data

                    # Autre erreur, essayer le suivant
                    print(f"⚠️ {provider.name} erreur {response.status_code}")
                    continue

            except (httpx.TimeoutException, httpx.ConnectError) as e:
                print(f"⚠️ {provider.name} timeout/connexion: {e}")
                self._mark_rate_limited(provider, 30)
                continue

        # Tous les providers ont échoué
        raise Exception("Tous les providers sont indisponibles")

import os

# Définir la chaîne de fallback
providers = [
    # 1. Groq - gratuit, ultra-rapide
    Provider(
        name="groq",
        base_url="https://api.groq.com/openai/v1",
        api_key=os.getenv("GROQ_API_KEY", ""),
        model="llama-3.3-70b-versatile",
        timeout=10.0,
        is_free=True
    ),
    # 2. Cerebras - gratuit, encore plus rapide
    Provider(
        name="cerebras",
        base_url="https://api.cerebras.ai/v1",
        api_key=os.getenv("CEREBRAS_API_KEY", ""),
        model="llama-3.3-70b",
        timeout=10.0,
        is_free=True
    ),
    # 3. OpenRouter free - gratuit, bonne disponibilité
    Provider(
        name="openrouter-free",
        base_url="https://openrouter.ai/api/v1",
        api_key=os.getenv("OPENROUTER_API_KEY", ""),
        model="meta-llama/llama-3.3-70b-instruct:free",
        timeout=15.0,
        is_free=True
    ),
    # 4. Claude Sonnet via OpenRouter - payant, filet de sécurité
    Provider(
        name="claude-sonnet",
        base_url="https://openrouter.ai/api/v1",
        api_key=os.getenv("OPENROUTER_API_KEY", ""),
        model="anthropic/claude-sonnet-4",
        timeout=30.0,
        is_free=False
    ),
]

manager = ModelManager(providers)

# Utilisation
import asyncio

async def main():
    response = await manager.complete(
        messages=[
            {"role": "system", "content": "Tu es un assistant utile."},
            {"role": "user", "content": "Explique le théorème de Bayes simplement."}
        ]
    )

    content = response["choices"][0]["message"]["content"]
    provider = response["_provider"]
    is_free = response["_is_free"]

    print(f"Réponse de {provider} (gratuit: {is_free}):")
    print(content)

asyncio.run(main())

import hashlib
import json
from functools import lru_cache

class CachedModelManager(ModelManager):
    """ModelManager avec cache pour économiser les requêtes."""

    def __init__(self, providers, cache_ttl=3600):
        super().__init__(providers)
        self._cache: dict[str, tuple[dict, float]] = {}
        self._cache_ttl = cache_ttl

    def _cache_key(self, messages, temperature):
        raw = json.dumps({"m": messages, "t": temperature}, sort_keys=True)
        return hashlib.sha256(raw.encode()).hexdigest()

    async def complete(self, messages, temperature=0.7, max_tokens=2048):
        key = self._cache_key(messages, temperature)

        # Vérifier le cache
        if key in self._cache:
            cached, timestamp = self._cache[key]
            if time.time() - timestamp < self._cache_ttl:
                cached["_from_cache"] = True
                return cached

        # Sinon, appel normal
        result = await super().complete(messages, temperature, max_tokens)

        # Stocker en cache
        self._cache[key] = (result, time.time())
        return result

# ❌ Mauvais : prompt verbeux
system_prompt = """
Tu es un assistant très intelligent et serviable qui répond
toujours de manière détaillée et précise aux questions des
utilisateurs. Tu dois être poli et professionnel en toutes
circonstances. Tes réponses doivent être complètes et bien
structurées avec des exemples quand c'est pertinent.
"""

# ✅ Bon : prompt concis, même résultat
system_prompt = """Assistant utile. Réponses précises, structurées, avec exemples si pertinent."""

# Pour les tâches simples (classification, extraction)
simple_providers = [
    Provider(name="groq-small", ..., model="gemma2-9b-it"),
]

# Pour les tâches complexes (rédaction, raisonnement)
complex_providers = [
    Provider(name="groq-large", ..., model="llama-3.3-70b-versatile"),
]

# ❌ 10 requêtes séparées (10 RPM consommées)
for item in items:
    result = await manager.complete([
        {"role": "user", "content": f"Classifie : {item}"}
    ])

# ✅ 1 seule requête (1 RPM consommée)
items_text = "\n".join(f"- {item}" for item in items)
result = await manager.complete([
    {"role": "user", "content": f"Classifie chaque élément :\n{items_text}\n\nRéponds en JSON."}
])

# Configuration OpenClaw avec fallback
default_model: google/gemini-2.5-flash  # Gratuit, bon par défaut

# OpenRouter pour les modèles Llama gratuits
# Configurez votre clé OpenRouter dans les tools