Comparaison des APIs LLM : prix, performances, limites

Performance (benchmarks) ↑
│
│  Claude Opus 4.5 ●
│  Claude Sonnet 4.5 ●    ● GPT-4o
│  Gemini 1.5 Pro ●
│                     ● Mistral Large 3
│           DeepSeek-R1 ●
│
│  Claude Haiku 4.5 ●  ● GPT-4o mini
│         ● Gemini 2.0 Flash
│              ● Devstral 2
│
└────────────────────────────────────→ Prix ($/1M tokens)

from tenacity import retry, wait_random_exponential, stop_after_attempt

@retry(wait=wait_random_exponential(min=1, max=60), stop=stop_after_attempt(6))
def call_llm(prompt):
    # Retry automatique avec exponential backoff
    return client.chat.completions.create(...)

# 50% moins cher, latence 24h acceptable
batch = client.batches.create(
    input_file_id="file-abc123",
    endpoint="/v1/chat/completions",
    completion_window="24h"
)

from typing import List, Callable

class MultiProviderLLM:
    """LLM avec fallback automatique"""

    def __init__(self, providers: List[Callable]):
        self.providers = providers  # Ordre de priorité

    def generate(self, prompt: str) -> str:
        for i, provider in enumerate(self.providers):
            try:
                response = provider(prompt)
                if i > 0:
                    print(f"⚠️ Fallback to provider {i+1}")
                return response
            except Exception as e:
                print(f"❌ Provider {i+1} failed: {e}")
                if i == len(self.providers) - 1:
                    raise Exception("All providers failed")
                continue

# Usage
llm = MultiProviderLLM([
    lambda p: openai_call(p),      # 1. OpenAI (primaire)
    lambda p: anthropic_call(p),   # 2. Anthropic (backup 1)
    lambda p: google_call(p)       # 3. Google (backup 2)
])

response = llm.generate("Explain quantum computing")

def smart_route(task_type: str, prompt: str):
    """Route vers le meilleur provider selon la tâche"""

    routes = {
        "code": {
            "provider": "mistral",
            "model": "devstral-2",
            "reason": "Spécialisé code"
        },
        "reasoning": {
            "provider": "deepseek",
            "model": "deepseek-r1",
            "reason": "Raisonnement économique"
        },
        "chat": {
            "provider": "google",
            "model": "gemini-2.0-flash",
            "reason": "Rapide et pas cher"
        },
        "analysis": {
            "provider": "google",
            "model": "gemini-1.5-pro",
            "reason": "Long context 2M"
        },
        "translation": {
            "provider": "mistral",
            "model": "mistral-large-3",
            "reason": "Excellent multilingue EU"
        },
        "bulk": {
            "provider": "deepseek",
            "model": "deepseek-v3",
            "reason": "Prix ultra-bas"
        }
    }

    config = routes.get(task_type, routes["chat"])
    print(f"📍 Routing to {config['provider']} ({config['reason']})")

    return call_provider(config["provider"], config["model"], prompt)

# Usage
response = smart_route("code", "Write a binary search in Python")

import tiktoken

def estimate_cost(prompt: str, provider: str, model: str) -> float:
    """Estime le coût d'un appel"""

    # Compter tokens (approximation)
    enc = tiktoken.get_encoding("cl100k_base")
    input_tokens = len(enc.encode(prompt))
    estimated_output = input_tokens * 0.5  # Assume output = 50% input

    # Prix par million (janvier 2026)
    prices = {
        "openai/gpt-4o": {"in": 2.50, "out": 10.00},
        "anthropic/claude-sonnet-4.5": {"in": 3.00, "out": 15.00},
        "anthropic/claude-opus-4.5": {"in": 5.00, "out": 25.00},
        "google/gemini-1.5-pro": {"in": 1.25, "out": 5.00},
        "google/gemini-2.0-flash": {"in": 0.075, "out": 0.30},
        "mistral/devstral-2": {"in": 0.40, "out": 2.00},
        "deepseek/deepseek-v3": {"in": 0.27, "out": 1.10},
        "deepseek/deepseek-r1": {"in": 0.55, "out": 2.19}
    }

    key = f"{provider}/{model}"
    if key not in prices:
        return float('inf')

    cost = (input_tokens * prices[key]["in"] / 1_000_000) + \
           (estimated_output * prices[key]["out"] / 1_000_000)

    return cost

def cheapest_provider(prompt: str, min_quality_tier: int = 2):
    """Choisit le provider le moins cher pour qualité acceptable"""

    # Quality tiers : 1 (best) -> 3 (good enough)
    providers = [
        {"provider": "anthropic", "model": "claude-opus-4.5", "tier": 1},
        {"provider": "anthropic", "model": "claude-sonnet-4.5", "tier": 1},
        {"provider": "openai", "model": "gpt-4o", "tier": 1},
        {"provider": "google", "model": "gemini-1.5-pro", "tier": 2},
        {"provider": "mistral", "model": "mistral-large-3", "tier": 2},
        {"provider": "google", "model": "gemini-2.0-flash", "tier": 2},
        {"provider": "deepseek", "model": "deepseek-v3", "tier": 3}
    ]

    # Filtrer par qualité minimum
    candidates = [p for p in providers if p["tier"] >= min_quality_tier]

    # Trouver le moins cher
    costs = [(p, estimate_cost(prompt, p["provider"], p["model"])) for p in candidates]
    best = min(costs, key=lambda x: x[1])

    print(f"💰 Cheapest: {best[0]['provider']} (${best[1]:.6f})")
    return best[0]

import random
from collections import defaultdict

class LoadBalancer:
    """Distribue la charge entre providers"""

    def __init__(self):
        self.request_count = defaultdict(int)
        self.providers = [
            {"name": "openai", "weight": 0.5, "rpm_limit": 500},
            {"name": "anthropic", "weight": 0.3, "rpm_limit": 50},
            {"name": "google", "weight": 0.2, "rpm_limit": 2000}
        ]

    def get_provider(self):
        """Sélection pondérée avec respect des rate limits"""

        # Filtrer providers sous leur limite
        available = [
            p for p in self.providers
            if self.request_count[p["name"]] < p["rpm_limit"]
        ]

        if not available:
            raise Exception("All providers at rate limit")

        # Sélection pondérée
        weights = [p["weight"] for p in available]
        selected = random.choices(available, weights=weights)[0]

        self.request_count[selected["name"]] += 1
        return selected["name"]

balancer = LoadBalancer()
provider = balancer.get_provider()

pip install litellm

from litellm import completion

# Même interface pour tous les providers
response = completion(
    model="gpt-4o",  # ou "claude-3-5-sonnet", "gemini/gemini-1.5-pro"
    messages=[{"role": "user", "content": "Hello"}]
)

# Fallback automatique
response = completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
    fallbacks=["claude-sonnet-4.5", "gemini/gemini-2.0-flash"]
)

# Load balancing
response = completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
    num_retries=3
)

from langchain.chat_models import ChatOpenAI, ChatAnthropic
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser

# Changer de provider = changer 1 ligne
llm = ChatOpenAI(model="gpt-4o")
# llm = ChatAnthropic(model="claude-sonnet-4.5")
# llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash")

prompt = ChatPromptTemplate.from_template("Explain {topic}")
chain = prompt | llm | StrOutputParser()

response = chain.invoke({"topic": "quantum computing"})

from portkey_ai import Portkey

portkey = Portkey(
    api_key="YOUR_PORTKEY_API_KEY",
    virtual_key="openai-virtual-key"  # Gestion centralisée des clés
)

response = portkey.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}],
    # Fallback automatique si erreur
    config={
        "fallback": {
            "targets": [
                {"virtual_key": "anthropic-key", "model": "claude-sonnet-4.5"}
            ]
        }
    }
)

import time
from openai import OpenAI
from anthropic import Anthropic
import google.generativeai as genai

def benchmark_provider(provider_name, call_func, iterations=10):
    """Benchmark latence d'un provider"""
    latencies = []

    for i in range(iterations):
        start = time.time()
        call_func()
        end = time.time()
        latencies.append((end - start) * 1000)  # ms

    return {
        "provider": provider_name,
        "mean": sum(latencies) / len(latencies),
        "min": min(latencies),
        "max": max(latencies),
        "p95": sorted(latencies)[int(0.95 * len(latencies))]
    }

# Tester chaque provider
results = []

# OpenAI
openai_client = OpenAI()
results.append(benchmark_provider(
    "OpenAI GPT-4o mini",
    lambda: openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": "Hi"}],
        max_tokens=10
    )
))

# Anthropic
anthropic_client = Anthropic()
results.append(benchmark_provider(
    "Anthropic Claude Haiku",
    lambda: anthropic_client.messages.create(
        model="claude-3-haiku-20240307",
        messages=[{"role": "user", "content": "Hi"}],
        max_tokens=10
    )
))

# Afficher résultats
for r in sorted(results, key=lambda x: x["mean"]):
    print(f"{r['provider']}: {r['mean']:.0f}ms (p95: {r['p95']:.0f}ms)")

User Query → Embedding (OpenAI)
           ↓
      Vector Search (Chroma)
           ↓
      Context Retrieved
           ↓
      LLM avec Fallback :
        1. OpenAI GPT-4o (primaire)
        2. Anthropic Claude (si 1 fail)
        3. Google Gemini (si 2 fail)
           ↓
      Response

class MultiProviderRAG:
    def __init__(self):
        self.vectorstore = ...  # Chroma
        self.providers = [
            ("openai", "gpt-4o"),
            ("anthropic", "claude-sonnet-4.5"),
            ("google", "gemini-2.0-flash")
        ]

    def ask(self, question: str) -> str:
        # 1. Retrieval
        docs = self.vectorstore.similarity_search(question, k=5)
        context = "\n".join([d.page_content for d in docs])

        # 2. Generate avec fallback
        for provider, model in self.providers:
            try:
                return self.generate(provider, model, question, context)
            except Exception as e:
                print(f"❌ {provider} failed: {e}")
                continue

        raise Exception("All providers failed")