Intégration d'API - Se connecter à l'IA

La leçon précédente t'a montré ce qu'est un LLM, un token et une fenêtre de contexte. Le problème, c'est qu'un tel modèle n'habite pas sur ton ordinateur : il tourne sur les serveurs du fournisseur. Pour l'utiliser depuis Python, il faut envoyer une requête HTTP, la signer avec une clé API et déballer la réponse. À la main, c'est une heure de bricolage ; avec la bibliothèque officielle, quatre lignes.

Cette leçon porte exactement sur ces quatre étapes : installer, importer, appeler, lire le résultat. Suivre un modèle à travers le réseau ne diffère guère du pistage dans la savane : ce qui compte, c'est de rester sur le bon sentier, pas de courir vite.

Installation : pip, et non npm

Les bibliothèques Python s'installent avec le gestionnaire pip. Premier piège : le web déborde d'exemples écrits pour JavaScript, où le même paquet s'installe avec npm install openai. npm est le gestionnaire de paquets de Node.js - en Python, il n'installe rien, et au mieux il répondra qu'il ne connaît pas cette commande.

Deuxième piège : le nom du paquet. L'entreprise s'appelle OpenAI, le produit ChatGPT et la famille de modèles GPT - mais sur PyPI, le paquet s'appelle simplement openai. Les commandes pip install chatgpt et pip install gpt4 n'installent pas la bibliothèque officielle, car OpenAI ne publie aucun paquet sous ces noms. De la même manière, le paquet d'Anthropic s'appelle anthropic, et non claude.

1pip install openai
2pip install anthropic

Après ces deux commandes, ton environnement contient deux paquets indépendants. Aucun des deux n'a encore envoyé la moindre requête et aucun ne connaît ta clé API : la clé n'arrive qu'au moment de créer le client.

Import et client OpenAI

L'ordre de la ligne d'import ne change jamais : from → openai → import → OpenAI. from désigne d'abord le paquet dans lequel on puise, et seulement ensuite import désigne le nom que l'on veut en extraire. Fais attention à la casse : le paquet s'écrit en minuscules (openai), la classe du client en majuscules (OpenAI). Les intervertir est l'erreur la plus fréquente sur cette unique ligne. Le bloc ci-dessous fait ensuite le travail complet : il crée un client OpenAI et envoie un message au modèle gpt-4.

1from openai import OpenAI
2
3client = OpenAI(api_key="your-api-key")
4
5response = client.chat.completions.create(
6    model="gpt-4",
7    messages=[
8        {"role": "system", "content": "Tu es un guide de safari nomme Darwin."},
9        {"role": "user", "content": "Quel animal de la savane court le plus vite ?"}
10    ],
11    temperature=0.7,
12    max_tokens=500
13)

L'appel se lit comme un chemin : client → .chat → .completions → .create(. Le client regroupe les familles d'API, chat est la famille des conversations, completions est la ressource logée à l'intérieur de cette famille, et create est l'action que tu exécutes dessus. Cet ordre n'a rien d'arbitraire : client.completions.chat n'existe pas, parce que completions vit à l'intérieur de chat, et non l'inverse. Élément par élément, pour créer un chat completion tu enchaînes client, ., chat, ., completions, ., create.

Le nom du modèle n'est qu'une simple chaîne de caractères. Ici c'est "gpt-4", mais "gpt-5" tiendrait tout aussi bien à cette place : la bibliothèque ne vérifie rien de son côté, elle transmet le nom tel quel. Une faute de frappe finira en erreur renvoyée par le serveur, et c'est justement une bonne nouvelle.

Le paramètre max_tokens est plus sournois. Il limite la longueur de la réponse, pas celle de la question, et quand la limite est atteinte, le modèle cesse simplement d'écrire - au milieu d'une phrase, sans lever la moindre exception. Le code fonctionne, la réponse existe, elle est seulement tronquée. Si tes résultats s'arrêtent régulièrement en pleine pensée la faute revient rarement au modèle : c'est max_tokens qui est trop bas. Le paramètre temperature, lui, règle le hasard : 0 donne des réponses aussi reproductibles que possible, 1 des réponses plus variées.

Lire la réponse

La variable response ne contient pas de texte. Elle contient un objet rempli de métadonnées, et le contenu utile se trouve quatre pas plus loin.

1answer = response.choices[0].message.content
2print(answer)

Le chemin est response → .choices[0] → .message → .content, exactement dans cet ordre. choices est une liste, parce que l'API sait renvoyer plusieurs variantes de réponse d'un coup, et [0] sélectionne la première. message est l'objet message, qui porte entre autres un rôle et un contenu, et content est enfin le texte brut. Oublier [0] te rend une liste au lieu d'un message, et t'arrêter à .message te rend un objet dont l'affichage est un vidage de champs illisible - sans aucune erreur, simplement pas ce que tu voulais.

Le client Anthropic

Avec le modèle Claude, la démarche est très proche, seuls les noms changent. L'import suit le même ordre : from → anthropic → import → Anthropic. Là encore, le paquet en minuscules et la classe en majuscules. Tu croiseras aussi la variante import anthropic, où le client se crée par anthropic.Anthropic(...) - elle fonctionne tout aussi bien, mais je te conseille la version avec from, car un nom de classe déjà extrait reste plus court à utiliser. Le code qui suit crée un client Anthropic et envoie un message au modèle Claude.

1from anthropic import Anthropic
2
3client = Anthropic(api_key="your-api-key")
4
5message = client.messages.create(
6    model="claude-sonnet-4-6",
7    max_tokens=1024,
8    system="Tu es un expert du langage Python.",
9    messages=[
10        {"role": "user", "content": "Comment ecrire une fonction de tri ?"}
11    ]
12)
13
14print(message.content[0].text)

Trois différences méritent d'être retenues. Le chemin d'appel est plus court - client.messages.create(, sans chat ni completions. L'instruction système est un paramètre à part, system, et non une entrée dans messages : y glisser un rôle "system" déclenche une erreur de l'API. Enfin, max_tokens est ici obligatoire : sans lui, la requête ne part même pas. La réponse se lit par message.content[0].text, et non par choices - une frontière facile à franchir par erreur quand un même projet utilise les deux fournisseurs.

Le streaming, ou stream=True

Par défaut, tu attends la réponse entière avant de voir quoi que ce soit. Sur un texte long, cela fait une dizaine de secondes de silence complet. Le paramètre stream=True change une seule chose : la réponse arrive par morceaux, token par token, et tu peux l'afficher au fur et à mesure.

1stream = client.chat.completions.create(
2    model="gpt-4",
3    messages=[{"role": "user", "content": "Raconte une histoire de la savane"}],
4    stream=True
5)
6
7for chunk in stream:
8    content = chunk.choices[0].delta.content
9    if content:
10        print(content, end="", flush=True)

Au lieu d'un objet unique, tu reçois un flux de fragments que tu parcours avec une boucle. En mode streaming, il n'y a pas de .message : le fragment porte un .delta, c'est-à-dire l'incrément de contenu. Le premier et le dernier fragment ont un delta.content égal à None, et c'est précisément pour cela que if content: est là. Sans cette vérification, Python écrit le mot "None" au milieu du texte et ne signale aucune erreur.

Il vaut aussi la peine de savoir ce que stream=True ne fait pas. Il ne sert pas à chiffrer la communication - le chiffrement est l'affaire de HTTPS et fonctionne à l'identique dans les deux modes. Il ne sert pas non plus à la compression des données - la compression relève du transport HTTP et la bibliothèque s'en occupe indépendamment de ce paramètre. Il ne sert pas davantage à enregistrer la réponse dans un fichier : si tu veux en garder une trace, c'est à toi d'ouvrir un fichier et d'y ajouter les fragments au fur et à mesure. Le nombre de tokens consommés et le coût, eux, restent identiques. Seul change le moment où le texte apparaît à l'écran : en temps réel, token par token.

Résumé

• Les bibliothèques Python s'installent avec pip install openai. npm install openai appartient au monde de Node.js et ne fonctionne pas en Python.
• pip install gpt4 et pip install chatgpt n'installent pas la bibliothèque officielle - sur PyPI, le paquet se nomme openai.
• Import du client OpenAI : from → openai → import → OpenAI, donc le paquet en minuscules et la classe en majuscules.
• Import du client Anthropic : from → anthropic → import → Anthropic, sur exactement le même modèle.
• Appel du chat OpenAI : client → .chat → .completions → .create(, soit élément par élément client . chat . completions . create.
• Lecture de la réponse : response → .choices[0] → .message → .content.
• Chez Anthropic, tu appelles client.messages.create(...), max_tokens est obligatoire, l'instruction passe par le paramètre system, et le texte se lit dans message.content[0].text.
• stream=True sert à recevoir la réponse en temps réel, token par token. Il ne chiffre pas la communication, ne compresse pas les données et n'enregistre rien dans un fichier.
• Le nom du modèle est une simple chaîne, par exemple "gpt-4", "gpt-5" ou "claude-sonnet-4-6".

La prochaine leçon s'attaquera au contenu des messages eux-mêmes : le prompt engineering montre comment formuler une consigne pour que le modèle vise juste du premier coup. Retiens pour l'instant une seule chose : toute l'API tient en quatre gestes - installer le paquet, importer la classe du client, appeler create et extraire le texte au bout du chemin.

1# ===========================================
2# Labo Safari : OpenAI Chat Completions
3# ===========================================
4# Utilise l'API OpenAI pour créer un assistant
5# guide de safari qui répond aux questions sur la faune.
6
7from openai import OpenAI
8
9# --- Initialiser le client ---
10client = OpenAI(api_key="your-api-key-here")
11
12# --- Créer un chat completion ---
13response = client.chat.completions.create(
14    model="gpt-4",
15    messages=[
16        {
17            "role": "system",
18            "content": "Tu es un guide de safari expérimenté nommé Darwin. "
19                       "Réponds de façon concise aux questions sur la faune africaine."
20        },
21        {
22            "role": "user",
23            "content": "Quel est l'animal le plus rapide de la savane ?"
24        }
25    ],
26    temperature=0.7,
27    max_tokens=150
28)
29
30# --- Extraire la réponse ---
31answer = response.choices[0].message.content
32print("=== Réponse du guide de safari ===")
33print(f"Darwin dit : {answer}")
34print(f"\nTokens utilisés : {response.usage.total_tokens}")
35
36# TODO : Ajoute un message de suivi à la conversation
37# en étendant la liste messages
38# messages = [
39#     {"role": "system", "content": "Tu es le guide de safari Darwin."},
40#     {"role": "user", "content": "Quel est l'animal le plus rapide ?"},
41#     {"role": "assistant", "content": answer},
42#     {"role": "user", "content": "À quelle vitesse peut-il courir ?"}
43# ]
44# follow_up = client.chat.completions.create(
45#     model="gpt-4",
46#     messages=messages,
47#     temperature=0.7
48# )
49# print(f"\nSuivi : {follow_up.choices[0].message.content}")
50
51# TODO : Essaie une temperature différente (0.0 pour du déterministe)
52# creative_response = client.chat.completions.create(
53#     model="gpt-4",
54#     messages=[
55#         {"role": "user", "content": "Décris un coucher de soleil sur la savane."}
56#     ],
57#     temperature=...
58# )
59# print(f"\nCréatif : {creative_response.choices[0].message.content}")
60