L'API OpenAI Chat Completion fournit une interface programmatique pour accéder aux modèles de langage de ChatGPT. Elle permet d'envoyer des séquences de messages et de recevoir des réponses générées par le modèle, avec prise en charge du streaming, des conversations multi-tours et des fonctionnalités multimodales.

Obtention d'un jeton d'accès

Pour utiliser l'API, il faut d'abord obtenir un jeton d'authentification. Accédez au tableau de bord développeur, créez un compte si nécessaire, et générez une clé API. La création initiale offre souvent un crédit gratuit pour commencer.

Envoi d'une requête de base

Une requête typique nécessite trois paramètres principaux : l'en-tête d'autorisation avec le jeton, le choix du modèle (comme gpt-4 ou gpt-3.5-turbo), et un tableau de messages. Chaque message contient un rôle (user, assistant, ou system) et un contenu textuel.

Paramètres optionnels courants :

• max_tokens : Limite la longueur de la réponse.
• temperature : Contrôle la créativité (valeur entre 0 et 2).
• n : Nombre de réponses alternatives à générer.
• response_format : Spécifie le format de sortie (par exemple, JSON structuré).

Exemple de réponse JSON :

{
  "id": "chatcmpl-exemple123",
  "object": "chat.completion",
  "created": 1700000000,
  "model": "gpt-4",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Bonjour ! Comment puis-je vous aider ?"
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 10,
    "completion_tokens": 8,
    "total_tokens": 18
  }
}

Les champs clés incluent id (identifiant de la requête), model (modèle utilisé), choices (réponses générées) et usage (statistiques de consommation de tokens).

Utilisation du streaming pour les réponses en temps réel

Activer le streaming en définissant stream à true permet de recevoir la réponse par morceaux, utile pour les interfaces utilisateur dynamiques. La réponse se présente comme un flux de données JSON séparées par des lignes commençant par data:. Un marqueur [DONE] indique la fin du flux.

Exemple avec Python en utilisant la bibliothèque requests :

import requests

api_endpoint = "https://api.openai.com/v1/chat/completions"
api_key = "votre_cle_api"

request_headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

request_data = {
    "model": "gpt-4",
    "messages": [{"role": "user", "content": "Décris la couleur bleue."}],
    "stream": True
}

with requests.post(api_endpoint, json=request_data, headers=request_headers, stream=True) as response:
    for line in response.iter_lines():
        if line:
            print(line.decode())

Conversations à plusieurs tours

Pour maintenir le contexte, incluez l'historique des échanges dans le tableau messages. Chaque message représente un tour de conversation, permettant au modèle de répondre en fonction du dialogue antérieur.

Exemple en JavaScript (Node.js) :

const axios = require('axios');

const apiUrl = 'https://api.openai.com/v1/chat/completions';
const apiKey = 'votre_cle_api';

const conversationHistory = [
  { role: 'system', content: 'Vous êtes un assistant technique.' },
  { role: 'user', content: 'Comment fonctionne le streaming ?' },
  { role: 'assistant', content: 'Le streaming envoie les données progressivement.' },
  { role: 'user', content: 'Donne un exemple.' }
];

axios.post(apiUrl, {
  model: 'gpt-4',
  messages: conversationHistory
}, {
  headers: { 'Authorization': `Bearer ${apiKey}` }
})
.then(response => console.log(response.data.choices[0].message.content))
.catch(error => console.error('Erreur:', error));

Intégration avec la bibliothèque Python OpenAI

La bibliothèque officielle openai simplifie l'interaction. Configurez les variables d'environnement OPENAI_API_KEY et, si nécessaire, OPENAI_BASE_URL pour utiliser un endpoint personnalisé.

Installation : pip install openai

Exemple de code :

import os
from openai import OpenAI

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "Quelles sont les tendances en IA ?"}
    ]
)

print(response.choices[0].message.content)

Modèles avec capacité de recherche en ligne

Certains modèles comme gpt-4-browsing peuvent effectuer des recherches web en temps réel pour enrichir leurs réponses. Le résultat inclut souvent des liens sources, et le contenu doit être rendu avec une syntaxe Markdown pour une meilleure lisibilité.

Modèles de vision multimodale

Les modèles comme gpt-4o traitent à la fois texte et images. Pour envoyer une image, structurez le contenu comme une liste d'objets avec des champs type (soit text, soit image_url).

Exemple avec cURL :

curl -X POST 'https://api.openai.com/v1/chat/completions' \
-H 'Authorization: Bearer votre_cle_api' \
-H 'Content-Type: application/json' \
-d '{
    "model": "gpt-4o",
    "messages": [
      {
        "role": "user",
        "content": [
          {"type": "text", "text": "Décris cette image."},
          {"type": "image_url", "image_url": {"url": "https://exemple.com/image.jpg"}}
        ]
      }
    ]
}'

Modèles de génération d'images

Des modèles spécialisés comme gpt-4o-image génèrent des images à partir de descriptions textuelles. La requête inclut un contenu mixte avec des textes et des références de fichiers.

Gestion des erreurs

L'API renvoie des codes HTTP standards avec des messages d'erreur explicites. Par exemple :

• 401 Unauthorized : Jeton manquant ou invalide.
• 429 Too Many Requests : Limite de débit dépassée.
• 500 Internal Server Error : Erreur interne du serveur.

Réponse d'erreur typique :

{
  "error": {
    "message": "Requête incorrecte",
    "type": "invalid_request_error",
    "code": "invalid_api_key"
  }
}