IA agentique vs IA générative : le passage de la création à l'action

IA agentique vs IA générative : le passage de la création à l'action

L'intelligence artificielle traverse une transformation fondamentale. Depuis quelques années, l'IA générative domine les titres – des modèles qui créent du texte, des images, du code et de la musique à partir de jeux de données massifs. Ces systèmes, comme GPT-4, DALL·E et Stable Diffusion, sont des maîtres de la génération de contenu. Mais un nouveau paradigme émerge : **l'IA agentique**. Au lieu de simplement produire des résultats, les systèmes d'IA agentique prennent des actions délibérées, utilisent des outils, prennent des décisions et poursuivent des objectifs avec une intervention humaine minimale.

Le passage de la création à l'action n'est pas qu'un changement sémantique – il représente une nouvelle façon de penser ce que l'IA peut accomplir. Là où l'IA générative répond à « Que peux-tu écrire ou dessiner ? », l'IA agentique demande « Que peux-tu faire ou accomplir ? ». Cet article explore les différences, les implications pratiques et la manière de commencer à construire dès aujourd'hui les deux types de systèmes.

Prérequis

Avant de plonger dans le code, vous aurez besoin de quelques composants de base.

• **Python 3.9+** — le langage principal pour le développement IA.
• **pip** — le gestionnaire de paquets Python.
• **Une clé API OpenAI** — nécessaire pour les exemples d'IA générative (inscrivez-vous sur platform.openai.com).
• **Facultatif : une clé SerpAPI** — pour les capacités de recherche de l'IA agentique (inscrivez-vous sur serpapi.com).
• **Un terminal ou une invite de commande** — les commandes sont écrites pour macOS/Linux ; les utilisateurs Windows doivent adapter les chemins et les commandes d'environnement virtuel.

Nous installerons les paquets Python suivants :

• `openai` — la bibliothèque officielle OpenAI.
• `langchain` — framework pour construire des workflows agentiques.
• `langchain-community` — outils communautaires incluant la recherche et les maths.
• `python-dotenv` — pour gérer les variables d'environnement.

Installation pas à pas

Commencez par créer un environnement virtuel propre pour éviter les conflits de dépendances.

# Créer un répertoire de projet
mkdir ai-comparison
cd ai-comparison

# Créer un environnement virtuel
python3 -m venv venv

# L'activer
source venv/bin/activate   # Sur Windows : venv\Scripts\activate

# Mettre à jour pip
pip install --upgrade pip

Installez maintenant les paquets requis.

# Installer la bibliothèque OpenAI
pip install openai

# Installer LangChain et les outils communautaires
pip install langchain langchain-community

# Installer dotenv pour la gestion sécurisée des clés API
pip install python-dotenv

Configurez vos variables d'environnement. Créez un fichier `.env` à la racine du projet et ajoutez vos clés :

OPENAI_API_KEY=sk-votre-clé-ici
SERPAPI_API_KEY=votre-clé-serpapi-ici   # si vous utilisez la recherche web

Pour charger ces clés dans vos scripts Python, vous utiliserez `load_dotenv()` comme montré plus loin.

L'IA générative en pratique

L'IA générative est le point de départ le plus simple. Vous lui donnez une instruction, et elle produit une complétion. L'exemple suivant utilise le modèle GPT-4o d'OpenAI pour générer un court poème.

Créez un fichier `generate_poem.py` :

import os
from dotenv import load_dotenv
from openai import OpenAI

# Charger la clé API depuis le fichier .env
load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Écris un court poème sur l'intelligence artificielle dans le style d'un haïku."}
    ],
    max_tokens=80,
    temperature=0.7
)

poem = response.choices[0].message.content
print("Poème généré :\n")
print(poem)

Exécutez-le :

python generate_poem.py

Le résultat sera un haïku créatif et contextuel. Il s'agit de pure génération – le modèle n'a aucune mémoire des interactions précédentes à moins que vous ne les fournissiez, et il n'a aucune capacité à agir sur le monde extérieur. Il crée, puis s'arrête.

L'IA agentique en pratique

L'IA agentique va plus loin. Un agent peut percevoir son environnement (via des outils), raisonner sur une tâche, décider d'actions, les exécuter et tirer des leçons des résultats. LangChain fournit un moyen simple de construire de tels agents. Dans cet exemple, nous créons un agent capable d'effectuer des recherches web et de faire des calculs arithmétiques pour répondre à une question d'un utilisateur.

Créez un fichier `agent_question.py` :

import os
from dotenv import load_dotenv
from langchain_openai import ChatOpenAI
from langchain.agents import initialize_agent, AgentType
from langchain_community.tools import WikipediaQueryRun, DuckDuckGoSearchRun
from langchain_community.utilities import WikipediaAPIWrapper
from langchain_core.tools import Tool
from langchain_core.tools import tool

load_dotenv()

# Initialiser le modèle de langage
llm = ChatOpenAI(model="gpt-4o", temperature=0, api_key=os.getenv("OPENAI_API_KEY"))

# Définir les outils : recherche Wikipedia et une calculatrice simple
wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
search = DuckDuckGoSearchRun()

@tool
def calculator(expression: str) -> str:
    """Évalue une expression mathématique et retourne le résultat."""
    try:
        result = eval(expression)
        return f"Le résultat est {result}"
    except Exception as e:
        return f"Erreur : {e}"

tools = [
    Tool(
        name="Wikipedia",
        func=wikipedia.run,
        description="Utile pour rechercher des informations factuelles sur Wikipedia."
    ),
    Tool(
        name="DuckDuckGo Search",
        func=search.run,
        description="Utile pour les recherches web générales lorsque vous avez besoin d'informations récentes."
    ),
    Tool(
        name="Calculatrice",
        func=calculator,
        description="Évalue une expression mathématique comme '2 + 3 * 4'."
    )
]

# Initialiser l'agent avec le type "zero-shot-react-description"
agent = initialize_agent(
    tools=tools,
    llm=llm,
    agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
    verbose=True,
    handle_parsing_errors=True
)

# Poser une question qui nécessite l'utilisation d'outils
question = "Quelle est la population du Japon en 2023 ? Ajoute ensuite 5 millions."
response = agent.invoke({"input": question})
print("\nRéponse finale :\n", response["output"])

Exécutez le script :

python agent_question.py

Vous verrez le raisonnement pas à pas de l'agent (car `verbose=True`). Il cherchera d'abord la population du Japon en 2023, puis utilisera l'outil calculatrice pour ajouter 5 millions, et enfin produira une réponse unique. C'est de l'action : l'IA a non seulement produit du texte, mais a aussi orchestré des outils externes et retourné un résultat vérifiable.

Comparer les deux

Ce qu'ils font

• **L'IA générative** produit des résultats statiques : texte, images, audio. Elle est bonne pour la création de contenu, le résumé, la traduction et le brainstorming.
• **L'IA agentique** exécute des processus dynamiques : elle peut interroger des bases de données, exécuter du code, envoyer des e-mails ou contrôler des appareils. Elle est adaptée à l'automatisation des tâches, la recherche, le service client et l'aide à la décision.

Comment ils fonctionnent

Les modèles génératifs sont généralement de grands réseaux de transformeurs entraînés à prédire le jeton suivant. Ils n'ont pas de capacité intégrée à interagir avec le monde. Les systèmes agentiques, en revanche, combinent un modèle de langage avec une boucle de raisonnement (comme ReAct — Reasoning + Acting) et un ensemble d'outils. Le modèle décide quel outil utiliser en fonction de l'état actuel, observe le résultat de l'outil et continue jusqu'à ce que l'objectif soit atteint.

Collaboration, pas compétition

Les deux paradigmes sont complémentaires. Un système agentique contient souvent un modèle génératif comme « cerveau ». Le modèle génératif comprend l'intention de l'utilisateur, élabore le plan et interprète les résultats des outils. La couche agentique ajoute les « mains » pour exécuter les actions. Comme le soulignent les discussions dans les actualités OpenAI et le blog Microsoft AI, l'avenir de l'IA mélangera probablement ces approches. Par exemple, un agent de support client pourrait utiliser l'IA générative pour rédiger une réponse polie, mais utiliser des capacités agentiques pour vérifier le statut d'une commande dans une base de données.

Limites et considérations

Aucun paradigme n'est parfait.

• **L'IA générative** souffre d'hallucinations – elle peut produire des informations fausses mais formulées avec assurance. Elle n'a pas non plus de mémoire persistante (sauf si vous l'implémentez en externe).
• **L'IA agentique** est plus complexe à déboguer. Une utilisation inappropriée des outils ou des boucles infinies peuvent se produire. Elle nécessite également une gestion minutieuse des autorisations : si un agent peut écrire dans le système de fichiers ou envoyer des e-mails, les risques de sécurité augmentent. Des entreprises comme Anthropic et NVIDIA mènent des recherches sur des frameworks agentiques sécurisés, soulignant la nécessité d'une supervision et de contraintes.

De plus, les systèmes agentiques peuvent être plus lents car chaque action nécessite un aller-retour vers le LLM et l'outil. Le coût augmente également avec de multiples appels API. Les développeurs doivent peser la valeur de l'action autonome par rapport à la latence et aux dépenses.

La voie à suivre

Le passage de la création à l'action est accéléré par de nouveaux frameworks (LangChain, AutoGPT, Microsoft Copilot) et par des modèles de fondation qui prennent en charge nativement l'utilisation d'outils (GPT-4 avec function calling, la capacité d'utilisation d'outils de Claude). À mesure que ces modèles deviennent plus fiables, nous verrons l'IA agentique passer de démos expérimentales à des systèmes de production qui gèrent des calendriers, réservent des voyages, mènent des recherches et coordonnent avec d'autres agents logiciels.

À bien des égards, l'explosion de l'IA générative était la phase « apprendre à parler » de l'intelligence artificielle. L'IA agentique représente « apprendre à marcher » – et finalement courir. Le véritable potentiel de l'IA ne réside pas dans sa capacité à générer un poème parfait, mais dans sa capacité à agir sur le monde, à résoudre des problèmes et à devenir un véritable partenaire dans nos tâches quotidiennes.

Conclusion

L'IA générative a donné une voix aux machines ; l'IA agentique leur donne des mains. Les deux sont puissants, chacun avec des forces distinctes. L'IA générative excelle dans la création, la créativité et la communication. L'IA agentique excelle dans l'exécution, l'autonomie et l'obtention de résultats tangibles. Comprendre quand utiliser chacune – et comment les combiner – est la clé pour construire des applications d'IA percutantes aujourd'hui.

Que vous génériez des textes marketing avec un simple appel API ou que vous construisiez un assistant de recherche autonome qui cherche, calcule et rapporte, les outils sont désormais entre vos mains. Le passage de la création à l'action n'est pas qu'une tendance – c'est la prochaine étape logique de notre cheminement pour rendre l'IA vraiment utile.