Type a topic. Get a real course — with lessons, diagrams, tests, homework and spaced review — built by the AI subscription you already pay for, stored on your own machine.
Everyone "learns with ChatGPT" now — and a week later all that's left is a chat transcript you'll never reopen. Chats answer questions; they don't teach. Real learning needs structure, practice, feedback and repetition.
Learn (Almost) Anything turns "I want to understand X" into an actual course: an agent interviews you, researches the topic, designs a curriculum, writes illustrated lessons, quizzes you, grades your homework, and schedules flashcard reviews so the material sticks. Everything lives on your disk. There's no platform, no subscription of ours, no server with your data — the engine is the Claude Code or Codex CLI you already have.
It's the difference between asking a smart friend questions all evening and having that friend sit down and teach you properly.
You pick a topic, language, format and agent. The course can be a full academic course, a compact mini-module, a podcast-style series, a single lesson — or a roadmap that maps the whole journey first.
Most AI tools stop at "here's some text". This one closes the loop:
- Lessons that look like lessons — articles with real sourced images, Mermaid diagrams, galleries and sandboxed interactive widgets. Every draft goes through an editor/fact-check pass before you see it.
- Comprehension tests — question pools that check understanding, not verbatim recall, and interleave concepts from earlier modules.
- Real homework — essays, diagrams, file uploads, GitHub repos, and autograded coding tasks that actually run your code. The agent reviews submissions and makes you retry until it passes.
- Spaced repetition — flashcards are extracted from each lesson and scheduled for review, so the course keeps working on you after you've read it.
- Lecture audio — free OS voices out of the box, optional premium Gemini TTS, cached on disk.
Don't want the full treatment? Checkboxes at creation turn tests and homework off, and you can skip the clarifying interview entirely — title, plan, go.
For big goals ("become a data engineer", "learn academic painting from zero") a single course is the wrong shape. A roadmap lays out stages and skills, runs a quick diagnostic to find out what you already know, and spawns a lesson or a full course from any skill — each one aware of where it sits in the bigger picture.
Drop documents, links and folders into a Space and courses created there ground themselves in your material — strictly (only your sources) or openly (your sources first, the web second). Attach custom MCP servers to a course and the agent can research through any tool you trust.
This is the part companies asked for. Spin up your own catalog server inside your infrastructure — one Docker command, hidden from the public internet:
docker run -d -p 8080:8080 \
-e PUBLIC_ORIGIN=http://catalog.internal.example.com:8080 \
-e CATALOG_UPLOAD_TOKEN=your-secret \
-v laa-catalog-data:/data \
legostin/laa-catalog:latestEveryone on the team adds the URL in Settings and gets a shared internal course library: onboarding tracks, domain knowledge, tooling guides. Authors publish with the team token; everyone else browses, installs and pulls updates with no token at all. Courses remember which catalog they came from, so update checks keep working even across reconfigurations. The public catalog stays available alongside.
And of course: publish your best courses to the public catalog, install other people's courses, translate any course into another language — structure, lessons, tests, homework, diagram labels and even baked-in image text included.
Author and publish courses straight from Claude Code: a built-in MCP server (laa-course) lets the model design the structure, write and fact-check the lessons, pick images and cite sources itself, then save and publish them to your catalog — including arbitrarily-nested documentation with working cross-links and space-grounded courses (build only from supplied docs/repos). Generation runs inside Claude Code; the server only persists, lists status, edits structure and publishes (it never calls an LLM).
The server ships inside the app and is a single, zero-dependency file — you only need Claude Code and node on your PATH. The easiest way: open Settings → Generate courses from Claude Code and click Copy command — it's prefilled with the correct path for your OS. Or register it by hand:
# macOS (path inside the installed .app)
claude mcp add laa-course \
--env CATALOG_URL=http://localhost:8080 --env CATALOG_UPLOAD_TOKEN=your-token \
-- node "/Applications/Learn (Almost) Anything.app/Contents/Resources/sidecar/src/course-mcp/server.mjs"
# Windows (path inside the install dir; adjust if you installed elsewhere)
claude mcp add laa-course ^
--env CATALOG_URL=http://localhost:8080 --env CATALOG_UPLOAD_TOKEN=your-token ^
-- node "C:\Program Files\Learn (Almost) Anything\resources\sidecar\src\course-mcp\server.mjs"
# Linux (AppImage/deb — adjust to your install path)
claude mcp add laa-course \
--env CATALOG_URL=http://localhost:8080 --env CATALOG_UPLOAD_TOKEN=your-token \
-- node "/usr/lib/learn-almost-anything/resources/sidecar/src/course-mcp/server.mjs"Verify with claude mcp list (→ laa-course: connected), then just ask: "generate documentation on how HTTP/2 works and publish it". Courses are stored under $LAA_COURSE_STORE (default ~/.laa-course-mcp). The repo also ships a .claude/skills/generate-course skill that drives the whole authoring workflow.
The app is free and runs no paid backend. Every LLM call goes through an agent CLI already installed and authenticated on your machine:
| You have | It powers | Install |
|---|---|---|
| Claude Pro / Max | Claude Code CLI | npm i -g @anthropic-ai/claude-code → claude login |
| ChatGPT / Codex plan | Codex CLI | npm i -g @openai/codex → codex login |
Install both and pick per course. Optional extras, each off by default: Brave Search API (web/image grounding), Gemini API (generated illustrations, premium TTS). A quality/cost tier per course (quick / balanced / premium) controls research depth, reasoning effort and how much material gets generated — so a quick mini-course stays cheap and a premium deep-dive goes all in.
Provider pricing changes; check Claude Code plans, Codex pricing, Gemini API, Brave Search API.
- Download the latest build from Releases — macOS
.dmg(Apple Silicon / Intel, signed and notarized) or Windows.msi/.exe(unsigned for now, SmartScreen may warn). - Make sure Node.js 20+ is installed — the local sidecar runs the agent SDKs through it.
- Have at least one agent CLI logged in (table above), then launch the app and create your first course.
The UI ships in English and Russian; course content can be generated in any language you pick — a single library happily mixes English, Russian and Chinese courses.
Installed builds self-update: the app checks GitHub Releases, downloads a signed updater bundle, verifies and installs it.
The generation pipeline (click to expand)
You pick one agent (Claude or Codex) when creating the course; every LLM step then runs through it via a local Node sidecar:
- Interview — a few adaptive clarifying questions become the course brief (skippable).
- Plan — the agent researches (web / Context7 / MediaWiki / arXiv / OpenAlex / your Space), designs the module tree and classifies the subject category.
- Per-lesson generation — draft (article + widgets) → editor & fact-check review → widget validation; then illustrations (real image vs code snippet, per block), a test, homework and flashcards in parallel. Accuracy-critical categories get an extra background fact-check pass.
flowchart TD
U["Topic, language, format, agent, space"] --> CC["create_course"]
CC --> SC[["Node sidecar (Claude Code / Codex)"]]
SC --> WQ["Interview → course brief"]
WQ --> BS["Plan: research → curriculum → category"]
BS --> LOOP{"For each lesson"}
LOOP --> D1["Draft: article + widgets"]
D1 --> D2["Editor + fact-check review"]
D2 --> D3["Widget validation"]
D3 --> ILL["Illustrations"]
D3 --> TST["Test"]
D3 --> HW["Homework"]
D3 --> FC["Flashcards"]
ILL --> RDY["Lesson ready"]
TST --> RDY
HW --> RDY
FC --> RDY
RDY --> LOOP
LOOP -->|all done| FIN(["Course ready"])
Stack: Tauri 2 (desktop shell) · React 19 + TypeScript + Vite · Node sidecar calling @anthropic-ai/claude-agent-sdk and @openai/codex-sdk · SQLite + files for local storage · Playwright + system Chrome for visual widget checks · bundled MCP servers for controlled research tools.
- Courses, progress and media live in the local app data directory. No Learn server hosts your content.
- Agent providers receive only the prompts and course context needed for generation; optional Gemini/Brave integrations receive only the requests for features you enabled.
- Catalog publishing and ngrok sharing happen only when you explicitly trigger them.
- v0.3.0 — private self-hosted catalogs (Docker image + multi-server support in the app), tests/homework toggles and a skippable interview at course creation, multiline topic input.
- v0.2.0 — single lessons, roadmaps, runnable autograded code assignments, custom MCP servers.
- v0.1.x — public catalog, course formats, signed in-app updates, richer lesson visuals.
git clone https://github.com/legostin/learn-almost-anything.git
cd learn-almost-anything
pnpm install
pnpm --dir sidecar install
pnpm tauri devRequires Rust stable, pnpm, and Node 20+. pnpm tauri build produces bundles under src-tauri/target/release/bundle/; for local browser/share testing keep the frontend build current with pnpm build:watch.
The catalog server lives in a separate repository and ships as the legostin/laa-catalog Docker image; the app talks to https://catalog.almost-anything.io by default and to any private servers you add.
Not set. Source is open for reading and personal use; use at your own risk.
More utilities by the author: legost.in