Welcome to Memento

Memento is a knowledge-intelligence platform. Bring your documents, papers, and notes into one place — then turn them into a chat partner, an audio overview, a narrated video, a mind map, flashcards, and study reports, all grounded in your own sources.

What Memento does

Upload one or many sources into a notebook. Memento reads and indexes them, then everything you generate — answers, audio, video, maps — is built only from that material, with citations back to the source. No hallucinated facts from the open web unless you ask for it.

Who it's for

Students revising for exams, researchers digesting a stack of papers, and professionals upskilling on the move. If you have material to learn and not enough time, Memento reshapes it into whatever format helps it stick.

How Memento is different from a chatbot

A general chatbot answers from everything it was trained on — which means it can be confidently wrong, and it has no idea what's in your documents. Memento flips that around:

The workflow at a glance

Almost everything in Memento follows the same three-step shape:

1. Add sources into a notebook — PDFs, web pages, or pasted text.
2. Memento indexes them so they become searchable by meaning.
3. You ask or generate — chat, or open the Studio to make audio, video, a mind map, flashcards, a quiz, or a report.

Once you understand this loop, every feature in these docs is just a different thing you can produce from step 3.

From one notebook, many formats

The same set of sources can become very different things depending on how you want to learn. A single folder of lecture notes can turn into a podcast for your commute, a narrated video to revise from, a mind map to see the structure, and a quiz to test yourself — all grounded in exactly the same material, so nothing drifts out of scope.

Two ways to read these docs

• Using the App — you just want to use Memento in the browser. Start at Notebooks & sources.
• Developers — you're running or extending Memento. Start at Architecture.

Quickstart

From zero to your first generated overview in about two minutes.

1. Sign in

Open app.memento.lunartech.ai and sign in. New notebooks live under your account and stay private to you.

2. Create a notebook

Click New notebook, give it a name, and open it. A notebook is a workspace that holds a set of related sources and everything you generate from them.

3. Add sources

Drag files into the sources panel, or paste a link or raw text. Memento supports:

• Documents — PDF, Word, plain text, Markdown
• Web pages — paste a URL and Memento fetches the readable content
• Pasted text — notes, transcripts, anything you copy in

Each source is parsed, chunked, and embedded so it becomes searchable. You'll see it flip to ready when indexing finishes.

4. Ask or generate

Now you can either ask a question in chat, or open the Studio panel and generate an asset:

# Chat
Ask: "Summarise the main argument and list the evidence."

# Studio → Audio Overview
Pick a language and length → Generate

# Studio → Video Overview
Pick a style (Dark cinematic / NotebookLM light) → Generate

Tips for your first notebook

• Keep one topic per notebook. A notebook about "Cell Biology" gives sharper answers than one mixing biology, history, and tax law — because everything you generate is scoped to that notebook's sources.
• Add more than one source when you can. A single PDF makes a fine overview; three or four related sources make a genuinely useful mind map and knowledge graph.
• Wait for ready. A source is only usable once indexing finishes. Large PDFs take a little longer.

If something looks off

Where to go next

• Core concepts — notebooks, sources, grounding, the studio
• Audio Overview — voices, languages, and lengths
• Video Overview — styles and diagrams

Core concepts

A few ideas that show up everywhere in Memento. Understanding these makes the rest of the docs click.

Notebook

A notebook is your workspace. It groups a set of sources and every asset you generate from them — chats, overviews, maps, cards. Notebooks are private to your account by default.

Source

A source is one piece of material you add: a PDF, a web page, or pasted text. When you add a source, Memento extracts its text, splits it into chunks, and creates a vector embedding for each chunk so it can be searched by meaning, not just keywords.

Grounding & citations

Everything Memento generates is grounded in your sources. When you ask a question, it retrieves the most relevant chunks (semantic + keyword search) and passes only those to the language model. Answers link back to the exact source they came from, so you can verify every claim.

The Studio

The Studio is the panel where you generate media: Audio Overview, Video Overview, Mind Map, Flashcards, Quiz, and Reports. Each one reads your notebook and produces a finished, self-contained asset you can open, replay, or download.

Jobs

Heavier generations (audio, video, graphs) run as background jobs on a worker rather than blocking your browser. A job is queued, claimed by the worker, retried automatically if a step fails, and marked complete when the asset is saved. That's why you can close the tab and come back to a finished video.

Chunks & embeddings, explained simply

Two words show up a lot in these docs, so here's the plain-English version:

• Chunk — a source is too big to search all at once, so Memento cuts it into smaller overlapping passages (a few paragraphs each). The overlap means an idea that spans a page break isn't lost.
• Embedding — each chunk is turned into a list of numbers that captures its meaning. Two chunks about the same idea end up "close" to each other, even if they use different words. That's how Memento finds the right passage when you ask a question phrased differently from the text.

Asset

Anything you generate — an audio overview, a video, a mind map, a set of flashcards, a report — is saved as an asset on the notebook. Assets stay there so you can reopen, replay, download, or delete them later. You're never regenerating from scratch just to look at something again.

Quick glossary

Notebooks & sources

How to bring material into Memento and keep it organised.

Creating a notebook

From your home screen, click New notebook. Name it after the topic you're studying — one notebook per subject, paper set, or project works best, because everything you generate is scoped to that notebook's sources.

Adding sources

Open a notebook and use the Sources panel on the left:

What happens on upload

Each source goes through a short pipeline before it's usable:

1. Extract — pull clean text out of the file or page
2. Chunk — split it into overlapping passages sized for retrieval
3. Embed — turn each chunk into a vector so it's searchable by meaning
4. Index — store it against the notebook, ready to query

When indexing finishes, the source shows as ready and the notebook auto-generates a short summary and suggested questions.

Managing sources

Toggle a source off to exclude it from generation without deleting it, or remove it entirely. Deleting a source also cleans up its embeddings so it no longer influences answers.

Getting good text in = getting good results out

Everything Memento produces is only as good as the text it can read from your sources. A few things help:

• Prefer text-based PDFs. A PDF you can select and copy text from extracts cleanly. A PDF that's really just scanned images of pages has no text to read — those work poorly unless they've been run through OCR first.
• Trim the noise. If you're pasting text, drop long reference lists, cookie banners, or navigation menus — they dilute the useful content.
• One coherent topic per source keeps retrieval sharp.

How many sources should I add?

You can always add more sources to an existing notebook later; new material is indexed and folded into future answers and generations.

Chat with sources

Ask questions in natural language and get answers grounded in your notebook, with citations.

How it works

When you send a message, Memento runs retrieval-augmented generation (RAG):

1. Your question is embedded and matched against your source chunks (semantic + keyword)
2. The most relevant passages are retrieved
3. Those passages — and only those — are sent to the language model with your question
4. The answer comes back with citations linking to the source passages used

Citations

Every answer references the passages it drew from. Click a citation to jump to the exact place in the source, so you can confirm the model didn't drift.

Getting better answers

• Be specific — "list the limitations the authors acknowledge" beats "tell me about this".
• Ask for structure — tables, bullet lists, and step-by-steps all work.
• Follow up — the chat keeps context, so you can drill in without repeating yourself.

Prompts that work well

Chat is most useful when you ask it to do something specific with the material. A few patterns:

What chat can and can't do

• Can — answer from your sources, quote them, compare them, restructure them, and explain them at any level.
• Can't (by design) — invent facts that aren't in your notebook. If the answer isn't in your sources, Memento will tell you rather than guess. That's the point of grounding — add a source that covers the gap and ask again.

Knowledge graph

See the key entities across your sources and how they relate — a bird's-eye view of a whole notebook.

What it shows

Memento extracts entities (people, concepts, methods, datasets, organisations) and the relationships between them across all your sources, then draws them as an interactive graph. Nodes are entities; edges are the connections found in the text.

Reading the graph

• Bigger, labelled nodes are the most connected — the core ideas of the notebook.
• Edges show a stated relationship between two entities.
• Drag to pan, scroll to zoom, and click a node to focus its neighbourhood.

How the graph is built

Memento reads across all the ready sources in the notebook and pulls out named things and the relationships stated between them. Rather than drawing every single entity it finds — which would be an unreadable tangle — it surfaces the most connected core entities and the links among them, so the picture stays legible even for a large notebook.

Knowledge graph vs. mind map

They look similar but answer different questions:

Good for

Comparing several papers, finding where sources agree or contradict, and orienting yourself in an unfamiliar topic before you start reading in depth. If a notebook has only one short source, the graph will be sparse — it comes alive when you give it several related sources to connect.

Audio Overview

Turn a notebook into a narrated, two-host overview you can listen to — in your choice of language.

Generating one

Open the Studio panel, choose Audio Overview, pick a language and a length, and click Generate. The job runs on the worker and you'll be notified when it's ready to play.

Two distinct hosts

The overview is written as a conversation between two hosts with distinct voices — one leads, one asks the questions a listener would. This keeps a long overview engaging instead of a flat monologue.

Languages

Audio Overview supports 140+ languages, including Nepali, Hindi, Spanish, French, German, Japanese, Chinese, Portuguese, and Italian. Choose the language from the dropdown before generating — the script and the narration are both produced in that language.

Lengths

Pick a shorter overview for a quick briefing or a longer one for a deep dive. Longer overviews cover more of the source material and spend more time on each theme.

What happens when you hit Generate

Behind the scenes, an Audio Overview is produced in a few stages, all as a background job:

1. Plan — Memento reads your notebook and outlines the key points worth covering.
2. Script — it writes a two-host conversation in your chosen language, in a natural back-and-forth rather than a flat reading.
3. Narrate — each line is spoken by its host's voice using neural text-to-speech.
4. Stitch — the spoken lines are joined into one continuous audio track and saved to your notebook.

Good ways to use it

• Commute learning — generate an overview the night before and listen on the way in.
• Pre-reading — hear the big picture before you sit down with the full sources.
• Revision — a spoken recap is a different memory channel from re-reading notes.
• Language practice — generate the same notebook in a language you're learning.

Video Overview

A narrated slide deck built from your sources — with section slides, comparisons, stats, and diagrams — playable in-app and exportable as MP4.

Two visual styles

Slide types

Memento plans the deck from your material and picks the right slide for each idea: title, section, content, comparison, stats, table, quote, diagram (a real flowchart), and summary.

Diagrams

Where a concept is a process or a relationship, Memento renders a proper flowchart rather than a wall of text — dark nodes with clear white labels on the cinematic style, and light nodes on the NotebookLM style, so they're readable either way.

How it's built

A two-stage pipeline first analyses your sources into a plan, then writes the slides from that plan, so the deck has a real structure instead of disconnected bullet points. Narration is generated per slide and timed to the visuals.

The slide types in detail

How the two-stage pipeline works

The quality of a video comes from planning it before writing it — the same way a good presenter outlines before making slides:

1. Analyse — Memento reads your sources and builds a structured plan: what the sections are, what each slide should cover, and which slide type fits each idea.
2. Write — it then writes each slide from that plan, so the deck flows as a connected story instead of a pile of disconnected bullets.

Narration is generated for each slide and timed to how long that slide is shown, so the voice and the visuals stay in step.

Choosing a style

Both styles contain identical information — the difference is purely the look:

• Dark — Cinematic: high-contrast and dramatic. Good for a presentation feel or watching on a screen.
• Google NotebookLM: bright, clean, and calm. Good for study notes and easy reading, and it prints/screenshots nicely.

Mind Map

A hierarchical map of a notebook's ideas — expandable, zoomable, and quick to scan.

What it is

The Mind Map breaks your material into a central topic with branching sub-topics and details. Unlike the knowledge graph (which shows many-to-many relationships), the mind map is a clean tree — ideal for revising structure and hierarchy.

Using it

• Expand / collapse branches to focus on one area at a time.
• Zoom and pan to move around a large map; reset to fit it all on screen.
• Fullscreen for presenting or studying, and close (the × in the top-right) to return to your notebook.

The controls

When to reach for a mind map

Use a mind map when you want to understand structure — how a topic decomposes into parts and sub-parts. It's excellent for revising the skeleton of a subject before an exam, or for planning your own writing from source material. If you instead want to see how ideas across several sources interconnect, use the knowledge graph.

Flashcards & Quiz

Turn a notebook into active-recall study material — cards to flip and quizzes to grade you.

Flashcards

Memento generates question-and-answer cards from your sources. Flip through them, mark what you know, and it tracks your progress for spaced repetition — resurfacing the cards you struggle with more often.

Quizzes

Quizzes are auto-generated multiple-choice questions drawn straight from your material. Answer them to check your understanding; Memento grades you and shows the correct answer with a short explanation.

Why spaced repetition works

You remember things better when you're tested on them just as you're about to forget, rather than re-reading them over and over. Flashcards use this: cards you get right are shown less often, and cards you struggle with come back sooner. Over a few sessions, your effort concentrates on exactly the material you haven't locked in yet.

A simple study loop

1. Read or watch an overview of the notebook to get the big picture.
2. Run through the flashcards to drill the facts and definitions.
3. Take the quiz to check you can apply them under question form.
4. Go back to chat to clear up anything you missed.

Reports & Handbooks

Long-form written outputs — a structured report or a study handbook built from your notebook.

Reports

Generate a structured written report that synthesises your sources into sections with headings, explanations, and references back to the material. Useful when you need a written summary you can read, share, or hand in as a starting draft.

Handbooks

A handbook is a longer, guide-style document — organised into chapters with explanations and study aids — for when you want a comprehensive written companion to a topic rather than a quick summary.

Report or handbook — which?

Working with the output

• Use it as a first draft — a structured starting point you refine, not a finished submission.
• Cross-check anything important against the source it came from before you rely on it.
• Pair it with a Video Overview or flashcards so you have the same material in a written and an active-recall form.

Languages & voices

Memento is multilingual across chat, audio, and video.

Text

Chat and written outputs work in a wide range of languages — ask in your language and Memento answers in it.

Narration

Audio Overview and Video Overview narrate in 140+ languages. Pick the narration language from the dropdown before generating. Both the script and the spoken audio are produced in that language.

Examples of supported languages include:

• English, Spanish, French, German, Italian, Portuguese
• Hindi, Nepali, Japanese, Chinese
• …and many more

Voices & fallback

Narration uses a neural text-to-speech engine that provides natural, distinct voices per language. If that engine is briefly unavailable mid-job, Memento automatically falls back to a self-hosted voice so the job still completes rather than failing outright.

Picking the narration language

Before you generate an Audio or Video Overview, choose the language from the dropdown in the generation dialog. Memento then writes the script and speaks it in that language — it's not translating an English recording, it's producing the whole thing natively in your choice.

How the voice fallback works

Narration normally uses a high-quality neural voice service. If that service is briefly unreachable in the middle of a job, Memento doesn't fail the whole overview — it automatically switches to a self-hosted backup voice and carries on. You still get your audio; occasionally a segment may sound slightly different if the switch happened mid-job.

Providers & configuration

Memento is provider-agnostic. Each capability — language model, embeddings, text-to-speech, images — sits behind a swappable interface, so you can change the engine with configuration, not code.

Pluggable by design

Nothing in Memento is hard-wired to a single vendor. Each subsystem reads a provider setting and a key from the environment, so you can pick what fits your budget and availability.

Automatic fallback

Relying on a single provider is a single point of failure. Memento's language and speech layers are built to fail over automatically: if the primary provider errors or times out, the request is retried on a secondary one, so a brief outage doesn't break chat, quizzes, or media generation.

Why this design matters

AI providers change prices, deprecate models, and have outages — often with little notice. Because every capability in Memento is behind a swappable interface, none of that forces a rewrite:

• Cost control — move to a cheaper model or a free tier by changing a setting, not the code.
• Resilience — if one provider goes down, the fallback keeps the app working.
• No lock-in — you're never trapped with one vendor's pricing or terms.
• Future-proof — a better model that appears next month can be dropped in with a key.

Bring your own key

For a self-hosted deployment, you supply the keys for whichever providers you choose via environment variables. Nothing is hard-coded to a specific vendor. See Self-hosting for exactly which variables control each capability.

Privacy & data

Your notebooks are yours.

Your material

Sources you upload and assets you generate live in your account and are private to you by default. Memento generates answers from your notebook — it doesn't train on your material.

Where things live

• Text, embeddings, and metadata are stored in the application database.
• Media files (audio, video) are stored in object storage and served to you over secure links.

Deleting data

You can delete any generated asset or source from its menu. Deleting a source also removes its embeddings so it no longer affects future answers. Deleting a notebook removes its contents.

What leaves Memento

To generate answers and media, Memento sends the relevant text to your configured AI providers (language model, embeddings, text-to-speech). It sends the passages needed for the task — not necessarily your whole library — and it doesn't use your material to train those models. When you self-host, you choose those providers yourself, so you control where that processing happens.

Good practice

• Delete sources and assets you no longer need — it keeps notebooks focused and removes the data.
• Use separate notebooks for sensitive vs. shareable material.
• Remember that generated media (audio, video) is stored so you can replay it; delete it when you're done if it contains anything sensitive.

Architecture

How the pieces fit together — for anyone running, extending, or contributing to Memento.

The big picture

Memento is a few cooperating parts: a web app, a serverless database with edge functions, a background worker for heavy jobs, and object storage for media.

  Browser (React app)
        │
        ├──▶ Edge functions ──▶ Language model / Embeddings   # fast, interactive: chat, quiz, cards
        │        │
        │        └──▶ Database (Postgres + vector search)
        │
        └──▶ Job queue ──▶ Worker ──▶ TTS / Video / Graph      # heavy, background: audio, video
                                │
                                └──▶ Object storage (media files)

The parts

The job queue

Anything slow runs as a job. The worker claims queued jobs, executes them with automatic retries, and moves permanently failing jobs to a dead-letter state. A reaper re-queues jobs that get stuck, so the pipeline is self-healing. This is why long media survives a page reload — the state lives in the queue, not the browser.

Two paths through the system

Requests split into two lanes depending on how fast they need to be:

• Interactive lane — chat, quizzes, flashcards, the mind map, and embeddings run through edge functions, which respond quickly so the UI feels live.
• Heavy lane — audio, video, and knowledge-graph generation are pushed onto the job queue and run on the worker, which can take minutes without blocking anything.

A job's life

1. Enqueued — the app inserts a job row when you hit Generate.
2. Claimed — the worker picks it up and marks it in-progress.
3. Run — it executes the steps (plan → write → narrate → encode, etc.).
4. Retry — a transient failure is retried automatically a few times.
5. Complete or dead-letter — on success the asset is saved; if it keeps failing it's moved aside so the queue never jams.
6. Reaper — a periodic sweep re-queues any job that got stuck, so the pipeline is self-healing.

Technology, at a glance

Self-hosting

Run your own Memento. The stack is designed to run on free or low-cost tiers.

What you'll need

• A database with vector search and edge functions
• A serverless worker host for background jobs
• Object storage for media
• Keys for your chosen language model, embeddings, and TTS providers

Configuration

Configuration is entirely via environment variables — copy the example file and fill in your own values. Everything provider-related is a swap of key and setting.

# start from the template
cp .env.example .env

# then set the providers you want, e.g.
TTS_PROVIDER=edge          # neural TTS, with automatic fallback
EMBEDDING_PROVIDER=...      # your embeddings provider
SLIDE_IMAGES=off           # toggle generated slide imagery

Build & run

# front-end
npm install
npm run build

# worker
cd worker && npm install && npm run build

Full setup steps, the complete variable list, and the contributor guide live in the repository's README and CONTRIBUTING files.

Rough setup order

1. Database — create the project, enable vector search, and apply the schema and edge functions.
2. Storage — create a bucket for media and note its access details.
3. Worker — deploy the worker package and point it at your database.
4. Front-end — build the app and deploy the static output (e.g. to Cloudflare Pages), with your public app config set as build-time variables.
5. Secrets — set provider keys as server-side secrets on the edge functions and the worker.

Checking it works

• Create a notebook and add a small text source — it should reach ready (confirms extraction + embeddings).
• Ask a question in chat — a cited answer confirms the language model and retrieval are wired up.
• Generate a short Audio Overview — success confirms the worker, TTS, and storage are all connected.

Changelog

Recent, notable changes to Memento.

Latest

• New  Narration language picker on both Audio and Video Overview — 140+ languages including Nepali.
• New  Neural text-to-speech with automatic self-hosted fallback, and two distinct hosts in Audio Overview.
• New  Automatic language-model fallback so a single provider outage no longer breaks chat and generation.
• Improved  Video Overview: two styles (Dark cinematic + NotebookLM light), real flowchart diagrams, instant in-app playback with MP4 packaged right after.
• Improved  Knowledge graph simplified to the core entities for a readable overview.
• Improved  Resizable studio panel and a cleaner mind-map viewer with a clear close control.
• Fixed  Delete controls across generated assets, with confirmation.

No results

Nothing matched your search. Try a different term, or browse the sidebar.