Salut, agent en formation ! Emma ici, de retour d’une autre plongée nocturne dans le monde fascinant, parfois frustrant, des agents IA. Si tu es comme moi, tu as probablement passé les derniers mois à entendre des murmures (ou des cris) à propos des agents IA et tu t’es dit : « D’accord, ça a l’air cool, mais aussi… qu’est-ce que c’est, vraiment, et comment puis-je en avoir un qui fasse quelque chose pour moi ? »
Eh bien, tu es au bon endroit. Aujourd’hui, nous n’allons pas simplement parler de ce que sont les agents IA *en théorie*. Nous allons retrousser nos manches et aborder une question qui en préoccupe beaucoup d’entre vous (et moi, jusqu’à récemment) : Comment construire un agent IA simple qui puisse réellement naviguer sur Internet pour moi et répondre à des questions spécifiques ?
Oublions l’engouement pendant un instant. Nous allons nous concentrer sur le pratique. Nous viserons le « Je peux vraiment faire ça fonctionner sur mon ordinateur portable. » Parce qu’honnêtement, voir, c’est croire, non ?
Mes propres erreurs (et succès) avec le navigateur
Quand j’ai commencé à expérimenter avec l’idée d’un agent capable d’utiliser Internet, j’avais de grandes visions. Je voulais qu’il recherche des sujets complexes, compare des prix sur une douzaine de sites, et soit essentiellement mon assistant numérique personnel. Ce que j’ai obtenu, au début, c’était beaucoup d’erreurs, quelques scrapers web cassés, et un profond sentiment d’inadéquation. Mes premières tentatives étaient comme essayer d’apprendre à un tout-petit à manipuler une machine complexe – beaucoup d’enthousiasme, aucune compréhension des mécanismes sous-jacents.
Le plus gros obstacle ? Faire en sorte qu’un modèle IA interagisse avec Internet de manière significative et contrôlée. C’est une chose de poser une question à ChatGPT à laquelle il connaît déjà la réponse. C’est autre chose de lui demander d’aller chercher de nouvelles informations, de les interpréter, puis d’agir en conséquence. C’est là que la partie « agent » entre vraiment en jeu.
Après beaucoup d’essais et d’erreurs, j’ai réalisé que la clé n’était pas de construire une entité super complexe et omnisciente dès le départ. Il fallait commencer petit, avec une tâche très spécifique, et développer à partir de là. Et c’est exactement ce que nous allons faire aujourd’hui. Nous allons créer un agent de navigateur de base qui peut se rendre sur un site web spécifique, extraire des informations et faire un rapport.
Qu’est-ce qu’un agent AI de navigateur ?
Avant d’explorer le code, clarifions rapidement. Un agent IA, à sa base, est un programme IA conçu pour accomplir une tâche spécifique de manière autonome. Il observe son environnement (dans notre cas, Internet), prend des décisions basées sur ses objectifs, et ensuite agit. Un agent IA *navigateur* utilise spécifiquement des capacités de navigation web comme outil.
Pensez-y comme ceci : vous dites à votre agent, « Trouve-moi la météo actuelle à Londres. » Au lieu de simplement puiser dans ses connaissances internes, un agent navigateur ouvrirait (idéalement) un navigateur web, se rendrait sur un site météo, trouverait l’information, puis vous la communiquerait. C’est la différence entre poser une question à un bibliothécaire à laquelle il connaît déjà la réponse, et lui demander d’aller chercher un livre, de lire un chapitre spécifique, puis de le résumer pour vous.
Pour notre agent simple, nous allons utiliser quelques bibliothèques Python courantes qui rendent tout ce processus beaucoup moins intimidant.
Les outils dont nous aurons besoin
Vous n’avez pas besoin d’un superordinateur pour cela. Juste votre configuration de développement habituelle. Voici ce que nous allons utiliser :
- Python : Notre langage de programmation de prédilection. (J’utilise la version 3.9, mais la 3.8+ devrait convenir.)
requests: Une bibliothèque fantastique pour effectuer des requêtes HTTP (c’est-à-dire récupérer des pages web).BeautifulSoup(bs4) : C’est notre magicien du parsing web. Il nous aide à naviguer et à extraire des données à partir de HTML.- Une API de Grand Modèle Linguistique (LLM) : Nous aurons besoin d’un accès à un LLM comme les modèles GPT d’OpenAI ou Claude d’Anthropic. Pour ce tutoriel, je vais supposer que vous avez une clé API OpenAI.
Tout d’abord, préparons notre environnement. Si vous n’avez pas ces bibliothèques installées, ouvrez votre terminal ou votre invite de commande et exécutez :
pip install requests beautifulsoup4 openai
Et assurez-vous d’avoir votre clé API OpenAI à portée de main. Vous devez la définir comme variable d’environnement ou la passer directement dans votre script. Pour simplifier, je vais l’afficher directement, mais en production, les variables d’environnement sont toujours meilleures.
Notre mission : Trouver un article spécifique sur un blog
Fixons un objectif concret et réalisable. La mission de notre agent sera de :
- Se rendre sur un blog spécifique (utilisons un URL de blog fictif pour l’instant, ou même agent101.net si vous vous sentez aventureux !).
- Trouver un titre de post de blog qui contient un mot-clé spécifique (par exemple, « débutant »).
- Extraire l’URL de ce post de blog.
- Résumer le contenu de ce post de blog en utilisant un LLM.
C’est un point de départ fantastique car cela combine l’interaction web avec la compréhension du LLM. C’est comme demander à votre assistant numérique de « me trouver le dernier article sur les agents IA pour débutants sur agent101.net et de me dire de quoi il s’agit. »
Étape 1 : Récupérer la page web
La première étape pour tout agent de navigateur est de « voir » la page web. Nous allons utiliser la bibliothèque requests pour cela. Faisons un script simple :
import requests
def fetch_webpage(url):
try:
response = requests.get(url)
response.raise_for_status() # Lève une HTTPError pour des réponses incorrectes (4xx ou 5xx)
return response.text
except requests.exceptions.RequestException as e:
print(f"Erreur lors de la récupération de l'URL {url} : {e}")
return None
# Utilisons une URL de remplacement pour l'instant.
# Remplacez par une véritable URL de blog qui a des articles si vous voulez tester !
blog_url = "https://www.example-blog.com/articles" # Utilisez une véritable URL ici !
html_content = fetch_webpage(blog_url)
if html_content:
print("Contenu de la page web récupéré avec succès.")
# Nous traiterons ce contenu à l'étape suivante
else:
print("Échec de la récupération de la page web.")
Une note rapide sur les URL : Pour que cela fonctionne, vous aurez besoin d’une véritable URL de blog. Si vous n’en avez pas sous la main, vous pouvez utiliser un site comme `http://quotes.toscrape.com/` pour tester le scraping simple, mais pour des posts de blog, trouvez un vrai blog. Même ce site, agent101.net, pourrait fonctionner si vous adaptez les sélecteurs CSS par la suite !
Étape 2 : Analyser le HTML et trouver des liens d’articles
Maintenant que nous avons le HTML brut, c’est comme avoir un énorme livre sans index. BeautifulSoup est notre indexeur. Nous devons lui indiquer comment trouver les titres d’articles et leurs liens correspondants.
C’est la partie la plus délicate car la structure HTML de chaque site web est différente. Vous devrez « inspecter » l’élément sur le site cible. Faites un clic droit sur un titre d’article de votre blog choisi et sélectionnez « Inspecter » (ou « Inspecter l’élément »). Recherchez des motifs communs comme les tags <h2> pour les titres, ou les tags <a> pour les liens, souvent imbriqués dans un <div> avec un nom de classe spécifique.
Pour la démonstration, supposons une structure de blog commune où les titres des articles se trouvent dans des tags <h2>, et leurs liens se trouvent dans un tag <a> directement à l’intérieur ou précédant cela.
from bs4 import BeautifulSoup
def find_article_links(html_content, keyword):
soup = BeautifulSoup(html_content, 'html.parser')
article_data = []
# Ceci est un exemple générique. Vous devrez ajuster les sélecteurs en fonction du site cible.
# Modèles courants : div avec la classe 'article-item', h2 avec la classe 'article-title', etc.
# Supposons que les articles soient dans des éléments 'div' avec la classe 'post'
# et que les titres soient dans des balises 'h2' à l'intérieur de ces divs, avec un lien à l'intérieur.
# Exemple : Cherchez toutes les balises qui pourraient contenir des titres d'articles
# Puis vérifiez si elles sont liées.
# Une approche plus solide pourrait consister à trouver d'abord les conteneurs :
article_containers = soup.find_all('div', class_='article-card') # Ajustez cette classe !
if not article_containers:
# Retour à une autre sélection si la première ne fonctionne pas
article_containers = soup.find_all('article') # Une autre balise courante
for container in article_containers:
title_tag = container.find('h2') # Ou 'h3', 'a', etc.
link_tag = container.find('a', href=True) # Trouvez le premier lien dans le conteneur
if title_tag and link_tag:
title = title_tag.get_text(strip=True)
href = link_tag['href']
# Assurez-vous que l'URL soit absolue si elle est relative
if href.startswith('/'):
full_url = requests.compat.urljoin(blog_url, href)
else:
full_url = href
if keyword.lower() in title.lower():
article_data.append({'title': title, 'url': full_url})
return article_data
# ... (code précédent pour fetch_webpage) ...
if html_content:
search_keyword = "beginner" # Quel article recherchons-nous ?
found_articles = find_article_links(html_content, search_keyword)
if found_articles:
print(f"\nArticles trouvés contenant '{search_keyword}':")
for article in found_articles:
print(f"- Titre : {article['title']}\n URL : {article['url']}")
# Pour cet exemple, prenons simplement le premier trouvé
target_article = found_articles[0]
else:
print(f"\nAucun article trouvé contenant '{search_keyword}'.")
target_article = None
else:
target_article = None
Personnalisation Cruciale : Les lignes comme soup.find_all('div', class_='article-card') et container.find('h2') sont des espaces réservés. Vous *devez* les adapter en fonction de la structure HTML réelle du blog que vous ciblez. C’est là qu’inspecter la page web devient essentiel. Mon meilleur conseil est de commencer large (par exemple, `soup.find_all(‘a’)` pour obtenir tous les liens) puis de réduire avec des classes ou des IDs.
Étape 3 : Extraire le Contenu de l’Article Ciblé
Une fois que nous avons l’URL de notre article ciblé, nous devons récupérer son contenu et ensuite extraire le texte principal. Cela est souvent plus facile que d’analyser une page d’index, car la plupart du contenu des articles se trouve dans une balise de contenu principal <div> ou <article>.
# ... (code précédent) ...
import openai
import os
# Définissez votre clé API OpenAI
# Meilleure pratique : os.environ.get("OPENAI_API_KEY")
# Pour cet exemple, affectation directe :
openai.api_key = "YOUR_OPENAI_API_KEY" # REMPLACEZ CECI PAR VOTRE CLÉ RÉELLE !
def extract_article_text(article_url):
article_html = fetch_webpage(article_url)
if not article_html:
return None
soup = BeautifulSoup(article_html, 'html.parser')
# Cela dépend fortement de la structure du site web.
# Modèles courants : trouver un div avec la classe 'entry-content', 'article-body', 'main-content'
# Ou juste les balises à l'intérieur de la balise principale de l'article.
# Essayons de trouver les zones de contenu communes.
content_div = soup.find('div', class_='entry-content') # Commun pour WordPress
if not content_div:
content_div = soup.find('article') # Une autre bonne balise générale
if not content_div:
# En dernier recours, obtenir toutes les balises de paragraphe
paragraphs = soup.find_all('p')
return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
# Si nous avons trouvé une div/article spécifique de contenu, extrayons tout le texte des paragraphes
paragraphs = content_div.find_all('p')
article_text = "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
return article_text
if target_article:
print(f"\nRécupération du contenu pour : {target_article['title']}")
article_text_content = extract_article_text(target_article['url'])
if article_text_content:
# print(article_text_content[:500]) # Affiche les 500 premiers caractères pour vérifier
print("\nTexte de l'article extrait avec succès. Passons à la summarisation.")
else:
print("Échec de l'extraction du texte de l'article.")
article_text_content = "" # Assurez-vous qu'il ne soit pas None pour l'étape suivante
else:
article_text_content = ""
Encore une fois, la ligne soup.find('div', class_='entry-content') est votre cible principale pour la personnalisation. Utilisez l’inspecteur de votre navigateur !
Étape 4 : Résumer avec un LLM
Enfin, le moment où nous faisons intervenir l’intelligence artificielle ! Nous allons alimenter le texte extrait à un LLM et lui demander. C’est là que “l’intelligence” de notre agent brille vraiment.
# ... (code précédent) ...
def summarize_text_with_llm(text):
if not text:
return "Aucun texte fourni pour la résumé."
# Tronquer le texte s'il est trop long pour la fenêtre de contexte du modèle
# GPT-3.5-turbo a une fenêtre de contexte de 16k, mais il est bon de rester raisonnable.
# Pour un débutant, viser 4000-8000 tokens est sûr.
# Environ 1 token = 4 caractères pour du texte anglais.
max_tokens_for_input = 12000 # Ajustez en fonction de la capacité de votre modèle et des considérations de coût
if len(text) > max_tokens_for_input * 4: # Estimation grossière des caractères
text = text[:max_tokens_for_input * 4]
print(f"Avertissement : texte tronqué à ~{max_tokens_for_input} tokens pour le traitement LLM.")
try:
response = openai.chat.completions.create(
model="gpt-3.5-turbo", # Ou "gpt-4", "claude-3-opus-20240229", etc.
messages=[
{"role": "system", "content": "Vous êtes un assistant utile qui résume les articles de blog de manière concise."},
{"role": "user", "content": f"Veuillez résumer le message de blog suivant pour moi :\n\n{text}"}
],
temperature=0.7, # Contrôle de l'aléatoire. Plus bas pour des résumés plus ciblés.
max_tokens=500 # Tokens max pour le résumé lui-même
)
return response.choices[0].message.content.strip()
except openai.APIError as e:
print(f"Erreur API OpenAI : {e}")
return "Échec dû à une erreur d'API."
except Exception as e:
print(f"Une erreur imprévue s'est produite lors de la résumé : {e}")
return "Échec dû à une erreur imprévue."
if article_text_content:
print("\nDemande de résumé LLM...")
summary = summarize_text_with_llm(article_text_content)
print("\n--- Résumé de l'Article ---")
print(summary)
else:
print("\nImpossible de résumer : aucun contenu d'article disponible.")
Et voilà ! Un agent IA basique mais fonctionnel qui peut naviguer, extraire et résumer. Ce n’est plus juste une théorie ; c’est un morceau de code tangible que vous pouvez exécuter.
Tout Mettre Ensemble (Script Complet)
Voici le script complet pour un copier-coller et des tests faciles. N’oubliez pas de remplacer les URLs de remplacement et votre clé API OpenAI !
import requests
from bs4 import BeautifulSoup
import openai
import os
# --- Configuration ---
# Remplacez par l'URL de votre blog. Assurez-vous qu'il contient des articles !
TARGET_BLOG_URL = "https://www.example-blog.com/articles"
SEARCH_KEYWORD = "beginner" # Le mot-clé à rechercher dans les titres d'articles
OPENAI_API_KEY = "YOUR_OPENAI_API_KEY" # REMPLACEZ CECI ! Ou utilisez os.environ.get("OPENAI_API_KEY")
# Définir la clé API OpenAI
openai.api_key = OPENAI_API_KEY
# --- Fonctions d'Aide ---
def fetch_webpage(url):
"""Récupère le contenu HTML d'une URL donnée."""
try:
response = requests.get(url, timeout=10) # Ajout d'un délai d'attente
response.raise_for_status()
return response.text
except requests.exceptions.RequestException as e:
print(f"Erreur lors de la récupération de l'URL {url} : {e}")
return None
def find_article_links(html_content, base_url, keyword):
"""Analyse le HTML pour trouver les titres et URLs d'articles correspondant à un mot-clé."""
soup = BeautifulSoup(html_content, 'html.parser')
article_data = []
# --- POINT DE PERSONNALISATION 1 : Ajustez ces sélecteurs pour votre blog cible ---
# Inspectez la page du blog pour trouver les balises HTML et classes correctes pour les conteneurs d'articles, titres et liens.
article_containers = soup.find_all('div', class_='article-card') # Commun pour les cartes/aperçus d'articles
if not article_containers:
article_containers = soup.find_all('article') # Une autre balise commune pour des articles individuels
if not article_containers:
print("Avertissement : Impossible de trouver les balises de conteneur d'article communes. Essai d'une recherche plus large.")
# Retour : regardez juste tous les liens qui pourraient être des liens d'articles
all_links = soup.find_all('a', href=True)
for link in all_links:
title_text = link.get_text(strip=True)
if keyword.lower() in title_text.lower():
href = link['href']
full_url = requests.compat.urljoin(base_url, href)
article_data.append({'title': title_text, 'url': full_url})
return article_data # Retournez tôt si seuls des liens larges ont été trouvés
for container in article_containers:
# Recherchez le titre et le lien dans chaque conteneur
title_tag = container.find(['h2', 'h3', 'a']) # Les titres sont souvent dans h2/h3 ou directement liés
link_tag = container.find('a', href=True)
if title_tag and link_tag:
title = title_tag.get_text(strip=True)
href = link_tag['href']
# Construire l'URL complète si elle est relative
full_url = requests.compat.urljoin(base_url, href)
if keyword.lower() in title.lower():
article_data.append({'title': title, 'url': full_url})
return article_data
def extract_article_text(article_url):
"""Récupère une page d'article et extrait son contenu textuel principal."""
article_html = fetch_webpage(article_url)
if not article_html:
return None
soup = BeautifulSoup(article_html, 'html.parser')
# --- POINT DE PERSONNALISATION 2 : Ajustez ces sélecteurs pour le contenu principal de l'article ---
# Recherchez la zone de contenu principal de l'article (par exemple, div avec la classe 'entry-content', 'article-body')
content_area = soup.find('div', class_='entry-content')
if not content_area:
content_area = soup.find('article', class_='main-article-content') # Un autre modèle commun
if not content_area:
content_area = soup.find('div', id='content') # Encore un autre ID commun
if content_area:
paragraphs = content_area.find_all('p')
return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
else:
# Retour : obtenir toutes les balises de paragraphe si la zone de contenu spécifique n'est pas trouvée
print(f"Avertissement : Zone de contenu spécifique non trouvée pour {article_url}. Extraction de tous les paragraphes.")
paragraphs = soup.find_all('p')
return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
def summarize_text_with_llm(text):
"""Utilise un LLM pour le texte fourni."""
if not text or len(text.strip()) < 50: # Longueur minimale du texte pour tenter un résumé
return "Pas assez de contenu pour le résumé."
# Troncature simple pour rester dans les limites typiques de la fenêtre de contexte
# Envisagez d'utiliser un véritable compteur de tokens pour plus de précision si nécessaire
max_chars_for_llm = 40000 # Environ 10k tokens pour GPT-3.5-turbo 16k context
if len(text) > max_chars_for_llm:
print(f"Avertissement : Texte tronqué de {len(text)} à {max_chars_for_llm} caractères pour LLM.")
text = text[:max_chars_for_llm]
try:
response = openai.chat.completions.create(
model="gpt-3.5-turbo", # Vous pouvez utiliser "gpt-4" si vous y avez accès et souhaitez une meilleure qualité
messages=[
{"role": "system", "content": "Vous êtes un assistant utile qui résume les articles de blog de manière concise et claire."},
{"role": "user", "content": f"Veuillez fournir un résumé concis de l'article de blog suivant, en mettant en évidence les points clés :\n\n{text}"}
],
temperature=0.6, # Un peu moins aléatoire pour les résumés
max_tokens=600 # Max tokens pour le résumé généré
)
return response.choices[0].message.content.strip()
except openai.APIError as e:
print(f"Erreur API OpenAI : {e}")
return f"Échec en raison d'une erreur API : {e}"
except Exception as e:
print(f"Une erreur imprévue s'est produite pendant le résumé : {e}")
return f"Échec en raison d'une erreur imprévue : {e}"
# --- Logique Principale de l'Agent ---
def run_browser_agent():
print(f"Démarrage de l'agent de navigation pour {TARGET_BLOG_URL} afin de trouver des articles sur '{SEARCH_KEYWORD}'...")
# Étape 1 : Récupérer la page principale du blog
blog_html = fetch_webpage(TARGET_BLOG_URL)
if not blog_html:
print("L'agent n'a pas réussi à récupérer la page principale du blog. Sortie.")
return
# Étape 2 : Trouver des articles correspondant au mot-clé
found_articles = find_article_links(blog_html, TARGET_BLOG_URL, SEARCH_KEYWORD)
if not found_articles:
print(f"Aucun article trouvé contenant '{SEARCH_KEYWORD}' sur {TARGET_BLOG_URL}. L'agent a terminé.")
return
print(f"\nTrouvé {len(found_articles)} articles potentiels contenant '{SEARCH_KEYWORD}' :")
for i, article in enumerate(found_articles):
print(f"{i+1}. Titre : {article['title']}\n URL : {article['url']}")
# Pour cet exemple, traitons le premier article trouvé
target_article = found_articles[0]
print(f"\nTraitement du premier article trouvé : '{target_article['title']}' à {target_article['url']}")
# Étape 3 : Extraire le contenu de l'article cible
article_content = extract_article_text(target_article['url'])
if not article_content:
print(f"L'agent n'a pas réussi à extraire le contenu de {target_article['url']}. Impossible de résumer.")
return
print(f"\nContenu de l'article extrait (premiers 200 caractères) : {article_content[:200]}...")
# Étape 4 : Résumer le contenu en utilisant LLM
print("\nDemande à LLM l'article...")
summary = summarize_text_with_llm(article_content)
print("\n--- Rapport Final de l'Agent ---")
print(f"Titre de l'Article : {target_article['title']}")
print(f"URL de l'Article : {target_article['url']}")
print("\nRésumé :")
print(summary)
print("\n--- Tâche de l'Agent Complétée ---")
if __name__ == "__main__":
run_browser_agent()
Points Clés Actionnables pour Votre Propre Parcours d’Agent
Ce petit projet n’est que la pointe de l’iceberg, mais il vous montre les mécanismes de base. Voici ce que j’ai appris et ce que vous devriez garder à l’esprit :
- Commencez Petit, Pensez Spécifique : Ne tentez pas de construire Skynet dès le premier jour. Choisissez une tâche très étroite et réalisable pour votre agent. « Trouver une recette de lasagne végétalienne » est mieux que « cuisine le dîner pour moi. »
- Le Web Scraping est le Far West : Chaque site web est différent. Vous PASSEREZ du temps à inspecter les éléments dans votre navigateur pour obtenir les bons sélecteurs CSS ou XPath. C’est le travail de base, mais c’est essentiel. Les sites web changent, donc votre agent pourrait nécessiter des ajustements occasionnels.
- La Gestion des Erreurs est Votre Amie : Des choses vont mal se passer. Les sites web seront hors ligne, votre internet coupera, les appels API échoueront. Ajoutez des
try-exceptpour gérer gracieusement ces problèmes. - Les LLMs sont Intelligents, mais Ont Besoin de Direction : La qualité de la sortie de votre LLM dépend fortement de votre prompt. Soyez clair, concis, et dites-lui exactement ce que vous attendez. De plus, soyez conscient des limites de la fenêtre de contexte et des coûts.
- Ceci est une Fondation : Nous avons construit un agent à un tour. Les véritables agents impliquent souvent plusieurs étapes, une logique conditionnelle (par exemple, « si je trouve cela, alors fais cela ») et de la mémoire. Mais vous avez maintenant les blocs de construction.
J’espère qu’en voyant cet agent simple prendre vie, le concept entier d’« agent IA » devient un peu moins mystérieux. Ce n’est pas de la magie ; c’est juste une automatisation intelligente construite sur des outils existants. Allez-y, bricolez et construisez vos propres petits assistants numériques !
Bon codage,
Emma Walsh, agent101.net
Articles Connexes
- Comment les Agents IA maîtrisent plusieurs Langues en douceur
- J’ai rendu mon Agent IA utile (voici comment)
- J’ai construit un Agent IA en 2026 : Mon avis honnête
🕒 Published: