DeepTutor: The AI Assistant That Personalizes Learning with Agents

What if your next private tutor was an AI that adapts to your pace, generates personalized quizzes from your own course materials, and solves complex problems step by step with precise citations? That is the promise behind DeepTutor, an open-source learning assistant developed by the University of Hong Kong's Data Intelligence Lab (HKUDS). First released in December 2025 and completely rewritten for version 1.0 in April 2026, the project has already crossed 17,000 GitHub stars. Here is why DeepTutor could reshape how you learn.

DeepTutor is a personalized learning assistant built on a multi-agent architecture. The concept is straightforward: you upload your documents (textbooks, research papers, lecture notes, technical manuals) and the tool builds an intelligent knowledge base from which a team of AI agents collaborates to support your learning journey.

Unlike a simple chatbot that answers questions, DeepTutor offers five unified modes sharing a single conversation thread. You can start with a freeform discussion (Chat), escalate to multi-agent problem solving (Deep Solve), generate quizzes from your uploaded documents (Quiz Generation), launch an in-depth investigation on a topic (Deep Research), or create visual mathematical animations (Math Animator). Context carries across every mode switch.

The tool is fully open source under the Apache 2.0 license, self-hostable, and supports over 30 LLM providers: OpenAI, Anthropic, DeepSeek, Gemini, Groq, Mistral, Ollama, and many others. Your data stays on your machine.

DeepTutor was born inside the HKU Data Intelligence Lab (HKUDS), a research group at the University of Hong Kong led by Chao Huang. The team interviewed numerous students and identified a recurring frustration: existing learning tools were fragmented. One tool for flashcards, another for summaries, yet another for quizzes, and none of them shared context or truly adapted to the learner's progress.

The first open-source version was published in late December 2025. Within five days, the project had crossed 1,400 GitHub stars.

Three months later, in April 2026, the team released version 1.0, a complete ground-up rewrite spanning roughly 200,000 lines of code. This new version introduced TutorBots, the Math Animator mode, the Co-Writer, and a full CLI interface. The project then crossed the 17,000-star mark with 2,200 forks.

What sets DeepTutor apart from conventional educational chatbots is its dual-loop multi-agent architecture. The system separates the investigation process from the solving process, enabling deeper analysis and more accurate solutions than single-turn AI tutors.

The Analysis Loop involves two agents. The InvestigateAgent explores the question by querying the knowledge base (RAG), the web, and academic paper databases. The NoteAgent compiles and structures the discovered information into actionable notes.

The Solve Loop deploys four agents. The PlanAgent develops a resolution strategy. The ManagerAgent coordinates execution. The SolveAgent applies the plan step by step. The CheckAgent verifies the consistency and accuracy of the final result.

This dual-loop architecture is complemented by a two-layer plugin system. The first layer provides 7 tools: knowledge base retrieval (RAG), web search, code execution, deep reasoning, brainstorming, academic paper search, and GeoGebra visualization. The second layer defines 5 capabilities, which are multi-agent pipelines combining several tools: Chat, Deep Solve, Deep Question (quiz generation), Deep Research, and Math Animator.

DeepTutor offers five modes that all share the same conversation context, letting you switch between them without losing any information.

Chat is the standard conversation mode, enhanced by tools. The assistant can query your knowledge base, run web searches, execute code, or activate deep reasoning to answer your questions. Every response cites its sources precisely.

Deep Solve is the multi-agent problem-solving mode. You pose a complex problem (mathematics, physics, programming) and the system activates the dual analysis/solve loop. The result is a detailed, step-by-step solution with explicit reasoning and source citations.

Quiz Generation (Deep Question) creates assessments directly from your uploaded documents. The system generates questions at adapted difficulty levels, with a tracking mechanism to prevent duplicates and offer follow-up questions when you answer incorrectly.

Deep Research decomposes a topic into subtopics, launches parallel research agents across the web, academic databases, and your local documents, then produces a structured, fully cited report.

Math Animator uses Manim (the mathematical animation library made famous by 3Blue1Brown) to create visual animations explaining mathematical concepts. Version 1.0.1 added a Chart.js/SVG visualization pipeline for interactive charts and diagrams.

TutorBots are one of DeepTutor v1.0's most distinctive innovations. These are not chatbots: they are autonomous tutors, each with its own workspace, memory, personality, and skill set.

Each TutorBot is configured through a "soul file" that defines its personality, teaching style, and domain of expertise. A TutorBot can be a patient, Socratic math professor, a direct and pragmatic programming coach, or a rigorous academic research mentor.

TutorBots have independent persistent memory. They remember what you have studied, your strengths, and your gaps. They can even send proactive reminders through a "heartbeat" system that keeps them alive beyond conversation sessions. TutorBots integrate with 12 messaging platforms, including Discord, Telegram, and WeChat.

DeepTutor offers four installation methods suited to different user profiles. The project requires Python 3.11+ and Node.js 16+.

Option A: The Setup Tour (recommended). An interactive assistant walks you through configuration with live connection testing:

git clone https://github.com/HKUDS/DeepTutor.git
cd DeepTutor
conda create -n deeptutor python=3.11 && conda activate deeptutor
python scripts/start_tour.py

Option B: Manual local install. For those who prefer full control:

pip install -e ".[server]"
cd web && npm install && cd ..
cp .env.example .env
python -m deeptutor.api.run_server
cd web && npm run dev -- -p 3782

Option C: Docker. The simplest method for quick deployment, supporting both amd64 and arm64:

docker compose -f docker-compose.ghcr.yml up -d

Option D: CLI only. For a browser-free experience:

pip install -e ".[cli]"
deeptutor chat
deeptutor run deep_solve "Solve the integral of x²sin(x)"

LLM configuration uses a .env file where you set your provider (LLM_BINDING), model (LLM_MODEL), and API key. DeepTutor supports 30+ providers, from OpenAI to Ollama for fully local operation.

One of DeepTutor's strongest advantages is its compatibility with a very broad range of LLM and embedding providers.

This flexibility lets you run DeepTutor with local models via Ollama for total privacy, or with the most powerful models from OpenAI and Anthropic for maximum performance. Web search is also configurable, with Brave recommended thanks to its generous free tier.

The AI tutoring market has matured significantly in 2026. Here is how DeepTutor stacks up against the most popular alternatives.

Khanmigo excels at Socratic guided tutoring within Khan Academy's structured curriculum. It never gives direct answers but guides you with questions. However, it is proprietary, paid ($4/month), and does not support custom document upload or agent customization.

NotebookLM from Google excels at multi-source synthesis. You upload up to 50 documents and the AI responds exclusively from those sources with precise citations. Its signature Audio Overview feature generates podcast-style audio from your materials. But it offers no multi-agent solving, no adaptive quizzes, and no autonomous TutorBots.

The Knowledge Hub is DeepTutor's foundation. You upload your documents (PDFs, Markdown, text files) and the tool transforms them into a RAG-ready (Retrieval-Augmented Generation) knowledge base. Documents are indexed with vector embeddings, enabling precise semantic search rather than simple keyword matching.

You can organize your knowledge into color-coded notebooks, each dedicated to a subject or course. AI-generated insights and notes are automatically filed into the appropriate notebook. The system supports multiple embedding providers: OpenAI, DashScope, Ollama, SiliconFlow, and vLLM, with configurable vector dimensions (for example, 3072 for text-embedding-3-large).

DeepTutor maintains a "living profile" for each learner. This profile records what you have studied, topics you have mastered, identified gaps, and your learning preferences. Every feature (Chat, Deep Solve, Quiz, Research) continuously feeds this profile.

This persistent memory is stored locally in a SQLite database. It survives restarts and lets the AI pick up exactly where you left off, even after days away. This is what separates DeepTutor from a simple chatbot: the assistant genuinely remembers your journey.

Data persistence is handled through Docker volumes: ./data/user for user settings, memory, sessions, and logs, and ./data/knowledge_bases for uploaded documents and vector indices.

DeepTutor supports two document processing backends: Docling and MinerU. Both handle PDF extraction with layout-awareness, meaning they correctly parse multi-column layouts, tables, figures, and mathematical formulas. The extracted content is then chunked, embedded, and stored in the vector index for semantic retrieval.

The hybrid retrieval system combines vector similarity search with traditional keyword matching, ensuring that both conceptual queries ("explain the relationship between entropy and information") and specific lookups ("what does equation 3.7 state") return accurate results. Every answer from the AI includes precise citations pointing back to the exact source document and page.

DeepTutor is fully controllable from the command line, an approach that makes it accessible to both humans and AI agents. The CLI provides rich terminal rendering for human users and structured JSON output for automated integrations.

Knowledge base management, sessions, memory, and TutorBots are all managed through the CLI. Every command can produce structured JSON output, which means you can integrate DeepTutor into automation pipelines or use it as a tool for other AI agents. For example, a CI/CD pipeline could automatically generate quizzes from updated documentation, or a research agent could use Deep Research to compile literature reviews.

deeptutor chat                                    # Interactive REPL
deeptutor run chat "Explain the Fourier transform"
deeptutor run deep_solve "Solve this equation"
deeptutor kb create my-kb --doc textbook.pdf       # Create knowledge base
deeptutor kb list                                  # List knowledge bases
deeptutor memory show                              # View learning profile

The CLI also supports one-shot mode, where you can run a single command and get a complete answer without entering an interactive session. This is particularly useful for scripting and batch operations, or when you need a quick answer without launching the full web interface.

TutorBots are not limited to the DeepTutor web interface. They can be deployed across 12 messaging platforms, including Discord, Telegram, WeChat, Slack, and more. Each deployed TutorBot maintains its personality, memory, and skill set regardless of the platform. A student could interact with their math TutorBot on Discord during study sessions and switch to Telegram for quick questions on the go, with the TutorBot remembering the full conversation history across both platforms.

The TutorBot framework is built on the nanobot architecture, which provides lightweight, event-driven agent execution. Each TutorBot runs as an independent process with its own event loop, memory store, and tool access. The heartbeat system periodically checks for scheduled reminders, upcoming deadlines, or learning milestones, proactively reaching out to the student without waiting for them to initiate a conversation.

Despite its strengths, DeepTutor has several limitations worth knowing.

Installation complexity is the first barrier. Unlike NotebookLM or Khanmigo which are ready-to-use web services, DeepTutor requires a local setup with Python, Node.js, and LLM provider configuration. The Docker option simplifies the process but remains more technical than a SaaS service.

LLM API costs can add up. While the tool itself is free, using models like GPT-4o or Claude via API generates variable costs. The alternative is running local models through Ollama, but that requires significant hardware (GPU recommended).

Project maturity means some instability. Version 1.0 shipped in April 2026 and the API is evolving rapidly. Configurations and formats may change between minor releases.

Multimodal support is currently limited to text documents (PDF, Markdown, plain text). Direct upload of images, videos, or audio files to enrich the knowledge base is not yet available, though the community has requested it.

Beyond the five main modes, DeepTutor includes two complementary features that enrich the learning experience.

The Co-Writer is a Markdown editor where AI is a first-class collaborator. You select a text passage and the AI can rewrite, expand, or summarize it by drawing from your knowledge base and the web. It is particularly useful for writing theses, research reports, or synthesis notes.

The Guided Learning feature generates structured, visual learning paths from your documents. Each knowledge point is presented on an interactive HTML page with contextual explanations and comprehension questions. It is the feature that transforms a plain course PDF into a genuine interactive learning journey.

DeepTutor fills a real gap in the AI-assisted learning ecosystem. Where most AI tutors are simply chatbots connected to an LLM, DeepTutor offers a complete multi-agent architecture with persistent memory, TutorBot personalization, and five interaction modes sharing the same context.

The ideal user profile is a university student, researcher, or professional in continuing education working with dense technical documents who needs structured, adaptive support. If you are simply looking for a chatbot to answer general questions, alternatives like ChatGPT or Khanmigo are more accessible.

For B2B teams and SaaS companies that invest heavily in onboarding and training, DeepTutor also opens an interesting door. Imagine uploading your entire product documentation, API references, and internal knowledge base, then letting new hires interact with a personalized TutorBot that guides them through your stack at their own pace. The combination of persistent memory, adaptive quizzes, and multi-agent problem solving makes DeepTutor far more than a study tool. It is a platform for building intelligent, context-aware learning experiences on top of any document corpus.

With 17,000 GitHub stars, an Apache 2.0 license, support for 30+ LLM providers, and a unique multi-agent architecture, DeepTutor stands as the most ambitious open-source AI tutor of 2026. The project illustrates a deeper trend: personalized learning through autonomous agents is no longer science fiction but a pip install away.