Responses API vs Chat Completions : pourquoi migrer

Responses API vs Chat Completions

La Chat Completions API a été le standard pendant des années. Depuis 2025, OpenAI la considère comme legacy et recommande la Responses API pour tous les nouveaux projets. Voyons pourquoi.

Ce qui change fondamentalement

L’ancien modèle : Chat Completions

Avec Chat Completions, vous gériez manuellement l’historique de conversation :

from openai import OpenAI
client = OpenAI()

# Ancien modèle — Chat Completions (legacy)
response = client.chat.completions.create(
    model="gpt-5.3",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant utile."},
        {"role": "user", "content": "Quelle est la capitale de la France ?"},
    ]
)
print(response.choices[0].message.content)
# Résultat : "La capitale de la France est Paris."

Le nouveau modèle : Responses API

Avec la Responses API, l’interface est simplifiée et plus puissante :

from openai import OpenAI
client = OpenAI()

# Nouveau modèle — Responses API
response = client.responses.create(
    model="gpt-5.3",
    input="Quelle est la capitale de la France ?"
)
print(response.output_text)
# Résultat : "La capitale de la France est Paris."

Les avantages concrets de la migration

1. Gestion de session côté serveur

Plus besoin de renvoyer tout l’historique à chaque requête :

# Première question
response = client.responses.create(
    model="gpt-5.3",
    input="Je m'appelle Marie."
)

# Deuxième question — le contexte est conservé automatiquement
followup = client.responses.create(
    model="gpt-5.3",
    input="Comment je m'appelle ?",
    previous_response_id=response.id
)
print(followup.output_text)
# Résultat : "Vous vous appelez Marie."

Avec Chat Completions, vous auriez dû renvoyer l’intégralité des messages précédents.

2. Structured Output garanti

La Responses API garantit que la sortie respecte votre schéma JSON :

from pydantic import BaseModel

class Ville(BaseModel):
    nom: str
    pays: str
    population: int

response = client.responses.create(
    model="gpt-5.3",
    input="Donnez-moi les informations sur Paris.",
    text={"format": {"type": "json_schema", "json_schema": {
        "name": "ville",
        "strict": True,
        "schema": Ville.model_json_schema()
    }}}
)
print(response.output_text)
# Résultat : {"nom": "Paris", "pays": "France", "population": 2161000}

3. Function calling simplifié

La déclaration et l’exécution des fonctions sont plus naturelles :

response = client.responses.create(
    model="gpt-5.3",
    input="Quelle météo fait-il à Lyon ?",
    tools=[{
        "type": "function",
        "name": "get_meteo",
        "description": "Obtenir la météo d'une ville",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string", "description": "Nom de la ville"}
            },
            "required": ["ville"]
        }
    }]
)

# L'API retourne directement l'appel de fonction à exécuter
for item in response.output:
    if item.type == "function_call":
        print(f"Fonction : {item.name}, Arguments : {item.arguments}")
# Résultat : Fonction : get_meteo, Arguments : {"ville": "Lyon"}

4. Streaming amélioré

Le streaming inclut des événements structurés avec types :

stream = client.responses.create(
    model="gpt-5.3",
    input="Racontez une courte histoire.",
    stream=True
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)

Guide de migration rapide

Quand rester sur Chat Completions ?

La Chat Completions API reste fonctionnelle et n’est pas supprimée. Vous pouvez rester dessus si :

• Votre code existant fonctionne et n’a pas besoin d’évolution
• Vous utilisez des bibliothèques tierces qui ne supportent pas encore la Responses API
• Vous avez un pipeline de test complet basé sur l’ancien format

Pour tout nouveau projet, utilisez la Responses API.

Points clés à retenir

• La Responses API remplace Chat Completions avec une interface plus simple
• La gestion de session côté serveur élimine le besoin de renvoyer l’historique
• Le Structured Output et le function calling sont nativement intégrés
• La migration est directe : les concepts restent les mêmes, seule la syntaxe change