IA agentique / IA générative

IA agentique / IA générative

Le paysage de l'intelligence artificielle connaît un changement fondamental, passant d'une génération de contenu passive à une exécution autonome active. L'IA générative a posé les bases en permettant aux machines de produire du texte cohérent, des images réalistes et du code fonctionnel. L'IA agentique s'appuie sur cette fondation, transformant les modèles de simples générateurs statiques en systèmes dynamiques capables de planifier, raisonner, utiliser des outils et itérer pour atteindre des objectifs. Le résultat est une nouvelle classe de logiciels qui ne se contentent pas de répondre à des questions, mais accomplissent des flux de travail complets.

Les organisations de tout le secteur font progresser ces deux paradigmes. OpenAI, Anthropic, Microsoft et NVIDIA contribuent chacune au discours technique en évolution par le biais de leurs canaux de recherche et d'ingénierie respectifs. Leurs travaux couvrent l'entraînement de modèles fondationnels, l'alignement sur la sécurité, l'infrastructure cloud et l'accélération matérielle. À mesure que ces couches mûrissent, les développeurs gagnent un accès pratique aux capacités agentiques qui étaient auparavant confinées aux laboratoires de recherche. Cet article propose un guide pratique pour construire avec l'IA générative et agentique, depuis la configuration de l'environnement jusqu'à un agent ReAct fonctionnel.

Comprendre le paysage

L'IA générative désigne des modèles — généralement de grands transformeurs ou des réseaux de diffusion — qui apprennent des motifs à partir de données d'entraînement et synthétisent des sorties nouvelles. Qu'il s'agisse de produire du contenu marketing, de déboguer du code ou de générer des données synthétiques, l'interaction fondamentale reste de type requête-réponse. Le modèle reçoit une invite et retourne une complétion.

L'IA agentique étend cette boucle d'interaction en introduisant l'autonomie. Un système agentique perçoit un objectif, le décompose en sous-tâches, sélectionne les outils appropriés, observe les résultats intermédiaires et ajuste son plan. Cette architecture s'appuie souvent sur un modèle de langage comme moteur de raisonnement, mais l'intelligence est distribuée à travers la boucle plutôt que concentrée dans une seule passe avant. L'utilisation d'outils, la mémoire et la logique de contrôle deviennent des composants de première classe.

La convergence de ces approches constitue la direction que prend le développement d'applications moderne. Un modèle génratif fournit le raisonnement sémantique ; un cadre agentique fournit la machine à états et les liaisons d'outils. Ensemble, ils permettent des applications qui interagissent avec des API, interrogent des bases de données, exécutent du code et valident leurs propres sorties. Les sections suivantes détaillent la construction pratique d'un tel système.

Prérequis

Avant d'installer des logiciels, assurez-vous que votre environnement répond aux critères de base. Vous aurez besoin d'un système d'exploitation moderne — Linux, macOS, ou Windows Subsystem for Linux (WSL) — avec Python 3.9 ou plus récent installé. Ce tutoriel utilise pip pour la gestion des paquets, vérifiez donc que pip est disponible aux côtés de votre interpréteur Python.

Vous aurez également besoin d'une clé API d'OpenAI. Cette clé permet d'accéder au point de terminaison des complétions de chat, qui sert de colonne vertébrale de raisonnement pour les exemples génratifs et agentiques. Si votre organisation utilise Azure OpenAI Service, le code peut être adapté en modifiant l'initialisation du client, bien que ce guide suppose la plateforme OpenAI standard.

Les exigences matérielles sont modestes. L'exécution sur CPU est suffisante pour la couche d'orchestration car l'inférence lourde s'exécute à distance sur l'infrastructure d'OpenAI. Cependant, assurez-vous de disposer d'au moins 2 Go de RAM disponible et d'une connexion Internet stable. Les besoins en espace disque sont minimes ; l'environnement Python et les bibliothèques consommeront moins de 500 Mo.

Les outils optionnels mais recommandés incluent Git, pour le contrôle de version, et un gestionnaire d'environnements virtuels tel que venv. Ils ne sont pas strictement nécessaires, mais ils évitent les conflits de dépendances et rendent la configuration reproductible.

Installation étape par étape

Commencez par créer un répertoire dédié pour le projet. Isoler votre travail évite d'encombrer des dossiers existants avec de nouvelles dépendances.

```bash mkdir agentic-ai-lab && cd agentic-ai-lab ```

Créez un environnement virtuel Python dans ce répertoire. Un environnement virtuel garantit que les paquets que vous installez n'interfèrent pas avec votre installation Python système.

```bash python3 -m venv venv ```

Activez l'environnement virtuel pour que les commandes pip suivantes installent les paquets dans ce contexte isolé plutôt que dans l'environnement global.

```bash source venv/bin/activate ```

Sur les systèmes Windows utilisant PowerShell ou l'invite de commandes, exécutez plutôt le script d'activation situé dans le répertoire Scripts.

```bash venv\Scripts\activate ```

Avec l'environnement actif, mettez pip à jour vers la dernière version. Cela minimise les problèmes de compatibilité lors de l'installation.

```bash pip install --upgrade pip ```

Installez les bibliothèques principales nécessaires pour l'accès à l'IA générative et l'orchestration agentique. Vous aurez besoin du client officiel OpenAI, des liaisons LangChain pour OpenAI, et de LangGraph pour le cadre agentique.

```bash pip install openai langchain langchain-openai langgraph ```

Pour garder votre clé API hors du code source, créez un fichier d'environnement local. La commande suivante génère un fichier caché `.env` à la racine de votre projet.

```bash touch .env ```

Ouvrez le fichier `.env` dans votre éditeur de texte préféré et ajoutez votre clé API OpenAI. Remplacez l'espace réservé par votre clé réelle.

```bash echo "OPENAI_API_KEY=sk-your-key-here" > .env ```

Exportez la clé dans votre session shell actuelle pour que les scripts Python puissent la lire directement pendant ce tutoriel.

```bash export OPENAI_API_KEY=$(grep OPENAI_API_KEY .env | cut -d '=' -f2) ```

Vérifiez que la clé est correctement chargée en affichant les premiers caractères. N'affichez jamais la clé entière dans un terminal partagé.

```bash echo $OPENAI_API_KEY | cut -c1-10 ```

Confirmez que tous les paquets sont correctement installés en exécutant un test d'importation rapide. Cette commande devrait se terminer silencieusement sans sortie si tout est correctement lié.

```bash python -c "import openai, langchain, langgraph; print('OK')" ```

Votre environnement est maintenant prêt. Les étapes restantes consistent à écrire et exécuter des scripts Python qui mettent en œuvre à la fois les motifs génratifs et agentiques.

Exemples d'utilisation

Exemple 1 : IA générative fondamentale

Le point d'entrée le plus simple est l'interaction directe avec un grand modèle de langage via le client OpenAI. Cela établit que votre clé API, l'accès réseau et les versions des bibliothèques fonctionnent. Créez un fichier nommé `generate.py` et remplissez-le avec le code suivant.

Ce script importe le client OpenAI et initialise une connexion en utilisant la clé API que vous avez exportée précédemment.

```python from openai import OpenAI

client = OpenAI() ```

Le client envoie une requête de complétion de chat au modèle `gpt-4o-mini`. Ce modèle offre un bon équilibre entre capacité et latence pour le prototypage.

```python response = client.chat.completions.create( model="gpt-4o-mini", messages=[ {"role": "system", "content": "You are a concise technical assistant."}, {"role": "user", "content": "Explain the difference between generative AI and agentic AI in one paragraph."} ], temperature=0.2 ) ```

Enfin, extrayez et affichez le texte généré depuis l'objet réponse.

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

Exécutez le script depuis votre terminal.

```bash python generate.py ```

Vous devriez recevoir un paragraphe cohérent distinguant l'IA générative comme une technologie de création de contenu et l'IA agentique comme un système piloté par des objectifs et utilisant des outils. Cela confirme que votre pipeline génratif est opérationnel.

Exemple 2 : IA agentique avec outils et raisonnement

Aller au-delà de la génération en un seul tour nécessite un cadre agentique. Cet exemple utilise LangGraph pour construire un agent ReAct — une architecture qui entrelace le Raisonnement et l'Action. Le modèle réfléchit à un problème, décide s'il doit utiliser un outil, observe la sortie de l'outil, et répète jusqu'à atteindre une réponse finale.

Créez un nouveau fichier nommé `agent.py`. Commencez par importer les modules nécessaires. `ChatOpenAI` fournit l'interface du modèle, `tool` décore les fonctions personnalisées, et `create_react_agent` construit la machine à états.

```python from langchain_openai import ChatOpenAI from langchain_core.tools import tool from langgraph.prebuilt import create_react_agent ```

Définissez un outil de calculatrice simple. Le décorateur `@tool` expose la fonction à l'agent avec un nom et une description dérivés de la docstring.

```python @tool def multiply(a: float, b: float) -> float: """Multiply two numbers and return the product.""" return a * b ```

Définissez un deuxième outil qui sim