Guide de déploiement d’Agent Reach : faire comprendre à Claude Code / OpenClaw X (Twitter) / Xiaohongshu / Bilibili

Une phrase de présentation : ton agent IA sait coder comme un pro, mais dès qu’il faut lui dire « va chercher des infos sur Internet », il est complètement à la rue ? Agent Reach est la solution en une ligne — il installe d’un coup 14+ plateformes (Twitter/X, Reddit, YouTube, Bilibili, Xiaohongshu, Douyin, comptes WeChat…), et l’agent sait lui-même quel outil appeler.

Présentation du projet

Agent Reach est un « installateur d’aptitudes Internet » pour les agents IA. GitHub : Panniantong/Agent-Reach, licence MIT, package Python.

Son positionnement central est très particulier : ce n’est pas un framework, c’est un échafaudage (scaffolding).

Concrètement ? Une fois qu’un agent IA (Claude Code / OpenClaw / Cursor / Windsurf...) a installé Agent Reach, il ne passe pas par une couche d’emballage d’Agent Reach : il appelle directement les outils en amont — twitter-cli / rdt-cli / yt-dlp / xhs-cli / douyin-mcp-server / Jina Reader / gh CLI — sélectionnés, testés contre les pièges par les auteurs du projet, et livrés avec des paramètres par défaut.

Agent Reach ne fait que :

1. Installeur — une seule commande pip install agent-reach + agent-reach install pour tout installer d’un coup
2. Diagnostiqueur — agent-reach doctor : une commande qui te dit quelles plateformes fonctionnent, lesquelles ne fonctionnent pas, et comment corriger
3. Configureur — gestion centralisée et unique des authentifications (cookies), clés API, services MCP, etc.
4. Injection de SKILL — enregistre SKILL.md pour l’agent afin que, lorsqu’il rencontre des besoins du type « rechercher sur X/Twitter » ou « regarder une vidéo », il appelle automatiquement l’outil correspondant

Canaux pris en charge (14+ plateformes) :

Une phrase : pas besoin de mémoriser des commandes, pas besoin de bricoler des scrapeurs : tu parles à l’agent et il va sur Internet.

Difficulté / durée / bénéfices

• Difficulté : ⭐ (débutant, vraiment une commande)
• Durée : 5–15 minutes (sur un ordinateur local) ; 30 minutes (serveur, incluant la configuration des cookies)
• Bénéfices :
  • faire lire directement à Claude Code / OpenClaw Twitter, consulter Xiaohongshu et lire les sous-titres YouTube
  • comprendre la différence de conception entre « scaffolding » et « framework » dans l’écosystème des outils d’agents IA
  • maîtriser l’usage de Cookie-Editor pour gérer un grand nombre de cookies sur plusieurs plateformes, afin d’éviter les pièges du login par QR
  • savoir que agent-reach doctor est une bonne pratique pour la chaîne d’outils de l’agent

Public cible (profils)

• Développeurs qui travaillent avec Claude Code / OpenClaw / Cursor
• Ceux qui veulent que l’agent IA puisse vraiment naviguer et vérifier des infos, pas rester bouche bée
• Ceux qui ne veulent pas faire du bricolage spécifique (scrapeur) ou payer des API dédiées pour X/Twitter, Reddit ou Xiaohongshu
• Ceux qui ont déjà une chaîne d’outils d’agents IA et veulent ajouter une couche « capacité Internet »
• Ceux qui lancent de longues tâches avec l’agent et cherchent une façon de réduire les coûts de calcul (on y reviendra plus tard)

Dépendances et environnement essentiels

Configuration minimale :

Recommandé / optionnel :

Arbre complet de la structure du projet

Agent-Reach/
├── pyproject.toml                # définition du package Python
├── agent_reach/
│   ├── __init__.py               # numéro de version
│   ├── cli.py                    # point d’entrée CLI (argparse)
│   ├── core.py                   # routes read/search (cœur)
│   ├── config.py                 # gestion de configuration YAML
│   ├── doctor.py                 # moteur de diagnostic
│   ├── cookie_extract.py         # outil d’extraction de cookies
│   ├── channels/                 # un fichier par plateforme
│   │   ├── base.py               # classe abstraite BaseChannel
│   │   ├── web.py                # Jina Reader
│   │   ├── twitter.py            # twitter-cli
│   │   ├── youtube.py            # yt-dlp
│   │   ├── github.py             # gh CLI
│   │   ├── bilibili.py           # yt-dlp + bili-cli
│   │   ├── reddit.py             # rdt-cli
│   │   ├── xiaohongshu.py        # xhs-cli
│   │   ├── douyin.py             # douyin-mcp-server
│   │   ├── linkedin.py           # linkedin-mcp
│   │   ├── wechat.py             # Exa + Camoufox
│   │   ├── rss.py                # feedparser
│   │   ├── exa_search.py         # Exa via mcporter
│   │   ├── weibo.py
│   │   ├── v2ex.py
│   │   ├── xueqiu.py
│   │   └── xiaoyuzhou.py
│   ├── integrations/
│   │   └── mcp_server.py         # intégration via MCP server
│   ├── skill/                    # SKILL.md pour l’agent
│   ├── guides/                   # documentation (CH/EN/JA/KR)
│   ├── scripts/                  # scripts d’installation
│   └── utils/
├── config/
│   └── mcporter.json             # configuration des outils MCP
├── tests/                        # tests pytest
└── docs/                         # versions multilingues du README

En tant qu’utilisateur, tu n’as besoin de toucher qu’à trois commandes : pip install / agent-reach install / agent-reach doctor. channels/ est pour l’extension par les développeurs.

Étapes pas à pas

Étape 1 : installation de base (chemin principal)

# Recommandé : installer via pipx isolé
pipx install agent-reach

# Ou via pip (attention : ne pas l’installer dans le Python système)
python3 -m venv ~/.agent-reach-venv
source ~/.agent-reach-venv/bin/activate
pip install agent-reach

Après l’installation, tu devrais avoir cette commande :

agent-reach --version
# agent-reach 1.4.0

Étape 2 : installer d’un coup tous les outils en amont

# Mode par défaut : détection automatique de l’environnement, installation de toutes les dépendances
agent-reach install --env=auto

Elle procède successivement à :

1. Installer les dépendances système (Node.js / gh CLI / mcporter / twitter-cli / rdt-cli, etc.)
2. Configurer le moteur de recherche (intégration MCP vers Exa, sans clé)
3. Déterminer si c’est sur un ordinateur local ou un serveur, et donner des recommandations différentes
4. Enregistrer SKILL.md dans le répertoire skills/ de l’agent

openclaw config set tools.profile "coding"
openclaw gateway restart

Étape 3 : état des canaux (diagnostic)

agent-reach doctor

Tu devrais voir un résultat du type :

✅ web              Jina Reader OK
✅ youtube          yt-dlp 2025.10.x installé
✅ rss              feedparser 6.0.x
✅ exa_search       Exa MCP connecté
✅ github           gh CLI 2.x authentifié
⚠️  twitter         twitter-cli pas connecté  → run : twitter login
⚠️  reddit          rdt-cli pas connecté       → run : rdt login
✅ bilibili         yt-dlp OK
⚠️  xiaohongshu     xhs-cli pas connecté      → voir étape 4
✅ douyin           douyin-mcp-server OK
✅ wechat           recherche Exa OK
✅ v2ex             API OK

✅ signifie prêt à l’emploi ; ⚠️ signifie qu’il faut une configuration supplémentaire (généralement une authentification par cookies).

Étape 4 : configurer l’auth pour les plateformes qui nécessitent des cookies (point clé)

X/Twitter / Xiaohongshu / Reddit font partie des cas qui nécessitent un état de connexion : on utilise une authentification par cookies plutôt que le scan QR.

Installe d’abord Cookie-Editor : dans la boutique d’applications de Chrome / Edge, cherche « Cookie-Editor » et installe-le.

Processus unifié :

1. Connecte-toi manuellement à x.com / xiaohongshu.com / reddit.com dans le navigateur
2. Clique sur l’icône du plugin Cookie-Editor → « Export » → choisis le format « Netscape »
3. Envoie la chaîne de cookies exportée à l’agent, puis dis : « Aide-moi à configurer Twitter »
4. L’agent appelle cookie_extract.py pour l’enregistrer dans ~/.agent-reach/config.yaml
5. Permissions du fichier à 600, seul ton compte peut le lire

# Tu peux aussi configurer directement en ligne de commande, sans passer par l’agent
agent-reach config set twitter.cookie "$(pbpaste)"  # macOS
agent-reach config set xhs.cookie "$(xclip -o)"     # Linux

Étape 5 : valider les plateformes avec cookies

agent-reach doctor

Relance le diagnostic : les plateformes marquées auparavant en ⚠️ devraient passer en ✅.

Étape 6 : faire un premier essai à l’agent

Dis à ton agent (Claude Code / OpenClaw / Cursor) :

Dis-moi ce qu’il y a dans ce tweet : https://x.com/vercel/status/1234567890

Après avoir lu SKILL.md, l’agent appellera automatiquement la commande « twitter tweet URL », et renverra le contenu du tweet en quelques secondes.

Essaie plusieurs combinaisons :

Cherche sur Reddit ce dont on parle récemment sur r/LocalLLaMA
Lis ce tutoriel YouTube : https://youtube.com/watch?v=xxx
Regarde sur Xiaohongshu ce que contiennent les posts populaires sur « camping gear »
À quoi sert ce dépôt GitHub : https://github.com/xxx/yyy

Tu verras un détail : tu n’as pas besoin de dire à l’agent quelle commande exécuter. SKILL.md a déjà écrit les correspondances : « lire X/Twitter = twitter CLI », « regarder une vidéo = yt-dlp », etc. C’est la plus grande différence entre Agent Reach et un simple ensemble d’outils : une fois installé, l’agent est conscient et choisit l’outil, au lieu de tout tester au hasard.

Étape 7 (optionnel) : recherche sémantique sur tout le web

Par défaut, Exa est déjà connecté, aucune clé API n’est nécessaire. Demande directement à l’agent :

Cherche les cadres d’agents LLM les plus récents en 2026 et donne-moi 5 articles les plus pertinents

Il appellera l’outil Exa via MCP, récupérera les résultats, puis appellera Jina Reader pour extraire le texte intégral et tout organiser en rapport.

Étape 8 (optionnel) : accès aux dépôts GitHub privés

# Connexion unique
gh auth login

Après l’OAuth, l’agent pourra lire tes dépôts privés, créer des issues, des PR et faire des reviews.

Étape 9 (optionnel) : renforcement pour Bilibili / Douyin

Bilibili en local : plug-and-play. Sur un serveur à l’étranger, il faut un proxy (~$1/mois, recommandé : des proxies résidentiels type FluxNode) :

# On suppose que ton proxy est http://127.0.0.1:7890
agent-reach config set bilibili.proxy "http://127.0.0.1:7890"
agent-reach doctor  # relance le diagnostic

Douyin : pas besoin de se connecter du tout. Envoie simplement à l’agent le lien de partage :

Analyse cette vidéo Douyin : https://v.douyin.com/xxxxx

L’agent appelle mcporter call 'douyin.parse_douyin_video_info(...)' et te renvoie les informations de la vidéo + un lien de téléchargement sans filigrane.

Étape 10 (optionnel) : mode sécurité / désinstallation

Mode sécurité (utile sur serveurs de production ou machines multi-utilisateurs) :

# N’installe pas automatiquement les paquets système ; juste liste ce qui sera fait
agent-reach install --env=auto --safe

# Ou prévisualiser ce qui sera fait, sans exécuter réellement
agent-reach install --env=auto --dry-run

Désinstallation complète :

agent-reach uninstall             # supprime configuration + fichiers de skill
agent-reach uninstall --keep-config  # conserve les tokens, utile pour réinstaller
pip uninstall agent-reach         # désinstalle le package Python

Dépannage des problèmes fréquents

Q1 : OpenClaw lors de l’installation affiche « permission denied » / l’agent ne bouge pas

Cause : par défaut, OpenClaw met tools.profile = messaging, ce qui n’autorise pas l’agent à exécuter des commandes shell. Correction :

openclaw config set tools.profile "coding"
openclaw gateway restart
# Ouvre une nouvelle session, puis renvoie « aide-moi à installer Agent Reach »

Ou modifie ~/.openclaw/openclaw.json :

{
  "tools": { "profile": "coding" }
}

Q2 : Xiaohongshu, la connexion QR tourne en boucle

N’utilise pas le QR. Directement :

1. Installe Cookie-Editor depuis la boutique d’applications Chrome
2. Connecte-toi à Xiaohongshu via la version web du navigateur
3. Cookie-Editor → Export → Netscape
4. Envoie la chaîne à l’agent, puis dis « aide-moi à configurer Xiaohongshu »
5. C’est réglé en 30 secondes

Q3 : Reddit renvoie 403 dès qu’on le sollicite

Depuis 2024, Reddit impose une authentification. Correction :

# Installe rdt-cli (normalement déjà installé pendant l’étape Agent Reach install)
pipx install rdt-cli

# Connexion unique (il récupère automatiquement les cookies depuis ton Chrome)
rdt login

# Vérifier
rdt search "LocalLLaMA" --limit 5

Comme pour Twitter / Xiaohongshu, rdt login utilise l’extraction automatique des cookies du navigateur, pas le QR.

Q4 : Serveur à l’étranger : impossible de se connecter à Bilibili

Les IP à l’étranger sont bloquées par Bilibili : il faut un proxy résidentiel. Deux options :

# Option 1 : config en ligne de commande (recommandé : proxies peu chers type FluxNode)
agent-reach config set bilibili.proxy "http://user:pass@proxy:port"

# Option 2 : variables d’environnement
export HTTP_PROXY="http://user:pass@proxy:port"
export HTTPS_PROXY="http://user:pass@proxy:port"

Un proxy résidentiel bon marché (~$1/mois) suffit : pas besoin de le monter soi-même.

Q5 : agent-reach doctor indique « channel not found » / conflit de fichiers de canaux

En général, cela vient d’une installation incomplète d’une partie des outils en amont, ou du fait qu’ils ont été installés dans le Python système au lieu de pipx. La réparation la plus propre : tout recommencer à zéro :

agent-reach uninstall
pipx uninstall agent-reach
# Nettoyer d’éventuels restes de ~/.agent-reach/
rm -rf ~/.agent-reach/

pipx install agent-reach
agent-reach install --env=auto
agent-reach doctor

Q6 : changement de navigateur / cookies expirés

Les cookies expirent au bout de quelques mois. Refaire simplement le flux « connexion navigateur → Cookie-Editor export → envoyer à l’agent ». L’agent écrasera automatiquement les anciens cookies dans ~/.agent-reach/config.yaml.

Q7 (Bonus) : quand l’agent lance une longue tâche et que la facture explose, comment faire les comptes ?

Je te raconte un piège dans lequel je me suis moi-même fait prendre.

Agent Reach résout le problème de « comment l’agent se connecte à Internet », mais au fond, quand l’agent appelle des outils, il consomme toujours des tokens du LLM. Une tâche typique « recherche de concurrents + synthèse » implique 5 à 10 tours d’appels d’outils (recherche, récupération de pages, lecture de tweets, puis re-recherche, puis re-lecture) : en une exécution, on peut vite atteindre des dizaines de milliers de tokens. Et si tu exécutes 20 tâches par jour, la facture explose rapidement.

Tests de trois manières (mon expérience de déploiement perso) :

1. Brancher l’API officielle d’Anthropic — l’expérience la plus complète, mais quand Claude Opus exécute des tâches d’agent, une journée de travail avec facture à quatre chiffres en RMB est tout à fait normale
2. Brancher des agrégateurs comme OpenRouter — légèrement moins cher que l’officiel, mais ça reste cher
3. Brancher Defapi — ma solution actuelle. La moitié du prix officiel, et au niveau du protocole c’est totalement compatible : côté Agent Reach, la configuration reste identique, pas besoin de modifier le moindre code de SKILL / prompt / appels d’outils

Configuration concrète (en supposant que ton agent utilise le protocole Claude / Anthropic) :

# ~/.openclaw/openclaw.json ou env pour Claude Code
ANTHROPIC_BASE_URL=https://api.defapi.org
ANTHROPIC_API_KEY=sk-xxxxxx    # récupère la clé depuis le dashboard de defapi.org

Chez Defapi, la plupart des modèles sont compatibles avec ces trois protocoles majeurs — v1/chat/completions (OpenAI) / v1/messages (Anthropic) / v1beta/models (Gemini). Changer de modèle revient simplement à changer de nom. Pour des tâches « denses en appels d’outils » comme : récupération de tweets, analyse Xiaohongshu, synthèse de sous-titres vidéo… passer mensuellement d’une facture à quatre chiffres à une facture à trois chiffres est clairement réalisable.

Lectures complémentaires / pistes avancées

• Canal personnalisé : ajoute un fichier dans agent_reach/channels/, hérite de BaseChannel, implémente can_handle(url) / read(url) / search(query) / check() ; puis refais pip install -e .. Le seuil est très bas : un fichier par plateforme
• Remplacer les outils en amont : channels/web.py utilise Jina Reader par défaut. Tu le trouves insuffisant ? Remplace par Firecrawl / Crawl4AI / un scraper maison : il suffit de changer l’import
• Mécanisme SKILL.md : après installation d’Agent Reach, SKILL.md s’enregistre automatiquement dans ~/.claude/skills/ / ~/.openclaw/skills/. Tu peux écrire ton propre SKILL.md pour apprendre à l’agent quel channel privilégier dans un scénario donné
• n’importe quel MCP via mcporter : ce n’est pas seulement Exa. N’importe quel serveur compatible MCP peut être raccordé via config/mcporter.json. Il suffit de modifier l’alias vers la commande de lancement
• Partage entre plusieurs agents : la configuration d’Agent Reach ~/.agent-reach/config.yaml est au niveau fichier. Si tu as plusieurs agents (Claude Code + OpenClaw + Cursor) sur une même machine, tu peux partager la même configuration
• Raccordement avec Defapi : Agent Reach récupère les données, Defapi effectue la réflexion ; une « couche d’obtention d’informations », une « couche de coût de calcul ». Les deux sont pilotés par protocole. Ensemble, ça donne un « workflow d’agent longue durée à faible coût »

Dépôt GitHub : Panniantong/Agent-Reach. La documentation multilingue se trouve dans docs/README_en.md / docs/README_ja.md / docs/README_ko.md. L’idée de conception est dans la section « conception » à la fin du README. Pour contribuer à un channel, fais juste une PR : l’auteur Neo Reid est très actif.