> ## Documentation Index
> Fetch the complete documentation index at: https://docs.memanto.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Beginner Workshop

> A hands-on, copy-paste walkthrough of Memanto — from installing the CLI to connecting it to your coding tool, one small step at a time.

# 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.

<Note>
  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.
</Note>

## Jump to a step

<CardGroup cols={2}>
  <Card title="1. Install Memanto" icon="download" href="#step-1-install-memanto">
    Get the `memanto` command on your machine.
  </Card>

  <Card title="2. Add your API key" icon="key" href="#step-2-add-your-api-key">
    Connect the CLI to your account.
  </Card>

  <Card title="3. Create your first agent" icon="robot" href="#step-3-create-your-first-agent">
    An agent is where your memories live.
  </Card>

  <Card title="4. Remember something" icon="brain" href="#step-4-store-your-first-memories">
    Store your first memories.
  </Card>

  <Card title="5. Recall it" icon="magnifying-glass" href="#step-5-recall-what-you-stored">
    Search by meaning, not keywords.
  </Card>

  <Card title="6. Ask a question" icon="comments" href="#step-6-ask-a-real-question">
    Get an answer built from your memories.
  </Card>

  <Card title="7. Open the dashboard" icon="table-columns" href="#step-7-open-the-web-dashboard">
    See everything in a browser.
  </Card>

  <Card title="8. Fix a memory" icon="pen" href="#step-8-fix-a-memory-you-got-wrong">
    Edit content, type, or confidence.
  </Card>

  <Card title="9. Retire and restore" icon="clock-rotate-left" href="#step-9-retire-a-memory-and-bring-it-back">
    The reversible way to remove something.
  </Card>

  <Card title="10. Delete for good" icon="trash" href="#step-10-delete-a-memory-for-good">
    `forget` — the one-way door.
  </Card>

  <Card title="11. Connect your coding tool" icon="plug" href="#step-11-connect-memanto-to-your-coding-tool">
    Claude Code, Cursor, Copilot, and more.
  </Card>

  <Card title="12. Bring memories with you" icon="right-left" href="#step-12-bring-memories-from-another-tool">
    Migrate from Mem0, Letta, Supermemory.
  </Card>

  <Card title="13. Handle contradictions" icon="code-merge" href="#step-13-handle-contradictions">
    When two memories disagree.
  </Card>

  <Card title="Cheat sheet" icon="list-check" href="#cheat-sheet">
    Every command from this page in one table.
  </Card>
</CardGroup>

## 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)

<Tip>
  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](/on-prem/quickstart). The commands in this workshop are exactly the same either way.
</Tip>

## 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`:

```bash theme={null}
pip install memanto
```

Check that it worked:

```bash theme={null}
memanto --version
```

You should see a version number printed. If you get "command not found", see [Troubleshooting](#troubleshooting).

<Accordion title="Prefer uv, Docker, or Node.js?">
  **uv** (a faster Python installer):

  ```bash theme={null}
  pip install uv
  uv tool install memanto
  ```

  **Docker** — runs the server without installing Python packages:

  ```bash theme={null}
  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:

  ```bash theme={null}
  npm install @moorcheh-ai/memanto
  ```

  See the [TypeScript SDK Reference](/sdk/typescript). The rest of this workshop uses the CLI.

  Full details: [Installation & Setup](/getting-started/installation).
</Accordion>

## Step 2: Add your API key

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

**Get the key:**

1. Sign up at [moorcheh.ai](https://moorcheh.ai).
2. Open [console.moorcheh.ai](https://console.moorcheh.ai) → **API Keys** → create a new key.
3. Copy it right away — it is only shown once.

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

```bash theme={null}
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:**

```bash theme={null}
memanto config show
```

Look for:

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

Now confirm Memanto can actually reach the service:

```bash theme={null}
memanto status
```

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

## 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`:

```bash theme={null}
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:

1. The agent was created.
2. 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:

```bash theme={null}
memanto status
```

<Accordion title="Switching between agents later">
  Make a second agent and Memanto switches to it. To go back:

  ```bash theme={null}
  memanto agent activate workshop
  ```

  List everything you've made:

  ```bash theme={null}
  memanto agent list
  ```

  More: [Agent Management](/guides/agent-management).
</Accordion>

## Step 4: Store your first memories

Now the fun part. Store a memory:

```bash theme={null}
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:

```bash theme={null}
memanto remember "I prefer short answers with code examples" --type preference
```

```bash theme={null}
memanto remember "We chose PostgreSQL over MySQL for the demo app" --type decision
```

```bash theme={null}
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](/reference/memory-types) when you want them.

### Useful extras

Add tags so you can filter later:

```bash theme={null}
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`):

```bash theme={null}
memanto remember "The team might move to a monorepo next quarter" \
  --type observation \
  --confidence 0.5
```

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

  ```bash theme={null}
  memanto upload ./my-notes.pdf
  ```

  Works with `.pdf`, `.docx`, `.xlsx`, `.json`, `.txt`, `.csv`, and `.md`. See [`memanto upload`](/cli/data/upload).
</Tip>

## 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:

```bash theme={null}
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:

```bash theme={null}
memanto recall "how should the assistant talk to me?"
```

```bash theme={null}
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:

```bash theme={null}
memanto recall "decisions" --type decision
```

Only show three results:

```bash theme={null}
memanto recall "demo setup" --limit 3
```

Filter by tag:

```bash theme={null}
memanto recall "database" --tags "infra"
```

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

```bash theme={null}
memanto recall --recent --limit 10
```

### Looking back in time

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

```bash theme={null}
memanto recall --as-of "yesterday"
```

Or what has changed recently:

```bash theme={null}
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](/cli/search/recall#relative-time-strings).

## Step 6: Ask a real question

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

```bash theme={null}
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.

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

  ```bash theme={null}
  memanto daily-summary
  ```

  It lists what you stored today and flags anything that looks contradictory. More in [Daily Workflows](/guides/daily-workflows).
</Tip>

## 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:

```bash theme={null}
memanto serve
```

**Terminal 2** — open the dashboard:

```bash theme={null}
memanto ui
```

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

<Warning>
  If you close the `memanto serve` window, the dashboard stops working. Leave it open while you're using the UI.
</Warning>

### 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](/cli/core/ui) has annotated screenshots of every one of these.

<Note>
  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.
</Note>

## 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:

```bash theme={null}
memanto recall "python"
```

Copy the ID from the result. Then edit it:

```bash theme={null}
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:

```bash theme={null}
memanto edit b7c3cf31-e537-49f1-abc4-c50ac6adeac5 \
  --type fact \
  --confidence 0.95 \
  --tags "demo,python"
```

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

## 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.

```bash theme={null}
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:**

```bash theme={null}
memanto recall --expired
```

**See only the live ones:**

```bash theme={null}
memanto recall "deploys" --active
```

### Changed your mind? Restore it

```bash theme={null}
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.

<Tip>
  This is the safe habit: **expire first, delete later.** Expiring is always reversible; deleting never is.
</Tip>

## Step 10: Delete a memory for good

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

```bash theme={null}
memanto forget b7c3cf31-e537-49f1-abc4-c50ac6adeac5
```

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

```bash theme={null}
memanto forget b7c3cf31-e537-49f1-abc4-c50ac6adeac5 --force
```

<Warning>
  `forget` is permanent. A forgotten memory **cannot** be restored — `memanto memory restore` only works on expired memories, not deleted ones.
</Warning>

### 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](/reference/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:

```bash theme={null}
memanto connect list
```

Then connect one. From inside your project directory:

```bash theme={null}
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:

```bash theme={null}
memanto connect claude-code --global
```

**Connect several tools at once**, interactively:

```bash theme={null}
memanto connect multi
```

**Undo it:**

```bash theme={null}
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:

```bash theme={null}
memanto memory sync
```

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

<Note>
  Not using a coding tool? Memanto also speaks [MCP](/integrations/mcp), which works with Claude Desktop and most other AI clients. See all options in the [Integrations overview](/integrations/overview).
</Note>

## 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:

```bash theme={null}
memanto migrate mem0 --dry-run
```

Happy with the preview? Run it for real:

```bash theme={null}
memanto migrate mem0
```

The same shape works for the others:

```bash theme={null}
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:

```bash theme={null}
memanto migrate mem0 --agent workshop
```

**Already have an export file?** Skip the live pull:

```bash theme={null}
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.

<Accordion title="Other things you can migrate">
  * **`okf`** — import an [Open Knowledge Format](/integrations/okf) bundle from a folder of markdown files: `memanto migrate okf ./okf-bundle --dry-run`
  * **`langfuse`** — a repeatable sync that turns [Langfuse](/integrations/langfuse) errors and slow traces into memories, one per error signature. Start with `memanto migrate langfuse --discover`.

  Full details: [`memanto migrate`](/cli/migrate/migrate).
</Accordion>

## 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:

```bash theme={null}
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:**

```bash theme={null}
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:**

```bash theme={null}
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?

```bash theme={null}
memanto conflicts --list
```

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

  ```bash theme={null}
  memanto schedule enable
  ```

  It runs the daily summary and the conflict scan for you. You just review the results. See [Daily Workflows](/guides/daily-workflows).
</Tip>

***

## 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

<Accordion title="'memanto: command not found'">
  Python installed the tool somewhere that isn't on your PATH. Try running it through Python directly:

  ```bash theme={null}
  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.
</Accordion>

<Accordion title="'No active agent' or 'Unauthorized'">
  Your session expired, or no agent is active. Check:

  ```bash theme={null}
  memanto status
  ```

  Then re-activate:

  ```bash theme={null}
  memanto agent activate workshop
  ```
</Accordion>

<Accordion title="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:

  ```bash theme={null}
  memanto ui --port 8080
  ```

  And if port 8000 is taken:

  ```bash theme={null}
  memanto serve --port 8001
  ```
</Accordion>

<Accordion title="'memanto conflicts' says there is no report">
  `conflicts` reads a report that `detect-conflicts` writes. Run the detection step first:

  ```bash theme={null}
  memanto detect-conflicts
  memanto conflicts
  ```
</Accordion>

<Accordion title="I want to start over">
  Delete the workshop agent and its memories:

  ```bash theme={null}
  memanto agent delete workshop
  ```

  Then create a fresh one and run through the steps again.
</Accordion>

## 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.

<CardGroup cols={2}>
  <Card title="CLI Reference" icon="terminal" href="/cli/overview">
    Every command with every flag.
  </Card>

  <Card title="Memory Operations" icon="brain" href="/guides/memory-operations">
    Batch storing, file uploads, extracting memories from chat logs.
  </Card>

  <Card title="Temporal Memory" icon="clock" href="/guides/temporal-memory">
    Point-in-time and "what changed" queries in depth.
  </Card>

  <Card title="Daily Workflows" icon="calendar" href="/guides/daily-workflows">
    Automated summaries and scheduled conflict scans.
  </Card>

  <Card title="Integrations" icon="plug" href="/integrations/overview">
    LangChain, CrewAI, MCP, n8n, and every coding tool.
  </Card>

  <Card title="REST API" icon="code" href="/getting-started/quickstart-api">
    Do all of this from your own code.
  </Card>
</CardGroup>

Stuck on something? Ask in [Discord](https://memanto.ai/discord) or email [support@moorcheh.ai](mailto:support@moorcheh.ai).