🦌 DeerFlow - 2.0

English | 中文 | 日本語 | Français | Русский

Le 28 février 2026, DeerFlow a décroché la 🏆 1re place sur GitHub Trending suite au lancement de la version 2. Un immense merci à notre incroyable communauté — c'est grâce à vous ! 💪🔥

DeerFlow (Deep Exploration and Efficient Research Flow) est un super agent harness open source qui orchestre des sub-agents, de la mémoire et des sandboxes pour accomplir pratiquement n'importe quelle tâche — le tout propulsé par des skills extensibles.

https://github.com/user-attachments/assets/a8bcadc4-e040-4cf2-8fda-dd768b999c18

[!NOTE] DeerFlow 2.0 est une réécriture complète. Il ne partage aucun code avec la v1. Si vous cherchez le framework Deep Research original, il est maintenu sur la branche 1.x — les contributions y sont toujours les bienvenues. Le développement actif a migré vers la 2.0.

Site officiel

Découvrez-en plus et regardez des démos réelles sur notre site officiel.

Coding Plan de ByteDance Volcengine

• Nous recommandons fortement d'utiliser Doubao-Seed-2.0-Code, DeepSeek v3.2 et Kimi 2.5 pour exécuter DeerFlow
• En savoir plus
• Développeurs en Chine continentale, cliquez ici

InfoQuest

DeerFlow intègre désormais le toolkit de recherche et de crawling intelligent développé par BytePlus — InfoQuest (essai gratuit en ligne)

---

Table des matières

• 🦌 DeerFlow - 2.0
• Site officiel
• InfoQuest
• Table des matières
• Installation en une phrase pour un coding agent
• Démarrage rapide
  • Configuration
  • Lancer l'application
  • Option 1 : Docker (recommandé)
  • Option 2 : Développement local
  • Avancé
  • Mode Sandbox
  • Serveur MCP
  • Canaux de messagerie
  • Traçage LangSmith
• Du Deep Research au Super Agent Harness
• Fonctionnalités principales
  • Skills et outils
  • Intégration Claude Code
  • Sub-Agents
  • Sandbox et système de fichiers
  • Context Engineering
  • Mémoire à long terme
• Modèles recommandés
• Client Python intégré
• Documentation
• ⚠️ Avertissement de sécurité
• Contribuer
• Licence
• Remerciements
  • Contributeurs principaux
• Star History

Installation en une phrase pour un coding agent

Si vous utilisez Claude Code, Codex, Cursor, Windsurf ou un autre coding agent, vous pouvez simplement lui envoyer cette phrase :

Aide-moi à cloner DeerFlow si nécessaire, puis à initialiser son environnement de développement local en suivant https://raw.githubusercontent.com/bytedance/deer-flow/main/Install.md

Ce prompt est destiné aux coding agents. Il leur demande de cloner le dépôt si nécessaire, de privilégier Docker quand il est disponible, puis de s'arrêter avec la commande exacte pour lancer DeerFlow et la liste des configurations encore manquantes.

Démarrage rapide

Configuration

1. Cloner le dépôt DeerFlow

bash git clone https://github.com/bytedance/deer-flow.git cd deer-flow

1. Générer les fichiers de configuration locaux

Depuis le répertoire racine du projet (deer-flow/), exécutez :

bash make config

Cette commande crée les fichiers de configuration locaux à partir des templates fournis.

1. Configurer le(s) modèle(s) de votre choix

Éditez config.yaml et définissez au moins un modèle :

```yaml models: - name: gpt-4 # Internal identifier display_name: GPT-4 # Human-readable name use: langchain_openai:ChatOpenAI # LangChain class path model: gpt-4 # Model identifier for API api_key: $OPENAI_API_KEY # API key (recommended: use env var) max_tokens: 4096 # Maximum tokens per request temperature: 0.7 # Sampling temperature

 - name: openrouter-gemini-2.5-flash
   display_name: Gemini 2.5 Flash (OpenRouter)
   use: langchain_openai:ChatOpenAI
   model: google/gemini-2.5-flash-preview
   api_key: $OPENAI_API_KEY          # OpenRouter still uses the OpenAI-compatible field name here
   base_url: https://openrouter.ai/api/v1

 - name: gpt-5-responses
   display_name: GPT-5 (Responses API)
   use: langchain_openai:ChatOpenAI
   model: gpt-5
   api_key: $OPENAI_API_KEY
   use_responses_api: true
   output_version: responses/v1

```

OpenRouter et les passerelles compatibles OpenAI similaires doivent être configurés avec langchain_openai:ChatOpenAI et base_url. Si vous préférez utiliser un nom de variable d'environnement propre au fournisseur, pointez api_key vers cette variable explicitement (par exemple api_key: $OPENROUTER_API_KEY).

Pour router les modèles OpenAI via /v1/responses, continuez d'utiliser langchain_openai:ChatOpenAI et définissez use_responses_api: true avec output_version: responses/v1.

Exemples de providers basés sur un CLI :

```yaml models: - name: gpt-5.4 display_name: GPT-5.4 (Codex CLI) use: deerflow.models.openai_codex_provider:CodexChatModel model: gpt-5.4 supports_thinking: true supports_reasoning_effort: true

 - name: claude-sonnet-4.6
   display_name: Claude Sonnet 4.6 (Claude Code OAuth)
   use: deerflow.models.claude_provider:ClaudeChatModel
   model: claude-sonnet-4-6
   max_tokens: 4096
   supports_thinking: true

```

• Codex CLI lit ~/.codex/auth.json
• L'endpoint Responses de Codex rejette actuellement max_tokens et max_output_tokens, donc CodexChatModel n'expose pas de limite de tokens par requête
• Claude Code accepte CLAUDE_CODE_OAUTH_TOKEN, ANTHROPIC_AUTH_TOKEN, CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR, CLAUDE_CODE_CREDENTIALS_PATH, ou en clair ~/.claude/.credentials.json
• Sur macOS, DeerFlow ne sonde pas le Keychain automatiquement. Exportez l'auth Claude Code explicitement si nécessaire :

bash eval "$(python3 scripts/export_claude_code_oauth.py --print-export)"

1. Définir les clés API pour le(s) modèle(s) configuré(s)

Choisissez l'une des méthodes suivantes :

• Option A : Éditer le fichier .env à la racine du projet (recommandé)

bash TAVILY_API_KEY=your-tavily-api-key OPENAI_API_KEY=your-openai-api-key # OpenRouter also uses OPENAI_API_KEY when your config uses langchain_openai:ChatOpenAI + base_url. # Add other provider keys as needed INFOQUEST_API_KEY=your-infoquest-api-key

• Option B : Exporter les variables d'environnement dans votre shell

bash export OPENAI_API_KEY=your-openai-api-key

Pour les providers basés sur un CLI : - Codex CLI : ~/.codex/auth.json - Claude Code OAuth : handoff explicite via env/fichier ou ~/.claude/.credentials.json

• Option C : Éditer config.yaml directement (non recommandé en production)

yaml models: - name: gpt-4 api_key: your-actual-api-key-here # Replace placeholder

Lancer l'application

Option 1 : Docker (recommandé)

Développement (hot-reload, montage des sources) :

make docker-init    # Pull sandbox image (only once or when image updates)
make docker-start   # Start services (auto-detects sandbox mode from config.yaml)

make docker-start ne lance provisioner que si config.yaml utilise le mode provisioner (sandbox.use: deerflow.community.aio_sandbox:AioSandboxProvider avec provisioner_url). Les processus backend récupèrent automatiquement les changements dans config.yaml au prochain accès à la configuration, donc les mises à jour de métadonnées des modèles ne nécessitent pas de redémarrage manuel en développement.

[!TIP] Sous Linux, si les commandes Docker échouent avec permission denied while trying to connect to the Docker daemon socket at unix:///var/run/docker.sock, ajoutez votre utilisateur au groupe docker et reconnectez-vous avant de réessayer. Voir CONTRIBUTING.md pour la solution complète.

Production (build des images en local, montage de la config et des données) :

make up     # Build images and start all production services
make down   # Stop and remove containers

[!NOTE] Le serveur d'agents LangGraph fonctionne actuellement via langgraph dev (le serveur CLI open source).

Accès : http://localhost:2026

Voir CONTRIBUTING.md pour le guide complet de développement avec Docker.

Option 2 : Développement local

Si vous préférez lancer les services en local :

Prérequis : complétez d'abord les étapes de « Configuration » ci-dessus (make config et clés API des modèles). make dev nécessite un fichier de configuration valide (par défaut config.yaml à la racine du projet ; modifiable via DEER_FLOW_CONFIG_PATH).

1. Vérifier les prérequis : bash make check # Verifies Node.js 22+, pnpm, uv, nginx

2. Installer les dépendances : bash make install # Install backend + frontend dependencies

3. (Optionnel) Pré-télécharger l'image sandbox : bash # Recommended if using Docker/Container-based sandbox make setup-sandbox

4. Démarrer les services : bash make dev

5. Accès : http://localhost:2026

Avancé

Mode Sandbox

DeerFlow supporte plusieurs modes d'exécution sandbox : - Exécution locale (exécute le code sandbox directement sur la machine hôte) - Exécution Docker (exécute le code sandbox dans des conteneurs Docker isolés) - Exécution Docker avec Kubernetes (exécute le code sandbox dans des pods Kubernetes via le service provisioner)

En développement Docker, le démarrage des services suit le mode sandbox défini dans config.yaml. En mode Local/Docker, provisioner n'est pas démarré.

Voir le Guide de configuration Sandbox pour configurer le mode de votre choix.

Serveur MCP

DeerFlow supporte des serveurs MCP et des skills configurables pour étendre ses capacités. Pour les serveurs MCP HTTP/SSE, les flux de tokens OAuth sont supportés (client_credentials, refresh_token). Voir le Guide MCP Server pour les instructions détaillées.

Canaux de messagerie

DeerFlow peut recevoir des tâches depuis des applications de messagerie. Les canaux démarrent automatiquement une fois configurés — aucune IP publique n'est requise.

Canal	Transport	Difficulté
Telegram	Bot API (long-polling)	Facile
Slack	Socket Mode	Modérée
Feishu / Lark	WebSocket	Modérée

Configuration dans config.yaml :

```yaml channels: # LangGraph Server URL (default: http://localhost:2024) langgraph_url: http://localhost:2024 # Gateway API URL (default: http://localhost:8001) gateway_url: http://localhost:8001

# Optional: global session defaults for all mobile channels session: assistant_id: lead_agent config: recursion_limit: 100 context: thinking_enabled: true is_plan_mode: false subagent_enabled: false

feishu: enabled: true app_id: $FEISHU_APP_ID app_secret: $FEISHU_APP_SECRET # domain: https://open.feishu.cn # China (default) # domain: https://open.larksuite.com # International

slack: enabled: true bot_token: $SLACK_BOT_TOKEN # xoxb-... app_token: $SLACK_APP_TOKEN # xapp-... (Socket Mode) allowed_users: [] # empty = allow all

telegram: enabled: true bot_token: $TELEGRAM_BOT_TOKEN allowed_users: [