1. Configuration et première réussite

Bienvenue dans votre parcours pour construire des agents(agent) IA avec Python ! À la fin de ce chapitre, vous aurez effectué votre premier appel réussi à un grand modèle de langage (Large Language Model, LLM) et compris exactement ce qui s’est passé en coulisses. C’est votre base pour tout ce qui suit.

Prérequis

Public & hypothèses

Ce livre s’adresse aux développeurs Python qui veulent construire des agents(agent) IA, mais n’ont aucune expérience préalable avec les LLM ou les frameworks IA. Nous partons du principe que vous êtes à l’aise avec :

• Les fondamentaux de Python : fonctions, classes, imports, structures de données de base
• Python 3.10+ : vous devez avoir Python 3.10 ou une version supérieure installée sur votre système
• Les environnements virtuels : créer et activer des venv avec python -m venv
• La gestion de paquets : installer des paquets avec pip
• Les variables d’environnement : définir et lire des variables d’environnement dans votre shell
• Les clés API : comprendre ce que sont les clés API et comment les obtenir auprès des fournisseurs de services

Si l’un de ces concepts ne vous est pas familier, nous vous recommandons de les revoir séparément avant de continuer. La documentation Python et les tutoriels sur les environnements virtuels et pip sont d’excellents points de départ.

Ce que nous ne supposons PAS : vous n’avez pas besoin de connaissances en machine learning, réseaux neuronaux, transformers, ou théorie de l’IA. Nous expliquerons les concepts spécifiques aux LLM au fur et à mesure que nous les rencontrerons, en les reliant toujours à des patterns de programmation familiers.

Convention de modèle

Tout au long de ce livre, nous utiliserons GPT-5-mini comme modèle par défaut pour les exemples. Voici pourquoi :

• Largement disponible : l’API d’OpenAI est accessible mondialement avec une inscription simple
• Vitesse raisonnable : avec un effort de raisonnement minimal, les réponses arrivent assez vite pour un développement itératif
• Économique : à 0,25 $ par million de tokens en entrée et 2,00 $ par million de tokens en sortie (en 2026), c’est abordable pour l’apprentissage et l’expérimentation
• Capacité suffisante : il gère très bien la grande majorité des tâches pratiques d’agents(agent) IA

Quand vous voyez des exemples de code sans modèle explicitement indiqué, partez du principe que nous utilisons GPT-5-mini. Dans le chapitre 2, nous explorerons l’ensemble des modèles disponibles (Claude, Gemini et d’autres variantes de GPT) et nous verrons quand vous pourriez choisir des alternatives selon la taille de la fenêtre de contexte, le coût, ou des capacités spécialisées.

1.1) Qu’est-ce qu’un LLM ?

Avant d’écrire du code, établissons ce avec quoi nous travaillons réellement. Un grand modèle de langage (Large Language Model, LLM) est un réseau neuronal entraîné sur d’immenses quantités de données textuelles afin de prédire quel texte devrait venir ensuite dans une séquence.

Voyez-le comme un système d’autocomplétion extrêmement sophistiqué. Quand vous tapez sur votre téléphone et qu’il vous suggère le mot suivant, c’est une version simple de ce que font les LLM. Mais les LLM opèrent à une échelle et avec une sophistication qui leur permettent de :

• Générer des réponses cohérentes et contextuellement appropriées à des questions
• Écrire du code, des essais, des e-mails et d’autres contenus structurés
• Traduire entre des langues
• Résumer de longs documents
• Extraire des informations à partir de texte non structuré
• Et bien plus encore

En quoi les LLM diffèrent des logiciels traditionnels

Les logiciels traditionnels suivent des règles explicites que vous programmez :

def calculate_discount(price, customer_type):
    if customer_type == "premium":
        return price * 0.8  # 20% de réduction
    elif customer_type == "regular":
        return price * 0.95  # 5% de réduction
    else:
        return price

Cette fonction produit toujours la même sortie pour les mêmes entrées. La logique est déterministe et transparente.

Les LLM fonctionnent différemment. Au lieu de règles explicites, ils utilisent des motifs appris à partir des données d’entraînement pour générer des réponses. Vous fournissez un texte d’entrée (appelé un prompt), et le modèle génère un texte de sortie (appelé une complétion(completion) ou réponse).

# Exemple conceptuel - nous écrirons bientôt du vrai code
response = llm.generate("Quelle est une bonne réduction pour les clients premium ?")
# Exemple de sortie : "Les clients premium reçoivent généralement des réductions de 15 à 25 %..."

Le LLM n’a pas de pourcentage de réduction codé en dur. Il génère une réponse à partir de motifs appris pendant l’entraînement. Cela signifie :

1. Les réponses peuvent varier : le même prompt peut produire des réponses légèrement différentes à chaque fois
2. Le comportement est appris, pas programmé : vous guidez le modèle avec des prompts plutôt qu’en écrivant une logique explicite
3. Les capacités émergent de l’échelle : le modèle peut gérer des tâches pour lesquelles il n’a pas été explicitement entraîné

Terminologie clé

Définissons des termes que vous rencontrerez constamment :

• Prompt : le texte d’entrée que vous envoyez au modèle. Voyez-le comme la « question » ou « instruction »
• Complétion(completion)/Réponse : le texte que le modèle génère en réponse à votre prompt
• Token : l’unité de base avec laquelle les LLM travaillent. Grossièrement, 1 token ≈ 4 caractères ou ¾ d’un mot. « Hello world » représente environ 2 tokens
• Fenêtre de contexte : la quantité maximale de texte (en tokens) que le modèle peut traiter en une fois. GPT-5-mini a une fenêtre de contexte de 400K tokens
• Température : un paramètre qui contrôle l’aléatoire. Plus bas (0.0-0.3) = plus focalisé et déterministe. Plus haut (0.7-1.0) = plus créatif et varié

Ce que les LLM peuvent et ne peuvent pas faire

Comprendre ce que les LLM font de manière fiable — et ce qu’ils ne font qu’en apparence — est essentiel pour construire des agents(agent) IA robustes.

Les LLM excellent à :

• Comprendre et générer du langage naturel : ils peuvent analyser l’intention, générer des réponses cohérentes et gérer des formulations complexes

"Je veux un remboursement" → Reconnaît l’intention : refund_request
"Résumez ce document" → Produit un résumé concis

• Suivre des instructions dans les prompts : avec des consignes claires, ils peuvent produire des sorties structurées comme du JSON ou du texte formaté

"Convertir en JSON : John Smith, 32 ans, vit à Boston"
→ {"name": "John Smith", "age": 32, "city": "Boston"}

• Reconnaître des motifs dans le texte : l’analyse de sentiment, la catégorisation et l’extraction d’informations fonctionnent de manière fiable

• Générer du code et du contenu structuré : ils peuvent écrire du Python valide, du SQL, ou d’autres sorties formatées lorsqu’ils sont correctement guidés

• Raisonnement étape par étape : lorsqu’on leur demande explicitement de « réfléchir étape par étape », ils décomposent les problèmes de façon méthodique

Limites des LLM :

• Ce n’est pas une base de données : ils ne récupèrent pas des faits — ils génèrent du texte statistiquement plausible. Ils peuvent affirmer avec assurance des informations incorrectes qui sonnent de manière autoritaire.

"Quand Python 4.0 est-il sorti ?" 
→ Pourrait générer "Python 4.0 est sorti en 2023" (faux, mais plausible)

• Ce n’est pas une calculatrice : ils prédisent à quoi une réponse devrait ressembler plutôt que de la calculer. Les calculs simples fonctionnent souvent ; les maths complexes échouent de manière imprévisible.

"Combien font 8 247 × 6 839 ?" → Peut produire un mauvais résultat qui paraît raisonnable

• Ce n’est pas déterministe : le même prompt peut produire des sorties différentes à chaque exécution. Cette variabilité est contrôlée par le paramètre de température.

• Ce n’est pas toujours exact : ils génèrent du texte plausible quel que soit le degré de véracité. Les « hallucinations » — des informations détaillées, sûres d’elles, mais entièrement fabriquées — surviennent fréquemment.

L’idée clé : construisez des agents(agent) qui combinent des LLM (pour la compréhension et la prise de décision) avec des outils traditionnels (pour le calcul, la récupération de données et les opérations factuelles). Nous mettrons en œuvre ce pattern à partir du chapitre 13, où le LLM décide quand utiliser une calculatrice plutôt que d’essayer de faire les maths lui-même.

Ce que vous apprendrez

Dans ce livre, vous apprendrez à construire des agents(agent) IA — des systèmes où le LLM décide de manière autonome quelles actions entreprendre pour atteindre des objectifs, plutôt que de suivre une logique prédéterminée. Nous explorerons ce paradigme en profondeur dans le chapitre 2.

1.2) Installer les dépendances

Mettons en place votre environnement de développement. Nous allons créer une structure de projet propre et installer LangChain, le framework que nous utiliserons pour construire des agents(agent) IA.

Vérifier l’installation de Python

Tout d’abord, assurez-vous que Python est installé sur votre système. Nous recommandons Python 3.10 ou une version supérieure (en 2026, Python 3.13 ou 3.14 sont de bons choix).

Vérifiez votre version de Python :

python --version
# or
python3 --version

Vous devriez voir une sortie du type Python 3.13.x ou Python 3.14.x.

Si Python n’est pas installé :

• macOS :

  • Téléchargez depuis python.org
  • Ou utilisez Homebrew : brew install python@3.14

• Windows :

  • Téléchargez depuis python.org
  • Cochez « Add Python to PATH » pendant l’installation

• Linux :

  • Ubuntu/Debian : sudo apt update && sudo apt install python3.14
  • Fedora : sudo dnf install python3.14

Après l’installation, vérifiez à nouveau avec python --version.

Remarque : sur certains systèmes, vous devrez peut-être utiliser python3 au lieu de python. Tout au long de ce livre, si python ne fonctionne pas, essayez python3.

Créer votre projet

Ouvrez votre terminal et créez un nouveau répertoire pour votre projet :

mkdir agentic-ai-project
cd agentic-ai-project

Créez un environnement virtuel pour isoler les dépendances :

python -m venv venv

Activez l’environnement virtuel :

# Sur macOS/Linux :
source venv/bin/activate
 
# Sur Windows :
venv\Scripts\activate

Vous devriez voir (venv) apparaître dans l’invite de votre terminal, indiquant que l’environnement virtuel est actif.

Installer LangChain et OpenAI

Nous allons installer l’intégration OpenAI de LangChain, qui inclut tout le nécessaire pour travailler avec les modèles d’OpenAI :

pip install langchain-openai

Cela installe langchain-openai avec ses dépendances, notamment langchain-core (les abstractions cœur de LangChain) et le client Python d’OpenAI. Vous devriez voir une sortie confirmant l’installation de plusieurs paquets.

Vérifiez l’installation :

pip show langchain-openai

Vous devriez voir des détails sur le paquet installé, y compris son numéro de version et son emplacement. Cela confirme que l’installation a réussi.

Obtenir votre clé API OpenAI

Pour appeler les modèles d’OpenAI, vous avez besoin d’une clé API :

1. Allez sur platform.openai.com
2. Inscrivez-vous ou connectez-vous
3. Allez dans API Keys dans les paramètres de votre compte
4. Cliquez sur « Create new secret key »
5. Copiez la clé (elle commence par sk-)

⚠️ Avertissement de sécurité : traitez cette clé comme un mot de passe. Ne la committez jamais dans un système de contrôle de version et ne la partagez pas publiquement. Toute personne possédant votre clé peut effectuer des appels API qui seront facturés sur votre compte.

Définir votre clé API comme variable d’environnement

La méthode recommandée pour fournir votre clé API est d’utiliser une variable d’environnement :

# Sur macOS/Linux :
export OPENAI_API_KEY='sk-your-actual-key-here'
 
# Sur Windows (Command Prompt) :
set OPENAI_API_KEY=sk-your-actual-key-here
 
# Sur Windows (PowerShell) :
$env:OPENAI_API_KEY='sk-your-actual-key-here'

Remarque : ce paramètre est temporaire et sera perdu lorsque vous fermerez le terminal. Pour une solution permanente, vous pouvez soit :

• Ajouter la commande export à votre fichier de configuration de shell (.bashrc, .zshrc, etc.)
• Utiliser un fichier .env (nous mettrons cela en place dans le chapitre 3 pour une meilleure organisation du projet)

Pour l’instant, le paramétrage temporaire suffit pour continuer.

Vérifiez qu’elle est bien définie :

# Sur macOS/Linux :
echo $OPENAI_API_KEY
 
# Sur Windows (Command Prompt) :
echo %OPENAI_API_KEY%
 
# Sur Windows (PowerShell) :
echo $env:OPENAI_API_KEY

Vous devriez voir votre clé API s’afficher. Sinon, répétez la commande export/set et assurez-vous qu’il n’y a pas de fautes de frappe.

1.3) Votre premier appel à un LLM

Passons maintenant à la partie la plus enthousiasmante : faisons votre premier appel à un LLM. Créez un fichier nommé first_call.py :

# first_call.py
from langchain_openai import ChatOpenAI
 
# Initialise le LLM
llm = ChatOpenAI(model="gpt-5-mini")
 
# Envoie un prompt et récupère une réponse
response = llm.invoke("Qu'est-ce que LangChain ?")
 
# Affiche la réponse
print(response.content)

Exécutez-le :

python first_call.py

Vous devriez voir une sortie similaire à ceci (le libellé exact peut varier) :

LangChain est un framework conçu pour simplifier le développement d'applications alimentées par de grands modèles de langage (LLM). Il fournit des outils et des abstractions pour construire des chaînes d'appels LLM, intégrer des sources de données externes, gérer les prompts et créer des agents capables d'interagir avec diverses API et bases de données. LangChain facilite la création d'applications d'IA complexes en fournissant des composants et des patterns réutilisables.

Félicitations ! Vous venez d’effectuer votre premier appel à un LLM. Décomposons ce qui s’est passé dans ce code.

Dépannage : si vous voyez une erreur :

• AuthenticationError : la clé API est invalide ou non définie → vérifiez votre variable d’environnement OPENAI_API_KEY (voir section 1.2)
• RateLimitError : requêtes trop rapides ou limite d’usage dépassée → attendez quelques secondes et réessayez, ou vérifiez l’usage sur platform.openai.com/usage
• APIConnectionError : problème de connectivité réseau → vérifiez votre connexion internet

Comprendre le code

Importer le wrapper LLM :

from langchain_openai import ChatOpenAI

ChatOpenAI est le wrapper de LangChain autour des modèles de chat d’OpenAI. Il gère pour vous l’authentification API, le formatage des requêtes et le parsing des réponses.

Initialiser le modèle :

llm = ChatOpenAI(model="gpt-5-mini")

Cela crée une instance configurée pour utiliser GPT-5-mini. En coulisses, LangChain lit votre variable d’environnement OPENAI_API_KEY pour l’authentification. Vous pourriez aussi passer la clé explicitement :

llm = ChatOpenAI(model="gpt-5-mini", api_key="sk-your-key")

Mais utiliser des variables d’environnement est plus sûr et plus flexible.

Invoquer le modèle :

response = llm.invoke("Qu'est-ce que LangChain ?")

La méthode invoke() envoie votre prompt à l’API d’OpenAI et attend la réponse complète. Il s’agit d’un appel synchrone : votre programme se met en pause jusqu’à l’arrivée de la réponse.

Accéder au contenu de la réponse :

print(response.content)

L’objet de réponse contient plusieurs champs. Le champ .content contient le texte réel généré par le modèle. Nous explorerons les autres champs dans la section suivante.

Essayez différents prompts

Modifiez le prompt pour voir comment le modèle répond à différentes entrées :

# first_call.py
from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-5-mini")
 
# Essayez différents prompts
prompts = [
    "Expliquez les décorateurs Python en une phrase.",
    "Combien font 15 * 23 ?",
    "Listez trois avantages à utiliser des annotations de type en Python.",
]
 
for prompt in prompts:
    response = llm.invoke(prompt)
    print(f"Prompt: {prompt}")
    print(f"Response: {response.content}\n")

Le modèle gère différents types de requêtes — explications, calculs et listes structurées. Vous remarquerez que les réponses peuvent varier légèrement si vous exécutez le même prompt plusieurs fois. C’est un comportement normal — nous explorerons pourquoi cela arrive et comment le contrôler dans le chapitre 2.

1.4) Que s’est-il passé ? (Flux Requête → Modèle → Réponse)

Examinons précisément ce qui s’est passé lorsque vous avez appelé llm.invoke(). Comprendre ce flux est crucial pour construire des agents(agent) IA fiables.

Le cycle complet requête-réponse

Suivons chaque étape :

Étape 1 : votre code appelle invoke()

response = llm.invoke("Qu'est-ce que LangChain ?")

La méthode invoke() est votre interface principale avec le LLM. Vous passez une chaîne de prompt, et elle renvoie un objet réponse contenant la réponse du modèle. Derrière cet appel simple, plusieurs étapes se produisent automatiquement.

Étape 2 : LangChain formate la requête

LangChain transforme votre chaîne en une requête API structurée. En coulisses, il crée une payload JSON comme celle-ci :

{
  "model": "gpt-5-mini",
  "messages": [
    {
      "role": "user",
      "content": "Qu'est-ce que LangChain ?"
    }
  ],
  "temperature": 1.0
}

Le tableau messages est la manière dont les modèles de chat reçoivent l’entrée. Chaque message a un role (user, assistant, ou system) et un content (le texte). Nous explorerons les rôles des messages dans le chapitre 4.

Étape 3 : appel API vers OpenAI

LangChain envoie une requête HTTPS POST vers l’endpoint API d’OpenAI :

POST https://api.openai.com/v1/chat/completions
Authorization: Bearer sk-your-api-key
Content-Type: application/json
 
{request payload}

Votre clé API authentifie la requête. Les serveurs d’OpenAI reçoivent la requête et la routent vers le modèle spécifié.

Étape 4 : le modèle traite le prompt

GPT-5-mini reçoit votre prompt et génère une réponse token par token. Le modèle :

1. Convertit votre texte en tokens (représentations numériques)
2. Traite les tokens à travers ses couches de réseau neuronal
3. Prédit le token suivant le plus probable
4. Répète jusqu’à générer une réponse complète ou atteindre une condition d’arrêt

Tout cela se passe sur les serveurs d’OpenAI — votre code se contente d’attendre le résultat.

Étape 5 : l’API renvoie la réponse

L’API d’OpenAI renvoie une réponse JSON :

{
  "id": "chatcmpl-8x7y9z",
  "object": "chat.completion",
  "created": 1704067200,
  "model": "gpt-5-mini",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "LangChain est un framework conçu pour simplifier..."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 12,
    "completion_tokens": 58,
    "total_tokens": 70
  }
}

Champs clés :

• message.content : le texte généré
• usage : le nombre de tokens pour la facturation et le monitoring
• finish_reason : pourquoi la génération s’est arrêtée ("stop" = fin naturelle, "length" = limite de tokens atteinte)

Étape 6 : LangChain parse la réponse

LangChain convertit le JSON en un objet Python que vous pouvez manipuler :

from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-5-mini")
response = llm.invoke("Qu'est-ce que LangChain ?")
 
# Explore l'objet réponse
print(f"Content: {response.content}")
print(f"Type: {type(response)}")
print(f"Response metadata: {response.response_metadata}")

Sortie :

Content: LangChain est un framework conçu pour simplifier...
Type: <class 'langchain_core.messages.ai.AIMessage'>
Response metadata: {'token_usage': {'completion_tokens': 58, 'prompt_tokens': 12, 'total_tokens': 70}, 'model_name': 'gpt-5-mini', 'finish_reason': 'stop'}

La réponse est un objet AIMessage avec plusieurs attributs utiles :

• content : le texte généré (ce que vous voulez généralement)
• response_metadata : usage des tokens, nom du modèle, raison de fin
• id : identifiant unique pour cette réponse
• usage_metadata : détail de la répartition des tokens

Comprendre l’usage des tokens

Avant d’examiner les nombres de tokens, une note rapide : les tokens sont les unités de base que les LLM traitent. En anglais, le texte utilise généralement un peu plus de 1 token par mot (par exemple, "explain quantum computing" = 3 mots, 4-5 tokens), mais les langues non anglaises comme le coréen ou le chinois nécessitent significativement plus de tokens pour représenter le même texte. Nous explorerons les tokens plus en détail dans le chapitre 2.

Examinons la consommation de tokens de plus près :

from langchain_openai import ChatOpenAI
 
llm = ChatOpenAI(model="gpt-5-mini")
response = llm.invoke("Expliquez l'informatique quantique en termes simples.")
 
usage = response.response_metadata['token_usage']
print(f"Input tokens: {usage['prompt_tokens']}")
print(f"Output tokens: {usage['completion_tokens']}")
print(f"Total tokens: {usage['total_tokens']}")

Sortie :

Input tokens: 11
Output tokens: 95
Total tokens: 106

Remarque : prompt_tokens = tokens en entrée (votre prompt), completion_tokens = tokens en sortie (la réponse du modèle), total_tokens = somme des deux.

La consommation de tokens varie selon :

• La longueur du prompt : les prompts plus longs utilisent plus de tokens en entrée
• Le niveau de détail de la réponse : les réponses détaillées génèrent plus de tokens en sortie
• La complexité de la langue : les termes techniques et le code peuvent être tokenisés différemment

Par exemple, un prompt court comme "What's 2+2?" peut n’utiliser que 5-6 tokens en entrée et 8-10 tokens en sortie, tandis que "Write a detailed essay about the history of Python programming language" pourrait utiliser 15-20 tokens en entrée et 500+ tokens en sortie.

Calcul du coût pour l’exemple ci-dessus :

Au tarif de GPT-5-mini (0,25 $ par million de tokens en entrée, 2,00 $ par million de tokens en sortie) :

• Entrée : 11 tokens × 0,25 $ / 1 000 000 = 0,00000275 $
• Sortie : 95 tokens × 2,00 $ / 1 000 000 = 0,00019 $
• Total : ~0,0002 $ (deux centièmes de centime)

Vous payez à la fois pour les tokens en entrée et en sortie, mais les tokens en sortie coûtent plus cher (8× dans ce cas).

Ce que vous avez appris

Vous comprenez maintenant le cycle de vie complet d’un appel à un LLM :

1. Votre code fournit une chaîne de prompt
2. LangChain la formate en une requête API avec authentification
3. L’API d’OpenAI route la requête vers le modèle
4. Le modèle génère une réponse token par token
5. L’API renvoie un JSON structuré avec la réponse et les métadonnées
6. LangChain la parse en un objet Python
7. Votre code accède au contenu et aux métadonnées

Vous avez aussi appris :

• Comment inspecter les objets de réponse et extraire les métadonnées
• Comment l’usage des tokens impacte les coûts

Cette base vous prépare pour le chapitre 2, où nous explorerons comment les LLM fonctionnent réellement sous le capot, comparerons différents modèles, et apprendrons des techniques de prompt engineering pour obtenir de meilleurs résultats.