Salut, agent en formation ! Emma ici, de retour sur agent101.net, et aujourd’hui nous allons explorer quelque chose qui mijote sous la surface depuis un moment mais qui commence enfin à prendre son envol : faire en sorte que les agents AI agissent pour vous, même si vous débutez. Plus précisément, nous allons parler de comment obtenir un agent AI simple pour surveiller une partie spécifique d’internet pour vous et vous dire quand quelque chose change. Pensez à cela comme à votre chien de chasse numérique personnel, mais bien moins encombrant.
Depuis des mois, je bricole divers outils AI, essayant de les pousser au-delà de la simple rédaction de poèmes amusants ou du résumé d’articles. Je voulais qu’ils soient proactifs. Je voulais qu’ils soient… des agents ! Mais chaque fois que je regardais un tutoriel, j’avais l’impression d’avoir besoin d’un diplôme en informatique et d’un weekend libre juste pour configurer l’environnement. Frustrant, non ?
Ensuite, il y a quelques semaines, j’essayais de suivre le lancement d’un produit spécifique – un nouvel appareil de maison intelligente que je devais absolument avoir. C’était l’un de ces trucs qui tombent sans beaucoup d’avertissement, et le stock disparaît en quelques minutes. Actualiser la page toutes les cinq minutes me rendait folle. Mes doigts faisaient mal, mes yeux étaient flous, et ma consommation de café était dangereusement élevée. C’est à ce moment-là que j’ai eu une révélation : c’est exactement le type de tâche répétitive, nécessitant de la vigilance, pour lequel un agent AI est parfait. Et j’ai trouvé un moyen de le faire qui, même moi, en tant que blogueuse tech auto-proclamée « se perd parfois dans YAML », pouvais gérer. Pas de frameworks sophistiqués, pas de bibliothèques obscures, juste un peu de Python et une bonne compréhension de ce qu’un assistant AI peut faire pour vous.
Aujourd’hui, nous allons donc créer un agent AI simple qui surveille une page web pour un changement spécifique et vous en informe. Il ne s’agit pas de construire le prochain Skynet ; il s’agit de résoudre un vrai problème quotidien avec une pincée de magie AI. Et croyez-moi, si je peux le faire, vous le pouvez aussi.
Qu’est-ce qu’un agent AI de surveillance simple ?
Au fond, un agent AI de surveillance est juste un programme qui observe quelque chose et réagit lorsque certaines conditions sont remplies. Dans notre cas, il va surveiller une page web. Pourquoi « agent AI » et pas juste « script » ? Eh bien, la partie « AI » entre en jeu lorsque nous commençons à penser à la façon dont il interprète les changements et à la façon dont il décide de ce qui est important. Pour ce tutoriel destiné aux débutants, nous gardons l’AI assez légère – pensez à cela comme à l’utilisation d’un modèle AI pour nous aider à comprendre le texte, sans nécessairement prendre des décisions complexes. La partie « agent » est la boucle : observer, réfléchir (un peu), agir, répéter.
Mon objectif avec cet agent était simple : je voulais savoir l’*instant* où la page produit de cet appareil de maison intelligente changeait de « Rupture de stock » à « En stock. » Je ne voulais pas recevoir des notifications pour chaque petite mise à jour, juste cette information cruciale. Cependant, ce n’est pas uniquement pour le lancement de produits. Imaginez suivre des offres d’emploi, des articles de presse sur un sujet spécifique, des changements de prix chez les concurrents, ou même des mises à jour de votre webcomic préféré. Les possibilités sont plutôt sympas une fois que vous avez compris le principe.
Les outils dont nous aurons besoin (ne paniquez pas, c’est minimal)
- Python : Si vous ne l’avez pas, allez le chercher. C’est gratuit et relativement facile à utiliser.
- Quelques bibliothèques Python : Nous utiliserons
requestspour récupérer des pages web,BeautifulSouppour analyser HTML, et potentiellement un moyen d’envoyer des notifications (commesmtplibpour l’email ou un simple webhook). - Un modèle AI (optionnel mais utile) : Pour cela, je vais supposer que vous avez accès à quelque chose comme l’API d’OpenAI ou l’API Gemini de Google. Nous l’utiliserons pour détecter intelligemment les changements plutôt que de simplement faire une correspondance de texte simple. C’est ici que l’« AI » entre véritablement en jeu au-delà d’un simple script.
- Un éditeur de texte : VS Code, Sublime Text, même Notepad si vous vous sentez old-school.
Vous voyez ? Rien de trop intimidant. Nous ne sommes pas en train de mettre en place des serveurs ou de configurer des services cloud compliqués. Tout cela se fait localement, sur votre machine, tout comme je l’ai fait.
Étape 1 : Récupération du contenu de la page web
Tout d’abord, notre agent doit vraiment « voir » la page web. Nous allons utiliser la bibliothèque requests pour cela. C’est comme votre navigateur, mais sans les graphiques raffinés – il obtient simplement le HTML brut.
import requests
def fetch_page_content(url):
try:
response = requests.get(url)
response.raise_for_status() # Cela déclenchera une HTTPError pour les mauvaises réponses (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
# Essayons avec une URL fictive (remplacez par votre cible réelle)
# Pour cet exemple, j'utiliserai un espace réservé. NE JAMAIS faire de scraping sans vérifier le robots.txt d'un site
# et les conditions d'utilisation. Soyez respectueux et ne surchargez pas les serveurs !
target_url = "https://example.com/product-page" # REMPLACEZ CECI PAR VOTRE CIBLE RÉELLE
current_content = fetch_page_content(target_url)
if current_content:
print("Contenu récupéré avec succès. Premiers 200 caractères :")
print(current_content[:200])
else:
print("Échec de la récupération du contenu.")
Lorsque j’ai écrit cela pour la première fois, j’ai en fait essayé de récupérer une page qui bloquait les requêtes automatisées. J’ai eu une erreur 403. Oups ! J’ai dû trouver un autre site cible ou figurez comment ajouter des en-têtes pour imiter un navigateur. Pour ce tutoriel, supposons que le site que vous ciblez est d’accord avec les requêtes de base. Vérifiez toujours le fichier robots.txt du site (par exemple, https://example.com/robots.txt) pour voir ce qu’ils autorisent et n’autorisent pas pour les robots. Le scraping éthique est important !
Étape 2 : Analyse du HTML pour trouver ce qui est important
Une fois que nous avons le HTML brut, c’est un fouillis de balises et de texte. Nous devons extraire la partie spécifique qui indique « En stock » ou « Rupture de stock. » C’est là que BeautifulSoup entre en jeu. Il nous aide à naviguer dans la structure HTML comme une carte.
C’était la partie la plus délicate pour moi. Chaque site web est différent. Vous devez ouvrir la page cible dans votre navigateur, cliquez avec le bouton droit sur l’élément qui vous intéresse (comme le texte « En stock »), et sélectionner « Inspecter » ou « Inspecter l’élément. » Cela vous montrera le code HTML pour cette partie spécifique. Recherchez des identifiants uniques comme des ID ou des noms de classe.
from bs4 import BeautifulSoup
def extract_relevant_info(html_content):
if not html_content:
return "Pas de contenu à analyser."
soup = BeautifulSoup(html_content, 'html.parser')
# Ceci est très spécifique à la page web que vous surveillez.
# VOUS DEVEZ CHANGER CECI.
# Exemple : Chercher un div avec une classe spécifique, ou un span avec du texte spécifique.
# Pour ma page produit, le statut du stock était souvent dans une balise avec une classe comme "product-status"
# Essayez de trouver un span ou un div contenant le statut du stock
stock_element = soup.find('span', class_='product-status') # Ajustez le nom de classe selon votre inspection
if not stock_element:
stock_element = soup.find('div', id='stock-indicator') # Ajustez l'ID selon votre inspection
if stock_element:
return stock_element.get_text(strip=True)
else:
# Si nous ne pouvons pas trouver l'élément spécifique, retournons un plus grand extrait ou même tout le corps
# et laissons le modèle AI s'en occuper. C'est un bon plan de secours.
body_content = soup.find('body')
if body_content:
return body_content.get_text(separator=' ', strip=True)
return "Élément spécifique non trouvé, fournissant le texte complet de la page (cela peut être bruyant)."
# En supposant que `current_content` provient de l'étape précédente
relevant_text = extract_relevant_info(current_content)
print(f"Texte pertinent extrait : {relevant_text[:200]}...") # Affiche les premiers 200 caractères
Mes tentatives initiales ici étaient des échecs hilarants. J’ai essayé de prendre juste la page entière et de la donner à l’AI, ce qui fonctionnait parfois mais était vraiment lent et coûteux (les appels API ne sont pas gratuits !). Ensuite, j’ai essayé d’être trop spécifique et j’ai raté l’élément parce que le nom de classe avait légèrement changé. La clé est de trouver un équilibre : assez spécifique pour réduire le bruit, assez général pour gérer des changements mineurs de mise en page.
Étape 3 : La magie AI – Détecter un changement significatif
Voici la partie amusante ! Au lieu de simplement faire une comparaison de texte simple (qui se déclencherait à chaque petit changement de publicité), nous allons utiliser un modèle AI pour nous dire si le *sens* du texte pertinent a changé de manière significative par rapport à notre intérêt (le statut du stock).
Pour cela, vous aurez besoin d’une clé API pour votre modèle AI choisi (OpenAI, Gemini, etc.). Stockez-la en toute sécurité, pas directement dans votre code !
import os
from openai import OpenAI # Ou `google.generativeai` si vous utilisez Gemini
# Configurez votre clé API OpenAI
# NE JAMAIS coder en dur les clés API ! Utilisez des variables d'environnement ou un fichier de configuration.
# os.environ["OPENAI_API_KEY"] = "VOTRE_CLE_API_ICI" # NE FAITES PAS CELA DANS LE CODE DE PRODUCTION
# Au lieu de cela, définissez-la dans votre terminal : export OPENAI_API_KEY="sk-..."
client = OpenAI() # Supposons que OPENAI_API_KEY est défini dans les variables d'environnement
def ask_ai_about_change(old_text, new_text, target_keyword="en stock"):
prompt = f"""
Vous êtes un assistant intelligent surveillant une page web pour des changements liés à la disponibilité des produits.
Je vais vous fournir deux versions de texte extraites d'une page produit.
Votre tâche est de déterminer si le statut de disponibilité du produit a changé de manière significative,
spécifiquement s'il est devenu '{target_keyword}' alors qu'il ne l'était pas auparavant,
ou s'il a changé de '{target_keyword}'.
Ancien texte :
"{old_text}"
Nouveau texte :
"{new_text}"
La disponibilité du produit a-t-elle changé vers ou depuis '{target_keyword}' ?
Si oui, expliquez brièvement le changement. Sinon, dites simplement 'Pas de changement significatif.'
Concentrez-vous uniquement sur la disponibilité, ignorez les changements mineurs de formulation ou de mise en forme.
"""
try:
completion = client.chat.completions.create(
model="gpt-3.5-turbo", # Ou "gpt-4", "gemini-pro", etc.
messages=[
{"role": "system", "content": "Vous êtes un assistant utile."},
{"role": "user", "content": prompt}
],
max_tokens=150
)
return completion.choices[0].message.content
except Exception as e:
print(f"Erreur lors de l'appel au modèle AI : {e}")
return "L'analyse AI a échoué."
# Exemple d'utilisation (vous feriez normalement cela dans une boucle)
# Pour l'instant, simulons un changement
# Supposons que 'previous_relevant_text' provienne d'un fetch précédent
previous_relevant_text = "Rupture de stock. Réapprovisionnement prévu dans 2 semaines."
new_relevant_text = "En stock ! Quantité limitée disponible."
ai_response = ask_ai_about_change(previous_relevant_text, new_relevant_text, "En stock")
print(f"Évaluation de l'IA : {ai_response}")
# Simuler aucun changement
new_relevant_text_no_change = "Rupture de stock. Réapprovisionnement prévu dans 3 semaines."
ai_response_no_change = ask_ai_about_change(previous_relevant_text, new_relevant_text_no_change, "En stock")
print(f"Évaluation de l'IA (simulation sans changement) : {ai_response_no_change}")
C’est ici que l’agent devient vraiment « IA. » Au lieu d’écrire des expressions régulières complexes ou des comparaisons de chaînes fragiles, je dis simplement à l’IA quel type de changement je recherche. C’est comme avoir un petit stagiaire qui comprend le contexte ! Lorsque j’ai essayé cela pour la première fois, je craignais que l’IA se perde dans de légères variations de formulation. Mais avec un bon prompt, c’était étonnamment solide. Elle a correctement identifié quand « Bientôt disponible » est devenu « Précommandez maintenant » comme un changement significatif, même si les mots exacts « En stock » n’étaient pas présents.
Étape 4 : Rassembler le tout – La boucle de l’agent et la notification
Un agent doit fonctionner en continu. Donc, nous allons encapsuler notre logique de récupération et de vérification dans une boucle. Et quand il trouve quelque chose, il doit nous le faire savoir !
import time
# ... (import requests, BeautifulSoup, os, OpenAI des étapes précédentes) ...
# Variable globale pour stocker le dernier état connu
last_known_status_text = ""
def send_notification(message):
print(f"\n!!! Alerte AGENT !!!\n{message}\n")
# Ici, vous intégreriez avec un véritable service de notification :
# - Email (en utilisant smtplib)
# - Service de notification push (Pushover, webhook IFTTT, bot Telegram)
# - Passerelle SMS
# Pour simplifier, nous imprimerons juste dans la console.
# Exemple pour l'email (nécessite une configuration) :
# import smtplib
# from email.mime.text import MIMEText
# msg = MIMEText(message)
# msg['Subject'] = 'Changement de page web détecté !'
# msg['From'] = '[email protected]'
# msg['To'] = '[email protected]'
# try:
# with smtplib.SMTP_SSL('smtp.example.com', 465) as smtp:
# smtp.login('[email protected]', 'votre_mot_de_passe')
# smtp.send_message(msg)
# print("Notification par email envoyée.")
# except Exception as e:
# print(f"Échec de l'envoi de l'email : {e}")
def run_agent(url, interval_seconds=300, target_keyword="En stock"):
global last_known_status_text
print(f"L'agent commence à surveiller {url} toutes les {interval_seconds} secondes.")
print("Récupération initiale...")
# Récupération initiale pour définir la ligne de base
html_content = fetch_page_content(url)
if html_content:
last_known_status_text = extract_relevant_info(html_content)
print(f"Statut initial défini : {last_known_status_text[:100]}...")
else:
print("Impossible de récupérer le contenu initial. L'agent commence avec une ligne de base vide.")
# Si la récupération initiale échoue, l'agent essaiera à nouveau lors de la première itération de la boucle
while True:
print(f"\n[{time.strftime('%Y-%m-%d %H:%M:%S')}] Vérification de {url}...")
current_html_content = fetch_page_content(url)
if current_html_content:
new_relevant_text = extract_relevant_info(current_html_content)
if not last_known_status_text: # Gérer le cas où la récupération initiale a échoué
last_known_status_text = new_relevant_text
print(f"Ligne de base définie après échec initial : {last_known_status_text[:100]}...")
if new_relevant_text != last_known_status_text:
print("Changement potentiel détecté. Demande à l'IA...")
ai_analysis = ask_ai_about_change(last_known_status_text, new_relevant_text, target_keyword)
if "Pas de changement significatif." not in ai_analysis:
send_notification(f"Mise à jour de la page web pour {url}:\n{ai_analysis}\nNouveau texte : {new_relevant_text[:200]}...")
last_known_status_text = new_relevant_text # Mettre à jour la ligne de base uniquement en cas de changement significatif
else:
print(f"L'IA a déterminé : {ai_analysis} (mineur, ignoré)")
# Même si l'IA dit qu'il n'y a pas de changement significatif, nous pourrions vouloir mettre à jour la ligne de base
# pour éviter des alertes répétées de "changement potentiel" pour la même différence mineure.
# Ou, laissez-le comme ça si vous voulez que l'IA réévalue chaque fois.
# Pour cet exemple, nous allons mettre à jour pour éviter de spammer l'IA pour des changements mineurs statiques.
last_known_status_text = new_relevant_text
else:
print("Aucun changement textuel détecté dans la section pertinente.")
else:
print(f"Échec de la récupération du contenu depuis {url} lors de cette itération.")
time.sleep(interval_seconds) # Attendre avant de vérifier à nouveau
# --- Exécution principale ---
if __name__ == "__main__":
# Configurez votre URL cible et l'intervalle souhaité
# Soyez conscient des politiques du site web et ne faites pas de requêtes trop fréquentes !
my_target_url = "https://www.some-store.com/new-widget-X" # <<< REMPLACEZ CELA !
monitoring_interval = 600 # Vérifiez toutes les 10 minutes (600 secondes)
desired_status = "En stock" # Quel mot-clé recherchons-nous ?
# IMPORTANT : Assurez-vous que votre clé API OpenAI est définie comme une variable d'environnement !
# export OPENAI_API_KEY="sk-..." dans votre terminal avant d'exécuter.
run_agent(my_target_url, monitoring_interval, desired_status)
J'ai défini mon intervalle à 5 minutes pour ce dispositif de maison intelligente insaisissable. Chaque fois que je voyais le message "Vérification...", je ressentais une petite montée d'excitation. Lorsque la notification est enfin arrivée – "En stock ! Quantité limitée disponible." – je jure que j'ai entendu des anges chanter. J'ai cliqué sur le lien, l'ai ajouté à mon panier et j'ai payé en quelques secondes. Succès ! Mon petit agent IA m'avait sauvé d'un rafraîchissement sans fin et m'avait aidé à obtenir ce gadget.
Leçons concrètes pour votre premier agent IA
- Commencez petit : N'essayez pas de construire un agent conversationnel complexe dès le départ. Une tâche simple de surveillance est parfaite pour apprendre les bases.
- Inspectez votre cible : Comprendre la structure HTML de la page web que vous surveillez est crucial. Utilisez les outils de développement de votre navigateur.
- L'ingénierie de prompt est clé : Plus vous décrivez de manière précise le type de changement que vous recherchez au modèle IA, plus ses réponses seront précises et utiles. Expérimentez avec vos prompts !
- Soyez respectueux : Ne bombardez pas les sites web de requêtes. Utilisez des intervalles raisonnables, vérifiez
robots.txt, et comprenez les conditions d'utilisation d'un site concernant l'accès automatisé. - Protégez vos clés : Ne codez jamais les clés API directement dans votre script. Utilisez des variables d'environnement.
- Itérez : Votre première tentative pourrait ne pas être parfaite. La mienne ne l'était certainement pas ! Ajustez vos sélecteurs `BeautifulSoup`, affinez votre prompt IA, et modifiez votre méthode de notification jusqu'à ce que ça fonctionne pour vous.
Construire cet agent a été un énorme boost de confiance pour moi. Cela m'a montré que l'IA n'est pas seulement pour les grandes entreprises ou la recherche académique. C'est un outil que nous, en tant qu'utilisateurs individuels et développeurs occasionnels, pouvons utiliser pour résoudre nos propres problèmes et rendre nos vies numériques un peu plus faciles. Alors allez-y, choisissez une page web que vous en avez marre de vérifier manuellement, et construisez votre propre chien de chasse numérique. Vous serez surpris de ce que vous pouvez accomplir !
Articles connexes
- Lorsque votre agent se rebelle : maîtriser les interrupteurs d'urgence
- Agents IA dans l'immobilier : transformer l'industrie
- API OpenAI en 2026 : 7 choses après 3 mois d'utilisation
🕒 Published: