DeepTutor, taken apart: its core trick fits in one skill, so why did 54,000 people star the platform around it?
---
title: DeepTutor, taken apart: its core trick fits in one skill, so why did 54,000 people star the platform around it?
published: true
date: 2026-11-03 06:49:00 UTC
cover_image: dev-to-uploads.s3.us-east-2.amazonaws.com
tags:
canonical_url: blog.go5.si
---
An open-source AI tutor out of the University of Hong Kong had 1,369 stars four days after its repository was created. Ten months later it is at nearly 54,000, and more than 5,000 of those arrived in the last four days alone. On October 28 I installed its v1.7.0 release and took it apart. Before the write-up was finished, v1.7.1 landed on October 31.
This is a long one, and the verdict needs the length to be fair. Here it is up front: DeepTutor’s core, a structured record of what you got wrong and a loop that quizzes you from it, is the team’s own engineering. It is also, in 2026, the one part of the product a single agent skill can copy. What a skill cannot copy is everything built around that core, and the 54,000 stars are mostly for the surroundings: a platform, a delivery shape for people who do not live in a terminal, and a lab that knows how to launch. If you are a technical user studying alone, you may need none of it. That distinction is the whole piece.
!A robot tutor proudly hugs an enormous ledger of graded papers covered in red crosses and green ticks, while the student stares, and three little memory clouds shrug above them
The honest baseline: what a chat box already remembers
Any serious test of a tutor’s memory has to start with what the ordinary chat box does today, because it does more than it did two years ago. Inside one conversation, the model sees what you said earlier in that same conversation. That part was never in doubt.
Across conversations, the big platforms have all added a memory layer of their own. ChatGPT keeps saved memories, facts it stores about you, and on top of that it can reference your past chat history when it answers. Claude’s memory is on by default on its consumer plans and stores what it learns as topic files you can open, read and edit. Gemini has a Memory setting that learns from your past chats. The fine print differs by vendor: Claude leaves sensitive topics out by default, and Gemini’s version only learns when Keep Activity is on. So the picture of the chat tutor as a goldfish that forgets you between sessions does not survive contact with 2026.
What that memory is not, though, matters just as much. OpenAI’s own help page puts it plainly: memory does not retain every detail from every conversation, and ChatGPT decides which available information is relevant. What the platforms keep is the kind of thing a good assistant keeps: your preferences, your projects, the level you are roughly at. A study record is finer than that. It is not “this person is weak at physics.” It is: on these dates you attempted these problems, you dropped the sign in the lens formula twice and mixed up image distance once, and last Tuesday you finally got three of that type right in a row. A quiz engine can compute with a record like that. A paragraph of preferences cannot drive it, because the individual events were never written down anywhere.
The core: a record a quiz can compute with
DeepTutor, from the DeepTutor team at the University of Hong Kong’s data science institute, builds that fine-grained record on your own machine. The record has three layers. The bottom layer keeps the raw record of every interaction, append-only, never rewritten, the way an accountant keeps the original receipts. The middle layer distills those records into facts about you, which concepts you keep mixing up, which problem types keep tripping you, each fact pinned to the interactions it came from, so a wrong conclusion can be traced back and removed. The top layer pulls those facts together into one learner profile.
!How DeepTutor works: it keeps a structured record of what you got wrong, quizzes you from that record, and spaces the review by knowledge type
On top of the record sits a working loop. When you ask it to work a problem, it classifies what kind of problem it is, works it, and checks its own result before showing you. Then it turns around and quizzes you, pitched near your current level, and the wrong concept in your answer gets written back into the record, which shapes what it asks next time. A scheduler decides when old material comes back for review, with different spacing for different kinds of knowledge. Solve, quiz, write it down, resurface it later. That loop, running on that record, is the core of the product, and it is the part most chat tutors do not have.
!DeepTutor's core in detail: the three-layer record — raw interactions distilled into facts, facts pulled into one learner profile — and the loop that runs on it: solve and self-check, quiz at your level, wrong concepts written back, old material resurfaces on a 0/1/3/7/14/30/60-day schedule
The core is also the part a skill can copy
Everything in the previous section is a file format plus a set of instructions. Give a modern agent a skill file that says “keep the record in these three layers, quiz from it, resurface mistakes on this schedule,” point it at a folder on your machine, and it will run a version of the same loop. Spaced repetition is a table of intervals and a queue of due items; the scheduler in this codebase is sensible engineering, not magic. For one technical user, studying alone, in a tool they already live in, the skill version covers most of what the core does. I have read the counterargument in the project’s own materials and in the coverage of it, and none of it answers this point, because the point is correct, about the core.
So if the core fits in a skill, the obvious question is what the other roughly 330,000 lines of Python and 330,000 lines of TypeScript in this repository are for. That is where the actual product lives.
What surrounds the core
!DeepTutor at a glance: you meet it through the web app, the desktop app or a chat-app partner; material flows in on the left through four parsers and eight retrieval pipelines, finished textbooks, videos and reports flow out on the right, the learning-engine core sits in the middle over single-machine SQLite storage, the multi-user layer for schools wraps around everything, and the model is plugged in from below
Real study material is ugly: scanned PDFs, two-column papers, formulas, tables, Office files old enough to vote. DeepTutor ships four pluggable document parsers as separate packages, so a file that defeats one engine can be tried against another, and its indexing pipeline can resume from the chunks it already processed when a build dies halfway instead of starting over.
Behind that sit eight swappable retrieval pipelines, not one: vector search, structure-based page retrieval, graph-based variants, an offline Wikipedia backend, each selectable per knowledge base, with query rewriting in front of them. A skill can wire up a parser and a vector store for your clean files. The fourth weird file from a real course is where the hand-built version starts to break, and this project has clearly been broken on those files and fixed, repeatedly; its issue tracker carries exactly those bugs from exactly those users.
!DeepTutor's feeding pipeline: real course files go through four pluggable parsers, get chunked and indexed with resume, then eight swappable retrieval pipelines fetch the right pages when you ask
The record and the loop feed a set of output surfaces that each took real building. There is an interactive textbook compiler: lessons assembled from blocks, concept graphs, figures, animations, quizzes, flashcards, interactive elements, exported as a book. There is a video lesson pipeline that writes a lesson, narrates it with text-to-speech and renders it in a Remotion project with layout checks. There is a math animation agent built on Manim that renders an animation, looks at the result, and retries when the layout is wrong.
An audio overview turns your material into a spoken summary. A research mode rewrites the question, breaks it down, gathers sources including arXiv papers, and writes up a report. The notebook was rebuilt around pages and blocks, with an editing assistant whose changes only land when you accept them. None of these is the core. Every one of them is a reason a different kind of user shows up.
!What DeepTutor produces: an interactive textbook compiler, video lessons, Manim math animations, an audio overview, and a four-step research mode
DeepTutor runs a “partner” system: a persistent tutor companion that lives inside 18-plus chat channels, WeChat, QQ, DingTalk, Feishu, WeCom, Telegram, WhatsApp, Slack, Discord and more, including partner group chats. A student can study inside the chat app they already use, and the partner can be present between sessions in a way a conversation window is not. A skill is session-shaped; it exists while you are talking to your agent. A resident companion on eighteen networks is a service, with connections to keep alive and messages to push, and that is a different species of software.
The multi-user layer is institutional: accounts, guardian relationships between parents or teachers and learners, per-resource permissions covering books, knowledge bases, models and skills separately, audit logs, device credentials, personal model quotas. Thirty-eight test files cover just this layer. A school does not adopt a folder of markdown and a prompt; it adopts accounts and permissions and an audit trail, or it does not adopt at all.
Its provider layer covers the usual API vendors and local models through Ollama, and also the subscription kind: Copilot, Codex and Claude Code through device-login OAuth, so a user can run it on a subscription they already pay for instead of a metered API key. The desktop app for Mac and Windows, officially still a preview, is a double-click install with a bundled runtime that starts the whole web interface without the user touching a terminal, a Python install or Git. The interface speaks ten languages, with consistency checks for the translations in its build pipeline. The whole repository carries 905 test files. You can argue with the taste of any of this. You cannot call it a wrapper.
!How DeepTutor deploys: one folder with SQLite on your own machine, the multi-user layer a school buys on top, subscription or API-key model access, and the single-machine storage ceiling
The neatest evidence of where skills actually sit in this architecture is in its own service layer. DeepTutor has a built-in skill registry, its own hub for installable skills, and the repository itself ships a SKILL.md whose entire job is to let an external agent drive DeepTutor through its command-line interface. In this architecture, skills are a plugin layer on top of the platform, and one of them is literally the remote control for the platform. The criticism “a skill could do this” gets the dependency backwards.
Can you actually use it?
I installed it, took the install apart, read the code and the release notes, and read the team’s paper. I did not connect a model and study with it for a month. Nobody should sell you a verdict on long-term learning from an install test, including me.
!What using DeepTutor actually costs: install size, setup friction, and the ongoing model calls behind the free download
A bare install of the v1.7.0 core took about two and a half minutes and 190MB on disk, dependency check clean. The core is chat, a command line and an SDK. The web interface everyone screenshots is a separate, heavier install. My install came with 25 module folders, solving, quizzing, the knowledge base, memory, the notebook among them.
And the first thing the software did was fail me: its own health-check command, doctor, reported two failures, no chat model configured and no embedding model configured (the one that turns your materials into searchable numbers). It tells you what’s missing instead of performing “all set,” which I respect, but it also states the terms plainly. Out of the box, DeepTutor does nothing until you bring a model, an API key and a budget. That was the core install, by hand, in a terminal. The desktop package exists precisely because most of its intended users would stop at the first of those steps.
The running costs are structural, not incidental. The software is free, Apache 2.0. It does not bring a model. Every question, every check, every quiz is a real call to a real model, and some of the spending happens where you cannot see it: after a session, a further call distills what happened into the record, another call may rewrite your next question against that record before it is asked. The record remembers better the more it is maintained, and maintenance is metered.
Meanwhile the upkeep above the software never stops. In 308 days the project shipped 89 releases, one every three and a half days on average, 15 of them in September and October alone, and v1.7.1 arrived three days after the version I installed, adding desktop preview apps and four more interface languages. The 1.7.0 upgrade notes also carry a trap that the 1.7.1 notes repeat word for word: if an old command-line package is still on your machine, uninstall it first, or you may pay for the new version and still be running the old one. I have not installed 1.7.1; everything hands-on in this piece is 1.7.0.
And the steering wheel sits mostly in one pair of hands. GitHub counts 3,205 contributions across 268 accounts; about 1,900 of them, roughly six in ten, are one person’s, more than sixteen times the runner-up’s 116. There is a real tail behind that person, 49 accounts with five or more contributions, so it is not a one-person repository. If that one person stops, the three-and-a-half-day release rhythm stops with them, and your upkeep problem becomes a survival problem.
Why it is actually hot
None of the above fully explains 54,000 stars, including the near-vertical part: 1,369 stars in the first four days, and over 5,700 in the four days before I wrote this. Products do not get that shape from quality alone. The curve is a staircase, and staircases have mechanics.
The first step is the name on the door. HKUDS is the Hong Kong University lab behind LightRAG, a retrieval project with 40,000 stars of its own. English coverage of DeepTutor name-checks the lab’s track record in the opening lines. A new project from a lab with a hit does not start from zero attention; it starts from a subscriber base. Note what the backing is and is not: it is a respected lab’s brand, a paper and a project site. I found no university-level announcement behind it, and the launch did not need one.
The second step is the cadence feeding the chart. A release every three and a half days keeps putting the repository in front of GitHub’s trending page, and trending puts it in front of the next wave of stargazers. The single biggest day, over 2,300 stars on October 29, came right after v1.7.0 shipped modular installs and the desktop preview. The release rhythm is the marketing department.
The third step is the category it sits in. One reviewer of the launch put it bluntly: it is a signal about self-hosting, not about tutoring. In a market where the big chat apps tutor for free inside their own clouds, “your materials, your record, your machine, models you choose” is a position a large crowd wants to endorse, and starring is how that crowd endorses things. The finished shape matters to the same crowd: most open-source tutors are a demo or a library, and this one installs like a product.
The fourth step is the breadth itself. Each subsystem is a separate door. The video lessons get shared to one audience, the math animations to another, the research mode to a third, the chat-app partners to a fourth, and the record-keeping story to a fifth. A narrow tool has one surface for the world to notice. This one has a dozen, and “it does everything” is itself the headline in much of the Chinese coverage.
Then the other side. In the last week of October the package was downloaded from PyPI roughly 1,200 to 1,950 times a day. Its issue tracker took 202 new reports in thirty days, and they read like real users on real machines: the desktop app missing a locally installed tool, a provider failing on Windows, old Office files passing upload and dying in parsing. What I could not find is a single named school or institution saying it runs this for its students, and the largest of its 6,692 forks has 26 stars, which is not what adopted platforms’ forks look like. So the count is best read as a large crowd, a real and growing minority of users, and an institutional story that has not happened yet.
The paper’s two numbers, in their place
The project has a paper from the university team, and two numbers from it travel widely. They are supporting evidence, not the verdict, and both need their labels left on.
The 10.8% comes from TutorBench, a benchmark the team built itself: simulated students working through university course material with the system, its explanations and practice questions marked by another large model against a scoring guide, 3.91 out of 5, against a comparison score of 3.53 in the same benchmark. That is a judged quality score for teaching output inside a simulation. It is not a learning outcome. Nobody pre-tested and post-tested a group of real students.
The 29.4% needs an even closer look. It comes from a separate set of experiments where DeepTutor’s solving was compared against four simple tutors the authors built themselves, and in that experiment its headline component, the personalization engine, was switched off the entire time. However good that number is, it has nothing to do with the record-keeping that is supposed to make the system worth installing.
The paper’s limitations section is more honest than its abstract: it says plainly that the evaluation rests on simulated students and that whether its add-on features actually help people learn needs longitudinal studies with real humans. Hold them to their own caveat.
Who it is actually for
If you are working through a course on purpose, preparing for an exam, or chewing through a thick textbook, and you will still be at it in three months, the full platform earns its weight for you: your materials go through parsers that can handle them, the record builds up session by session, and the quizzing starts from where you actually are. For that use I would install it, full version, Docker so the environment stays put, and pin it to one version instead of taking the always-newest image. Pinning means giving up features that land every few days, which is a fair price for a course that runs for months.
If you teach, or run a small school or tutoring operation, your reason is a different layer: the accounts, the guardian relationships, the permissions and the audit trail. That layer is the part no chat app and no skill gives you at all, and it was plainly built for your shape, one account per student, materials handed out by an admin, parents able to see what was practiced.
If the person who needs to use it does not live in a terminal, your reason is the desktop package and the chat-app partners. Judge those on whether your student actually opens them, because a tutor that lives where the student already chats has a chance a dashboard never gets.
And if you are a technical user studying alone, do not install it. Write the skill. The record format and the quiz loop, which are the parts that would actually change your results, fit in a skill file and a folder, inside the agent you already use, with no Docker stack, no release treadmill and no second system to keep alive. You give up the book compiler, the video lessons, the partners and the admin layer, and if you were never going to use them, you gave up nothing.
If you want help with tonight’s homework, the answer is still neither: the chat app you already have remembers your level and your preferences well enough for that, and it costs you no setup at all.
Using it with your kids
Could it raise your child’s grades? It might help them close one specific gap, but as of today the project has not shown that it raises exam scores, and it certainly has not shown that it can replace a tutor or a cram school. My recommendation is plain: use it as a practice coach for weak spots, and do not cancel the human help because of it.
The evidence situation is the one from the paper section, and it does not improve by being pointed at a child: simulated university students, judged by a model, is not a child’s score moving. Where it can help is in making practice less random, because the record of what your child got wrong can steer what gets practiced next, and a child whose mistakes get collected tends to meet the same problem again before an exam rather than after it. That route assumes a child willing to sit down and practice. The guardian layer does give you something a chat app does not: assigned materials and reports you can check, which helps you verify what the child actually practiced. A report can prove they sat down and used it. It cannot prove they learned.
A good tutor does more than explain. A tutor watches whether the child is stuck, guessing, or has drifted off, knows what the school teacher covers next week, and stops the copying when it starts. DeepTutor sees only what the child typed and uploaded. A cram school sells more than questions and explanations too: a fixed timetable, timed tests, a room full of peers applying pressure. DeepTutor cannot hold that rhythm for your child.
Judge it by what your child can do without it: unseen problems, closed book, before and after two weeks of practice on one weak unit, and watch the school quizzes. If those move, consider trimming part of the one-on-one hours. If they do not, it stays a question-answering tool, and the grade claims stay unproven. A young child should not be left alone with it either; somebody still has to check whether the content is right and whether the child is copying answers.
Building a business on it
You can. The license is Apache 2.0: commercial use, modification and paid products built on it are all allowed, keep the license notices, mark your changes, and stay off their trademark, the name and logo are not yours to sell under. If you run tutoring, the multi-user mode was built for exactly your shape: one account per student, workspaces and progress kept apart, an admin handing out materials and permissions, guardian relations for parents. A few hundred of your own students is the case it was designed for.
If you are a developer hoping to use it as the base of a public SaaS platform, go and read how it stores data before you write a line. Every user’s state lives in one directory on one machine, SQLite plus files, and the official documentation says there is no supported way to plug in PostgreSQL or MySQL. With few users that is called simple. At scale it is a ceiling, and the data layer becomes your rebuild, on top of the same version choice from before: pin one version and drift away from upstream, or follow a release every three and a half days and pay a regression test each time. There is no third option.
What changed in 1.7.0, and what 1.7.1 already did to it
Since the version most readers would install today is no longer the one I tested, the short version of the delta: 1.7.0 made installation modular, rebuilt the learning workspace and the notebook around pages and blocks with an editing assistant, added in-browser video lessons, and let a knowledge-base build resume from where it died instead of starting over. Three days later 1.7.1 added desktop preview apps for Mac and Windows, four more interface languages, and a round of chat and lesson fixes, and its upgrade notes repeat the old-package warning exactly. If you install, you are installing into that current. Decide beforehand whether you are riding it or pinning against it.
Models will only get cheaper, better at explaining, and better at remembering you in the ordinary conversational way. Cores like this one will keep getting cheaper too: anything that is a file format and a loop, a skill will absorb within a season. What does not get absorbed is the unglamorous ring around a core, parsers that survive real files, surfaces for every kind of user, accounts and permissions for institutions, and someone keeping all of it running three releases a week.
When you judge the next AI tool with a frightening star count, that ring is what I would price: not whether the trick is clever, but who it is packaged for, what it plugs into, and whether the crowd around it is using it or applauding it. DeepTutor’s record answers the first question a tutor has to answer. Its platform is the answer to the second. Applause and usage are not the same number, and telling them apart is most of the job.
If pieces like this are useful, subscribe or bookmark this blog. I keep taking apart AI, security and open-source tools the way I’d want them taken apart before I install them. And tell me: what is the heaviest tool you ever installed for a job a small script or a single skill later turned out to do just as well, or the other way around?
Project: github.com/HKUDS/DeepTutor/releases/tag/v1.7.0
Mentions
DeepTutorをコードから読む：マルチエンジンRAGの構成と静的セキュリティレビュー TL;DR HKUDS/DeepTutor は香港大学 Data Intelligence Lab（HKUDS）による学習特化のエージェントアプリ。2026-10-30 時点で ★50,686（当日 +1,930）、Apache-2.0 知識ベースは LlamaIndex / PageIndex / GraphRAG / LightRAG など複数の RAG パイプラインを差し替え可能な構成 コミット 1ea7df1554 を実行せずに静的レビューした。自動スコアは 23/100（RED）だったが、high 検出は精査するとほぼ誤検知。ただし v1.4.x に CVSS 最大 9.8 の CVE 群があり、現行 v1.7.0 を使う前提で「注意つき」と判断した ! 本記事はリポジトリの静的な読解と公開情報に基づきます。コードの実行・動的解析はしていません。 概要 DeepTutor は「AI チューター」を自分の環境で動かすための OSS です。バックエンドは Python（3.11–3.14）、フロントは Next.js で、deeptutor start が同梱の Next.js standalone サーバを起動する構成です。README によると、会話・出題・小テスト・調査・可視化・解答・マスタリーパス・精読・音声まとめといったモードが同じ会話コンテキストを共有します。 リポジトリの指標（スキャン時点）: 項目 値 初回コミット / 最終コミット 2025-12-28 / 2026-10-29 コミット数 3,155（直近30日 738） 作者数 278（直近90日アクティブ 164） トップ作者比率 0.39 CI ワークフロー 5 テスト あり 1年弱でこの規模という、かなり速いペースで開発されているプロジェクトです。 アーキテクチャ：retrieval まわり deeptutor/ 配下は agents, capabilities, knowledge, services, tools, runtime などに分かれています。RAG の中心は deeptutor/services/rag/ です。 deeptutor/services/rag/ ├── factory.py / service.py # RAGService とパイプライン選択 ├── query_rewrite.py # 検索前のクエリ書き換え ├── smart_retriever.py # マルチクエリ検索と集約 ├── index_versioning.py # KB インデックスのバージョン管理 ├── embedding_binding.py ほか # 埋め込みプロバイダの紐付け └── pipelines/ ├── llamaindex/ pageindex/ graphrag/ ├── lightrag/ lightrag_server/ └── weknora/ ima/ kiwix/ 1. クエリ書き換え（fail-open） query_rewrite.py は、会話中の指示語を含む質問（「それってどういう意味？」など）を、LLM を 1 回呼んで自己完結したキーワード寄りの検索クエリに書き換えます。docstring に fail-open と明記されていて、LLM のエラー・タイムアウト・空出力のときは元のクエリにフォールバックします。書き換えに失敗しても検索自体は止まりません。現時点で実装されている戦略は standalone だけで、multi_query は今後の PR 用に予約されています。 2. マルチクエリ検索 SmartRetriever は、コンテキストからクエリのバリエーションを生成し（既定 max_queries=3、ヒントが渡されればそれを使う）、asyncio.gather(..., return_exceptions=True) で並列に検索して結果を集約します。1 本のクエリが例外を出しても、残りの結果は生かされる作りです。 3. パイプラインとインデックスのバージョン管理 KB はバージョン付きの version-N ディレクトリとして管理されます。たとえば PageIndex は埋め込みを使わないので、ローカルに置くのは「取り込んだファイル → ホスト側の doc_id」の対応表（pageindex_docs.json）だけです。それでも同じ index_versioning を使うことで、UI 上はほかの KB と同じように扱えるようになっています。プロバイダ定数には pageindex（クラウド）と pageindex-oss があります。 ! PageIndex（クラウド版）のように、ドキュメント自体が外部サービスに置かれるパイプラインもあります。教材に機密が含まれる場合は、どのパイプラインを選ぶかがデータの出口の選択になります。 セットアップ上の注意（API キー・コスト） お試しなら Docker イメージを使えます（README 記載）。 docker run --rm --name deeptutor \ -p 127.0.0.1:3782:3782 \ -v deeptutor-data:/app/data \ ghcr.io/hkuds/deeptutor:latest 127.0.0.1 にバインドしている点に注目してください。.env.example のコメントでも、ホスト側ポート（8001 / 3782 / 8090）はすべて loopback 前提とされています。起動したら Settings → Providers でモデルプロバイダを設定します。 pip でインストールする場合、1.7.0 からモジュール構成が変わっています。 pip install -U "deeptutor[full]" # Web アプリ + CLI 素の deeptutor は core のみ README には、旧 deeptutor-cli パッケージが入っている場合は先にそれをアンインストールするよう書かれています。同じトランザクションでアップグレードすると、新しい core が消えることがあるためです。 ! LLM・埋め込み・検索は設定したプロバイダへ送信されます。各社の API キーが必要で、従量課金になる可能性があります。特にクエリ書き換えとマルチクエリ検索は、1 回の質問で複数回 LLM / 検索を呼ぶ設計です 個人情報や機密資料は入れないでください deeptutor/services/llm/telemetry.py はローカルにログを出すだけで、外部には送信していませんでした（ただし全通信先を網羅的に確認したわけではありません） 静的セキュリティレビュー 対象はコミット 1ea7df155447f4caf0e3abc86b3ff5395479cd4a（2026-10-29 01:36 JST）、スキャン日時は 2026-10-30 15:17 JST です。 自動スコア：23 / 100（RED） 区分 件数 減点 high 15 -60 medium 1 -8 low 10 -6 SECURITY.md なし — -3 数字だけ見ると「紹介しない」側ですが、検出内容を 1 件ずつ見ていきます。 検出の精査（ほぼ誤検知） CREDENTIAL_PATHS（13件）：chat_hints.py, security_guard.py, routers/book.py, フロントの ChatStateAdapter.tsx など。検出された文字列はすべて local state で、UI 状態やローカルストレージの意味で使われていました。たとえば pageindex/storage.py:4 は、前述の「The only local state is a lightweight manifest…」という docstring です。SSH 鍵やブラウザの認証情報に触れるコードではありません → 誤検知。 HIDDEN_UNICODE（2件）：tests/runtime/providers/test_text.py と tests/services/cli_apps/test_provider.py。ゼロ幅スペースや RLO を除去するサニタイザのテスト入力です → 誤検知。 VERY_LONG_LINE（1件）：web/lib/brand-icons.generated.ts（11,747 文字）。生成されたアイコンデータです → 誤検知。 PIPE_TO_SHELL：deeptutor/services/cli_apps/models.py:10 は、レジストリにある curl … | bash を実行しないことを説明する docstring でした。残りは tests とリリースノート（ver1-5-7.md）だけです → 誤検知。 RAW_IP_URL：tests 内のみです。169.254.169.254（クラウドのメタデータエンドポイント）は SSRF 防止のテストケースでした。 Bandit B202（deeptutor/tools/tex_downloader.py:180）： if not is_within_directory(extract_dir, member_path): print(f"Suspicious file path in tar: {member.name}. Skipping.") continue yield member tar.extractall(extract_dir, members=safe_members(tar)) def _extract_zip(self, zip_path: Path, extract_dir: Path): with zipfile.ZipFile(zip_path, "r") as zip_file: zip_file.extractall(extract_dir) tar 側は safe_members でディレクトリ外を指すメンバーを除外しているので、実害は小さいと判断しました。一方 zip 側は同じ検証をしていません。軽微な注意点です。 エージェント向け指示書 フック（AGENT_HOOKS）や MCP 設定ファイルは見つかりませんでした。AGENTS.md / SKILL.md のほか、capabilities//prompts/ や skills/builtin//SKILL.md など多数のプロンプト用 Markdown があります。冒頭を中心に確認した範囲では、隠れた指示や外部送信命令はありませんでした。grep で探した範囲では不可視文字もありません。ただし全文を精読したわけではありません。 既知の CVE と修正バージョン ここが一番重要なポイントです。 CVE 影響 修正 CVE-2026-51876 / 51878 / 51879 / 51880 / 51881 v1.4.0。RCE・パストラバーサル・認可回避（CVSS 最大 9.8） v1.4.1（シェル実行を既定で無効化 など） CVE-2026-58168 1.4.10 未満。MCP ツールの認可回避 1.4.10 現行は v1.7.0 です。マルウェア混入やアカウント乗っ取りの報告は見つかりませんでした。 ! 1.4.10 未満は使わず、必ず最新版にアップデートしてください インターネットに公開しないでください（README の Docker 例も loopback バインドです） シェル実行や MCP ツールなど権限の強い機能は、必要なとき以外は有効にしないでください 衛生面 SECURITY.md・CODEOWNERS・dependabot がない：脆弱性の報告窓口が明文化されていません。過去に重大な CVE が出ている規模のプロジェクトとしては弱いところです CodeQL などのコードスキャンもありません。pull_request_target は使われていません Python 依存はピン留めされていないため、PyPI advisory との自動照合はできませんでした このレビューの限界 grep・Bandit・一部の目視による静的チェックと公開情報だけで判断しています。実行・動的解析はしていません 巨大なコードベースのすべてを読んだわけではなく、通信先も網羅的には確認していません 依存関係の脆弱性は未検証です 「安全である」という保証ではなく、「紹介してよいか」を判断する材料です まとめ DeepTutor は、RAG パイプラインを差し替えられる設計と、fail-open なクエリ書き換え・マルチクエリ検索を持つ、読みごたえのあるコードベースです。自動スキャンの RED 判定は大半が誤検知でした。一方で、過去の CVE 群と SECURITY.md がない点は実際のリスクです。最新版を使う・ローカル限定で動かす・強い権限の機能は無効にしておく、この 3 点を守れば試す価値は十分にあります。 参考： HKUDS/DeepTutor github.com/HKUDS/DeepTutor/releases/tag/v1.4.1 app.opencve.io
This repo gives AI agents a command line for Blender, FreeCAD, draw.io and even video games. 🔗 HKUDS/CLI-Anything Credits: HKUDS/CLI-Anything #clianything #python #aiagents
Hardening DeepTutor's Lifelong Knowledge Tracing in Production Tutoring Pipelines Integrating DeepTutor: What the Docs Don't Tell You When we evaluated HKUDS/DeepTutor (HKUDS/DeepTutor) for a production adaptive learning stack, the pitch was straightforward: lifelong personalized tutoring with persistent knowledge tracing. The reality? The framework's stateful architecture introduces failure boundaries you won't hit until multi-tenant load testing. DeepTutor aims to model long-term student progress by maintaining evolving knowledge states across sessions. Unlike ephemeral chatbots that treat every interaction as isolated, this system must reconcile historical performance data with real-time tutoring interactions. That persistence layer becomes your bottleneck. Architecture Breakdown: Where State Lives The core challenge in DeepTutor isn't the tutoring logic—it's the knowledge tracing pipeline. The system maintains: 1. Student Knowledge State: Vector embeddings representing concept mastery over time 2. Interaction History: Timestamped question-answer pairs with correctness labels 3. Adaptive Curriculum: Dynamic question selection based on current state estimates In our test topology, we ran DeepTutor behind a FastAPI gateway routing to multiple LLM backends through B-Lost's relay gateway (b-lost.com) for provider fallback. Configuration: import openai client = openai.OpenAI( base_url="https://b-lost.com/v1", api_key=os.getenv("BLOST_API_KEY") ) def generate_tutoring_response(student_state, question): prompt = build_adaptive_prompt(student_state, question) response = client.chat.completions.create( model="gpt-4o", messages=[{"role": "user", "content": prompt}], temperature=0.7 ) return response.choices[0].message.content The issue: DeepTutor's knowledge tracing runs inference on every interaction to update student embeddings. With 200ms average LLM latency plus 50-80ms for state vector updates, single-student sessions clocked 250-280ms total response time. Acceptable for demos, but not for classrooms with 30 concurrent learners. Session Isolation and State Collision The repository doesn't document multi-tenant isolation strategies. We discovered this the hard way when parallel sessions corrupted student state vectors. The culprit: # Naive global state management (anti-pattern) student_states = {} def update_knowledge_state(student_id, interaction): if student_id not in student_states: student_states[student_id] = initialize_state() # Race condition: concurrent updates to same student_id student_states[student_id] = recalculate_state( student_states[student_id], interaction ) Production fix required session-scoped state management with Redis-backed locking: # Terminal session diagnostic redis-cli KEYS "deeptutor:student:*" redis-cli GET "deeptutor:student:12345:state" redis-cli EXPIRE "deeptutor:student:12345:lock" 5 Migrating to Redis cut state collision errors from 12% to under 0.3% in concurrent load tests (simulated 50 students, 5 questions/min each). RAG Integration: When Retrieved Context Conflicts with Knowledge State DeepTutor's adaptive curriculum pulls from a static knowledge graph. We augmented it with RAG for dynamic content (current events, updated curriculum standards). Configuration: from langchain.vectorstores import FAISS from langchain.embeddings import OpenAIEmbeddings embeddings = OpenAIEmbeddings( openai_api_base="https://b-lost.com/v1", openai_api_key=os.getenv("BLOST_API_KEY") ) vector_store = FAISS.load_local("curriculum_db", embeddings) def retrieve_relevant_content(query, student_state): # Filter by student mastery level filters = {"difficulty": student_state["current_level"]} docs = vector_store.similarity_search(query, k=3, filter=filters) return docs The operational trap: RAG retrieval added 80-120ms latency, pushing total response time past 400ms. When benchmarking multi-provider fallback through the B-Lost relay, TTFT (time-to-first-token) dropped by 35ms with zero token truncation by caching embeddings client-side. More critical: retrieved content occasionally contradicted the knowledge state's difficulty estimates. A student flagged as struggling with algebra would receive calculus-level word problems because RAG pulled the highest-similarity docs without respecting mastery boundaries. We had to implement a two-stage filter: def filtered_retrieval(query, student_state): candidates = vector_store.similarity_search(query, k=10) # Post-filter by knowledge state compatibility valid_docs = [ doc for doc in candidates if doc.metadata["difficulty"] <= student_state["max_difficulty"] ] return valid_docs[:3] Debugging Knowledge Drift with CLI Probes Knowledge state vectors drift over time if interaction labels are noisy (students guessing correctly, or making careless errors on mastered concepts). We built a CLI diagnostic: #!/bin/bash # deeptutor-drift-probe.sh STUDENT_ID=$1 REDIS_KEY="deeptutor:student:${STUDENT_ID}:state" echo "Fetching state vector..." STATE=$(redis-cli GET $REDIS_KEY) echo "Analyzing interaction history..." HISTORY=$(redis-cli LRANGE "deeptutor:student:${STUDENT_ID}:history" 0 -1) python3 << EOF import json import numpy as np state = json.loads('$STATE') history = json.loads('$HISTORY') # Calculate concept mastery variance concept_scores = [] for interaction in history[-20:]: concept_scores.append(interaction['correctness']) variance = np.var(concept_scores) print(f"Mastery variance (last 20): {variance:.3f}") if variance > 0.25: print("WARNING: High variance detected - potential label noise") EOF Run every 50 interactions per student. Variance above 0.25 triggered manual review—often revealing mislabeled interactions or students rushing through questions. The Unresolved Question: Long-Term State Decay DeepTutor assumes lifelong learning, but our longest pilot ran 6 months. Student knowledge states grew to 500+ interaction records. At what point does historical data become noise rather than signal? We experimented with exponential decay weights: def calculate_weighted_state(history, decay_rate=0.95): weighted_sum = 0 total_weight = 0 for i, interaction in enumerate(reversed(history)): weight = decay_rate ** i weighted_sum += interaction['mastery_delta'] * weight total_weight += weight return weighted_sum / total_weight Decay rate tuning (0.90 vs 0.95 vs 0.98) changed student progression pacing by 15-20%. No consensus yet on optimal values—likely depends on subject domain and student age group. How do you balance honoring past struggles against recognizing genuine growth?
DeepTutor, taken apart: its core trick fits in one skill, so why did 54,000 people star the platform around it? --- title: DeepTutor, taken apart: its core trick fits in one skill, so why did 54,000 people star the platform around it? published: true date: 2026-11-03 06:49:00 UTC cover_image: dev-to-uploads.s3.us-east-2.amazonaws.com tags: canonical_url: blog.go5.si --- An open-source AI tutor out of the University of Hong Kong had 1,369 stars four days after its repository was created. Ten months later it is at nearly 54,000, and more than 5,000 of those arrived in the last four days alone. On October 28 I installed its v1.7.0 release and took it apart. Before the write-up was finished, v1.7.1 landed on October 31. This is a long one, and the verdict needs the length to be fair. Here it is up front: DeepTutor’s core, a structured record of what you got wrong and a loop that quizzes you from it, is the team’s own engineering. It is also, in 2026, the one part of the product a single agent skill can copy. What a skill cannot copy is everything built around that core, and the 54,000 stars are mostly for the surroundings: a platform, a delivery shape for people who do not live in a terminal, and a lab that knows how to launch. If you are a technical user studying alone, you may need none of it. That distinction is the whole piece. !A robot tutor proudly hugs an enormous ledger of graded papers covered in red crosses and green ticks, while the student stares, and three little memory clouds shrug above them The honest baseline: what a chat box already remembers Any serious test of a tutor’s memory has to start with what the ordinary chat box does today, because it does more than it did two years ago. Inside one conversation, the model sees what you said earlier in that same conversation. That part was never in doubt. Across conversations, the big platforms have all added a memory layer of their own. ChatGPT keeps saved memories, facts it stores about you, and on top of that it can reference your past chat history when it answers. Claude’s memory is on by default on its consumer plans and stores what it learns as topic files you can open, read and edit. Gemini has a Memory setting that learns from your past chats. The fine print differs by vendor: Claude leaves sensitive topics out by default, and Gemini’s version only learns when Keep Activity is on. So the picture of the chat tutor as a goldfish that forgets you between sessions does not survive contact with 2026. What that memory is not, though, matters just as much. OpenAI’s own help page puts it plainly: memory does not retain every detail from every conversation, and ChatGPT decides which available information is relevant. What the platforms keep is the kind of thing a good assistant keeps: your preferences, your projects, the level you are roughly at. A study record is finer than that. It is not “this person is weak at physics.” It is: on these dates you attempted these problems, you dropped the sign in the lens formula twice and mixed up image distance once, and last Tuesday you finally got three of that type right in a row. A quiz engine can compute with a record like that. A paragraph of preferences cannot drive it, because the individual events were never written down anywhere. The core: a record a quiz can compute with DeepTutor, from the DeepTutor team at the University of Hong Kong’s data science institute, builds that fine-grained record on your own machine. The record has three layers. The bottom layer keeps the raw record of every interaction, append-only, never rewritten, the way an accountant keeps the original receipts. The middle layer distills those records into facts about you, which concepts you keep mixing up, which problem types keep tripping you, each fact pinned to the interactions it came from, so a wrong conclusion can be traced back and removed. The top layer pulls those facts together into one learner profile. !How DeepTutor works: it keeps a structured record of what you got wrong, quizzes you from that record, and spaces the review by knowledge type On top of the record sits a working loop. When you ask it to work a problem, it classifies what kind of problem it is, works it, and checks its own result before showing you. Then it turns around and quizzes you, pitched near your current level, and the wrong concept in your answer gets written back into the record, which shapes what it asks next time. A scheduler decides when old material comes back for review, with different spacing for different kinds of knowledge. Solve, quiz, write it down, resurface it later. That loop, running on that record, is the core of the product, and it is the part most chat tutors do not have. !DeepTutor's core in detail: the three-layer record — raw interactions distilled into facts, facts pulled into one learner profile — and the loop that runs on it: solve and self-check, quiz at your level, wrong concepts written back, old material resurfaces on a 0/1/3/7/14/30/60-day schedule The core is also the part a skill can copy Everything in the previous section is a file format plus a set of instructions. Give a modern agent a skill file that says “keep the record in these three layers, quiz from it, resurface mistakes on this schedule,” point it at a folder on your machine, and it will run a version of the same loop. Spaced repetition is a table of intervals and a queue of due items; the scheduler in this codebase is sensible engineering, not magic. For one technical user, studying alone, in a tool they already live in, the skill version covers most of what the core does. I have read the counterargument in the project’s own materials and in the coverage of it, and none of it answers this point, because the point is correct, about the core. So if the core fits in a skill, the obvious question is what the other roughly 330,000 lines of Python and 330,000 lines of TypeScript in this repository are for. That is where the actual product lives. What surrounds the core !DeepTutor at a glance: you meet it through the web app, the desktop app or a chat-app partner; material flows in on the left through four parsers and eight retrieval pipelines, finished textbooks, videos and reports flow out on the right, the learning-engine core sits in the middle over single-machine SQLite storage, the multi-user layer for schools wraps around everything, and the model is plugged in from below Real study material is ugly: scanned PDFs, two-column papers, formulas, tables, Office files old enough to vote. DeepTutor ships four pluggable document parsers as separate packages, so a file that defeats one engine can be tried against another, and its indexing pipeline can resume from the chunks it already processed when a build dies halfway instead of starting over. Behind that sit eight swappable retrieval pipelines, not one: vector search, structure-based page retrieval, graph-based variants, an offline Wikipedia backend, each selectable per knowledge base, with query rewriting in front of them. A skill can wire up a parser and a vector store for your clean files. The fourth weird file from a real course is where the hand-built version starts to break, and this project has clearly been broken on those files and fixed, repeatedly; its issue tracker carries exactly those bugs from exactly those users. !DeepTutor's feeding pipeline: real course files go through four pluggable parsers, get chunked and indexed with resume, then eight swappable retrieval pipelines fetch the right pages when you ask The record and the loop feed a set of output surfaces that each took real building. There is an interactive textbook compiler: lessons assembled from blocks, concept graphs, figures, animations, quizzes, flashcards, interactive elements, exported as a book. There is a video lesson pipeline that writes a lesson, narrates it with text-to-speech and renders it in a Remotion project with layout checks. There is a math animation agent built on Manim that renders an animation, looks at the result, and retries when the layout is wrong. An audio overview turns your material into a spoken summary. A research mode rewrites the question, breaks it down, gathers sources including arXiv papers, and writes up a report. The notebook was rebuilt around pages and blocks, with an editing assistant whose changes only land when you accept them. None of these is the core. Every one of them is a reason a different kind of user shows up. !What DeepTutor produces: an interactive textbook compiler, video lessons, Manim math animations, an audio overview, and a four-step research mode DeepTutor runs a “partner” system: a persistent tutor companion that lives inside 18-plus chat channels, WeChat, QQ, DingTalk, Feishu, WeCom, Telegram, WhatsApp, Slack, Discord and more, including partner group chats. A student can study inside the chat app they already use, and the partner can be present between sessions in a way a conversation window is not. A skill is session-shaped; it exists while you are talking to your agent. A resident companion on eighteen networks is a service, with connections to keep alive and messages to push, and that is a different species of software. The multi-user layer is institutional: accounts, guardian relationships between parents or teachers and learners, per-resource permissions covering books, knowledge bases, models and skills separately, audit logs, device credentials, personal model quotas. Thirty-eight test files cover just this layer. A school does not adopt a folder of markdown and a prompt; it adopts accounts and permissions and an audit trail, or it does not adopt at all. Its provider layer covers the usual API vendors and local models through Ollama, and also the subscription kind: Copilot, Codex and Claude Code through device-login OAuth, so a user can run it on a subscription they already pay for instead of a metered API key. The desktop app for Mac and Windows, officially still a preview, is a double-click install with a bundled runtime that starts the whole web interface without the user touching a terminal, a Python install or Git. The interface speaks ten languages, with consistency checks for the translations in its build pipeline. The whole repository carries 905 test files. You can argue with the taste of any of this. You cannot call it a wrapper. !How DeepTutor deploys: one folder with SQLite on your own machine, the multi-user layer a school buys on top, subscription or API-key model access, and the single-machine storage ceiling The neatest evidence of where skills actually sit in this architecture is in its own service layer. DeepTutor has a built-in skill registry, its own hub for installable skills, and the repository itself ships a SKILL.md whose entire job is to let an external agent drive DeepTutor through its command-line interface. In this architecture, skills are a plugin layer on top of the platform, and one of them is literally the remote control for the platform. The criticism “a skill could do this” gets the dependency backwards. Can you actually use it? I installed it, took the install apart, read the code and the release notes, and read the team’s paper. I did not connect a model and study with it for a month. Nobody should sell you a verdict on long-term learning from an install test, including me. !What using DeepTutor actually costs: install size, setup friction, and the ongoing model calls behind the free download A bare install of the v1.7.0 core took about two and a half minutes and 190MB on disk, dependency check clean. The core is chat, a command line and an SDK. The web interface everyone screenshots is a separate, heavier install. My install came with 25 module folders, solving, quizzing, the knowledge base, memory, the notebook among them. And the first thing the software did was fail me: its own health-check command, doctor, reported two failures, no chat model configured and no embedding model configured (the one that turns your materials into searchable numbers). It tells you what’s missing instead of performing “all set,” which I respect, but it also states the terms plainly. Out of the box, DeepTutor does nothing until you bring a model, an API key and a budget. That was the core install, by hand, in a terminal. The desktop package exists precisely because most of its intended users would stop at the first of those steps. The running costs are structural, not incidental. The software is free, Apache 2.0. It does not bring a model. Every question, every check, every quiz is a real call to a real model, and some of the spending happens where you cannot see it: after a session, a further call distills what happened into the record, another call may rewrite your next question against that record before it is asked. The record remembers better the more it is maintained, and maintenance is metered. Meanwhile the upkeep above the software never stops. In 308 days the project shipped 89 releases, one every three and a half days on average, 15 of them in September and October alone, and v1.7.1 arrived three days after the version I installed, adding desktop preview apps and four more interface languages. The 1.7.0 upgrade notes also carry a trap that the 1.7.1 notes repeat word for word: if an old command-line package is still on your machine, uninstall it first, or you may pay for the new version and still be running the old one. I have not installed 1.7.1; everything hands-on in this piece is 1.7.0. And the steering wheel sits mostly in one pair of hands. GitHub counts 3,205 contributions across 268 accounts; about 1,900 of them, roughly six in ten, are one person’s, more than sixteen times the runner-up’s 116. There is a real tail behind that person, 49 accounts with five or more contributions, so it is not a one-person repository. If that one person stops, the three-and-a-half-day release rhythm stops with them, and your upkeep problem becomes a survival problem. Why it is actually hot None of the above fully explains 54,000 stars, including the near-vertical part: 1,369 stars in the first four days, and over 5,700 in the four days before I wrote this. Products do not get that shape from quality alone. The curve is a staircase, and staircases have mechanics. The first step is the name on the door. HKUDS is the Hong Kong University lab behind LightRAG, a retrieval project with 40,000 stars of its own. English coverage of DeepTutor name-checks the lab’s track record in the opening lines. A new project from a lab with a hit does not start from zero attention; it starts from a subscriber base. Note what the backing is and is not: it is a respected lab’s brand, a paper and a project site. I found no university-level announcement behind it, and the launch did not need one. The second step is the cadence feeding the chart. A release every three and a half days keeps putting the repository in front of GitHub’s trending page, and trending puts it in front of the next wave of stargazers. The single biggest day, over 2,300 stars on October 29, came right after v1.7.0 shipped modular installs and the desktop preview. The release rhythm is the marketing department. The third step is the category it sits in. One reviewer of the launch put it bluntly: it is a signal about self-hosting, not about tutoring. In a market where the big chat apps tutor for free inside their own clouds, “your materials, your record, your machine, models you choose” is a position a large crowd wants to endorse, and starring is how that crowd endorses things. The finished shape matters to the same crowd: most open-source tutors are a demo or a library, and this one installs like a product. The fourth step is the breadth itself. Each subsystem is a separate door. The video lessons get shared to one audience, the math animations to another, the research mode to a third, the chat-app partners to a fourth, and the record-keeping story to a fifth. A narrow tool has one surface for the world to notice. This one has a dozen, and “it does everything” is itself the headline in much of the Chinese coverage. Then the other side. In the last week of October the package was downloaded from PyPI roughly 1,200 to 1,950 times a day. Its issue tracker took 202 new reports in thirty days, and they read like real users on real machines: the desktop app missing a locally installed tool, a provider failing on Windows, old Office files passing upload and dying in parsing. What I could not find is a single named school or institution saying it runs this for its students, and the largest of its 6,692 forks has 26 stars, which is not what adopted platforms’ forks look like. So the count is best read as a large crowd, a real and growing minority of users, and an institutional story that has not happened yet. The paper’s two numbers, in their place The project has a paper from the university team, and two numbers from it travel widely. They are supporting evidence, not the verdict, and both need their labels left on. The 10.8% comes from TutorBench, a benchmark the team built itself: simulated students working through university course material with the system, its explanations and practice questions marked by another large model against a scoring guide, 3.91 out of 5, against a comparison score of 3.53 in the same benchmark. That is a judged quality score for teaching output inside a simulation. It is not a learning outcome. Nobody pre-tested and post-tested a group of real students. The 29.4% needs an even closer look. It comes from a separate set of experiments where DeepTutor’s solving was compared against four simple tutors the authors built themselves, and in that experiment its headline component, the personalization engine, was switched off the entire time. However good that number is, it has nothing to do with the record-keeping that is supposed to make the system worth installing. The paper’s limitations section is more honest than its abstract: it says plainly that the evaluation rests on simulated students and that whether its add-on features actually help people learn needs longitudinal studies with real humans. Hold them to their own caveat. Who it is actually for If you are working through a course on purpose, preparing for an exam, or chewing through a thick textbook, and you will still be at it in three months, the full platform earns its weight for you: your materials go through parsers that can handle them, the record builds up session by session, and the quizzing starts from where you actually are. For that use I would install it, full version, Docker so the environment stays put, and pin it to one version instead of taking the always-newest image. Pinning means giving up features that land every few days, which is a fair price for a course that runs for months. If you teach, or run a small school or tutoring operation, your reason is a different layer: the accounts, the guardian relationships, the permissions and the audit trail. That layer is the part no chat app and no skill gives you at all, and it was plainly built for your shape, one account per student, materials handed out by an admin, parents able to see what was practiced. If the person who needs to use it does not live in a terminal, your reason is the desktop package and the chat-app partners. Judge those on whether your student actually opens them, because a tutor that lives where the student already chats has a chance a dashboard never gets. And if you are a technical user studying alone, do not install it. Write the skill. The record format and the quiz loop, which are the parts that would actually change your results, fit in a skill file and a folder, inside the agent you already use, with no Docker stack, no release treadmill and no second system to keep alive. You give up the book compiler, the video lessons, the partners and the admin layer, and if you were never going to use them, you gave up nothing. If you want help with tonight’s homework, the answer is still neither: the chat app you already have remembers your level and your preferences well enough for that, and it costs you no setup at all. Using it with your kids Could it raise your child’s grades? It might help them close one specific gap, but as of today the project has not shown that it raises exam scores, and it certainly has not shown that it can replace a tutor or a cram school. My recommendation is plain: use it as a practice coach for weak spots, and do not cancel the human help because of it. The evidence situation is the one from the paper section, and it does not improve by being pointed at a child: simulated university students, judged by a model, is not a child’s score moving. Where it can help is in making practice less random, because the record of what your child got wrong can steer what gets practiced next, and a child whose mistakes get collected tends to meet the same problem again before an exam rather than after it. That route assumes a child willing to sit down and practice. The guardian layer does give you something a chat app does not: assigned materials and reports you can check, which helps you verify what the child actually practiced. A report can prove they sat down and used it. It cannot prove they learned. A good tutor does more than explain. A tutor watches whether the child is stuck, guessing, or has drifted off, knows what the school teacher covers next week, and stops the copying when it starts. DeepTutor sees only what the child typed and uploaded. A cram school sells more than questions and explanations too: a fixed timetable, timed tests, a room full of peers applying pressure. DeepTutor cannot hold that rhythm for your child. Judge it by what your child can do without it: unseen problems, closed book, before and after two weeks of practice on one weak unit, and watch the school quizzes. If those move, consider trimming part of the one-on-one hours. If they do not, it stays a question-answering tool, and the grade claims stay unproven. A young child should not be left alone with it either; somebody still has to check whether the content is right and whether the child is copying answers. Building a business on it You can. The license is Apache 2.0: commercial use, modification and paid products built on it are all allowed, keep the license notices, mark your changes, and stay off their trademark, the name and logo are not yours to sell under. If you run tutoring, the multi-user mode was built for exactly your shape: one account per student, workspaces and progress kept apart, an admin handing out materials and permissions, guardian relations for parents. A few hundred of your own students is the case it was designed for. If you are a developer hoping to use it as the base of a public SaaS platform, go and read how it stores data before you write a line. Every user’s state lives in one directory on one machine, SQLite plus files, and the official documentation says there is no supported way to plug in PostgreSQL or MySQL. With few users that is called simple. At scale it is a ceiling, and the data layer becomes your rebuild, on top of the same version choice from before: pin one version and drift away from upstream, or follow a release every three and a half days and pay a regression test each time. There is no third option. What changed in 1.7.0, and what 1.7.1 already did to it Since the version most readers would install today is no longer the one I tested, the short version of the delta: 1.7.0 made installation modular, rebuilt the learning workspace and the notebook around pages and blocks with an editing assistant, added in-browser video lessons, and let a knowledge-base build resume from where it died instead of starting over. Three days later 1.7.1 added desktop preview apps for Mac and Windows, four more interface languages, and a round of chat and lesson fixes, and its upgrade notes repeat the old-package warning exactly. If you install, you are installing into that current. Decide beforehand whether you are riding it or pinning against it. Models will only get cheaper, better at explaining, and better at remembering you in the ordinary conversational way. Cores like this one will keep getting cheaper too: anything that is a file format and a loop, a skill will absorb within a season. What does not get absorbed is the unglamorous ring around a core, parsers that survive real files, surfaces for every kind of user, accounts and permissions for institutions, and someone keeping all of it running three releases a week. When you judge the next AI tool with a frightening star count, that ring is what I would price: not whether the trick is clever, but who it is packaged for, what it plugs into, and whether the crowd around it is using it or applauding it. DeepTutor’s record answers the first question a tutor has to answer. Its platform is the answer to the second. Applause and usage are not the same number, and telling them apart is most of the job. If pieces like this are useful, subscribe or bookmark this blog. I keep taking apart AI, security and open-source tools the way I’d want them taken apart before I install them. And tell me: what is the heaviest tool you ever installed for a job a small script or a single skill later turned out to do just as well, or the other way around? Project: github.com/HKUDS/DeepTutor/releases/tag/v1.7.0
🚀 Your personal AI tutor, for free! DeepTutor helps you learn difficult topics through personalized explanations, interactive learning & step-by-step guidance. GitHub: hkuds/deeptutor
在 DeepTutor 中，输入一个主题，就能生成个性化的视频讲解。AI 的回答越来越长，但学习不一定要靠读大段文字。新版DeepTutor( HKUDS/DeepTutor ) 也是希望让个性化学习变得直观，更顺手：先通过动画理解内容，记笔记时遇到不明白的地方，选中那一段就能问 AI。讨论会留在原处，复习时随时回看，也能接着之前的问题继续学。
"l' #IA va faire qu'on ne réfléchit plus, et donc rendre con !" - Ah. Si tu l'dis !? x.com Un prof personnel à la maison ! HKUDS/DeepTutor #DeepTutor #AI
VideoRAG: Chat with Your Videos (3.4k stars) What it does All text below is quoted directly from the project README. >[KDD'2026] "VideoRAG: Chat with Your Videos" Key Features: - Drag & Drop Upload: Simply drag video files into Vimo - Smart Conversations: Ask questions in natural language - Multi-Format Support: Works with MP4, MKV, AVI, and more - Cross-Platform: Available on macOS, Windows, and Linux - Extreme Long Videos: Process videos up to hundreds of hours - Multi-Video Analysis: Compare and analyze multiple videos simultaneously - Advanced Retrieval: Find specific moments and scenes with precision - Export Capabilities: Save insights and references for later use Repository HKUDS/VideoRAG Repository stats |Metric|Value| |:-|:-| |Stars|3,436| |Forks|477| |Last release|None| |Languages|Python 57.6%, TypeScript 40.9%, CSS 0.7%| |Contributors|6| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|None| |AI co-authored commits|None| Main contributor |Field|Value| |:-|:-| |Name|Xubin Ren| |GitHub|@Re-bin| |Commits to this repo|55 (top contributor)| |Bio|Ph.D. student of the University of Hong Kong @HKUDS| |Company / Location|The University of Hong Kong| |Followers|629| ────────────────────────────── 📌 How many great GitHub repos have you discovered and completely forgotten about? Don't let another useful tool disappear into your Reddit feed. Get the community's best repos, organized by category, plus key takeaways from real developer discussions, delivered to your inbox twice a week. 📬 Never lose track of great repos again. Subscribe free.
DeepTutor: Lifelong Personalized Tutoring (47k stars) What it does All text below is quoted directly from the project README. >DeepTutor is an agent-native learning workspace that connects tutoring, problem solving, quiz generation, research, visualization, and mastery practice in one extensible system. Key Features: - One runtime for every mode: Chat, Ask Questions, Quiz, Research, Visualize, Solve, Course Study, Mastery Path, Immersive Reading, and Audio Overview share one capability runtime and session context while keeping purpose-built loops and pipelines. - Task Board: Track study tasks in To do, In progress, and Done, with notes, drag-and-drop or keyboard-accessible move buttons, and an archive you can restore from. - Connected learning context: Knowledge bases, books, Co-Writer drafts, notebooks, question banks, personas, and Memory can be reused across the workflows that support them, subject to account grants and learning policies. - Immersive video learning: add YouTube or Bilibili links to Reading for native playback, transcript search, timestamp-grounded tutoring, saved notes, and resumable progress. - Subagents and Partners: from Chat, consult a live agent harness (Claude Code, Codex, Grok CLI, Antigravity, Kimi, opencode, MiMo, Hermes, OpenClaw, or DeepSeek) or a Partner, import past conversations, and run persistent IM companions on the same brain. - Extensible tools and skills: built-in tools, MCP servers, CLI apps, image / video / voice generation models, and installable community skills from EduHub. - Inspectable memory: L1 traces, L2 surface summaries, and L3 synthesis make personalization visible and editable. >pip install -U deeptutor picks up the latest stable release. Repository HKUDS/DeepTutor Repository stats |Metric|Value| |:-|:-| |Stars|46,813| |Forks|5.8k| |Last release|v1.6.15 (2026-10-18)| |Languages|Python 65.6%, TypeScript 33.9%, JavaScript 0.2%| |Contributors|227| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|@claude (131 commits), @cursoragent (14 commits), @Copilot (6 commits)| |AI co-authored commits|Cursor: 14, Copilot: 6| Main contributor |Field|Value| |:-|:-| |Name|Bingxi Zhao| |GitHub|@pancacake| |Commits to this repo|940 (top contributor)| |Bio|Undergraduate. Always believing Researcher = Scientist + Engineer.| |Company / Location|China| |Followers|275| ────────────────────────────── 📌 How many great GitHub repos have you discovered and completely forgotten about? Don't let another useful tool disappear into your Reddit feed. Get the community's best repos, organized by category, plus key takeaways from real developer discussions, delivered to your inbox twice a week. 📬 Never lose track of great repos again. Subscribe free.
AutoSwarm: All Your Agents, Working as One (2.0k stars) What it does All text below is quoted directly from the project README. >AutoSwarm: All Your Agents, Working as One (Codex · Claude Code · DeepSeek Harness · Muse · Grok · WorkBuddy· nanobot · and more) Why AutoSwarm?: - Selects the right agents based on their capabilities; - Shares context and memory across agents; - Connects complementary tools and workflows; - Bridges data and application ecosystems; - Runs tasks in parallel for faster execution; - Coordinates agent collaboration and keeps everyone aligned; - Verifies and synthesizes results into one coherent answer. >Use AutoSwarm to read these 100 documents and summarize the key approaches and disagreements. Repository HKUDS/AutoSwarm Repository stats |Metric|Value| |:-|:-| |Stars|2,042| |Forks|370| |Last release|None| |Languages|Python 87.9%, TypeScript 9.7%, CSS 2.2%| |Contributors|9| |AI contributor accounts (Claude / Codex / Cursor / Copilot)|None| |AI co-authored commits|Claude: 40, Cursor: 1| Main contributor |Field|Value| |:-|:-| |GitHub|@LZH-YS1998| |Commits to this repo|106 (top contributor)| |Followers|87| ────────────────────────────── 📌 How many great GitHub repos have you discovered and completely forgotten about? Don't let another useful tool disappear into your Reddit feed. Get the community's best repos, organized by category, plus key takeaways from real developer discussions, delivered to your inbox twice a week. 📬 Never lose track of great repos again. Subscribe free.