Utiliser des modèles gratuits sans sacrifier la qualité

# Single endpoint, all models
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": "Explain machine learning to me"}]
  }'

from groq import Groq

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

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

print(response.choices[0].message.content)
# Response in under 500ms for most requests!

import google.generativeai as genai

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

model = genai.GenerativeModel("gemini-2.5-flash")
response = model.generate_content("Summarize this 200-page document...")

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": "Hello!"}]
)

# Near-instant response
print(response.choices[0].message.content)

User request
    │
    ▼
┌─────────────┐     Rate limit?     ┌──────────────┐     Rate limit?     ┌─────────────┐
│  Groq Free  │ ──────────────────▶ │  Cerebras    │ ──────────────────▶ │  OpenRouter  │
│  (free)     │                     │  (free)      │                     │  (free)      │
└─────────────┘                     └──────────────┘                     └─────────────┘
                                                                               │
                                                                          Rate limit?
                                                                               │
                                                                               ▼
                                                                    ┌──────────────────┐
                                                                    │  Claude Sonnet   │
                                                                    │  (paid, safety net)│
                                                                    └──────────────────┘

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:
    """Manages a fallback chain between LLM providers."""

    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:
        """Checks if a provider is not rate limited."""
        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):
        """Marks a provider as temporarily unavailable."""
        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]:
        """Sends a request trying each provider in the chain."""

        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 - mark and move to next
                        retry_after = int(response.headers.get("retry-after", 60))
                        self._mark_rate_limited(provider, retry_after)
                        print(f"⚠️ {provider.name} rate limited, retry in {retry_after}s")
                        continue

                    if response.status_code == 200:
                        data = response.json()
                        # Add metadata about the provider used
                        data["_provider"] = provider.name
                        data["_is_free"] = provider.is_free
                        return data

                    # Other error, try next
                    print(f"⚠️ {provider.name} error {response.status_code}")
                    continue

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

        # All providers failed
        raise Exception("All providers are unavailable")