Vibeleaderboard
Index / app
Visit github.com
Category
AI Agents
Pricing
Open Source
Type
APP
Builder
hkuds
Latest release
v1.6.5
Date

About

Agent-native personalized learning assistant that combines unified chat workspace, autonomous TutorBots, AI co-writing, and guided learning paths. Features persistent memory and knowledge bases to create adaptive, context-aware tutoring experiences.

What it does

DeepTutor is a self-hosted tutoring system you run yourself. A Python backend serves an API and a Next.js web app, and a separate command line front end drives the same engine. Work is split into named capabilities: chat, step-by-step solving, question generation, deep research, visualization, a math animation renderer, and a mastery path. Documents you upload become searchable knowledge bases the tutor retrieves from while answering. It can also call external tool servers over the Model Context Protocol, and answer through chat channels such as Telegram, Slack and Matrix.

Why it's ranked here

Breadth here is genuine, and so is the weight that comes with it. A plain install already pulls an API server, vector search, PDF handling, several model provider SDKs and a database client, and the supported Python range is capped below 3.14 because compiled wheels break above it. Against that, the pinning is unusually well reasoned: many version bounds carry a comment naming the exact failure they prevent, with issue numbers. Judge it as a learning platform you operate, not a library you drop into an existing app.

What's good

Operational care shows in small places. Optional engines import lazily and degrade instead of crashing: vector search falls back to a brute force store when the accelerated backend is absent, and the memory probe falls back to reading kernel process files. The container drops both the backend and frontend processes to an unprivileged user with a fixed numeric id. Startup refuses to boot when a capability manifest names a tool the registry does not have. Chat history import reads folders in the browser, so those transcripts never transit the server.

Tradeoffs

Authentication is off by default, and in that mode the API accepts any origin through a wildcard pattern. Tightening it means enabling auth and listing origins explicitly. The subprocess sandbox that runs generated code is also on by default; the compose setup diverts execution to a hardened runner, a plain container build does not. Building the image compiles from source: it installs a Rust toolchain, build tooling and graphics libraries, and keeps a git client in the production stage so the tutor can install command line apps at runtime.

How to use it well

Pick this if you want a private study stack over your own documents, with your own model keys, and you are comfortable running containers plus an optional database sidecar. It pays off when the material is yours: course notes, papers, question banks you want retrieved and quizzed against. It is not a coding assistant, though it can consult external agent command line tools you already have. It also does not replace a course management system: enrolment, grading records and institutional reporting sit outside what it handles.

Technical notes+

pyproject.toml declares Apache-2.0, caps the interpreter at >=3.11,<3.14 with a comment blaming missing 3.14 wheels for compiled base deps, and exposes one console script pointing at deeptutor_cli/main.py. Core dependencies already include the API server, LlamaIndex with BM25 and FAISS, PyMuPDF, several provider SDKs and an MCP client; heavier engines sit in extras (partners, matrix, math-animator, graphrag, rag-lightrag, parse-markitdown/docling/pymupdf4llm/liteparse, dev, all), mirrored for container builds by requirements.txt, requirements/cli.txt and requirements/server.txt. deeptutor/api/main.py builds the FastAPI app with a lifespan that starts an event bus, partner manager and cron service, validates capability manifests against the tool registry, and computes CORS: when auth is disabled it sets an allow_origin_regex of https?://.* rather than an explicit list. deeptutor_cli/main.py is a Typer tree (partner, chat, kb, skill, memory, plugin, config, session, notebook, provider, book) plus a generic capability runner and start/serve commands; deeptutor/__main__.py and deeptutor_cli/__main__.py both delegate to it. Dockerfile is three stages, node:22-slim for the frontend and python:3.11-slim for runtime, with supervisord running backend and frontend as UID 1000. web/lib/chat-import/index.ts scans and parses Claude Code or Codex session folders client side through the File System Access API. .env.example only maps host ports; in-container ports come from runtime settings.

Observed

License
Apache-2.0, declared in pyproject.toml
Runtime
Python backend restricted to 3.11 through 3.13, with a Next.js web frontend
Interfaces
Typer command line app, HTTP and WebSocket API, browser UI, and an MCP client
Install surface
pip package with extras for server, partners, matrix, math animation, GraphRAG, LightRAG, parsing engines and dev tooling
Deployment
Multi-stage Dockerfile; supervisord runs backend and frontend as a non-root user with UID 1000
Retrieval
LlamaIndex with BM25 and a FAISS vector store by default, GraphRAG and LightRAG as opt-in engines
Auth default
Authentication disabled out of the box; that mode also enables a wildcard CORS origin regex
Chat channels
Partner extra bundles Telegram, Slack, Lark, DingTalk, WeCom, QQ and Zulip SDKs; Matrix is a separate extra

Read from README.md, pyproject.toml, requirements.txt, requirements/cli.txt, requirements/server.txt, Dockerfile, .env.example, deeptutor/__main__.py, deeptutor/api/main.py, deeptutor_cli/main.py, deeptutor_cli/__main__.py, web/i18n/index.ts, web/lib/chat-import/index.ts, web/locales/en/app.json.

What it can do

  • Create personalized learning paths

    User learning goals and current knowledge levelStructured sequence of learning materials and exercises

  • Provide autonomous tutoring sessions

    Student questions and learning topicInteractive explanations and guided problem-solving

  • Co-write educational content with AI assistance

    Partial text or writing prompts from userCompleted essays, reports, or study materials

  • Maintain persistent learning context across sessions

    Previous conversations and learning historyContextually relevant responses based on past interactions

  • Adapt tutoring approach based on student performance

    Student responses and progress dataModified difficulty level and teaching strategies

  • Manage unified chat workspace with multiple learning modes

    User requests for different types of learning supportSwitched interface modes for specific learning activities

Tags

ai-tutorpersonalized-learningmulti-agentrageducational-aiautonomous-agentsknowledge-base

Tech Stack

PythonDocker

Comments (0)

No comments yet

Editorially curated, with community endorsements as a secondary signal. Corrections welcome.