# đŠ DeerFlow - 2.0
[English](./README.md) | [äžæ](./README_zh.md) | [æ„æŹèȘ](./README_ja.md) | Français
[](./backend/pyproject.toml)
[](./Makefile)
[](./LICENSE)
> 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 (**D**eep **E**xploration and **E**fficient **R**esearch **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`](https://github.com/bytedance/deer-flow/tree/main-1.x) â les contributions y sont toujours les bienvenues. Le dĂ©veloppement actif a migrĂ© vers la 2.0.
## Site officiel
[
](https://deerflow.tech)
Découvrez-en plus et regardez des **démos réelles** sur notre [**site officiel**](https://deerflow.tech).
## 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](https://www.byteplus.com/en/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
- [DĂ©veloppeurs en Chine continentale, cliquez ici](https://www.volcengine.com/activity/codingplan?utm_campaign=deer_flow&utm_content=deer_flow&utm_medium=devrel&utm_source=OWO&utm_term=deer_flow)
## InfoQuest
DeerFlow intĂšgre dĂ©sormais le toolkit de recherche et de crawling intelligent dĂ©veloppĂ© par BytePlus â [InfoQuest (essai gratuit en ligne)](https://docs.byteplus.com/en/docs/InfoQuest/What_is_Info_Quest)
---
## Table des matiĂšres
- [đŠ DeerFlow - 2.0](#-deerflow---20)
- [Site officiel](#site-officiel)
- [InfoQuest](#infoquest)
- [Table des matiĂšres](#table-des-matiĂšres)
- [Démarrage rapide](#démarrage-rapide)
- [Configuration](#configuration)
- [Lancer l'application](#lancer-lapplication)
- [Option 1 : Docker (recommandé)](#option-1--docker-recommandé)
- [Option 2 : Développement local](#option-2--développement-local)
- [Avancé](#avancé)
- [Mode Sandbox](#mode-sandbox)
- [Serveur MCP](#serveur-mcp)
- [Canaux de messagerie](#canaux-de-messagerie)
- [Du Deep Research au Super Agent Harness](#du-deep-research-au-super-agent-harness)
- [Fonctionnalités principales](#fonctionnalités-principales)
- [Skills et outils](#skills-et-outils)
- [Intégration Claude Code](#intégration-claude-code)
- [Sub-Agents](#sub-agents)
- [Sandbox et systĂšme de fichiers](#sandbox-et-systĂšme-de-fichiers)
- [Context Engineering](#context-engineering)
- [Mémoire à long terme](#mémoire-à -long-terme)
- [ModÚles recommandés](#modÚles-recommandés)
- [Client Python intégré](#client-python-intégré)
- [Documentation](#documentation)
- [Contribuer](#contribuer)
- [Licence](#licence)
- [Remerciements](#remerciements)
- [Contributeurs principaux](#contributeurs-principaux)
- [Star History](#star-history)
## DĂ©marrage rapide
### Configuration
1. **Cloner le dépÎt DeerFlow**
```bash
git clone https://github.com/bytedance/deer-flow.git
cd deer-flow
```
2. **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.
3. **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)"
```
4. **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) :
```bash
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](CONTRIBUTING.md#linux-docker-daemon-permission-denied) pour la solution complÚte.
**Production** (build des images en local, montage de la config et des données) :
```bash
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](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](backend/docs/CONFIGURATION.md#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](backend/docs/MCP_SERVER.md) 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
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: [] # empty = allow all
# Optional: per-channel / per-user session settings
session:
assistant_id: mobile_agent
context:
thinking_enabled: false
users:
"123456789":
assistant_id: vip_agent
config:
recursion_limit: 150
context:
thinking_enabled: true
subagent_enabled: true
```
Définissez les clés API correspondantes dans votre fichier `.env` :
```bash
# Telegram
TELEGRAM_BOT_TOKEN=123456789:ABCdefGHIjklMNOpqrSTUvwxYZ
# Slack
SLACK_BOT_TOKEN=xoxb-...
SLACK_APP_TOKEN=xapp-...
# Feishu / Lark
FEISHU_APP_ID=cli_xxxx
FEISHU_APP_SECRET=your_app_secret
```
**Configuration Telegram**
1. Ouvrez une conversation avec [@BotFather](https://t.me/BotFather), envoyez `/newbot`, et copiez le token HTTP API.
2. DĂ©finissez `TELEGRAM_BOT_TOKEN` dans `.env` et activez le canal dans `config.yaml`.
**Configuration Slack**
1. CrĂ©ez une Slack App sur [api.slack.com/apps](https://api.slack.com/apps) â Create New App â From scratch.
2. Dans **OAuth & Permissions**, ajoutez les Bot Token Scopes : `app_mentions:read`, `chat:write`, `im:history`, `im:read`, `im:write`, `files:write`.
3. Activez le **Socket Mode** â gĂ©nĂ©rez un App-Level Token (`xapp-âŠ`) avec le scope `connections:write`.
4. Dans **Event Subscriptions**, abonnez-vous aux bot events : `app_mention`, `message.im`.
5. DĂ©finissez `SLACK_BOT_TOKEN` et `SLACK_APP_TOKEN` dans `.env` et activez le canal dans `config.yaml`.
**Configuration Feishu / Lark**
1. CrĂ©ez une application sur [Feishu Open Platform](https://open.feishu.cn/) â activez la capacitĂ© **Bot**.
2. Ajoutez les permissions : `im:message`, `im:message.p2p_msg:readonly`, `im:resource`.
3. Dans **Events**, abonnez-vous à `im.message.receive_v1` et sélectionnez le mode **Long Connection**.
4. Copiez l'App ID et l'App Secret. DĂ©finissez `FEISHU_APP_ID` et `FEISHU_APP_SECRET` dans `.env` et activez le canal dans `config.yaml`.
**Commandes**
Une fois un canal connecté, vous pouvez interagir avec DeerFlow directement depuis le chat :
| Commande | Description |
|---------|-------------|
| `/new` | DĂ©marrer une nouvelle conversation |
| `/status` | Afficher les infos du thread en cours |
| `/models` | Lister les modĂšles disponibles |
| `/memory` | Consulter la mémoire |
| `/help` | Afficher l'aide |
> Les messages sans prĂ©fixe de commande sont traitĂ©s comme du chat classique â DeerFlow crĂ©e un thread et rĂ©pond de maniĂšre conversationnelle.
## Du Deep Research au Super Agent Harness
DeerFlow a dĂ©marrĂ© comme un framework de Deep Research â et la communautĂ© s'en est emparĂ©e. Depuis le lancement, les dĂ©veloppeurs l'ont poussĂ© bien au-delĂ de la recherche : construction de pipelines de donnĂ©es, gĂ©nĂ©ration de prĂ©sentations, mise en place de dashboards, automatisation de workflows de contenu. Des usages qu'on n'avait jamais anticipĂ©s.
Ăa nous a rĂ©vĂ©lĂ© quelque chose d'important : DeerFlow n'Ă©tait pas qu'un simple outil de recherche. C'Ă©tait un **harness** â un runtime qui donne aux agents l'infrastructure nĂ©cessaire pour vraiment accomplir du travail.
On l'a donc reconstruit de zéro.
DeerFlow 2.0 n'est plus un framework Ă assembler soi-mĂȘme. C'est un super agent harness â clĂ© en main et entiĂšrement extensible. Construit sur LangGraph et LangChain, il embarque tout ce dont un agent a besoin out of the box : un systĂšme de fichiers, de la mĂ©moire, des skills, une exĂ©cution sandboxĂ©e, et la capacitĂ© de planifier et de lancer des sub-agents pour les tĂąches complexes et multi-Ă©tapes.
Utilisez-le tel quel. Ou démontez-le et faites-en le vÎtre.
## Fonctionnalités principales
### Skills et outils
Les skills sont ce qui permet Ă DeerFlow de faire *pratiquement n'importe quoi*.
Un Agent Skill standard est un module de capacitĂ© structurĂ© â un fichier Markdown qui dĂ©finit un workflow, des bonnes pratiques et des rĂ©fĂ©rences vers des ressources associĂ©es. DeerFlow est livrĂ© avec des skills intĂ©grĂ©s pour la recherche, la gĂ©nĂ©ration de rapports, la crĂ©ation de prĂ©sentations, les pages web, la gĂ©nĂ©ration d'images et de vidĂ©os, et bien plus. Mais la vraie force rĂ©side dans l'extensibilitĂ© : ajoutez vos propres skills, remplacez ceux fournis, ou combinez-les en workflows composites.
Les skills sont chargĂ©s progressivement â uniquement quand la tĂąche le nĂ©cessite, pas tous en mĂȘme temps. Ăa permet de garder la fenĂȘtre de contexte lĂ©gĂšre et de bien fonctionner mĂȘme avec des modĂšles sensibles au nombre de tokens.
Quand vous installez des archives `.skill` via le Gateway, DeerFlow accepte les métadonnées frontmatter optionnelles standard comme `version`, `author` et `compatibility`, plutÎt que de rejeter des skills externes par ailleurs valides.
Les outils suivent la mĂȘme philosophie. DeerFlow est livrĂ© avec un ensemble d'outils de base â recherche web, fetch de pages web, opĂ©rations sur les fichiers, exĂ©cution bash â et supporte les outils custom via des serveurs MCP et des fonctions Python. Remplacez n'importe quoi. Ajoutez n'importe quoi.
Les suggestions de suivi générées par le Gateway normalisent désormais aussi bien la sortie texte brut du modÚle que le contenu riche au format bloc/liste avant de parser la réponse en tableau JSON, de sorte que les wrappers de contenu propres à chaque provider ne suppriment plus silencieusement les suggestions.
```
# Paths inside the sandbox container
/mnt/skills/public
âââ research/SKILL.md
âââ report-generation/SKILL.md
âââ slide-creation/SKILL.md
âââ web-page/SKILL.md
âââ image-generation/SKILL.md
/mnt/skills/custom
âââ your-custom-skill/SKILL.md â yours
```
#### Intégration Claude Code
Le skill `claude-to-deerflow` vous permet d'interagir avec une instance DeerFlow en cours d'exĂ©cution directement depuis [Claude Code](https://docs.anthropic.com/en/docs/claude-code). Envoyez des tĂąches de recherche, vĂ©rifiez le statut, gĂ©rez les threads â le tout sans quitter le terminal.
**Installer le skill** :
```bash
npx skills add https://github.com/bytedance/deer-flow --skill claude-to-deerflow
```
Assurez-vous ensuite que DeerFlow tourne (par défaut sur `http://localhost:2026`) et utilisez la commande `/claude-to-deerflow` dans Claude Code.
**Ce que vous pouvez faire** :
- Envoyer des messages à DeerFlow et recevoir des réponses en streaming
- Choisir le mode d'exécution : flash (rapide), standard, pro (planification), ultra (sub-agents)
- Vérifier la santé de DeerFlow, lister les modÚles/skills/agents
- GĂ©rer les threads et l'historique des conversations
- Upload des fichiers pour analyse
**Variables d'environnement** (optionnel, pour des endpoints custom) :
```bash
DEERFLOW_URL=http://localhost:2026 # Unified proxy base URL
DEERFLOW_GATEWAY_URL=http://localhost:2026 # Gateway API
DEERFLOW_LANGGRAPH_URL=http://localhost:2026/api/langgraph # LangGraph API
```
Voir [`skills/public/claude-to-deerflow/SKILL.md`](skills/public/claude-to-deerflow/SKILL.md) pour la référence API complÚte.
### Sub-Agents
Les tùches complexes tiennent rarement en une seule passe. DeerFlow les décompose.
L'agent principal peut lancer des sub-agents Ă la volĂ©e â chacun avec son propre contexte dĂ©limitĂ©, ses outils et ses conditions d'arrĂȘt. Les sub-agents s'exĂ©cutent en parallĂšle quand c'est possible, remontent des rĂ©sultats structurĂ©s, et l'agent principal synthĂ©tise le tout en une sortie cohĂ©rente.
C'est comme ça que DeerFlow gĂšre les tĂąches qui prennent de quelques minutes Ă plusieurs heures : une tĂąche de recherche peut se dĂ©ployer en une dizaine de sub-agents, chacun explorant un angle diffĂ©rent, puis converger vers un seul rapport â ou un site web â ou un jeu de slides avec des visuels gĂ©nĂ©rĂ©s. Un seul harness, de nombreuses mains.
### Sandbox et systĂšme de fichiers
DeerFlow ne se contente pas de *parler* de faire les choses. Il dispose de son propre ordinateur.
Chaque tĂąche s'exĂ©cute dans un conteneur Docker isolĂ© avec un systĂšme de fichiers complet â skills, workspace, uploads, outputs. L'agent lit, Ă©crit et Ă©dite des fichiers. Il exĂ©cute des commandes bash et du code. Il visualise des images. Le tout sandboxĂ©, le tout auditable, zĂ©ro contamination entre les sessions.
C'est la différence entre un chatbot avec accÚs à des outils et un agent doté d'un véritable environnement d'exécution.
```
# Paths inside the sandbox container
/mnt/user-data/
âââ uploads/ â your files
âââ workspace/ â agents' working directory
âââ outputs/ â final deliverables
```
### Context Engineering
**Contexte isolĂ© des Sub-Agents** : chaque sub-agent s'exĂ©cute dans son propre contexte isolĂ©. Il ne peut voir ni le contexte de l'agent principal, ni celui des autres sub-agents. L'objectif est de garantir que chaque sub-agent reste concentrĂ© sur sa tĂąche sans ĂȘtre parasitĂ© par des informations non pertinentes.
**RĂ©sumĂ©** : au sein d'une session, DeerFlow gĂšre le contexte de maniĂšre agressive â en rĂ©sumant les sous-tĂąches terminĂ©es, en dĂ©chargeant les rĂ©sultats intermĂ©diaires vers le systĂšme de fichiers, en compressant ce qui n'est plus immĂ©diatement pertinent. Ăa lui permet de rester efficace sur des tĂąches longues et multi-Ă©tapes sans faire exploser la fenĂȘtre de contexte.
### MĂ©moire Ă long terme
La plupart des agents oublient tout dĂšs qu'une conversation se termine. DeerFlow, lui, se souvient.
D'une session Ă l'autre, DeerFlow construit une mĂ©moire persistante de votre profil, de vos prĂ©fĂ©rences et de vos connaissances accumulĂ©es. Plus vous l'utilisez, mieux il vous connaĂźt â votre style d'Ă©criture, votre stack technique, vos workflows rĂ©currents. La mĂ©moire est stockĂ©e localement et reste sous votre contrĂŽle.
Les mises à jour de la mémoire ignorent désormais les entrées de faits en double au moment de l'application, de sorte que les préférences et le contexte répétés ne s'accumulent plus indéfiniment entre les sessions.
## ModÚles recommandés
DeerFlow est agnostique en termes de modĂšle â il fonctionne avec n'importe quel LLM implĂ©mentant l'API compatible OpenAI. Cela dit, il offre de meilleures performances avec des modĂšles qui supportent :
- **De longues fenĂȘtres de contexte** (100k+ tokens) pour la recherche approfondie et les tĂąches multi-Ă©tapes
- **Des capacités de raisonnement** pour la planification adaptative et la décomposition de tùches complexes
- **Des entrées multimodales** pour la compréhension d'images et de vidéos
- **Un usage fiable des outils (tool use)** pour des appels de fonctions et des sorties structurées fiables
## Client Python intégré
DeerFlow peut ĂȘtre utilisĂ© comme bibliothĂšque Python intĂ©grĂ©e sans lancer l'ensemble des services HTTP. Le `DeerFlowClient` fournit un accĂšs direct in-process Ă toutes les capacitĂ©s d'agent et de Gateway, en retournant les mĂȘmes schĂ©mas de rĂ©ponse que l'API HTTP Gateway. Le HTTP Gateway expose Ă©galement `DELETE /api/threads/{thread_id}` pour supprimer les donnĂ©es de thread locales gĂ©rĂ©es par DeerFlow aprĂšs la suppression du thread LangGraph :
```python
from deerflow.client import DeerFlowClient
client = DeerFlowClient()
# Chat
response = client.chat("Analyze this paper for me", thread_id="my-thread")
# Streaming (LangGraph SSE protocol: values, messages-tuple, end)
for event in client.stream("hello"):
if event.type == "messages-tuple" and event.data.get("type") == "ai":
print(event.data["content"])
# Configuration & management â returns Gateway-aligned dicts
models = client.list_models() # {"models": [...]}
skills = client.list_skills() # {"skills": [...]}
client.update_skill("web-search", enabled=True)
client.upload_files("thread-1", ["./report.pdf"]) # {"success": True, "files": [...]}
```
Toutes les méthodes retournant des dicts sont validées en CI contre les modÚles de réponse Pydantic du Gateway (`TestGatewayConformance`), garantissant que le client intégré reste synchronisé avec les schémas de l'API HTTP. Voir `backend/packages/harness/deerflow/client.py` pour la documentation API complÚte.
## Documentation
- [Guide de contribution](CONTRIBUTING.md) - Mise en place de l'environnement de développement et workflow
- [Guide de configuration](backend/docs/CONFIGURATION.md) - Instructions d'installation et de configuration
- [Vue d'ensemble de l'architecture](backend/CLAUDE.md) - DĂ©tails de l'architecture technique
- [Architecture backend](backend/README.md) - Architecture backend et référence API
## Contribuer
Les contributions sont les bienvenues ! Consultez [CONTRIBUTING.md](CONTRIBUTING.md) pour la mise en place de l'environnement de développement, le workflow et les conventions.
La couverture de tests de régression inclut la détection du mode sandbox Docker et les tests de gestion du kubeconfig-path du provisioner dans `backend/tests/`.
## Licence
Ce projet est open source et disponible sous la [Licence MIT](./LICENSE).
## Remerciements
DeerFlow est construit sur le travail remarquable de la communauté open source. Nous sommes profondément reconnaissants envers tous les projets et contributeurs dont les efforts ont rendu DeerFlow possible. Nous nous tenons véritablement sur les épaules de géants.
Nous tenons Ă exprimer notre sincĂšre gratitude aux projets suivants pour leurs contributions inestimables :
- **[LangChain](https://github.com/langchain-ai/langchain)** : leur excellent framework propulse nos interactions LLM et nos chaßnes, permettant une intégration et des fonctionnalités fluides.
- **[LangGraph](https://github.com/langchain-ai/langgraph)** : leur approche innovante de l'orchestration multi-agents a été déterminante pour les workflows sophistiqués de DeerFlow.
Ces projets illustrent le pouvoir transformateur de la collaboration open source, et nous sommes fiers de bĂątir sur leurs fondations.
### Contributeurs principaux
Un grand merci aux auteurs principaux de `DeerFlow`, dont la vision, la passion et le dévouement ont donné vie à ce projet :
- **[Daniel Walnut](https://github.com/hetaoBackend/)**
- **[Henry Li](https://github.com/magiccube/)**
Votre engagement sans faille et votre expertise sont le moteur du succÚs de DeerFlow. Nous sommes honorés de vous avoir à la barre de cette aventure.
## Star History
[](https://star-history.com/#bytedance/deer-flow&Date)