Agent de recherche avec OpenClaw

Introduction

La veille manuelle coûte cher : 2 heures par jour à parcourir des flux RSS, Twitter, arXiv et des pages GitHub pour rester à jour sur un secteur qui évolue chaque semaine. Avec un agent de recherche OpenClaw, ce travail se fait en 5 minutes — pendant que vous dormez. Dans cet article, vous construisez pas à pas un agent qui agrège des sources web, synthétise l'information et génère un rapport quotidien structuré. Vous repartez avec du code prêt à adapter.

Résumé rapide

1. Créer un skill web_search qui interroge Brave Search et des flux RSS cibles.
2. Créer un skill summarize qui condense les résultats avec un LLM.
3. Créer un skill deduplicate pour éliminer les doublons entre sources.
4. Assembler les trois skills dans un agent OpenClaw avec une planification quotidienne.
5. Brancher un skill notify pour envoyer le rapport par Slack ou email.

Explication

Qu'est-ce qu'un agent de recherche IA ?

Un agent de recherche IA est un programme autonome qui exécute un cycle : collecter → filtrer → synthétiser → livrer. Contrairement à un script batch, il s'adapte : si une source est indisponible, il essaie une autre ; si le volume d'information double, il ajuste sa synthèse sans intervention humaine.

Pourquoi OpenClaw est adapté à ce cas d'usage

OpenClaw est conçu autour de la notion de skill — des unités fonctionnelles autonomes que l'agent orchestre. Pour un agent de veille, c'est exactement ce qu'il faut : chaque source, chaque transformation et chaque canal de sortie devient un skill indépendant, testable séparément, remplaçable sans toucher au reste du workflow.

Trois propriétés de la plateforme sont particulièrement utiles ici :

• Retry natif : si Brave Search rate, OpenClaw réessaie avec backoff exponentiel.
• Memory partagée : les résultats d'une session sont accessibles aux skills suivants sans passer par une base de données externe.
• Scheduler intégré : l'agent se déclenche via cron sans infrastructure supplémentaire.

Composants nécessaires

Composant	Rôle
Skill web_search	Interroge Brave Search API et parse les flux RSS
Skill summarize	Appelle un LLM (GPT-4o ou Claude) pour condenser
Skill deduplicate	Compare les URLs et titres pour éliminer les doublons
Skill score_reliability	Attribue un score de fiabilité à chaque source
Skill notify	Envoie le rapport final (Slack, email, Notion)

Pour aller plus loin sur la création de skills, consultez la documentation des skills OpenClaw.

Développement principal

Le besoin métier concret

Imaginez trois profils qui ont tous le même problème :

• L'analyste marché qui suit 12 concurrents et 3 catégories de produits. Elle consacre 90 minutes chaque matin à lire des articles avant de commencer son vrai travail.
• Le rédacteur tech qui doit proposer des sujets d'actualité chaque semaine. Il passe une heure à chercher ce qui a été publié depuis 7 jours sur ses thèmes.
• Le fondateur de startup qui surveille les évolutions réglementaires IA en Europe. Il rate régulièrement des publications importantes parce qu'il n'a pas le temps de surveiller toutes les sources.

Dans les trois cas, la structure du problème est identique : trop de sources, pas assez de temps, beaucoup de signal perdu. Un agent de veille OpenClaw résout exactement ce problème.

Le workflow complet

Sources web ──► web_search ──► deduplicate ──► score_reliability
                                                      │
                                                      ▼
                                               summarize ──► notify

Chaque étape est un skill OpenClaw distinct. Voici le code de chaque composant.

Skill 1 : web_search

from openclaw import skill, Memory

@skill(name="web_search", description="Fetch results from Brave Search and RSS feeds")
def web_search(query: str, rss_urls: list[str], memory: Memory) -> list[dict]:
    results = []

    # Brave Search
    brave_results = brave_api.search(query, count=20)
    for r in brave_results:
        results.append({
            "title": r["title"],
            "url": r["url"],
            "snippet": r["description"],
            "source": "brave",
            "published_at": r.get("age", "unknown"),
        })

    # RSS feeds
    for feed_url in rss_urls:
        feed = feedparser.parse(feed_url)
        for entry in feed.entries[:10]:
            results.append({
                "title": entry.title,
                "url": entry.link,
                "snippet": entry.get("summary", ""),
                "source": feed_url,
                "published_at": entry.get("published", "unknown"),
            })

    memory.set("raw_results", results)
    return results

Skill 2 : deduplicate

from openclaw import skill, Memory
from difflib import SequenceMatcher

@skill(name="deduplicate", description="Remove duplicate results by URL and title similarity")
def deduplicate(results: list[dict], memory: Memory) -> list[dict]:
    seen_urls = set()
    unique = []

    for item in results:
        url = item["url"]
        if url in seen_urls:
            continue

        # Check title similarity against already-kept items
        is_duplicate = False
        for kept in unique:
            ratio = SequenceMatcher(None, item["title"], kept["title"]).ratio()
            if ratio > 0.85:
                is_duplicate = True
                break

        if not is_duplicate:
            unique.append(item)
            seen_urls.add(url)

    memory.set("deduplicated_results", unique)
    return unique

Skill 3 : score_reliability

from openclaw import skill, Memory

TRUSTED_DOMAINS = [
    "arxiv.org", "github.com", "openai.com", "anthropic.com",
    "huggingface.co", "techcrunch.com", "wired.com"
]

@skill(name="score_reliability", description="Assign reliability score to each result")
def score_reliability(results: list[dict], memory: Memory) -> list[dict]:
    scored = []
    for item in results:
        domain = item["url"].split("/")[2].replace("www.", "")
        score = 1.0 if domain in TRUSTED_DOMAINS else 0.5
        scored.append({**item, "reliability_score": score})

    # Sort by score descending, keep top 15
    scored.sort(key=lambda x: x["reliability_score"], reverse=True)
    memory.set("scored_results", scored[:15])
    return scored[:15]

Skill 4 : summarize

from openclaw import skill, Memory
import openai

@skill(name="summarize", description="Synthesize results into a structured daily report")
def summarize(results: list[dict], topic: str, memory: Memory) -> str:
    formatted = "\n".join([
        f"- [{r['title']}]({r['url']}): {r['snippet'][:200]}"
        for r in results
    ])

    prompt = f"""Tu es un analyste expert en {topic}.
Voici les {len(results)} articles les plus pertinents du jour :

{formatted}

Génère un rapport structuré en français :
1. Les 3 informations les plus importantes (1 phrase chacune)
2. Tendances émergentes (2-3 phrases)
3. Actions recommandées pour un praticien

Sois concis, factuel, sans remplissage."""

    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=600,
    )

    report = response.choices[0].message.content
    memory.set("daily_report", report)
    return report

Skill 5 : notify

from openclaw import skill, Memory
import requests

@skill(name="notify", description="Send the daily report to Slack")
def notify(report: str, slack_webhook: str, memory: Memory) -> bool:
    payload = {
        "text": f"*Rapport de veille quotidien*\n\n{report}",
        "mrkdwn": True,
    }
    response = requests.post(slack_webhook, json=payload)
    return response.status_code == 200

Assemblage de l'agent

from openclaw import Agent, Schedule

agent = Agent(
    name="veille_agent",
    skills=[web_search, deduplicate, score_reliability, summarize, notify],
    schedule=Schedule.daily(at="07:00"),
)

agent.run(
    query="LangGraph OR CrewAI OR AutoGen agent framework",
    rss_urls=[
        "https://hnrss.org/frontpage",
        "https://github.com/langchain-ai/langgraph/releases.atom",
    ],
    topic="frameworks d'agents IA",
    slack_webhook="https://hooks.slack.com/services/YOUR/WEBHOOK",
)

Gains mesurables

Métrique	Avant (manuel)	Après (agent)
Temps quotidien	2 heures	5 minutes de lecture du rapport
Sources couvertes	5–8 (fatigue)	20+ en parallèle
Articles manqués	Fréquent	Rare (< 5 %)
Coût LLM	—	~0,04 $ / rapport

Limites à connaître

Hallucinations : le skill summarize peut inventer des détails si les snippets sont trop courts. Toujours inclure l'URL source dans le rapport pour vérification manuelle.

Sources peu fiables : le score_reliability basique ne détecte pas les sources biaisées avec un bon domaine. Affinez la liste TRUSTED_DOMAINS selon votre secteur.

Fréquence : un agent quotidien est suffisant pour la plupart des besoins. Au-delà d'un déclenchement toutes les 2 heures, le coût LLM monte et la valeur marginale diminue.

Pour des stratégies d'automatisation plus avancées, lisez notre guide sur l'automatisation SEO avec des agents.

Exemple concret

Veille sur les frameworks IA — rapport Slack quotidien

Sources : GitHub Releases (LangGraph, CrewAI, AutoGen), Hacker News frontpage, arXiv cs.AI dernières 24h.

Objectif : recevoir chaque matin à 7h un résumé des nouvelles versions, discussions techniques notables et papiers pertinents.

agent = Agent(
    name="ai_frameworks_watcher",
    skills=[web_search, deduplicate, score_reliability, summarize, notify],
    schedule=Schedule.daily(at="07:00"),
)

agent.run(
    query="LangGraph CrewAI AutoGen new release agent framework 2026",
    rss_urls=[
        "https://github.com/langchain-ai/langgraph/releases.atom",
        "https://github.com/microsoft/autogen/releases.atom",
        "https://hnrss.org/frontpage",
        "http://export.arxiv.org/rss/cs.AI",
    ],
    topic="frameworks d'agents IA open source",
    slack_webhook=os.environ["SLACK_WEBHOOK_URL"],
)

Résultat concret : après deux semaines d'utilisation, un rédacteur tech a réduit son temps de recherche de 70 minutes à 8 minutes par jour. Il a également détecté la sortie de LangGraph 0.3 le jour J, ce qu'il avait raté manuellement les trois fois précédentes.

Ce cas d'usage est directement adaptable à d'autres domaines : veille réglementaire, suivi de concurrents, monitoring de réputation de marque.

Bonnes pratiques

Ne pas agréger trop de sources dès le départ. Commencez avec 3 à 5 sources de haute qualité. Ajouter 20 RSS dès le premier jour noie le signal dans le bruit et augmente les coûts LLM sans améliorer la qualité du rapport.

Toujours déduplication avant synthèse. Sans le skill deduplicate, un même article réindexé par plusieurs agrégateurs occupe 30 à 40 % de la fenêtre de contexte envoyée au LLM. Le rapport devient répétitif et la synthèse moins précise.

Attribuer un score de fiabilité à chaque source. Les résultats Brave incluent des sites de faible qualité. Sans filtrage, le LLM résume des articles de faible valeur en premier. Un simple score par domaine connu suffit pour trier les 15 meilleurs résultats.

Inclure les URLs dans le rapport final. Un rapport sans liens force la relecture manuelle. Avec les URLs, la vérification d'une information prend 10 secondes.

Tester chaque skill isolément. OpenClaw permet de déclencher un skill seul. Validez web_search avant de brancher summarize — sinon le débogage est difficile.

Questions fréquentes

OpenClaw est-il gratuit pour un agent de veille quotidien ?

OpenClaw propose un tier gratuit avec un nombre de déclenchements limité par mois. Pour un agent quotidien, le tier gratuit couvre généralement l'usage personnel. Le coût principal est le LLM utilisé dans le skill summarize : comptez 0,03 à 0,08 $ par rapport avec GPT-4o selon la quantité de texte envoyé.

Comment éviter les hallucinations dans le rapport généré ?

Deux mesures suffisent dans la grande majorité des cas : limiter la synthèse aux snippets factuels (évitez les reformulations libres), et inclure systématiquement les URLs sources dans le prompt envoyé au LLM. Ainsi, le modèle ancre sa synthèse sur des extraits réels plutôt que sur ses connaissances internes.

Peut-on remplacer Brave Search par une autre API ?

Oui. Le skill web_search est modulaire. Vous pouvez substituer Brave Search par SerpAPI, Tavily ou une combinaison de flux RSS purs si vous n'avez pas besoin de recherche en temps réel. Tavily est souvent préféré pour les agents IA car son API retourne directement des extraits propres, ce qui réduit le prétraitement.

Quelle fréquence de déclenchement recommandez-vous ?

Une fois par jour (matin) couvre 90 % des besoins de veille. Si vous couvrez un secteur très réactif (cryptomonnaies, actualité politique), deux déclenchements par jour suffisent. Au-delà, le rapport perd en utilité : les changements entre deux déclenchements rapprochés sont trop mineurs pour justifier la lecture.

Articles liés

Pour aller plus loin, consultez la présentation complète des agents OpenClaw qui couvre l'architecture générale et les cas d'usage types, puis le guide des skills OpenClaw pour créer des composants réutilisables au-delà de la veille. Si vous souhaitez appliquer ce type d'automatisation à votre stratégie de contenu, le tutoriel créer un agent SEO montre comment enchaîner recherche, analyse et publication automatisée.

• Agents OpenClaw — architecture et cas d'usage
• Skills OpenClaw — guide complet
• OpenClaw — présentation du framework
• Automatisation SEO avec des agents IA
• Créer un agent SEO pas à pas

---

Vous voulez recevoir les templates OpenClaw prêts à l'emploi (agent de veille, agent SEO, agent de reporting) ? Abonnez-vous à la newsletter agents IA ci-dessous.