Skip to main content
Glama

Memora MCP

License: MIT MCP Apps TypeScript React

Turn any conversation into an interactive study session, right inside Claude Desktop. Ask Claude to make a deck and it generates the cards, then renders them as an inline review you can click through: flip flashcards, answer multiple-choice quizzes, and fill in cloze blanks. Every answer updates a spaced-repetition schedule, and your results flow back to Claude so it can drill what you missed.

Keywords: Model Context Protocol, MCP server, MCP Apps, Claude Desktop, flashcards, quizzes, spaced repetition, SRS, FSRS, Anki alternative.

Built on the MCP Apps extension (SEP-1865): core MCP spec 2025-11-25 plus the Apps extension 2026-01-26.

Three ways to study, rendered inline in Claude

Features

Three ways to study, all rendered inline and all graded the same way:

  • Flashcards: click to flip, then grade Got it / Missed it.

  • Multiple-choice quizzes: pick an option and the correct/wrong answers reveal instantly.

  • Cloze (fill-in-the-blank): the blank reveals in place so the sentence stays intact. Write a blank as [...] in a card front and it becomes a cloze card automatically.

Spaced repetition: every grade updates a per-card FSRS schedule (via ts-fsrs), so weak cards resurface sooner and due cards come first. Ask "what's due today?" for a summary across all your decks.

Organize with categories: name decks with :: to nest them (e.g. LLM::Attention). Browse the category tree, or the same tree as an interactive mind map, and study a whole branch in one merged session. Quiz decks are flagged with a badge.

Manage your decks: create, append to, edit, rename, and delete decks and cards without leaving the chat. Pass reverse when creating a deck to also drill each card back-to-front (handy for vocabulary).

Just JSON: decks live in data/decks.json, read live on every call. Hand-edit them or let Claude build them. No database, no external service.

Browse decks as a category tree or a mind map

Related MCP server: mcp-ankiconnect

The tools

Only review_deck and study open the inline flip-card UI; everything else returns a text summary, so editing or creating in chat no longer pops the widget.

Tool

What it does

review_deck

Open one deck for review (due cards first, capped per session).

study

Review a whole category subtree, merged into one session (capped per session).

create_deck

Generate flashcards or cloze cards; reverse also adds back-to-front cards.

create_quiz

Generate multiple-choice questions.

grade_card

Record a review result and update the card's FSRS schedule (called by the UI).

due_today

Summarize what is due across all decks, and flag struggling cards (3+ lapses).

edit_card

Change a card's front and/or back.

refine_card

Propose splitting a card into atomic pieces, or rewriting it to test understanding.

apply_refinement

Persist a refinement after the user approves the proposed cards.

capture

Turn something that just burned you (a bug, a missed question) into draft cards.

apply_capture

Persist captured cards after the user approves them.

rename_deck

Rename a deck (also moves it in the category tree).

delete_card

Remove a single card.

delete_deck

Remove a whole deck.

Card generation follows Memora's quality rules (atomic single-concept cards, 1-5 word answers, active recall, unambiguous, no answer leakage, application over definition), based on Wozniak's 20 Rules of Formulating Knowledge. New cards are linted on write and flagged (never blocked) so Claude can revise them.

How it works (MCP Apps)

A tool declares a ui:// resource. When Claude calls the tool, the host (Claude Desktop) fetches that resource, renders its HTML in a sandboxed iframe, passes the tool result to the UI, and the UI talks back to the host over JSON-RPC (to grade cards and report progress to the model).

The MCP Apps round trip

Quick start

Prerequisites

  • Node.js 20.11+

Connect to Claude Desktop

Open Settings > Developer > Edit Config and add Memora under mcpServers:

{
  "mcpServers": {
    "memora": {
      "command": "npx",
      "args": ["-y", "@servation/memora-mcp", "--stdio"]
    }
  }
}

Then fully quit Claude Desktop (from the system tray) and relaunch. memora appears under Settings > Developer, pre-loaded with a few sample decks.

Your decks are stored in ~/.memora/decks.json (override the path with the MEMORA_DECKS environment variable). Hand-edit that file or let Claude manage it.

git clone https://github.com/Servation/memora-mcp.git
cd memora-mcp
npm install
npm run build

Point the config at the built entry with an absolute path (decks then live in the repo's data/decks.json):

{
  "mcpServers": {
    "memora": {
      "command": "node",
      "args": ["C:\\path\\to\\memora-mcp\\dist\\main.js", "--stdio"]
    }
  }
}

Try it (in a Claude Desktop chat)

  • review my World Capitals deck

  • make me a deck of 10 Spanish travel phrases

  • make a reversible deck of 10 Spanish words (drills both directions)

  • make a fill-in-the-blank deck about the water cycle (cloze cards)

  • quiz me with 10 multiple-choice questions on the solar system

  • turn what we just discussed into a deck called "Photosynthesis"

  • study my LLM category

  • what's due today?

Tech stack

Deck format

{
  "Deck Name": [
    { "front": "Capital of France?", "back": "Paris" }
  ]
}
  • Stored in ~/.memora/decks.json when installed (or data/decks.json from source); override with MEMORA_DECKS.

  • Read live (mtime-cached). create_deck, create_quiz, and grade_card write here atomically.

  • A quiz card adds "options": ["...", "..."]; its back is the correct option.

  • A cloze card writes the blank as [...] in the front, with the hidden term as the back.

  • Cards gain a due date and an FSRS srs block as you review them; cards without them are treated as new.

  • Keep it valid JSON, or the server falls back to a built-in default deck.

Project structure

memora-mcp/
├── server.ts            # MCP tools + the ui:// resource
├── decks.ts             # data model, decks.json storage, result builder
├── scheduling.ts        # FSRS scheduling + review ordering
├── main.ts              # entry: stdio (Claude Desktop) or Streamable HTTP
├── mcp-app.html         # UI entry HTML (bundled by Vite)
├── src/
│   ├── mcp-app.tsx      # review orchestrator (flip / quiz / cloze, grade -> model)
│   ├── deck-lib.tsx     # tree, mind map, card list, quiz/cloze views, helpers
│   ├── mcp-app.module.css
│   └── global.css       # host theme variable fallbacks (light/dark)
├── data/decks.json      # editable decks, read live
├── media/               # README images
├── vite.config.ts       # single-file bundle config
└── tsconfig*.json

Development

npm run dev        # vite watch (UI) plus tsx server on http://localhost:3001/mcp
npm run typecheck  # tsc --noEmit

For fast local iteration you can also run the app against the MCP Apps reference host (basic-host) from the ext-apps repo.

Roadmap

See TODO.md for the backlog: npm + MCP Registry publishing, cross-client hosting (Streamable HTTP), tests around parsing and scheduling, and a real screen-capture demo GIF.

License

MIT

Available Tools

10 tools
create_deckCreate DeckA

Create (or extend) a flashcard deck from cards you generate based on the user's request or the current conversation, then display it for review. Use "::" in deck_name to nest under a category (e.g. "LLM::Attention"). The deck persists to data/decks.json.

Follow Memora's card-quality rules (based on Wozniak's '20 Rules of Formulating Knowledge'). The front is the prompt/question, the back is the answer:

  1. Minimum information (atomic): each card tests exactly one fact or concept. Split complex material into several simple cards; never ask for lists or paragraph answers.

  2. Concise answers: the back is ideally 1-5 words (a name, date, term, or single concept), never a sentence or paragraph.

  3. Active recall: make the front a specific question (not 'Explain X'), or a cloze deletion: write the blank as "[...]" in the front and the hidden term as the back (e.g. front "The Transformer was introduced in [...].", back "2017").

  4. Unambiguous: each front must point to exactly one correct answer.

Set reverse=true to also add the back->front version of each non-cloze card (useful for vocabulary or term/definition pairs that should be drilled both ways).

Inputs: cards (required), deck_name (required), append, reverse. Returns: deck, cards, count, dueCount, +3 more

create_quizCreate QuizA

Create (or extend) a multiple-choice quiz deck from questions you generate based on the user's request or the conversation, then display it for review. Use "::" in deck_name to nest under a category. Persists to data/decks.json and is reviewed like flashcards with spaced repetition.

Each question: a clear, specific prompt; 3 to 4 concise options with exactly ONE correct answer and plausible (not obviously wrong) distractors. The answer must match one of the options exactly.

Inputs: deck_name (required), questions (required), append. Returns: deck, cards, count, dueCount, +3 more

delete_cardDelete CardA

Delete a single card from a deck, identified by its front text. Refuses to delete a deck's last card (delete the deck instead).

Inputs: front (required), deck_name (required). Returns: deck, cards, count, dueCount, +3 more

delete_deckDelete DeckA

Delete a deck and all its cards. Refuses to delete the only remaining deck.

Inputs: deck_name (required).

due_todayDue TodayA

Summarize what is due to review right now across all decks: per-deck and total due/new counts. Pull-based (call it to see the summary); it does not appear on its own.

Inputs: no named parameters. Returns: date, decks, totalDue, totalNew

edit_cardEdit CardA

Edit a card's front and/or back in a deck, identified by its current front text, then re-render the deck. Keep edits within Memora's card-quality rules (atomic, concise 1-5 word answers, unambiguous).

Inputs: front (required), deck_name (required), new_back, new_front. Returns: deck, cards, count, dueCount, +3 more

grade_cardGrade CardA

Record a spaced-repetition review result for a single card and update its FSRS schedule in data/decks.json. Called by the flip-card UI; not for direct model use.

Inputs: front (required), correct (required), deck_name (required).

rename_deckRename DeckA

Rename a deck, preserving its cards and schedules. Use "::" in the new name to move it under a category. Fails if a deck with the new name already exists.

Inputs: new_name (required), deck_name (required). Returns: deck, cards, count, dueCount, +3 more

review_deckReview DeckA

Return the flashcards of a single Memora deck and display them as an interactive flip-card review (due cards first). Available decks: "Geography::World Capitals", "Geography::Rivers", "Science::Solar System", "Language::Spanish Basics". Deck names use "::" to form a category tree; use the study tool to review a whole category. Decks are read live from data/decks.json.

Inputs: deck_name. Returns: deck, cards, count, dueCount, +3 more

studyStudy CategoryA

Study every card under a category node of the deck tree. Deck names use "::" to nest (e.g. "LLM::Attention"); studying a node reviews all decks at or under that path, merged and shuffled into one session. Omit path to study all decks. Each card stays attributed to its source deck.

Inputs: path. Returns: deck, cards, count, dueCount, +3 more

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 10 tools

    Disambiguation5/5

    Each tool targets a distinct action: deck/quiz creation, card/deck deletion, editing, renaming, reviewing single decks or categories, grading, and summary. No two tools have overlapping purposes; descriptions clearly differentiate them.

    Naming Consistency3/5

    Most tools follow a verb_noun pattern (create_deck, delete_card, etc.), but 'due_today' is a noun phrase and 'study' is a bare verb, breaking the consistency. This mix could confuse an agent predicting tool names.

    Tool Count5/5

    10 tools is well-scoped for a flashcard/quiz application. Each tool serves a necessary function in the creation, management, review, and scheduling lifecycle without being excessive or sparse.

    Completeness4/5

    The tool set covers CRUD operations, review, and scheduling. However, there is no tool to list all decks or view cards without triggering a review session, which is a minor gap that could hinder agent workflows.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers