Complétion de chat OpenAI

Le cas d'utilisation le plus courant de l'API OpenAI en Python est la génération de complétions de chat. Cela implique d'envoyer une liste de messages à un modèle spécifié et de recevoir une réponse générée. L'API prend en charge les appels synchrones (bloquants) et asynchrones (non bloquants), et les réponses peuvent être reçues sous forme d'objet unique ou être diffusées par fragments.

Complétion de chat synchrone (sans diffusion)

Cet exemple montre comment envoyer une seule invite à l'API OpenAI et recevoir la réponse complète en une seule fois.

from openai import OpenAI

# Initialise le client OpenAI.
# La clé API est automatiquement chargée depuis la variable d'environnement OPENAI_API_KEY.
# Alternativement, vous pouvez la passer directement : client = OpenAI(api_key="votre_clé_api_ici")
client = OpenAI()

try:
    # Crée une complétion de chat
    chat_completion = client.chat.completions.create(
        messages=[
            {
                "role": "user",
                "content": "Quelle est la capitale de la France ?",
            }
        ],
        model="gpt-4o", # Spécifie le modèle à utiliser
    )

    # Accède au contenu du message généré
    response_content = chat_completion.choices[0].message.content
    print(f"Réponse sans diffusion :\n{response_content}")

except Exception as e:
    print(f"Une erreur est survenue : {e}")

Complétion de chat synchrone (avec diffusion)

Cet exemple montre comment recevoir la réponse du modèle de manière incrémentielle au fur et à mesure qu'elle est générée, ce qui est utile pour les applications qui souhaitent afficher la réponse en temps réel.

from openai import OpenAI

client = OpenAI()

print("Réponse avec diffusion :")
try:
    # Crée une complétion de chat avec diffusion activée
    stream = client.chat.completions.create(
        messages=[
            {
                "role": "user",
                "content": "Écris un court poème inspirant sur la beauté de la nature.",
            }
        ],
        model="gpt-4o", # Spécifie le modèle à utiliser
        stream=True, # Active la diffusion
    )

    # Itère sur le flux pour afficher les fragments au fur et à mesure de leur arrivée
    for chunk in stream:
        # Chaque fragment contient un objet 'delta' avec un contenu partiel
        # Utilise .delta.content ou "" pour gérer les cas où le contenu pourrait être None
        print(chunk.choices[0].delta.content or "", end="")
    print("\n") # Ajoute une nouvelle ligne à la fin pour une sortie propre

except Exception as e:
    print(f"Une erreur est survenue : {e}")

Complétion de chat asynchrone (sans diffusion)

Pour les applications asynchrones, le client AsyncOpenAI peut être utilisé avec await.

import asyncio
from openai import AsyncOpenAI

async def async_non_streaming_completion():
    # Initialise le client OpenAI asynchrone
    client = AsyncOpenAI()

    try:
        # Crée une complétion de chat asynchrone
        chat_completion = await client.chat.completions.create(
            messages=[
                {
                    "role": "user",
                    "content": "Résume l'idée principale de la physique quantique en une phrase.",
                }
            ],
            model="gpt-4o",
        )

        response_content = chat_completion.choices[0].message.content
        print(f"Réponse asynchrone sans diffusion :\n{response_content}")

    except Exception as e:
        print(f"Une erreur est survenue : {e}")

# Exécute la fonction asynchrone
# asyncio.run(async_non_streaming_completion())

Complétion de chat asynchrone (avec diffusion)

Les réponses avec diffusion sont également disponibles de manière asynchrone, permettant des mises à jour efficaces en temps réel dans les applications asynchrones.

import asyncio
from openai import AsyncOpenAI

async def async_streaming_completion():
    client = AsyncOpenAI()

    print("Réponse asynchrone avec diffusion :")
    try:
        # Crée une complétion de chat asynchrone avec diffusion
        stream = await client.chat.completions.create(
            messages=[
                {
                    "role": "user",
                    "content": "Raconte-moi une brève histoire sur un chevalier courageux et un dragon.",
                }
            ],
            model="gpt-4o",
            stream=True,
        )

        async for chunk in stream:
            print(chunk.choices[0].delta.content or "", end="")
        print("\n")

    except Exception as e:
        print(f"Une erreur est survenue : {e}")

# Exécute la fonction asynchrone
# asyncio.run(async_streaming_completion())