Beginner Workshop

This is a follow-along workshop. Every step gives you one command to copy, one thing to look at, and one short explanation of what just happened. You do not need to know anything about Memanto, vector databases, or embeddings. If you can open a terminal, you can finish this page. Time: about 30 minutes for the whole thing. You can also stop anywhere — each step is self-contained.

Every step below has its own link. Copy the link from a heading (hover it and click the anchor icon) to share “start here” with a teammate, or use the jump list below to resume where you left off.

Jump to a step

1. Install Memanto

Get the memanto command on your machine.

2. Add your API key

Connect the CLI to your account.

3. Create your first agent

An agent is where your memories live.

4. Remember something

Store your first memories.

5. Recall it

Search by meaning, not keywords.

6. Ask a question

Get an answer built from your memories.

7. Open the dashboard

See everything in a browser.

8. Fix a memory

Edit content, type, or confidence.

9. Retire and restore

The reversible way to remove something.

10. Delete for good

forget — the one-way door.

11. Connect your coding tool

Claude Code, Cursor, Copilot, and more.

12. Bring memories with you

Migrate from Mem0, Letta, Supermemory.

13. Handle contradictions

When two memories disagree.

Cheat sheet

Every command from this page in one table.

What you need

A terminal (Terminal on macOS/Linux, PowerShell or Command Prompt on Windows)
Python 3.10 or newer — check with python --version
A free Moorcheh API key (we get one in Step 2)

Don’t want to use an API key at all? You can run the whole stack on your own machine instead — see the On-Prem Quickstart. The commands in this workshop are exactly the same either way.

The 30-second version of what Memanto is

Normally, an AI assistant forgets everything when you close the chat. Memanto is a place to write things down so they survive. Three words cover almost everything you will do:

Word	What it means
agent	A container for memories. Like a notebook. You can have several.
remember	Save one piece of information into the notebook.
recall	Find information again by describing it in your own words.

That’s it. Everything else on this page is a variation on those three.

Step 1: Install Memanto

Memanto is a command-line tool. Install it with pip:

pip install memanto

Check that it worked:

memanto --version

You should see a version number printed. If you get “command not found”, see Troubleshooting.

Prefer uv, Docker, or Node.js?

uv (a faster Python installer):

pip install uv
uv tool install memanto

Docker — runs the server without installing Python packages:

docker pull moorcheh/memanto:latest
docker run -p 8000:8000 -e MOORCHEH_API_KEY=your_api_key moorcheh/memanto:latest

Node.js / TypeScript — if you are building a JS app rather than following along in a terminal:

npm install @moorcheh-ai/memanto

See the TypeScript SDK Reference. The rest of this workshop uses the CLI.Full details: Installation & Setup.

Step 2: Add your API key

Memanto stores your memories through Moorcheh. You need one key to talk to it. Get the key:

Sign up at moorcheh.ai.
Open console.moorcheh.ai → API Keys → create a new key.
Copy it right away — it is only shown once.

Give it to Memanto. Run memanto on its own to start the setup wizard:

memanto

It asks you a couple of questions:

Enter your Moorcheh API key: your_api_key_here
[Optional] Configure daily summary schedule? (y/n): n

Say n to the schedule for now — you can turn it on later. Check that it saved:

memanto config show

Look for:

Moorcheh API Key:    ✓ Configured
Configuration Path:  ~/.memanto/config.json

Now confirm Memanto can actually reach the service:

memanto status

Your key lives in ~/.memanto/config.json, outside your project folder — so it never lands in git by accident.

Step 3: Create your first agent

An agent is just a named box that holds memories. Memories stored in one agent are invisible to another, which is how you keep “work stuff” and “personal project stuff” apart. Let’s make one called workshop:

memanto agent create workshop

You’ll see something like:

Agent 'workshop' created successfully!
Pattern: tool
Agent activated automatically.
Activation expires: 2026-09-02T22:30:00Z
You can now run: memanto remember "..." and memanto recall "..."

Two things happened:

The agent was created.
A session was opened for it automatically, valid for 6 hours.

A session is Memanto’s way of knowing which agent your next command applies to. You almost never have to think about it — Memanto renews it for you when it gets close to expiring. Check what’s currently active any time:

memanto status

Switching between agents later

Make a second agent and Memanto switches to it. To go back:

memanto agent activate workshop

List everything you’ve made:

memanto agent list

More: Agent Management.

Step 4: Store your first memories

Now the fun part. Store a memory:

memanto remember "The workshop demo runs on Python 3.11" --type fact

The --type flag tells Memanto what kind of information this is. Try a couple more with different types:

memanto remember "I prefer short answers with code examples" --type preference

memanto remember "We chose PostgreSQL over MySQL for the demo app" --type decision

memanto remember "I will finish the workshop docs by Friday" --type commitment

Why types matter

You could skip --type entirely and Memanto would still work. But typing your memories lets you ask narrower questions later — “show me only my decisions” — instead of digging through everything. There are 13 types. You only need these four to start:

Type	Use it for	Example
`fact`	Something objectively true	”The API runs on port 8000”
`preference`	How you like things	”I prefer dark mode”
`decision`	A choice that was made	”We picked React”
`commitment`	Something you promised	”Ship the report Friday”

The other nine (goal, event, instruction, relationship, context, learning, observation, error, artifact) are in the Memory Types Reference when you want them.

Useful extras

Add tags so you can filter later:

memanto remember "The demo database resets every night at 2am" \
  --type fact \
  --tags "demo,infra"

Not fully sure about something? Lower its confidence (default is 0.8):

memanto remember "The team might move to a monorepo next quarter" \
  --type observation \
  --confidence 0.5

Have a whole document instead of one sentence? Upload it and Memanto pulls the memories out for you:

memanto upload ./my-notes.pdf

Works with .pdf, .docx, .xlsx, .json, .txt, .csv, and .md. See memanto upload.

Step 5: Recall what you stored

Here’s what makes Memanto different from a text file. Ask for something using completely different words than you stored:

memanto recall "what version of python are we on?"

You never wrote the word “version” — you wrote “runs on Python 3.11” — and it still comes back. Memanto matches on meaning, not on matching letters. Try a few more:

memanto recall "how should the assistant talk to me?"

memanto recall "which database did we pick?"

Reading the output

Each result looks like this:

1. Customer prefers email contact
   Type: preference
   Confidence: 0.98
   Created: 2026-05-08 09:00:00 UTC
   Source: user | Provenance: explicit_statement
   Tags: vip, billing

Confidence — how sure the memory is (you set this when storing).
Source — where it came from: you, an agent, or a file you uploaded.
Provenance — how it was obtained: stated directly, inferred, corrected, and so on.

The long ID string shown with each result is what you’ll use in Steps 8, 9, and 10 — keep this output open, you’ll need one of those IDs shortly.

Narrowing the search

Only show one type:

memanto recall "decisions" --type decision

Only show three results:

memanto recall "demo setup" --limit 3

Filter by tag:

memanto recall "database" --tags "infra"

Just show me the newest things, no search query needed:

memanto recall --recent --limit 10

Looking back in time

Memanto keeps history, so you can ask what things looked like on a given day:

memanto recall --as-of "yesterday"

Or what has changed recently:

memanto recall --changed-since "last week"

Plain English works here: today, yesterday, this week, last 3 days, past 12 hours. Full list in the recall reference.

Step 6: Ask a real question

recall hands you a list of memories. answer reads those memories and writes you a sentence.

memanto answer "What do you know about my workshop project?"

You get a written answer that pulls from everything you stored in Step 4, rather than a list you have to read yourself. Use recall when you want to see the raw memories. Use answer when you want a conclusion.

Want a plain-English roundup of the day? Try:

memanto daily-summary

It lists what you stored today and flags anything that looks contradictory. More in Daily Workflows.

Step 7: Open the web dashboard

Everything so far works in the terminal, but there is also a browser dashboard — much nicer for browsing a lot of memories. It needs two things running, so open two terminal windows. Terminal 1 — start the server and leave it running:

memanto serve

Terminal 2 — open the dashboard:

memanto ui

Your browser opens at http://localhost:3000.

If you close the memanto serve window, the dashboard stops working. Leave it open while you’re using the UI.

What to click first

Page	What it’s for
Dashboard	Which agent is active, connection health, session timing
Agents	See every agent, switch the active one
Playground	Store, recall, ask, and upload — the CLI steps above, as forms
Memory Explorer	Browse everything in a table; there’s a time-machine slider to view past states
Memory History	A heatmap of how much you stored, day by day
Conflicts	Resolve contradictions with buttons instead of prompts (Step 13)
Connections	Link coding tools (Step 11)
Configuration	Answer model, thresholds, session behavior, daily schedule

The memanto ui page has annotated screenshots of every one of these.

Everything in the dashboard is the same data as the CLI. Store a memory in the Playground, then run memanto recall in the terminal — it’s right there.

Step 8: Fix a memory you got wrong

Memories aren’t set in stone. First, find the ID of the one you want to change:

memanto recall "python"

Copy the ID from the result. Then edit it:

memanto edit b7c3cf31-e537-49f1-abc4-c50ac6adeac5 \
  --content "The workshop demo runs on Python 3.12"

Only the fields you name are replaced — everything else, including the original creation time, stays as it was. You can change several fields at once:

memanto edit b7c3cf31-e537-49f1-abc4-c50ac6adeac5 \
  --type fact \
  --confidence 0.95 \
  --tags "demo,python"

Replace b7c3cf31-... with a real ID from your own recall output. The IDs in this guide are examples.

Step 9: Retire a memory (and bring it back)

Sometimes information isn’t wrong, it’s just no longer true. “We deploy manually over SSH” was true last year; today it isn’t. You don’t want to delete that — it’s part of the history. That’s what expire is for.

memanto memory expire b7c3cf31-e537-49f1-abc4-c50ac6adeac5 --reason superseded

Memory expired.
  Memory ID: b7c3cf31-e537-49f1-abc4-c50ac6adeac5
  Reason: superseded
  Still recallable and labelled [EXPIRED]. Restore with 'memanto memory restore b7c3cf31-...'.

Nothing was destroyed. The content, tags, and confidence are all still there. Recall now shows it labelled:

[ACTIVE]  Deploys go through the release bot
[EXPIRED] Deploys are manual via ssh
Expired Sep 2, 2026 03:56 PM · policy: superseded

See only the expired ones:

memanto recall --expired

See only the live ones:

memanto recall "deploys" --active

Changed your mind? Restore it

memanto memory restore b7c3cf31-e537-49f1-abc4-c50ac6adeac5

Memory restored to active.

The expiry stamp is cleared completely — it’s as if it never happened.

This is the safe habit: expire first, delete later. Expiring is always reversible; deleting never is.

Step 10: Delete a memory for good

When you genuinely want something gone — a typo, a duplicate, something private — use forget:

memanto forget b7c3cf31-e537-49f1-abc4-c50ac6adeac5

It asks you to confirm first. To skip the prompt (useful in scripts):

memanto forget b7c3cf31-e537-49f1-abc4-c50ac6adeac5 --force

forget is permanent. A forgotten memory cannot be restored — memanto memory restore only works on expired memories, not deleted ones.

Expire or forget — which one?

	`memanto memory expire`	`memanto forget`
Content kept?	Yes	No
Shows in recall?	Yes, labelled `[EXPIRED]`	No
Reversible?	Yes, with `memory restore`	No
Use when	It stopped being true	It should never have existed

The full model is in Memory Lifecycle.

Step 11: Connect Memanto to your coding tool

Up to now you’ve been typing commands yourself. The real payoff is letting your AI coding tool read and write these memories on its own — so it remembers your project between sessions. See which tools Memanto can detect in your current folder:

memanto connect list

Then connect one. From inside your project directory:

memanto connect claude-code

✓ Memanto connected to Claude Code
  Scope: Local
  Path: /project/.claude/
  Status: Ready to use

Supported targets include claude-code, cursor, windsurf, codex, cline, continue, github-copilot, gemini-cli, opencode, goose, roo, antigravity, augment, and pi. Connect for every project on your machine instead of just this one:

memanto connect claude-code --global

Connect several tools at once, interactively:

memanto connect multi

Undo it:

memanto connect remove claude-code

What just happened

Memanto wrote a small instructions file for that tool (CLAUDE.md, .cursor/rules/memanto.mdc, and so on) telling it how to use your memory. From here, you can tell the assistant “remember that we use 4-space indentation” and it will store it in Memanto — and pick it up again tomorrow. You can also write your memories into a project file by hand:

memanto memory sync

That produces a MEMORY.md in the current folder, which most coding tools read automatically.

Not using a coding tool? Memanto also speaks MCP, which works with Claude Desktop and most other AI clients. See all options in the Integrations overview.

Step 12: Bring memories from another tool

Already using Mem0, Letta, or Supermemory? You don’t have to start over. Always preview first. A dry run shows exactly what would be imported and writes nothing:

memanto migrate mem0 --dry-run

Happy with the preview? Run it for real:

memanto migrate mem0

The same shape works for the others:

memanto migrate letta
memanto migrate supermemory

Memanto asks for that provider’s API key the first time and saves it to ~/.memanto/.env. Import into a specific agent instead of the active one:

memanto migrate mem0 --agent workshop

Already have an export file? Skip the live pull:

memanto migrate mem0 --file ./mem0_export.json

Every run — dry or real — leaves a folder under ~/.memanto/migrate/<provider>/<timestamp>/ with the exact records it mapped, so you can check its work.

Other things you can migrate

okf — import an Open Knowledge Format bundle from a folder of markdown files: memanto migrate okf ./okf-bundle --dry-run
langfuse — a repeatable sync that turns Langfuse errors and slow traces into memories, one per error signature. Start with memanto migrate langfuse --discover.

Full details: memanto migrate.

Step 13: Handle contradictions

Store enough things over enough time and two of them will eventually disagree. Memanto can find those for you. Create a contradiction on purpose so you have something to look at:

memanto remember "We chose MySQL for the demo app" --type decision

You told it PostgreSQL back in Step 4. Now those two decisions can’t both be current. Step A — find the conflicts:

memanto detect-conflicts

Conflict report generated: ~/.memanto/conflicts/workshop_2026-09-02_conflicts.json
  ! 1 conflict(s) detected
  Run 'memanto conflicts' to resolve interactively

This only looks. It changes nothing. Step B — resolve them:

memanto conflicts

Memanto shows both memories side by side with a recommendation, and asks what to do:

Conflict 1/1
[CONTRADICTION]  Database choice changed

Memory A (old):  ID: abc-123 · 2026-09-02
  We chose PostgreSQL over MySQL for the demo app

Memory B (new):  ID: def-456 · 2026-09-02
  We chose MySQL for the demo app

AI Recommendation:  Keep B (new)

Delete the loser (permanent):
[1] Keep A (old memory) — deletes B
[2] Keep B (new memory) — deletes A  << recommended
[3] Keep both
[4] Remove both
Expire the loser (reversible):
[5] Expire A (old memory)
[6] Expire B (new memory)
[7] Expire both
[8] Manual: type replacement
[s] Skip  [q] Quit

Choose:

Notice the menu is split in two:

Options 1–4 and 8 delete permanently. Gone, like Step 10.
Options 5–7 expire instead. The losing memory stays recallable and labelled, exactly like Step 9 — and you can restore it.

If you’re new, pick an expire option (5, 6, or 7). You keep the history and nothing is lost. Just want to look without deciding anything?

memanto conflicts --list

Want this to happen on its own every day? Turn on the scheduler:

memanto schedule enable

It runs the daily summary and the conflict scan for you. You just review the results. See Daily Workflows.

Cheat sheet

Everything from this workshop, in order:

Command	What it does
`pip install memanto`	Install the CLI
`memanto`	Interactive setup (API key)
`memanto config show`	Confirm the key is saved
`memanto status`	Active agent, session, connection health
`memanto agent create NAME`	Create an agent and activate it
`memanto agent activate NAME`	Switch to another agent
`memanto agent list`	List your agents
`memanto remember "..." --type fact`	Store a memory
`memanto upload ./file.pdf`	Store a whole document
`memanto recall "..."`	Search by meaning
`memanto recall --recent --limit 10`	Newest memories
`memanto recall --as-of "yesterday"`	What was true then
`memanto answer "..."`	A written answer from your memories
`memanto daily-summary`	Today’s roundup
`memanto serve`	Start the local server
`memanto ui`	Open the web dashboard
`memanto edit ID --content "..."`	Fix a memory
`memanto memory expire ID`	Retire it (reversible)
`memanto memory restore ID`	Un-retire it
`memanto forget ID`	Delete it (permanent)
`memanto connect list`	See connectable tools
`memanto connect claude-code`	Connect a coding tool
`memanto memory sync`	Write memories to `MEMORY.md`
`memanto migrate mem0 --dry-run`	Preview an import
`memanto detect-conflicts`	Find contradictions
`memanto conflicts`	Resolve them
`memanto schedule enable`	Run both automatically each day

Troubleshooting

'memanto: command not found'

Python installed the tool somewhere that isn’t on your PATH. Try running it through Python directly:

python -m memanto --version

If that works, add Python’s scripts folder to your PATH — or install with uv tool install memanto, which handles it for you.

'No active agent' or 'Unauthorized'

Your session expired, or no agent is active. Check:

memanto status

Then re-activate:

memanto agent activate workshop

The dashboard won't load

memanto ui needs memanto serve running in another terminal. Start that first, then run memanto ui.If port 3000 is taken:

memanto ui --port 8080

And if port 8000 is taken:

memanto serve --port 8001

'memanto conflicts' says there is no report

conflicts reads a report that detect-conflicts writes. Run the detection step first:

memanto detect-conflicts
memanto conflicts

I want to start over

Delete the workshop agent and its memories:

memanto agent delete workshop

Then create a fresh one and run through the steps again.

Where to go next

You now know the whole loop: store, find, correct, retire, and share memories with your tools. Pick whichever of these matches what you want to build.

CLI Reference

Every command with every flag.

Memory Operations

Batch storing, file uploads, extracting memories from chat logs.

Temporal Memory

Point-in-time and “what changed” queries in depth.

Daily Workflows

Automated summaries and scheduled conflict scans.

Integrations

LangChain, CrewAI, MCP, n8n, and every coding tool.

REST API

Do all of this from your own code.

Stuck on something? Ask in Discord or email support@moorcheh.ai.

​Beginner Workshop

​Jump to a step

1. Install Memanto

2. Add your API key

3. Create your first agent

4. Remember something

5. Recall it

6. Ask a question

7. Open the dashboard

8. Fix a memory

9. Retire and restore

10. Delete for good

11. Connect your coding tool

12. Bring memories with you

13. Handle contradictions

Cheat sheet

​What you need

​The 30-second version of what Memanto is

​Step 1: Install Memanto

​Step 2: Add your API key

​Step 3: Create your first agent

​Step 4: Store your first memories

​Why types matter

​Useful extras

​Step 5: Recall what you stored

​Reading the output

​Narrowing the search

​Looking back in time

​Step 6: Ask a real question

​Step 7: Open the web dashboard

​What to click first

​Step 8: Fix a memory you got wrong

​Step 9: Retire a memory (and bring it back)

​Changed your mind? Restore it

​Step 10: Delete a memory for good

​Expire or forget — which one?

​Step 11: Connect Memanto to your coding tool

​What just happened

​Step 12: Bring memories from another tool

​Step 13: Handle contradictions

​Cheat sheet

​Troubleshooting

​Where to go next

CLI Reference

Memory Operations

Temporal Memory

Daily Workflows

Integrations

REST API

Beginner Workshop

Jump to a step

What you need

The 30-second version of what Memanto is

Step 1: Install Memanto

Step 2: Add your API key

Step 3: Create your first agent

Step 4: Store your first memories

Why types matter

Useful extras

Step 5: Recall what you stored

Reading the output

Narrowing the search

Looking back in time

Step 6: Ask a real question

Step 7: Open the web dashboard

What to click first

Step 8: Fix a memory you got wrong

Step 9: Retire a memory (and bring it back)

Changed your mind? Restore it

Step 10: Delete a memory for good

Expire or forget — which one?

Step 11: Connect Memanto to your coding tool

What just happened

Step 12: Bring memories from another tool

Step 13: Handle contradictions

Cheat sheet

Troubleshooting

Where to go next