Salut, agent en formation ! Emma ici, de retour sur agent101.net, et aujourd’hui nous allons explorer quelque chose qui mijote depuis un moment mais qui commence enfin à prendre de l’ampleur : faire en sorte que les agents IA agissent pour vous, même si vous débutez. Plus précisément, nous allons parler de comment faire en sorte qu’un agent IA simple surveille une partie spécifique d’internet pour vous et vous informe lorsqu’un changement se produit. Pensez-y comme à votre chien de chasse numérique personnel, mais avec beaucoup moins de désordre.
Depuis des mois, je m’amuse avec divers outils IA, essayant de les pousser au-delà de simplement écrire des poèmes amusants ou résumer des articles. Je les voulais proactifs. Je les voulais… 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 week-end de libre juste pour configurer l’environnement. Frustrant, n’est-ce pas ?
Alors, il y a quelques semaines, j’essayais de suivre le lancement d’un produit spécifique – un nouvel appareil domotique que je devais absolument obtenir. C’était le genre de choses qui sortaient sans beaucoup d’avertissement, et le stock disparaissait en quelques minutes. Rafraîchir la page toutes les cinq minutes me rendait folle. Mes doigts étaient en feu, mes yeux étaient flous et ma consommation de café était dangereusement élevée. C’est alors que j’ai compris : c’est exactement le genre de tâche répétitive qui nécessite une vigilance pour laquelle un agent IA est parfait. Et j’ai trouvé un moyen de le faire que même moi, une blogueuse tech qui s’avoue parfois « confuse avec 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 IA peut faire pour vous.
Aujourd’hui, nous allons donc construire un agent IA simple qui surveille une page web pour un changement spécifique et vous notifie. Ce n’est pas de construire le prochain Skynet ; il s’agit de résoudre un vrai problème quotidien avec une touche de magie IA. Et croyez-moi, si je peux le faire, vous le pouvez aussi.
Qu’est-ce qu’un Agent IA de Surveillance Simple ?
Au fond, un agent IA 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 IA » et pas juste « script » ? Eh bien, la partie « IA » entre en jeu lorsque nous commençons à réfléchir à la manière dont il interprète les changements et comment il décide ce qui est important. Pour ce tutoriel destiné aux débutants, nous gardons l’IA assez légère – pensez à ça comme à l’utilisation d’un modèle IA pour nous aider à comprendre le texte, et non pas 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 *instantanément* lorsque la page produit pour cet appareil domotique passait de « Rupture de Stock » à « En Stock ». Je ne voulais pas être inondée de chaque mise à jour infime, juste ce morceau d’information crucial. Ce n’est pas uniquement pour les lancements de produits. Imaginez suivre des annonces d’emploi, des articles de presse sur un sujet spécifique, des changements de prix chez les concurrents, ou même des mises à jour sur votre webcomic préféré. Les possibilités sont plutôt sympas une fois que vous y prenez goût.
Les Outils dont Nous aurons Besoin (Ne Paniquez Pas, c’est Minimal)
- Python : Si vous ne l’avez pas, allez le chercher. Il est gratuit et relativement facile à utiliser.
- Quelques bibliothèques Python : Nous utiliserons
requestspour récupérer des pages web,BeautifulSouppour analyser le HTML, et potentiellement un moyen d’envoyer des notifications (commesmtplibpour les emails ou un simple webhook). - Un modèle IA (facultatif 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 effectuer une correspondance de texte simple. C’est ici que l’« IA » entre vraiment en jeu au-delà simplement d’un 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 configurons pas des serveurs ni des services cloud complexes. Tout cela est local, 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 sophistiqués – cela récupère juste 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 des réponses mauvaises (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 scraper sans vérifier le robots.txt du site
# et les conditions d'utilisation. Soyez respectueux et ne bombardez 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 demandes automatisées. J’ai eu une erreur 403. Oups ! J’ai dû trouver un autre site cible ou figurez-vous 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 demandes basiques. Vérifiez toujours le fichier robots.txt du site (par exemple, https://example.com/robots.txt) pour voir ce qu’ils autorisent et interdisent pour les robots d’indexation. 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. Cela nous aide à naviguer dans la structure HTML comme une carte.
C’était la partie la plus difficile pour moi. Chaque site web est différent. Vous devez ouvrir la page cible dans votre navigateur, faire un clic 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 IDs 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')
# Cela est très spécifique à la page web que vous surveillez.
# VOUS DEVEZ MODIFIER CECI.
# Exemple : Rechercher une div avec une classe spécifique, ou un span avec un 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 une div qui contient le statut du stock
stock_element = soup.find('span', class_='product-status') # Ajustez le nom de la classe en fonction de votre inspection
if not stock_element:
stock_element = soup.find('div', id='stock-indicator') # Ajustez l'ID en fonction de 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 morceau ou même tout le corps
# et laissons le modèle IA le déterminer. 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 (peut être bruyant)."
# Supposons que `current_content` soit provenant de l'étape précédente
relevant_text = extract_relevant_info(current_content)
print(f"Texte pertinent extrait : {relevant_text[:200]}...") # Afficher les 200 premiers caractères
Mes tentatives initiales ici étaient des échecs hilarants. J’ai essayé de tout récupérer sur la page et de le donner à l’IA, 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 la classe a légèrement changé. La clé est de trouver un équilibre : suffisamment spécifique pour réduire le bruit, général à la fois pour gérer les changements mineurs de mise en page.
Étape 3 : La Magie de l’IA – Détection de Changement Significatif
Maintenant, passons à la partie amusante ! Au lieu de simplement faire une comparaison de texte simple (qui se déclencherait à chaque petit changement d’annonce), nous allons utiliser un modèle IA pour nous dire si le *sens* du texte pertinent a changé de manière significative concernant notre intérêt (le statut du stock).
Pour cela, vous aurez besoin d’une clé API pour votre modèle IA choisi (OpenAI, Gemini, etc.). Conservez-la en 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 hardcoder 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 soit défini dans les variables d'environnement
def ask_ai_about_change(old_text, new_text, target_keyword="in 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é en dehors 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. Si non, dites simplement 'Aucun changement significatif.'
Concentrez-vous uniquement sur la disponibilité, ignorez les changements mineurs de formulation ou de formatage.
"""
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 le feriez normalement dans une boucle)
# Pour l'instant, simulons un changement
# Supposons que 'previous_relevant_text' provienne d'une extraction antérieure
previous_relevant_text = "Rupture de stock. Restockage 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. Restockage 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 “AI.” Au lieu d’écrire des modèles regex 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, j’avais peur que l’IA soit confuse par de légères variations de formulation. Mais avec un bon prompt, c’était étonnamment solide. Elle a correctement identifié quand “À venir” est devenu “Précommandez maintenant” comme un changement significatif, même si les mots exacts “En stock” n’étaient pas présents.
Étape 4 : Mettre le tout en œuvre – La boucle de l’agent et la notification
Un agent doit fonctionner en continu. Nous allons donc envelopper 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 un service de notification réel :
# - Email (en utilisant smtplib)
# - Service de notification push (Pushover, IFTTT webhook, bot Telegram)
# - Passerelle SMS
# Pour simplifier, nous allons juste imprimer 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 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 base vide.")
# Si la récupération initiale échoue, l'agent essaiera de 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"Base définie après un é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 "Aucun 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 # Met à jour la base uniquement sur un 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 base
# pour éviter les alertes répétées de "changement potentiel" pour la même différence mineure.
# Ou, le garder tel quel si vous voulez que l'IA réévalue à chaque fois.
# Pour cet exemple, nous mettrons à 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é
# Faites attention aux politiques du site et ne faites pas de demandes 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 de lancer.
run_agent(my_target_url, monitoring_interval, desired_status)
J'ai réglé mon intervalle à 5 minutes pour ce dispositif de maison intelligente insaisissable. Chaque fois que je voyais le message "Vérification...", je ressentais une petite excitation. Lorsque la notification est enfin arrivée - "En stock ! Quantité limitée disponible." - je jurerais avoir entendu des anges chanter. J'ai cliqué sur le lien, ajouté le produit à mon panier et a validé ma commande en quelques secondes. Succès ! Mon petit agent IA m'avait sauvé des rafraîchissements sans fin et m'avait aidé à obtenir ce gadget.
Conseils pratiques pour votre premier agent IA
- Commencez petit : Ne tentez pas de créer un agent conversationnel complexe dès le départ. Une tâche de surveillance simple 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.
- Les prompts sont essentiels : Plus vous décrivez clairement le type de changement que vous recherchez au modèle AI, plus ses réponses seront précises et utiles. Expérimentez avec vos prompts !
- Soyez respectueux : Ne surchargez pas les sites web de demandes. Utilisez des intervalles raisonnables, vérifiez
robots.txt, et comprenez les conditions d'utilisation d'un site concernant l'accès automatisé. - Sécurisez vos clés : Ne laissez jamais les clés API en dur directement dans votre script. Utilisez des variables d'environnement.
- Itérez : Votre première tentative ne sera peut-être pas parfaite. La mienne ne l'était certainement pas ! Ajustez vos sélecteurs `BeautifulSoup`, peaufinez votre prompt AI, et modifiez votre méthode de notification jusqu'à ce qu'elle fonctionne pour vous.
Construire cet agent était un immense booster de confiance pour moi. Cela m'a montré que l'IA n'est pas réservée aux grandes entreprises ou à la recherche académique. C'est un outil que nous, en tant qu'utilisateurs individuels et développeurs à petite échelle, pouvons utiliser pour résoudre nos propres problèmes et faciliter un peu notre vie numérique. Alors, avancez, choisissez une page web que vous en avez assez de vérifier manuellement, et construisez votre propre limier 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: