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-09-20 🎉 40 000 étoiles en 9 mois ! Nous continuerons à enrichir l'écosystème d'apprentissage de DeepTutor.
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, Ask Questions, Quiz, Research, Visualize, Solve, Course Study, Mastery Path, Immersive Reading et Immersive Watching partagent le même runtime de capacités et le même contexte de session, tout en conservant des boucles et des pipelines conçus pour chaque usage.
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 peuvent être réutilisés dans les flux de travail qui les prennent en charge, sous réserve des attributions du compte et des politiques d'apprentissage.
Apprentissage vidéo immersif — collez un lien YouTube pour une lecture native avec protection renforcée de la confidentialité, des sous-titres synchronisés, un tutorat ancré dans les horodatages et une progression reprenable ; les administrateurs peuvent basculer la lecture vers une instance Invidious auto-hébergée sans reconstruire les supports.
Sous-agents et Partners — depuis Chat, consultez un harness d'agent en direct (Claude Code, Codex, Grok CLI, Antigravity, Kimi, opencode, MiMo, Hermes, OpenClaw ou DeepSeek) ou un Partner, importez des 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, un LightRAG Server distant, un déploiement WeKnora auto-hébergé, une bibliothèque Tencent IMA ou MarginNote 4, ou un vault Obsidian lié, avec une analyse de documents enfichable. Consultez les modèles de rôle LightRAG natifs pour des paramètres d'extraction, de requête et de vision indépendants, une création limitée aux valeurs par défaut, et des reconstructions confirmées.
Outils et compétences extensibles — outils intégrés, serveurs MCP, applications CLI, 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 ; le Memory Graph relie les faits L2 aux preuves L1 et la synthèse L3 aux surfaces contributrices.

🚀 Démarrage

DeepTutor propose quatre chemins d'installation. Ils partagent tous une même structure de répertoire d'exécution : 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'exécution → installer → deeptutor init → deeptutor start.

Content Workspace

Le Content Workspace est distinct du répertoire d'exécution privé de DeepTutor. C'est le dossier que les agents peuvent lire, avec les fichiers générés sous outputs/<capability>/<session>/<turn>/. Les espaces de travail personnalisés isolent les conversations, les supports pédagogiques, la progression et les caches dans une arborescence privée .deeptutor/data/ que les outils de fichiers ne peuvent pas parcourir. Les paramètres, les identifiants et Memory restent partagés au niveau du compte.

Sans configuration, le content workspace est <runtime-home>/data/user/workspace. Les installations locales PyPI, CLI et depuis les sources peuvent choisir des dossiers dans Paramètres → Espaces de travail ; définissez le dossier par défaut avec :

deeptutor workspace show
deeptutor workspace set /absolute/path/to/my-folder
deeptutor workspace reset

Les capacités inspectent leur espace de travail sélectionné via les outils workspace intégrés. Le modèle ne reçoit que des chemins relatifs tels que outputs/... ; quand il utilise workspace_present, l'interface affiche un instantané authentifié et ouvrable. Le même chemin relatif exact fonctionne aussi dans un lien ou une image Markdown normal. Modifier le fichier source ultérieurement ne change pas un instantané déjà présenté.

Learning Space gère la bibliothèque de ressources. Dans Paramètres → Espaces de travail, attribuez des compétences, des services MCP et des bases de connaissances à chaque espace, ou conservez ses règles d'accès existantes. Les espaces existants gardent leurs accès actuels jusqu'à l'enregistrement d'une sélection. Les attributions référencent les ressources d'origine sans copier les identifiants ni les index de connaissances ; les compétences propres à un espace peuvent remplacer les versions partagées. Consultez les attributions de ressources aux espaces de travail.

L'exécution est en lecture seule en dehors de outputs/. Copier un fichier généré ailleurs dans le content workspace nécessite une confirmation explicite Allow once pour cette source et cette destination exactes. Un sandbox système ou le runner Docker impose cette frontière quand il est disponible ; le repli local par sous-processus restreint est indiqué comme best effort dans les paramètres Workspace.

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–3.14 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     # prompts for ports + LLM provider + optional embedding/search
deeptutor start    # starts backend + frontend; keep the terminal open

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, un fournisseur d'embedding optionnel pour la Base de Connaissances / RAG, ainsi qu'un fournisseur de recherche optionnel pour Web Search.

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–3.14 et Node.js 22 LTS pour correspondre à la CI et à Docker.

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

# Create a 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

# Install backend + frontend deps
python -m pip install -e .
( cd web && npm ci --legacy-peer-deps )

deeptutor init
deeptutor start --dev

deeptutor start compile une fois le frontend web/ local en production puis le réutilise ; --dev lance Next.js en HMR. Structure de configuration, ports et Ctrl+C correspondent à 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 — moteurs RAG / dev / partners / matrix / math-animator

pip install -e ".[rag-lightrag]"    # Built-in LightRAG engine (exact supported SDK)
pip install -e ".[graphrag]"        # Microsoft GraphRAG engine (Python 3.11–3.13)
pip install -e ".[dev]"             # tests/lint tools
pip install -e ".[partners]"        # Partner IM channel SDKs
pip install -e ".[video-learning]"  # compatibility extra; captions ship in the full/CLI installs
pip install -e ".[matrix]"          # Matrix channel without E2EE/libolm
pip install -e ".[matrix-e2e]"      # Matrix E2EE; requires libolm
pip install -e ".[math-animator]"   # Manim addon; requires LaTeX/ffmpeg/system libs

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 --dev 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 --dev

Option 3 — Docker · un conteneur autonome

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

ghcr.io/hkuds/deeptutor:latest — dernière version stable
ghcr.io/hkuds/deeptutor:<version> — version exacte sans le v initial (par exemple :1.6.3) ; les préversions ne reçoivent que leur tag de version

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

Pour choisir un dossier de contenu hôte au démarrage du conteneur, montez-le au chemin de conteneur stable et verrouillez DeepTutor sur ce chemin :

mkdir -p "$PWD/deeptutor-workspace/outputs"
docker run --rm --name deeptutor \
  -p 127.0.0.1:3782:3782 \
  -v deeptutor-data:/app/data \
  -v "$PWD/deeptutor-workspace:/workspace" \
  -e DEEPTUTOR_WORKSPACE_ROOT=/workspace \
  -e DEEPTUTOR_WORKSPACE_ALLOWED_ROOTS=/workspace \
  ghcr.io/hkuds/deeptutor:latest

Pour Compose, définissez DEEPTUTOR_WORKSPACE_HOST=/absolute/host/folder avant d'exécuter python scripts/docker_compose.py up -d. Si omis, ./data/user/workspace est utilisé. Les chemins Docker sont sélectionnés au démarrage et apparaissent donc verrouillés dans la page Paramètres Web.

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, le Content Workspace par défaut, la mémoire et les bases de connaissances persistent dans le volume deeptutor-data. Un Content Workspace monté séparément persiste à son chemin hôte à la place. Les extras optionnels appartiennent au déploiement, pas à un shell : définissez DEEPTUTOR_EXTRAS (et DEEPTUTOR_APT_PACKAGES pour les bibliothèques système) et chaque conteneur démarré à partir de celui-ci les réapplique, alors qu'un docker exec … pip install serait perdu au prochain compose down.

Ports hôte différents : modifiez le côté gauche de chaque correspondance -p host:container (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 les données d'exécution privées et le Content Workspace par défaut à travers les redémarrages ; un Content Workspace monté séparément persiste à son chemin hôte.

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

# Create a 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. Il propose toujours les sélecteurs Embedding et Search (choisissez Skip lorsque vous n'en avez pas besoin), écrit les principaux fichiers d'exécution (system.json, auth.json, integrations.json, interface.json, model_catalog.json, main.yaml, agents.yaml) et demande le fournisseur LLM actif et le modèle.

Commandes courantes

deeptutor chat                                          # interactive REPL
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 l'outil unique exec, puis de présenter le fichier d'espace de travail enregistré. Ces outils se montent dès qu'un backend sandbox est actif. DeepTutor sélectionne le backend configuré le plus robuste dans l'ordre suivant :

Sidecar runner : DEEPTUTOR_SANDBOX_RUNNER_URL achemine l'exécution vers le service durci et à moindres privilèges de Dockerfile.runner.
Linux bubblewrap : lorsqu'il est disponible, bwrap isole le processus et les fichiers.
Repli par sous-processus restreint : les installations locales et à conteneur unique ne l'utilisent que si cela est autorisé ; sous Docker, le conteneur reste une frontière supplémentaire.

Le paramètre sandbox_allow_subprocess de data/user/settings/system.json (par défaut true) ne contrôle que ce dernier repli. Définissez-le sur false (ou exportez DEEPTUTOR_SANDBOX_ALLOW_SUBPROCESS=0) pour refuser l'exécution par sous-processus lorsqu'aucun backend runner ou bwrap n'est disponible ; cela ne désactive pas ces backends plus robustes.

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 est l'éditeur recommandé ; les enregistrements des espaces de travail résident séparément dans data/user/.runtime/workspaces.sqlite3.

Fichier	Objectif
`model_catalog.json`	Connexions aux fournisseurs, profils LLM, tâche, embedding, recherche, TTS, STT, image et vidéo, identifiants et sélections actives
`system.json`	Ports backend/frontend, base d'API publique, CORS, vérification SSL, répertoire des pièces jointes et limites de téléversement/extraction
`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 et de sortie du modèle / thème / préférences de barre latérale
`document_parsing.json`	Choix du moteur d'analyse, points de terminaison distants et options propres à chaque moteur
`video_learning.json`	Fournisseur de lecture YouTube/Invidious par défaut, origines Invidious et adaptateur de transcription optionnel
`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

Les références de Web Search sont filtrées par défaut : seules les URL publiques http/https, sans identifiants intégrés ni ports inhabituels, sont affichées. Les déploiements peuvent ajouter une politique de domaines axée sur l'éducation dans data/user/settings/system.json :

{
  "web_search_source_filtering": {
    "enabled": true,
    "blocked_domains": ["spam.example"],
    "trusted_domains": ["edu.cn", "arxiv.org"]
  }
}

Lorsque trusted_domains n'est pas vide, les références sont limitées à ces domaines et à leurs sous-domaines ; blocked_domains prévaut toujours.

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.

Les profils LLM et de modèles de tâche proposent un paramètre de format API lorsque leur fournisseur permet un choix. Conservez Auto pour le routage normal et le repli, ou choisissez OpenAI Chat Completions, OpenAI Responses ou Anthropic Messages ; le mode Responses forcé continue d'échouer de manière fermée. Le champ persistant est api_format (auto, openai_chat, openai_responses ou anthropic) ; wire_api est un état de compatibilité dérivé. Les options de remplacement Auto / Supported / Not supported par modèle couvrent l'appel d'outils, l'entrée d'images, la sortie JSON et les contrôles de raisonnement.

Désinstallation et nettoyage

DeepTutor sépare son code installé, son répertoire d'exécution privé et son Content Workspace optionnel. Par défaut, le répertoire d'exécution est le répertoire dans lequel vous exécutez deeptutor init / deeptutor start ; --home PATH ou DEEPTUTOR_HOME le remplace. L'état privé de l'application est le répertoire data à l'intérieur de ce répertoire, donc la ligne de la bannière de démarrage commençant par Workspace: identifie cet emplacement d'exécution. Si Paramètres → Workspace pointe vers un autre dossier, sauvegardez ou supprimez ce dossier de contenu séparément ; il n'est volontairement pas effacé par la désinstallation de DeepTutor.

Arrêtez l'application. Appuyez sur Ctrl+C dans le terminal où s'exécute deeptutor start, ou lancez deeptutor stop [--home PATH] pour un lanceur démarré avec --detach ; arrêtez tout Partner en cours d'exécution ainsi que les conteneurs Docker détachés avant de supprimer des données.
Supprimez les données d'exécution uniquement si vous souhaitez également effacer tout l'état local. Cela comprend les paramètres et clés API, l'historique de chat, les sessions, Memory, Notebooks, Books, l'état de Reading, Skills, l'état de Partners, les journaux, Knowledge Bases, les caches d'analyse, les artefacts générés et le cache d'exécution du frontend packagé.

Commencez par copier le chemin Workspace: exact depuis la bannière de démarrage et vérifiez que son enfant data est bien le répertoire de données DeepTutor visé. Sauvegardez-le si son contenu peut encore être utile, puis déplacez ce répertoire exact vers la Corbeille de votre système d'exploitation. N'exécutez pas de commande de suppression récursive sur un chemin relatif ou une variable d'environnement non résolue.
Supprimez le paquet installé. Utilisez la commande correspondant à la distribution :
```
python -m pip uninstall deeptutor
python -m pip uninstall deeptutor-cli
```
Si l'environnement virtuel a été créé uniquement pour DeepTutor, supprimez-le avec votre gestionnaire d'environnements. Pour une installation depuis les sources, désactivez l'environnement, quittez le répertoire source et exécutez git status --short dans ce checkout exact. Ne déplacez le checkout vers la Corbeille qu'après avoir confirmé qu'il ne contient aucun travail sans rapport ou non commité.
Pour la voie Docker, inspectez le conteneur exact et le volume nommé avant de les supprimer. La suppression du volume efface définitivement les données gérées par Docker :
```
docker ps -a --filter name=^/deeptutor$
docker volume inspect deeptutor-data
docker rm -f deeptutor
docker volume rm deeptutor-data
```

📖 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.

Si une réponse perd une contrainte antérieure, cite des preuves faibles ou contredit les supports sélectionnés, rassemblez les diagnostics dans REASONING_SAFETY_CHECKLIST.md avant d'ouvrir une issue.

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

État des captures d'écran : la vue d'ensemble est à jour pour v1.6.5. Les captures de surface ci-dessous restent des références v1.4.6 pendant la mise à jour. Utilisez-les pour comprendre les parcours, pas comme navigation exacte actuelle.

🏗️ 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, zotero_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, kb_files, knowledge_frontier, read_source, read_memory, write_memory, read_skill, load_tools, exec, web_fetch, ask_user, list_notebook, write_note, question_bank, github, consult_subagent, workspace_list, workspace_read, workspace_search, workspace_present et workspace_export se montent automatiquement quand le tour dispose du bon contexte.

Le contexte se présente en deux types : le contexte de session persistant (capacité, espace de travail ou cours, outils, bases de connaissances, persona, modèle et état Reading / Mastery) persiste entre les tours ; les références ponctuelles (fichiers, historique de chat, livres, sections de lecture, carnets, banque de questions, agents importés) proviennent du menu + pour un seul tour. Le bouton vocal ne transcrit que le message en cours.

L'accueil garde Chat, Ask Questions, Quiz et Visualize accessibles en un clic ; Research pour les rapports cités, Solve pour le raisonnement guidé et Immersive Watching se trouvent sous Plus de Capacités. Apprentissage personnalisé regroupe Book, Mastery Path, Immersive Reading, Watching et Practice ; Reading ajoute des citations vérifiées, des notes enregistrées, des actions de lecture à voix haute / accompagnement d'étude / vocabulaire / quiz / traduction ancrées dans les sources, ainsi que la capture dans les carnets, tandis que Course Study conserve son contexte lié au cours.

🤝 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. Sa bibliothèque copie les bases de connaissances, les compétences et les carnets dans data/partners/<id>/workspace/, ou reste liée aux fichiers et aux ressources d'un espace de travail existant ; l'identité soul, les conversations et la mémoire Partner restent séparées. Les utilisateurs authentifiés non administrateurs conservent des sessions Partner et une mémoire relationnelle privées, tandis que le Partner consulte leur mémoire personnelle en lecture seule ; le trafic administrateur, de groupe et non lié utilise la portée Partner partagée.

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.

Pour une configuration plus rapide, la page de canal Partner peut créer une application Feishu/Lark ou un bot IA WeCom, ou connecter un compte WeChat personnel, à partir d'un scan QR dessiné dans le navigateur plutôt que dans le journal du serveur. Feishu/Lark détecte le domaine du compte et enregistre l'utilisateur qui scanne comme expéditeur autorisé initial. WeCom conserve une liste d'autorisation existante et, sinon, autorise par défaut tous les utilisateurs pouvant atteindre le bot, avec un avertissement visible d'accès ouvert ; les formulaires de canal manuels restent disponibles si le protocole de scan d'un fournisseur change.

🧑‍🚀 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 — Claude Code, Codex, Grok CLI, Antigravity, Kimi, opencode, MiMo Code, Hermes Agent, OpenClaw ou DeepSeek Harness sur votre machine, une passerelle Hermes distante, 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, ainsi que sa limite de rounds, avec la puce Agent, ou filtrez cette même liste d'agents connectés avec @ ; le choix reste associé à la session.

Connectez Grok CLI. Installez le Grok CLI de xAI sur la machine qui exécute le backend DeepTutor, exécutez-y grok login, puis vérifiez que grok --help liste bien --output-format streaming-json. Ouvrez ensuite My Agents → Connecter, sélectionnez Grok CLI, et choisissez un répertoire de travail. La détection vérifie la prise en charge du protocole par l'exécutable ; elle ne vérifie ni la connexion ni l'accès aux modèles. Le connecteur a été testé avec Grok CLI 1.0.3 ; les commandes tierces sans rapport portant elles aussi le nom grok ne sont pas prises en charge.

Dans Settings → Partners & agents → Grok CLI, laissez le modèle et l'effort de raisonnement vides pour utiliser les valeurs par défaut du CLI, ou saisissez des valeurs prises en charge par la sortie grok models de votre compte. Les instructions système sont transmises via --rules. Le mode de permission par défaut est dontAsk : Grok utilise ses règles existantes et sa gestion intégrée en lecture seule, et refuse les opérations nécessitant une approbation. Il s'agit d'une politique de permission du CLI, pas d'un sandbox du système de fichiers. Des modes plus larges peuvent être sélectionnés explicitement dans les paramètres ; les drapeaux CLI avancés restent disponibles via backends.grok.extra_args dans l'API de paramètres des sous-agents.

Grok utilise sa propre authentification et son propre stockage de session ; DeepTutor ne copie pas ses identifiants. Les consultations suivantes reprennent la session de la connexion dans le même répertoire de travail. Le texte et l'activité des outils sont diffusés en direct ; les charges utiles de pensée privées sont omises. La mémoire Grok inter-sessions est désactivée par défaut. Ce connecteur prend en charge les questions textuelles et les outils CLI, pas le transfert d'images ni l'import de conversations Grok passées. Sous Docker, installez et authentifiez Grok à l'intérieur du conteneur backend ; un CLI installé uniquement sur l'ordinateur du navigateur n'est pas accessible.

Consultation d'un sous-agent Claude Code en direct

Importez des conversations passées — apportez votre historique ChatGPT, Claude Code et Codex existant comme des conversations consultables et reprenables. Sélectionnez conversations.json depuis un export officiel de données ChatGPT pour un import d'instantané sûr et idempotent, choisissez l'historique Claude par projet / répertoire de travail, ou choisissez l'historique Codex par date du calendrier. Les agents basés sur un dossier restent actualisables afin que leur portée sélectionnée puisse récupérer de nouvelles conversations. Référencez-en une depuis un tour 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. Importez un .docx pour démarrer un brouillon, et exportez l'éditeur actuel en Markdown ou Word.

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 et conserve une trace de ses appels d'outils. Si le brouillon n'a pas changé pendant son travail, le résultat remplace directement le texte sélectionné et reste réversible avec Undo.

📖 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 modifiables — texte, encadrés, quiz, fiches, chronologies, code, figures, HTML interactif, animations, graphes de concepts, approfondissements et notes utilisateur — et chaque page dispose de son propre Chat de Page. Insérez, déplacez, régénérez, réécrivez ou changez le type d'un bloc ; les passages sélectionnés alimentent une boîte de réception de captures d'apprentissage à valider. La progression, les signets, les tentatives de quiz, les captures et le Chat de Page restent privés pour chaque lecteur, même lorsqu'un livre administrateur est partagé en lecture seule ou en édition collaborative ; la suppression d'un livre partagé reste réservée à l'administrateur. Tout livre s'exporte en Markdown, les compilations longues se mettent en pause et reprennent, et deeptutor book health / refresh-fingerprints signalent les sources qui ont divergé.

📚 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 hybride + BM25 avec reranking optionnel par cross-encoder et index FAISS exact-flat ou HNSW), PageIndex (récupération par raisonnement avec citations au niveau de la page, hébergé ou OSS auto-hébergé), 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), WeKnora (récupération depuis une base de connaissances de votre déploiement auto-hébergé, sans index local ni copie des documents), Tencent IMA (une bibliothèque que vous constituez dans IMA — interrogée, parcourue et mise à jour via son OpenAPI), MarginNote 4 (vos données d'étude MN4 — documents, extraits, fiches de carte mentale et les liens entre eux — poussées par l'Add-on de l'application et parcourues avec des outils dédiés), ou un vault Obsidian lié que le tuteur lit et écrit en place. Chaque KB est liée à un moteur.

Vous migrez une bibliothèque Obsidian, Hermes ou Markdown existante ? Consultez le guide de migration des connaissances pour les parcours de vault connecté et de copie indexée.

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). Une KB peut aussi suivre des dépôts GitHub (dépôt, branche, glob) ou des URL de sites de documentation (profondeur d'exploration et nombre de pages limités, resynchronisés toutes les 24 h par défaut) ; la synchronisation compare les empreintes pour détecter les contenus ajoutés, modifiés ou supprimés, afin que la documentation suivie reste à jour sans nouveau téléversement, et les dossiers liés récupèrent les fichiers locaux nouveaux ou modifiés lors de la synchronisation. 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, Tika, markitdown, PyMuPDF4LLM ou LiteParse — est choisie dans Paramètres → Connaissances & documents, avec les téléchargements de modèles locaux désactivés par défaut. Docling peut aussi fonctionner en mode distant contre un serveur Docling Serve (aucune installation ni modèle local nécessaire), configuré sur cette page (mode=remote, une URL de base de serveur, et une clé API optionnelle) ou les variables d'environnement DOCLING_MODE / DOCLING_API_BASE_URL / DOCLING_API_TOKEN. Tika est distant uniquement et pointe vers le serveur Apache Tika configuré sur cette page. La CLI reprend le cycle de vie avec list/info/create/add/search/set-default/delete, les commandes d'ajout et de suppression de sources, list-sources et sync.

Le moteur LightRAG intégré s'installe avec pip install 'deeptutor[rag-lightrag]'. Cet extra contient le SDK LightRAG pris en charge mais n'installe pas MinerU. Choisissez MinerU indépendamment dans Analyse de Documents et configurez son mode cloud ou installez sa CLI locale actuelle pour l'analyse structurée. MinerU accepte les PDF, les images raster courantes, les fichiers DOCX, PPTX et XLSX ; l'ancienne commande magic-pdf reste limitée aux PDF. Le mode texte seul et les autres moteurs d'analyse n'ont pas besoin de MinerU.

Les requêtes LightRAG natives et l'indexation incrémentielle nécessitent la configuration d'embedding enregistrée par l'index publié, incluant le modèle, la dimension et l'identité du point de terminaison. Si elle change, restaurez la configuration d'origine ou reconstruisez avec l'embedding actuel ; les index sans identité d'embedding enregistrée nécessitent une reconstruction. Les vues de détail de la base de connaissances et de version d'index affichent des conseils de récupération, tandis que les fichiers restent disponibles pour la consultation et le téléchargement.

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

Learning Space est la couche de bibliothèque, d'organisation et de personnalisation. Conversations & Matériaux contient Chat History, les carnets avec des enregistrements déplaçables et un export Markdown, ainsi qu'une banque de questions avec réponses et explications. Practice, dans Apprentissage personnalisé, transforme les questions enregistrées en séances de révision, en suivi des erreurs et en répétitions programmées. Personnalisation contient les personas, les compétences (livrets de jeu SKILL.md), les Services MCP connectables en un clic et les Applications CLI du catalogue CLI-Anything, chacune avec un guide d'utilisation chargé à la demande. L'espace de travail distinct My Courses regroupe les conversations par matière et les fils du tuteur ; chaque ressource n'est proposée que dans les flux de travail qui la prennent en charge.

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) avec des références aux entités L1 ; L3 est la synthèse inter-surfaces (L3/<profile|recent|scope|preferences>.md) qui consigne les surfaces L2 contributrices.

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 — avec des arêtes de preuve L2 → L1 exactes et des liens L3 → surfaces contributrices. 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 et s'ouvre sur Général, pour la langue de l'interface et de sortie du modèle. Sa navigation avec recherche mène à des pages indépendantes : Personnel couvre les espaces de travail, la migration des données, l'apparence et les statistiques d'utilisation ; Apprentissage & conversation couvre les suggestions de démarrage, les pièces jointes, Video Learning, les contrôles des apprenants et des responsables, Progression d'apprentissage, ainsi que Memory ; Modèles & services couvre les fournisseurs, les modèles de langage, les modèles de tâche, Embedding, la recherche, la voix et la génération multimodale ; Fonctionnalités & intégrations couvre les outils, les paramètres des capacités, Partners & agents et Connaissances & documents. Système contient Réseau, État d'exécution et À propos ; Conversations archivées permet de rechercher, restaurer ou supprimer définitivement les conversations archivées. État d'exécution contient la santé du backend, la mémoire résidente et la matrice Readiness, qui évalue les blocages, avertissements et suggestions pour les capacités. Les espaces de travail séparent les fichiers thématiques et l'état d'apprentissage ; Migration des données propose une migration vérifiée et un export. Un fournisseur conserve l'adresse et les identifiants d'un prestataire pour ses modèles de service ; les pages des modèles sélectionnent des fournisseurs enregistrés et configurent les noms et capacités des modèles. Les modèles de tâche réservent un petit modèle rapide au travail en arrière-plan — nommer les conversations et rédiger les suggestions de démarrage — et utilisent le modèle actif par défaut si le champ est vide. Voix regroupe la synthèse vocale et la transcription ; Génération multimodale regroupe les modèles d'image et de vidéo. Partners & agents configure les harnesses locaux et une passerelle Hermes distante.

Video Learning sous Paramètres → Apprentissage & conversation utilise par défaut le YouTube IFrame Player officiel avec protection renforcée de la confidentialité. Pour conserver la lecture locale, définissez l'origine de l'API Invidious gérée par l'administrateur (par exemple http://127.0.0.1:3000), testez-la, sélectionnez Invidious, puis enregistrez. Les vidéos nouvelles ou rouvertes adoptent immédiatement le fournisseur tout en conservant le même ID de support et la même progression. Les médias Invidious sont diffusés via le proxy byte-range de DeepTutor ; les URL en amont ne sont ni exposées au navigateur ni stockées sur disque. En cas de défaillance de l'instance, DeepTutor reste hors connexion à YouTube jusqu'à ce que l'apprenant choisisse explicitement la solution de repli YouTube native. Le tutorat basé sur les sous-titres publics est optionnel : installez .[video-learning] ; la lecture continue sans cet extra, tandis que la fonction Explain here basée sur les transcriptions est désactivée avec une explication.

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. Vous pouvez aussi simplement demander dans Chat : l'assistant lit la configuration actuelle, applique un changement, et indique s'il nécessite un redémarrage ou une réindexation — sondant un nouveau modèle avant de s'y engager, afin qu'il ne puisse jamais se basculer lui-même vers quelque chose d'inaccessible. Les clés API ne transitent jamais par le modèle, qui ouvre à la place le formulaire correspondant pour vous. 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.

OAuth OpenAI Codex (expérimental). Ajouter OpenAI Codex sous Paramètres → Fournisseurs ouvre une connexion dans le navigateur utilisant votre propre forfait ChatGPT, donc aucune OPENAI_API_KEY n'est nécessaire. Les jetons résident uniquement dans data/system/user-secrets/<owner>/private/openai-codex/ — dans le déploiement Compose multi-conteneurs, en dehors de tout arbre accessible au sandbox d'exécution — et DeepTutor ne lit ni ne modifie jamais votre connexion CLI ~/.codex. La liste des modèles provient du catalogue en direct de ce compte ; la connexion publie le profil, mais celui-ci ne devient le modèle actif que si aucun LLM n'est encore configuré. Comme un jeton autorise le forfait d'une seule personne, le profil n'est pas partageable par les attributions utilisateur : chaque compte se connecte pour lui-même, utilisateurs ordinaires compris. Leur carte de connexion se trouve sous Fournisseurs, et les modèles, le catalogue et la déconnexion qui en résultent restent privés à ce compte.

À la connexion et lors d'un Actualiser les modèles, DeepTutor lit la dernière version stable de @openai/codex depuis le registre npm officiel et l'utilise comme client_version de la requête de catalogue. Il s'agit uniquement de métadonnées : cela n'installe, ne télécharge ni ne met à jour le CLI Codex, et la requête npm ne transporte aucun identifiant OAuth. La découverte dispose d'un délai de trois secondes et d'une limite de réponse de 64 Kio. En cas d'échec, DeepTutor utilise la dernière version réussie pour ce compte, ou son repli intégré si aucune n'est mise en cache. Seul un catalogue en direct correctement analysé enregistre une nouvelle version ; les validateurs ne sont jamais réutilisés entre versions ou générations d'identifiants. Un rejet de version ou une structure de catalogue incompatible autorise une nouvelle tentative avec la version précédente ; les échecs d'authentification, de limitation de débit et TLS ne sont pas retentés comme des problèmes de version. Une actualisation manuelle en échec signale une erreur plutôt que de présenter un ancien catalogue mis en cache comme actualisé.

L'historique des versions réussies survit au renouvellement de jeton du même compte et aux erreurs d'authentification du catalogue, sans rendre à nouveau utilisables les données de modèle ou les ETags invalidés. La déconnexion efface le cache local de ce compte, y compris l'historique des versions. Les lectures d'état ordinaires et l'inférence n'interrogent pas npm. Les nouvelles entrées du catalogue ne remplacent pas un modèle déjà sélectionné ni ne redémarrent les sessions d'apprentissage ; figurer dans le catalogue n'établit pas une compatibilité complète du protocole d'inférence. Il n'existe pas de mise à jour de version en arrière-plan ni de paramètre de version utilisateur.

Les déploiements locaux par défaut Docker et Podman utilisent des réseaux loopback séparés et nécessitent un pont temporaire pendant la connexion. Suivez le guide du pont OAuth Codex local temporaire pour les commandes exactes de Docker, Compose, Podman et d'arrêt.

Pour un déploiement distant, le localhost du navigateur et le localhost du serveur sont deux machines différentes, donc un simple proxy inverse ne peut pas à lui seul acheminer le callback localhost du navigateur jusqu'au serveur. Utilisez un tunnel SSH comme pont de callback. Le tunnel atteint le port Web déjà publié ; Next.js ne réécrit que le chemin de callback exact vers le courtier de callback public, et ce courtier valide state avant de router vers l'opération OAuth d'origine. L'écouteur de callback reste sur le loopback du backend, les ports 1455 et 1457 ne sont pas publiés, et ce chemin prend en charge le réseau bridge Docker par défaut.

ssh -N -L 1455:127.0.0.1:3782 <ssh-user>@<server-host>

Si DeepTutor signale le port de callback de repli 1457, utilisez :

ssh -N -L 1457:127.0.0.1:3782 <ssh-user>@<server-host>

N'exécutez que la seule commande correspondant au port de callback réel ; n'exécutez jamais les deux. 3782 n'est que le port Web d'exemple : c'est le port frontend/conteneur configuré, rapporté comme callback_forward_port. Cette valeur ne garantit pas que ce même port écoute sur le 127.0.0.1 de l'hôte SSH. Si Docker ou Podman publie un port hôte différent, ou si un proxy inverse écoute sur un port différent, remplacez uniquement le port cible de droite (3782 ci-dessus) par le port Web réellement à l'écoute sur le 127.0.0.1 de l'hôte SSH ; conservez le port de callback de gauche à 1455 ou 1457. <server-host> est l'hôte SSH dont le loopback possède ce port à l'écoute. Si l'URL du navigateur nomme un proxy inverse ou un répartiteur de charge, remplacez-la par l'hôte frontend SSH correct.

La CLI affiche la commande de tunnel puis tente immédiatement d'ouvrir le navigateur. Sur un déploiement distant, laissez la page d'autorisation ouverte sans la terminer, établissez le tunnel affiché dans un autre terminal, et ne poursuivez l'autorisation qu'ensuite.

La détection de topologie distante a une limite liée à localhost. Si l'application Web elle-même est atteinte via un transfert localhost SSH ou IDE, le navigateur ne peut pas savoir que le serveur est distant. Pour l'opération Web en cours, laissez sa page d'autorisation inachevée, lisez redirect_uri dans l'URL d'autorisation de cette opération pour identifier le port de callback 1455 ou 1457, puis créez le second tunnel de ce port local vers le port Web réel. Autre possibilité : annulez cette opération Web et démarrez-en une nouvelle avec la CLI ; la sortie de la CLI appartient à la nouvelle opération et ne doit pas être utilisée pour l'opération Web existante. Les erreurs de quota et les échecs de catalogue sont rapportés tels quels et ne basculent jamais vers un fournisseur payant. Ce chemin de compatibilité est expérimental : l'interface en amont peut changer.

👥 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/                    # Admin workspace + global settings
├── users/<uid>/             # Per-user scope: chat history, memory, notebooks, KBs
├── partners/<id>/workspace/ # Partner (synthetic-user) scope
├── cli-apps/                # Installed CLI apps, mounted read-only into the sandbox
└── system/                  # auth · grants · audit · user-secrets/<owner> (OAuth tokens)

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, les livres partagés de référence et les attributions per-utilisateur. Les utilisateurs locaux créés par l'administrateur choisissent Standard, Learner ou Custom. Learner verrouille les capacités d'apprentissage et la politique des supports, ajoute un profil adaptatif et prend en charge des identifiants d'appareil révocables avec expiration et limites quotidiennes ; les guardians autorisés peuvent consulter les rapports, approuver des supports et réinitialiser les identifiants. Les autres utilisateurs obtiennent des espaces de travail isolés ainsi qu'un accès à portée limitée aux modèles, KB, compétences, Partners et livres partagés sans recevoir de clés API brutes. Si auth.json contient déjà un username + password_hash, ce compte est l'admin : /register reste fermé et les comptes créés depuis /admin/users ont toujours role=user jusqu'à leur promotion.

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/applications CLI et accès à l'exécution de code via des attributions ; configurez les livres partagés dans le panneau Book access de chaque utilisateur.

Pour des origines privées/publiques séparées, définissez auth.private_login_hosts (ou AUTH_PRIVATE_LOGIN_HOSTS) avec les hôtes frontend privés autorisés à afficher la connexion par mot de passe et l'inscription. Le frontend transmet le Host HTTP entrant au backend comme son assertion d'hôte frontend. Préservez le Host du navigateur à travers votre proxy inverse, et faites en sorte que l'entrée publique rejette les requêtes désignant un hôte privé ; n'exposez pas un port Next.js brut qui accepte des valeurs Host arbitraires. Le Host HTTP peut être forgé par un client direct, donc l'autorisation des hôtes privés dépend de cette frontière d'entrée. Le backend n'accepte les assertions d'hôte frontend que depuis le loopback par défaut. Si le frontend Web se connecte depuis un autre conteneur ou un autre hôte, définissez AUTH_TRUSTED_FRONTEND_PROXY_IPS avec l'adresse IP exacte de ce proxy frontend sur le processus backend (séparées par des virgules s'il y en a plusieurs). Gardez l'API backend privée au proxy frontend et n'incluez pas de réseaux clients généraux dans cette liste. Le loopback est toujours autorisé ; lorsque la liste n'est pas vide, un utilisateur authentifié sur une origine privée peut ouvrir Profil → Connexion d'appareil public et créer un lien d'appairage à courte durée de vie, lié à l'hôte, pour une origine publique HTTPS. La page publique /handoff échange le code à usage unique contre un ticket JWE tout aussi court dans un corps POST, consomme le ticket une seule fois, et reçoit le cookie de session HttpOnly normal.

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 et sélectionne un mode avec --capability ; deeptutor run <capability> "<message>" prend cette capacité comme premier argument positionnel et quitte après un tour. Les deux acceptent --tool, --kb, --config et --workspace pour sélectionner un espace de travail enregistré.

deeptutor chat                                              # interactive REPL
deeptutor chat --capability deep_solve --kb my-kb --tool rag
deeptutor run chat "Explain the Fourier transform" --tool rag --kb textbook
deeptutor run chat "Find recent work beyond this material" --kb textbook --tool knowledge_frontier
deeptutor run deep_research "Survey 2026 papers on RAG" \
  --config mode=report --config depth=standard

Les principales opérations de gestion de l'espace de travail sont également disponibles ici — bases de connaissances (kb), sessions (session), partners (partner), compétences (skill), carnets, mémoire et configuration ; l'organisation des cours et des sessions reste dans l'application Web. 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.

# One shot, machine-readable
deeptutor run deep_solve "Find d/dx[sin(x^2)]" --tool reason --format json

# Chain turns in one stateful session — capture the id, reuse it
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 ~200 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` dans le répertoire d'exécution actuel
`deeptutor doctor [--online]`	Vérifier si l'environnement d'exécution est prêt à démarrer une session ; `--online` sonde aussi le fournisseur de modèle configuré, `--format json` affiche le rapport
`deeptutor start [--home PATH] [--dev] [--detach] [--no-browser]`	Lancer le backend + frontend ensemble ; éventuellement détacher le processus ou empêcher l'ouverture du navigateur
`deeptutor stop [--home PATH]`	Arrêter un lanceur démarré avec `--detach`
`deeptutor serve [--port PORT]`	Démarrer uniquement le backend FastAPI
`deeptutor workspace show/set/reset`	Inspecter, sélectionner ou restaurer le Content Workspace par utilisateur
`deeptutor run <capability> <message>`	Exécuter un seul tour de capacité (`chat`, `ask_questions`, `deep_solve`, `deep_question`, `deep_research`, `visualize`, `math_animator`, `mastery_path`, `immersive_reading`, `course_study`, `immersive_watching`, `audio_overview`) ; 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/list-sources/sync`	Gérer les bases de connaissances et synchroniser les sources GitHub/web enregistrées (avec les commandes d'ajout et de suppression de sources)
`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 <provider>`	Authentification du fournisseur (`openai-codex` via OAuth ; `github-copilot` valide une session d'authentification Copilot existante ; `codebuddy` valide l'authentification du SDK CodeBuddy et lance la connexion si nécessaire)

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"               # search EduHub (the default hub)
deeptutor skill install socratic-tutor                # fetch → verify → register
deeptutor skill install eduhub:socratic-tutor@1.2.0   # pin a hub and a version
deeptutor skill list                                  # local skills with their hub provenance

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

deeptutor skill login                                 # browser sign-in to EduHub
deeptutor skill publish ./my-skill                    # interactive: pick a track + tags, then upload
deeptutor skill update                                # roll back or release a new 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 de manière défensive avec des contrôles de traversée de chemin, de nombre d'entrées, de taille, de taux de compression, de suffixe et de lien symbolique ; les bits exécutables sont supprimés, tandis que les fichiers sans extension restent autorisés ;
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, les importations depuis le navigateur arrivent dans la couche de compétences de l'appelant authentifié, tandis que les installations via la CLI et la console d'administration ciblent l'espace de travail du propriétaire/administrateur ; les compétences administrateur restent masquées et en lecture seule pour les utilisateurs ordinaires jusqu'à leur attribution.

É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
deeptutor skill install clawhub:udiedrichsen/stock-analysis

Quand plusieurs éditeurs partagent le même slug, la recherche affiche chaque éditeur et une référence d'installation entièrement qualifiée (clawhub:<ownerHandle>/<slug>).

Ajoutez d'autres registres dans data/user/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.

🤝 Partenaires Open Source

Avec le code : DEEPTUTOR20 — obtenez 20 $ de réduction sur votre premier abonnement PageIndex !

🌐 Communauté

🔗 Mainteneurs

Bingxi Zhao

Xingyu Hou

Jiahao Zhang

📮 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é. 🎁

Sous licence Apache License 2.0.

FilesExpand file tree

README_FR.md

Latest commit

History