DeepTutor : Tutorat Personnalisé à Vie

Fonctionnalités · Démarrage · Explorer · CLI · Écosystème · Communauté

🤝 Nous accueillons toutes les formes de contribution ! Votez sur les éléments de la feuille de route ou proposez-en de nouveaux sur Roadmap, et consultez notre Guide de contribution pour la stratégie de branches, les normes de code et comment démarrer.

📰 Actualités

2026-05-22 🌐 Site de documentation officiel en ligne sur deeptutor.info — guides, références et tours des capacités en un seul endroit.
2026-04-19 🎉 20 000 étoiles en 111 jours ! Merci pour votre soutien envers un tutorat véritablement personnalisé et intelligent.
2026-04-10 📄 Notre article est en ligne sur arXiv — lisez le preprint pour la conception et les idées derrière DeepTutor.
2026-02-06 🚀 10 000 étoiles en seulement 39 jours ! Un immense merci à notre incroyable communauté.
2026-01-01 🎊 Bonne Année ! Rejoignez notre Discord, WeChat, ou les Discussions — façonnons DeepTutor ensemble.
2025-12-29 🎓 DeepTutor est officiellement lancé !

✨ Fonctionnalités Clés

DeepTutor est un espace de travail d'apprentissage natif à l'agent qui connecte le tutorat, la résolution de problèmes, la génération de quiz, la recherche, la visualisation et la pratique de maîtrise dans un système extensible.

Un seul runtime pour chaque mode — Chat, Quiz, Research, Visualize, Solve et Mastery Path fonctionnent sur la même boucle d'agent, vous changez donc l'objectif, pas le moteur, et le contexte suit l'apprenant.
Contexte d'apprentissage connecté — Les bases de connaissances, les livres, les brouillons Co-Writer, les carnets, les banques de questions, les personas et la Memory restent disponibles dans tous les flux de travail au lieu de vivre dans des outils isolés.
Sous-agents et Partners — consultez un Claude Code, Codex ou Partner en direct depuis n'importe quel tour (ou importez leurs conversations passées), et exécutez des compagnons IM persistants sur le même cerveau.
Connaissances multi-moteur — bibliothèques RAG versionnées via LlamaIndex, PageIndex, GraphRAG, LightRAG, ou un vault Obsidian lié, avec une analyse de documents enfichable.
Outils et compétences extensibles — outils intégrés, serveurs MCP, modèles de génération d'images / vidéos / voix, et compétences communautaires installables depuis EduHub.
Mémoire inspectable — les traces L1, les résumés de surface L2 et la synthèse L3 rendent la personnalisation visible et modifiable, avec un Memory Graph qui retrace chaque affirmation jusqu'à son evidence.

🚀 Démarrage

DeepTutor propose quatre chemins d'installation. Ils partagent tous une même structure d'espace de travail : les paramètres résident dans data/user/settings/ sous le répertoire depuis lequel vous lancez l'application (ou sous DEEPTUTOR_HOME / deeptutor start --home si vous en définissez un explicitement). Pour l'application complète, le flux recommandé est choisir un répertoire d'espace de travail → installer → deeptutor init → deeptutor start.

Option 1 — Installer depuis PyPI · application Web locale complète + CLI, sans clonage

Application Web locale complète + CLI, sans clonage requis. Nécessite Python 3.11+ et un runtime Node.js 20+ dans le PATH (le serveur standalone Next.js packagé est lancé par deeptutor start).

mkdir -p my-deeptutor && cd my-deeptutor
pip install -U deeptutor
deeptutor init     # invite pour les ports + fournisseur LLM + embedding optionnel
deeptutor start    # démarre le backend + frontend ; gardez le terminal ouvert

deeptutor init demande le port backend (par défaut 8001), le port frontend (par défaut 3782), le fournisseur LLM / URL de base / clé API / modèle, et un fournisseur d'embedding optionnel pour la Base de Connaissances / RAG.

Après deeptutor start, ouvrez l'URL frontend affichée dans le terminal — par défaut http://127.0.0.1:3782. Appuyez sur Ctrl+C dans ce terminal pour arrêter le backend et le frontend. Ignorer deeptutor init est possible pour un essai rapide ; l'application démarre avec les ports par défaut et des paramètres de modèle vides, à configurer plus tard dans Paramètres → Modèles.

Option 2 — Installer depuis les sources · développer à partir d'un checkout

Pour le développement à partir d'un checkout. Utilisez Python 3.11+ et Node.js 22 LTS pour correspondre à la CI et à Docker.

git clone https://github.com/HKUDS/DeepTutor.git
cd DeepTutor

# Créer un venv (macOS/Linux). Windows PowerShell :
#   py -3.11 -m venv .venv ; .\.venv\Scripts\Activate.ps1
python3 -m venv .venv && source .venv/bin/activate
python -m pip install --upgrade pip

# Installer les dépendances backend + frontend
python -m pip install -e .
( cd web && npm ci --legacy-peer-deps )

deeptutor init
deeptutor start

Les installations depuis les sources exécutent Next.js en mode dev contre le répertoire web/ local ; tout le reste (structure de configuration, ports, arrêt avec Ctrl+C) correspond à l'Option 1.

Environnement Conda (à la place de venv)

conda create -n deeptutor python=3.11
conda activate deeptutor
python -m pip install --upgrade pip

Extras d'installation optionnels — dev / partners / matrix / math-animator

pip install -e ".[dev]"             # outils de tests/lint
pip install -e ".[partners]"        # SDKs de canaux IM Partner + client MCP
pip install -e ".[matrix]"          # canal Matrix sans E2EE/libolm
pip install -e ".[matrix-e2e]"      # Matrix E2EE ; nécessite libolm
pip install -e ".[math-animator]"   # addon Manim ; nécessite LaTeX/ffmpeg/libs système

Ajustements des dépendances frontend et dépannage du serveur de développement

Modifier les dépendances frontend : exécutez npm install --legacy-peer-deps pour actualiser web/package-lock.json, puis commitez web/package.json et web/package-lock.json.

Serveur de développement bloqué : si deeptutor start signale un frontend existant qui ne répond pas, arrêtez le PID qu'il affiche. Si aucun processus Next.js ne tourne réellement, les fichiers de verrou sont périmés — supprimez-les et réessayez :

rm -f web/.next/dev/lock web/.next/lock
deeptutor start

Option 3 — Docker · un conteneur autonome

Un conteneur pour l'application Web complète. Images sur GitHub Container Registry :

ghcr.io/hkuds/deeptutor:latest — version stable
ghcr.io/hkuds/deeptutor:pre — pré-version, si disponible

Voir CONTAINERIZATION.md pour les déploiements podman/rootless/système de fichiers racine en lecture seule et le guide complet par installation.

docker run --rm --name deeptutor \
  -p 127.0.0.1:3782:3782 \
  -v deeptutor-data:/app/data \
  ghcr.io/hkuds/deeptutor:latest

Seul le port 3782 doit être publié. Le navigateur parle exclusivement à l'origine frontend ; le middleware Next.js (web/proxy.ts) transmet /api/* et /ws/* au backend FastAPI à l'intérieur du conteneur. La publication de 8001 (-p 127.0.0.1:8001:8001) est optionnelle — utile uniquement pour accéder directement à l'API avec curl ou des scripts.

Ouvrez http://127.0.0.1:3782. Le conteneur crée /app/data/user/settings/*.json au premier démarrage ; configurez les fournisseurs de modèles depuis la page Paramètres Web. La configuration, les clés API, les journaux, les fichiers d'espace de travail, la mémoire et les bases de connaissances persistent dans le volume deeptutor-data.

Ports hôte différents : modifiez le côté gauche de chaque correspondance -p hôte:conteneur (ex. -p 127.0.0.1:8088:3782). Si vous changez les ports côté conteneur dans /app/data/user/settings/system.json, redémarrez et mettez à jour le côté droit de chaque correspondance en conséquence.
Détaché : ajoutez -d, puis docker logs -f deeptutor pour suivre, docker stop deeptutor pour arrêter, docker rm deeptutor avant de réutiliser le nom. Le volume deeptutor-data conserve vos paramètres et votre espace de travail à travers les redémarrages.

Docker distant / proxy inverse : le navigateur ne parle qu'à l'origine frontend (:3782) ; le middleware Next.js dans le conteneur transmet /api/* et /ws/* au serveur backend côté serveur. Pour le cas courant d'un conteneur unique, vous ne configurez pas du tout de base API — pointez simplement votre proxy inverse / terminateur TLS sur :3782. Vous n'avez besoin d'une base API que pour un déploiement séparé (backend dans un conteneur/hôte séparé) : définissez next_public_api_base dans data/user/settings/system.json avec l'adresse réseau interne que le serveur frontend utilise pour atteindre le backend (elle est lue côté serveur, jamais envoyée au navigateur).

{
  "next_public_api_base": "http://backend:8001"
}

next_public_api_base_external (et son alias public_api_base) sont acceptés comme solutions de repli à priorité inférieure. CORS utilise les origines frontend, pas les URLs d'API. Avec l'authentification désactivée, DeepTutor autorise les origines de navigateur HTTP/HTTPS normales par défaut. Avec l'authentification activée, ajoutez les origines frontend exactes :

{
  "cors_origins": ["https://deeptutor.example.com"]
}

Connexion à Ollama / LM Studio / llama.cpp / vLLM / Lemonade sur l'hôte

Dans Docker, localhost est le conteneur lui-même, pas votre machine hôte. Pour atteindre un service de modèle tournant sur l'hôte, utilisez la passerelle hôte (recommandé) :

docker run --rm --name deeptutor \
  -p 127.0.0.1:3782:3782 -p 127.0.0.1:8001:8001 \
  --add-host=host.docker.internal:host-gateway \
  -v deeptutor-data:/app/data \
  ghcr.io/hkuds/deeptutor:latest

Puis dans Paramètres → Modèles, pointez l'URL de base du fournisseur vers host.docker.internal :

Ollama LLM : http://host.docker.internal:11434/v1
Ollama embedding : http://host.docker.internal:11434/api/embed
LM Studio : http://host.docker.internal:1234/v1
llama.cpp : http://host.docker.internal:8080/v1
Lemonade : http://host.docker.internal:13305/api/v1

Docker Desktop (macOS/Windows) résout généralement host.docker.internal sans --add-host. Sur Linux, le drapeau est la façon portable de créer ce nom d'hôte avec les versions modernes de Docker Engine.

Alternative Linux — réseau hôte : ajoutez --network=host et supprimez les drapeaux -p. Le conteneur partage directement le réseau hôte, ouvrez donc http://127.0.0.1:3782 (ou le frontend_port dans system.json), et les services hôtes sont accessibles avec des URLs localhost normales comme http://127.0.0.1:11434/v1. Notez que le réseau hôte expose les ports du conteneur directement sur l'hôte et peut entrer en conflit avec des services existants — pour les maintenir sur loopback, définissez BACKEND_HOST=127.0.0.1 et FRONTEND_HOST=127.0.0.1 (voir CONTAINERIZATION.md).

Option 4 — CLI uniquement · sans interface Web, depuis un checkout des sources

Quand vous n'avez pas besoin de l'interface Web. Le paquet CLI uniquement est installé depuis un checkout des sources, pas depuis PyPI.

git clone https://github.com/HKUDS/DeepTutor.git
cd DeepTutor

# Créer un venv (macOS/Linux). Windows PowerShell :
#   py -3.11 -m venv .venv-cli ; .\.venv-cli\Scripts\Activate.ps1
python3 -m venv .venv-cli && source .venv-cli/bin/activate
python -m pip install --upgrade pip

python -m pip install -e ./packaging/deeptutor-cli
deeptutor init --cli
deeptutor chat

deeptutor init --cli partage la même structure data/user/settings/ que l'application complète mais ignore les invites de ports backend/frontend et désactive les embeddings par défaut (choisissez Yes si vous prévoyez d'utiliser deeptutor kb … ou les outils RAG). Il écrit quand même une structure d'exécution complète (system.json, auth.json, integrations.json, model_catalog.json, main.yaml, agents.yaml) et demande quand même le fournisseur LLM actif et le modèle.

Commandes courantes

deeptutor chat                                          # REPL interactif
deeptutor chat --capability deep_solve --tool rag --kb my-kb
deeptutor run chat "Explain Fourier transform"
deeptutor run deep_solve "Solve x^2 = 4" --tool rag --kb my-kb
deeptutor kb create my-kb --doc textbook.pdf
deeptutor memory show
deeptutor config show

L'installation locale deeptutor-cli n'inclut pas de ressources Web ni de dépendances serveur. Conservez le checkout des sources — l'installation modifiable y pointe. Pour ajouter l'application Web plus tard, installez le paquet PyPI (Option 1) et exécutez deeptutor init + deeptutor start depuis le même espace de travail.

Sandbox d'exécution de code (compétences office) · exécution du code généré par le modèle pour docx / pdf / pptx / xlsx

Les compétences office intégrées — docx / pdf / pptx / xlsx — fonctionnent en demandant au modèle d'écrire un court script Python (python-docx, reportlab, openpyxl, …), de l'exécuter via les outils exec / code_execution, et de renvoyer une URL de téléchargement. Ces outils se montent chaque fois qu'un backend sandbox est actif, ce qui est le cas par défaut dans chaque forme de déploiement :

Local (Option 1 / 2) et Docker (Option 3, conteneur unique) : un sandbox de sous-processus restreint exécute le code du modèle (sur l'hôte localement, ou à l'intérieur du conteneur sous Docker — le conteneur étant sa propre frontière d'isolation).
docker-compose : acheminé à la place vers un sidecar runner durci et à moindres privilèges (Dockerfile.runner) via DEEPTUTOR_SANDBOX_RUNNER_URL — la posture la plus solide, préférée automatiquement quand elle est présente.

Le sandbox de sous-processus est contrôlé par le paramètre sandbox_allow_subprocess dans data/user/settings/system.json (par défaut true). Exécuter le code généré par le modèle sur votre hôte est une vraie décision de confiance — définissez-le à false (ou exportez DEEPTUTOR_SANDBOX_ALLOW_SUBPROCESS=0) pour désactiver l'exécution côté hôte, au coût de ne plus pouvoir produire des fichiers avec les compétences office.

Référence de configuration — fichiers de configuration sous data/user/settings/ (JSON/YAML)

Tout ce qui se trouve sous data/user/settings/ est du JSON/YAML brut. La page Paramètres dans le navigateur est l'éditeur recommandé.

Fichier	Objectif
`model_catalog.json`	Profils de fournisseurs LLM, embedding et recherche ; clés API ; modèles actifs
`system.json`	Ports backend/frontend, base d'API publique, CORS, vérification SSL, répertoire des pièces jointes
`auth.json`	Basculement d'authentification optionnel, nom d'utilisateur, hachage de mot de passe, paramètres de jeton/cookie
`integrations.json`	Paramètres d'intégration PocketBase et sidecar optionnels
`interface.json`	Langue de l'interface / thème / préférences de barre latérale
`main.yaml`	Valeurs par défaut du comportement d'exécution et injection de chemin
`agents.yaml`	Paramètres de température et de jetons pour les capacités/outils

Le fichier .env à la racine du projet n'est pas lu comme fichier de configuration d'application. Pour une configuration minimale de modèle, ouvrez Paramètres → Modèles, ajoutez un profil LLM (URL de base / clé API / nom du modèle) et enregistrez. Ajoutez un profil d'embedding uniquement si vous prévoyez d'utiliser les fonctionnalités Base de Connaissances / RAG.

📖 Explorer DeepTutor

Commencez par les surfaces principales que vous utiliserez au quotidien : Chat, Partners, My Agents, Co-Writer, Book, Knowledge Center, Learning Space, Memory et Settings. La visite couvre ensuite les déploiements Multi-Utilisateur pour des espaces de travail partagés et isolés.

Accueil DeepTutor — l'espace de travail Chat avec chaque surface dans la barre latérale

🏗️ Architecture du système

💬 Chat — La Boucle d'Agent que Vous Utilisez Vraiment

Chat est la capacité par défaut et là où commence la plupart du travail. Un seul fil peut discuter normalement, appeler des outils, s'ancrer dans des bases de connaissances sélectionnées, lire des pièces jointes, générer des images, consulter des sous-agents, écrire des enregistrements dans le carnet et continuer avec le même contexte à travers les tours.

La boucle est délibérément simple : le modèle réfléchit en rounds, appelle des outils quand c'est utile, observe les résultats et termine avec un message sans outil. ask_user est spécial — plutôt que de deviner, l'agent peut mettre le tour en pause, poser une question de clarification structurée, et reprendre une fois que vous répondez.

Les outils basculables par l'utilisateur sont brainstorm, web_search, paper_search, reason et geogebra_analysis — plus imagegen et videogen une fois que vous avez configuré le modèle de génération correspondant. Les outils contextuels tels que rag, read_source, read_memory, write_memory, read_skill, load_tools, exec, web_fetch, ask_user, list_notebook, write_note, github et consult_subagent se montent automatiquement quand le tour dispose du bon contexte.

Le contexte se présente en deux types : le contexte de session persistant (sous-agent, bases de connaissances, persona, modèle, voix) vit sur la barre d'outils du compositeur et persiste entre les tours ; les références ponctuelles (fichiers, historique de chat, livres, carnets, banque de questions, agents importés) proviennent du menu + pour un seul tour.

Chat est aussi le point de lancement pour des capacités plus profondes : Quiz pour la génération de questions, Research pour les rapports cités, Visualize pour les graphiques / diagrammes / animations, et — sous Plus de Capacités — Solve pour le raisonnement guidé et Mastery Path pour les flux de plans d'apprentissage.

🤝 Partner — Compagnons Persistants sur le Même Cerveau

Les Partners sont des compagnons persistants avec leur propre âme, politique de modèle, bibliothèque, mémoire et canaux. Ce ne sont pas un moteur de bot séparé : chaque message web ou IM entrant devient un tour normal de ChatOrchestrator dans un espace de travail à portée partner. Un partner est « un chat qui a une personnalité et un numéro de téléphone. »

Chaque partner a un SOUL.md, une sélection de modèle, des canaux, une politique d'outils et une bibliothèque assignée. Les bases de connaissances, les compétences et les carnets sont copiés dans data/partners/<id>/workspace/, de sorte que les mêmes outils RAG, compétence, carnet et mémoire fonctionnent sans cas particuliers. Un partner lit la mémoire de son propriétaire mais n'écrit que la sienne.

La couche de canaux est pilotée par schéma et peut se connecter à des plateformes IM telles que Feishu, Telegram, Slack, Discord, DingTalk, QQ/NapCat, WeCom, WhatsApp, Zulip, Mattermost, Matrix, Mochat et Microsoft Teams selon les extras installés et les identifiants configurés. Un partner peut également être connecté comme sous-agent et consulté depuis un tour de chat normal — voir My Agents ci-dessous.

🧑‍🚀 My Agents — Consulter et Importer d'Autres Agents

Espace de travail My Agents de DeepTutor

My Agents transforme d'autres agents en contexte pour DeepTutor, et fait deux choses distinctes. Connectez un agent en direct — un Claude Code ou Codex CLI sur votre machine, ou l'un de vos Partners — et consultez-le depuis l'intérieur d'un tour de chat : DeepTutor exécute réellement l'autre agent et diffuse son travail dans le panneau d'Activité via l'outil consult_subagent. Sélectionnez-le avec la puce Agent (ou tapez @), et définissez combien de rounds la consultation peut prendre.

Consultation d'un sous-agent Claude Code en direct

Importez des conversations passées — apportez votre historique Claude Code et Codex existant comme des agents nommés, consultables et reprenables. Choisissez les jours à importer ; l'actualisation les re-synchronise. Référencez une conversation importée depuis n'importe quel tour de chat via + → My Agents, et DeepTutor la lit comme une transcription tierce — elle reste leur conversation, pas la voix propre de DeepTutor.

✍️ Co-Writer — Rédaction Markdown Sensible à la Sélection

Espace de travail Co-Writer de DeepTutor

Co-Writer est un espace de travail Markdown à vue divisée pour les rapports, tutoriels, notes et artefacts d'apprentissage longs. Les documents se sauvegardent automatiquement et affichent un aperçu en direct (math KaTeX, clôtures de diagrammes), et peuvent être enregistrés dans des carnets quand un brouillon devient un contexte réutilisable.

Son idée directrice est l'édition chirurgicale : sélectionnez une plage et demandez à DeepTutor de la réécrire, l'étendre ou la raccourcir. L'agent d'édition peut ancrer le changement dans une base de connaissances ou des preuves web, conserve une trace de ses appels d'outils, et montre chaque changement comme un diff accepter/rejeter — rien ne se place donc jusqu'à ce que vous l'approuviez.

📖 Book — Livres Vivants depuis Vos Matériaux

Book transforme des sources sélectionnées en un livre vivant interactif — pas un PDF statique, mais un environnement de lecture construit à partir de blocs typés. Un livre peut démarrer depuis des bases de connaissances, des carnets, des banques de questions ou l'historique de chat ; le flux de création propose un plan de chapitre avant que le contenu soit généré, vous pouvez donc revoir la forme au lieu d'accepter une sortie en un seul coup aveugle.

Chaque chapitre se compile en blocs typés — texte, encadrés, quiz, fiches, chronologies, code, figures, HTML interactif, animations, graphes de concepts, approfondissements et notes utilisateur — et chaque page a son propre Chat de Page. Les blocs sont modifiables : insérez, déplacez, régénérez ou changez le type d'un bloc sans réécrire le chapitre. Les commandes de maintenance comme deeptutor book health et deeptutor book refresh-fingerprints aident à détecter quand les connaissances source ont divergé des pages compilées.

📚 Knowledge Center — Bibliothèques RAG Multi-Moteur

Les bases de connaissances sont les collections de documents derrière le RAG — elles ancrent les tours de Chat, les éditions Co-Writer, la génération de Book et les conversations Partner. Ce qui est distinctif est un choix de moteurs de récupération : LlamaIndex (par défaut, vecteur local + BM25), PageIndex (hébergé, récupération par raisonnement avec citations au niveau de la page), GraphRAG et LightRAG (récupération par graphe de connaissances), LightRAG Server (récupération déléguée à une instance LightRAG externe connectée via HTTP), ou un vault Obsidian lié que le tuteur lit et écrit en place. Chaque KB est liée à un moteur.

En créant une KB, vous choisissez soit de créer nouvelle (uploadez des documents et construisez un index frais) soit de lier une existante (réutilisez un index construit ailleurs, lu en place sans re-indexation). La re-indexation écrit un nouveau répertoire plat version-N et conserve les précédents, donc un index fonctionnel n'est jamais détruit en milieu de reconstruction. Un seul document peut être supprimé même d'une base en état d'erreur — retirer un fichier dont l'analyse a échoué sans devoir tout supprimer et reconstruire. L'analyse de documents — Text-only, MinerU, Docling, markitdown ou PyMuPDF4LLM — est choisie dans Paramètres → Base de Connaissances, avec les téléchargements de modèles locaux désactivés par défaut. La CLI reprend le cycle de vie avec deeptutor kb list, info, create, add, search, set-default et delete.

🌐 Learning Space — Compétences, Personas et Contexte Réutilisable

Learning Space est la couche de bibliothèque et de personnalisation — là où vivent les choses qui persistent. Conversations & Matériaux contient votre historique de chat, vos carnets et une banque de questions (chaque question sauvegardée conserve votre réponse, la réponse de référence et une explication). Personnalisation contient les parcours de maîtrise, les personas (préréglages de comportement comme pair, assistant de recherche, enseignant) et les compétences (livrets de jeu SKILL.md que le modèle lit à la demande). Tout ici peut être réutilisé depuis Chat, Partners, Co-Writer et Book.

Vous n'avez pas à écrire chaque compétence vous-même — Importer depuis EduHub parcourt le catalogue communautaire et télécharge une compétence directement dans votre bibliothèque via une porte de sécurité (voir Écosystème).

🧠 Memory — Personnalisation Inspectable

Memory est un système en trois couches sauvegardé sur fichier que vous pouvez lire, organiser et auditer — délibérément pas un store vectoriel caché. L1 est le miroir de l'espace de travail plus une trace d'événements en ajout seul (trace/<surface>/<date>.jsonl) ; L2 contient des faits organisés par surface (L2/<surface>.md) ; L3 est la synthèse inter-surfaces (L3/<profile|recent|scope|preferences>.md). Parce que L2 cite L1 et L3 cite L2, rien dans votre profil n'est sans compte rendu.

Le Memory Graph montre toute la pyramide — la synthèse L3 au centre, L2 dans l'anneau du milieu, les traces L1 à l'extérieur — vous pouvez donc retracer n'importe quelle affirmation synthétisée jusqu'à l'événement brut exact qui la sous-tend. La Memory est suivie sur les surfaces chat, notebook, quiz, kb, book, partner et cowriter ; les budgets Mise à jour / Audit / Déduplication du consolidateur sont réglés dans Paramètres → Memory.

⚙️ Settings — Un Seul Plan de Contrôle

Settings est le plan de contrôle opérationnel, avec une bande de statut en direct (Backend, LLM, Embedding, Recherche) et une carte par zone : Apparence (thème + langue de l'interface), Réseau (base d'API, ports, CORS), Modèles (LLM, Embedding, Recherche, Texte-à-Parole, Parole-à-Texte, Génération d'Images, Génération de Vidéos), Base de Connaissances (moteur d'analyse de documents), Chat (outils, serveurs MCP, paramètres par capacité), Partners & Agents (les sous-agents que vous pouvez consulter depuis un tour), et Memory (les budgets du consolidateur).

Paramètres d'apparence et thèmes DeepTutor

La plupart des sections utilisent un flux brouillon-et-application, vous pouvez donc tester un fournisseur avant de vous y engager. Quatre thèmes sont livrés dans la boîte — Default, Cream, Dark et Glass. Les fichiers .env à la racine du projet sont intentionnellement ignorés ; la configuration d'exécution vit sous data/user/settings/*.json sauf si DEEPTUTOR_HOME ou deeptutor start --home pointe l'application ailleurs.

👥 Multi-Utilisateur — Déploiements Partagés · authentification optionnelle, espaces de travail isolés par utilisateur

L'authentification est désactivée par défaut — DeepTutor fonctionne en mode mono-utilisateur. Activez-la et un seul arbre data/ héberge un espace de travail admin, des espaces de travail per-utilisateur isolés et des espaces de travail partner côte à côte :

data/
├── user/                    # Espace de travail Admin + paramètres globaux
├── users/<uid>/             # Portée par utilisateur : historique de chat, mémoire, carnets, KB
├── partners/<id>/workspace/ # Portée partner (utilisateur synthétique)
└── system/                  # auth/users.json · grants/<uid>.json · audit/usage.jsonl

Le premier utilisateur enregistré devient admin et possède les catalogues de modèles, les identifiants de fournisseur, les bases de connaissances partagées, les compétences et les attributions per-utilisateur. Tous les autres obtiennent un espace de travail isolé et une page Settings expurgée — les modèles, KB et compétences assignés par l'admin apparaissent comme des options à portée, en lecture seule, jamais comme des clés d'API brutes.

Activer : activez l'auth dans data/user/settings/auth.json, redémarrez deeptutor start, enregistrez le premier admin sur /register, puis ajoutez des utilisateurs depuis /admin/users et assignez des modèles, KB, compétences, Partners, politique d'outils/MCP et accès à l'exécution de code via des attributions.

PocketBase reste une intégration mono-utilisateur — gardez integrations.pocketbase_url vide pour les déploiements multi-utilisateur sauf si vous avez configuré un store utilisateur externe.

⌨️ DeepTutor CLI — Interface Native à l'Agent

Un seul binaire deeptutor, deux façons d'accéder : un REPL interactif pour ceux qui vivent dans le terminal, et du JSON structuré pour d'autres agents qui pilotent DeepTutor comme un outil. Les mêmes capacités, outils et bases de connaissances dans les deux cas.

Piloter vous-même

deeptutor chat ouvre un REPL interactif ; deeptutor run <capacité> "<message>" exécute un seul tour et quitte. Les deux acceptent les mêmes drapeaux --capability, --tool, --kb et --config.

deeptutor chat                                              # REPL interactif
deeptutor chat --capability deep_solve --kb my-kb --tool rag
deeptutor run chat "Explain the Fourier transform" --tool rag --kb textbook
deeptutor run deep_research "Survey 2026 papers on RAG" \
  --config mode=report --config depth=standard

Tout ce que fait l'application Web est également disponible ici — bases de connaissances (kb), sessions (session), partners (partner), compétences (skill), carnets, mémoire et configuration. Liste complète ci-dessous.

Laisser un agent piloter

DeepTutor est conçu pour être opéré par un autre agent. Ajoutez --format json à n'importe quel run et chaque tour diffuse du NDJSON — un événement par ligne (content, tool_call, tool_result, done, …), chaque ligne étant taguée avec son session_id. Les exécutions sont headless-safe : une pause ask_user sans TTY se résout automatiquement avec une réponse vide au lieu de bloquer.

# Coup unique, lisible par machine
deeptutor run deep_solve "Find d/dx[sin(x^2)]" --tool reason --format json

# Enchaîner des tours dans une session avec état — capturer l'id, le réutiliser
SID=$(deeptutor run deep_research "Survey 2026 papers on RAG" \
  --config mode=report --config depth=standard --format json \
  | jq -r 'select(.type=="done").session_id')
deeptutor run deep_question "Quiz me on that survey" --session "$SID" --format json

Le dépôt inclut un SKILL.md racine — un document de passation de ~150 lignes qui enseigne à tout LLM utilisant des outils la totalité de la surface en une seule lecture. Remettez-le à Claude Code, Codex ou OpenCode (ils récupèrent SKILL.md automatiquement), ou enveloppez deeptutor run comme un outil dans une boucle LangChain / AutoGen. Recettes complètes : Agent Handoff.

Référence des commandes

Commande	Description
`deeptutor init`	Créer ou mettre à jour `data/user/settings` pour l'espace de travail actuel
`deeptutor start [--home PATH]`	Lancer le backend + frontend ensemble
`deeptutor serve [--port PORT]`	Démarrer uniquement le backend FastAPI
`deeptutor run <capacité> <message>`	Exécuter un seul tour de capacité (`chat`, `deep_solve`, `deep_question`, `deep_research`, `visualize`, `math_animator`, `mastery_path`) ; ajoutez `--format json` pour la sortie NDJSON
`deeptutor chat`	REPL interactif avec contrôles de capacité, outil, KB, carnet et historique
`deeptutor partner list/create/start/stop`	Gérer les partners connectés à IM
`deeptutor kb list/info/create/add/search/set-default/delete`	Gérer les bases de connaissances LlamaIndex
`deeptutor skill search/install/list/remove/login/logout/publish/update`	Gérer les compétences, installer depuis les hubs et publier les siennes (`eduhub:<slug>` par défaut, voir Écosystème)
`deeptutor memory show/clear`	Inspecter les documents de mémoire L2/L3 ou effacer la mémoire L1/toute
`deeptutor session list/show/open/rename/delete`	Gérer les sessions partagées
`deeptutor notebook list/create/show/add-md/replace-md/remove-record`	Gérer les carnets depuis des fichiers Markdown
`deeptutor book list/health/refresh-fingerprints`	Inspecter les livres et actualiser les empreintes des sources
`deeptutor plugin list/info`	Inspecter les outils et capacités enregistrés
`deeptutor config show`	Afficher le résumé de configuration
`deeptutor provider login <fournisseur>`	Auth du fournisseur (OAuth login `openai-codex` ; `github-copilot` valide une session auth Copilot existante)

Distribution CLI uniquement

Le paquet CLI uniquement se trouve dans packaging/deeptutor-cli. Dans ce checkout, installez-le depuis les sources :

python -m pip install -e ./packaging/deeptutor-cli

Il n'est pas encore publié sur PyPI, donc la section principale Démarrage conserve le chemin d'installation depuis les sources.

🧩 Écosystème — EduHub & la Communauté de Compétences

Les compétences DeepTutor utilisent le format ouvert Agent-Skills — un dossier avec un livret de jeu SKILL.md (frontmatter YAML + Markdown) et des fichiers de référence optionnels. Rien dans ce format n'est spécifique à DeepTutor, donc tout registre qui parle le format devient une source pour votre bibliothèque. DeepTutor inclut EduHub — notre propre registre de compétences axé sur l'éducation — configuré comme hub par défaut.

EduHub — l'écosystème de compétences de DeepTutor

EduHub est le hub communautaire que DeepTutor a lancé pour partager des compétences d'agent orientées enseignement — tuteurs socratiques, constructeurs de fiches, retours sur les essais, plans d'examen, explicateurs de concepts, et plus encore. Il est intégré à DeepTutor, il n'y a donc rien à configurer : un slug nu ou un préfixe eduhub: le résout.

Trouver et installer — dans le navigateur, ouvrez Learning Space → Compétences → Importer depuis EduHub pour parcourir le catalogue et télécharger une compétence directement dans votre bibliothèque. Depuis le terminal :

deeptutor skill search "socratic tutor"               # rechercher sur EduHub (le hub par défaut)
deeptutor skill install socratic-tutor                # récupérer → vérifier → enregistrer
deeptutor skill install eduhub:socratic-tutor@1.2.0   # épingler un hub et une version
deeptutor skill list                                  # compétences locales avec leur provenance de hub

Publiez la vôtre — emballez un SKILL.md et partagez-le avec la communauté :

deeptutor skill login                                 # connexion navigateur à EduHub
deeptutor skill publish ./my-skill                    # interactif : choisir une piste + étiquettes, puis uploader
deeptutor skill update                                # revenir en arrière ou publier une nouvelle version

EduHub est également un registre autonome compatible ClawHub, de sorte que les agents qui ne sont pas DeepTutor (Claude Code, Codex, …) peuvent l'utiliser directement via le CLI eduhub — npx eduhub install socratic-tutor.

La porte de sécurité d'importation

Quelle que soit la source, chaque importation passe la même porte de sécurité avant que quoi que ce soit ne touche votre espace de travail :

le verdict de sécurité du registre est vérifié en premier — les paquets signalés sont refusés sauf si vous passez --allow-unverified ;
les archives sont extraites défensivement (protections zip-slip / zip-bomb) derrière une liste blanche de suffixes texte/script, donc les binaires n'atterrissent jamais dans l'espace de travail ;
le frontmatter est normalisé selon le schéma de DeepTutor et always: est supprimé, donc une compétence téléchargée ne peut jamais se forcer dans chaque prompt système ;
la provenance — hub, version, verdict et heure d'installation — est écrite dans .hub-lock.json pour les audits et les mises à jour.

Dans les déploiements multi-utilisateur, l'installation est réservée à l'admin : une nouvelle compétence atterrit dans le catalogue admin et reste invisible aux autres utilisateurs jusqu'à ce qu'une attribution l'assigne, permettant à un admin de la vérifier avant de la déployer.

Également compatible avec ClawHub

Parce que DeepTutor parle le format ouvert Agent-Skills, ClawHub fonctionne aussi comme une source de première classe — il est intégré aux côtés d'EduHub. Choisissez-le avec le préfixe hub :

deeptutor skill search "git release notes" --hub clawhub
deeptutor skill install clawhub:git-release-notes@1.0.1

Ajoutez d'autres registres dans settings/skill_hubs.json : une entrée type: "clawhub" pointe vers n'importe quelle API HTTP compatible (EduHub et ClawHub parlent tous deux ce protocole), type: "command" enveloppe n'importe quelle CLI de récupération qu'un registre fournit, et "default" choisit le hub utilisé pour les slugs nus. Tous alimentent la même porte d'importation.

🌐 Communauté

📮 Contact

DeepTutor est un projet open-source dirigé par Bingxi Zhao au sein du groupe HKUDS, et il itère sous une forme entièrement open-source, construit ensemble avec la communauté. Jusqu'à présent, nous N'AVONS PAS de produits en ligne payants sous quelque forme que ce soit. N'hésitez pas à nous contacter à bingxizhao39@gmail.com pour des discussions, des idées ou des collaborations.

🙏 Remerciements

Nos plus sincères remerciements à Chao Huang, directeur du Data Intelligence Lab @ HKU, et à nos collègues du laboratoire HKUDS pour leur soutien chaleureux — en particulier Jiahao Zhang, Zirui Guo et Xubin Ren. Nous sommes également profondément reconnaissants envers la communauté open-source : vos étoiles, issues, pull requests et discussions façonnent DeepTutor chaque jour.

DeepTutor se tient également sur les épaules de remarquables projets open-source qui nous ont fourni à la fois des outils et de l'inspiration :

Projet	Rôle / Inspiration
LlamaIndex	Pipeline RAG et colonne vertébrale d'indexation de documents
nanobot	Moteur d'agent ultra-léger qui a propulsé le TutorBot original (HKUDS)
LightRAG	RAG simple & rapide (HKUDS)
AutoAgent	Framework d'agent sans code (HKUDS)
AI-Researcher	Pipeline de recherche automatisée (HKUDS)
OpenClaw	Passerelle d'agent ouverte et écosystème de compétences derrière ClawHub
Codex	CLI de codage natif à l'agent qui a inspiré notre flux de travail CLI
Claude Code	CLI de codage agentique qui a inspiré la boucle d'agent DeepTutor
ManimCat	Génération d'animations mathématiques pilotée par IA pour Math Animator

🗺️ Feuille de Route & Contribution

Nous voulons que DeepTutor continue d'itérer et de s'améliorer — et finalement de devenir un cadeau que nous offrons en retour à la communauté open-source. Notre feuille de route est mise à jour en continu ; votez sur les éléments ou proposez-en de nouveaux. Si vous souhaitez contribuer, consultez le Guide de contribution pour la stratégie de branches, les normes de code et comment démarrer.

Nous espérons que DeepTutor deviendra un cadeau pour la communauté. 🎁