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

# Memanto Cloud

> Hosted Memanto: sign in with your browser, connect your coding tools, and share one memory across every tool and computer.

# Memanto Cloud

**Memanto Cloud** is hosted Memanto. Your memories live in the cloud instead of on one machine, so every coding tool on every computer you sign in from shares the same agents. There is no API key to copy, no server to run, and nothing to install besides the CLI.

> [card] Sign in with your browser
>
> `memanto login` opens the Memanto console. Approve the computer and you're done.

> [card] One memory for all your tools
>
> Claude Code, Cursor, Codex and the rest read and write the same agent. A fact saved in one shows up in the next session of another.

> [card] Every computer
>
> Sign in on your laptop and your desktop: both see the same memories.

> [card] [Console](https://docs.memanto.ai/cloud/console/overview.md)
>
> Browse, search, edit and expire memories, resolve conflicts, and see which tools are connected, at [console.memanto.ai](https://console.memanto.ai).

> [card] [Console guide](https://docs.memanto.ai/cloud/console/overview.md)
>
> Every page of the Memanto console: memories, connections, migration, API keys, usage and billing.

> [card] [Cloud API](https://docs.memanto.ai/cloud/api/introduction.md)
>
> Call Memanto Cloud over HTTPS with an API key. No server and no sessions.

## Get started

### Option 1: let your coding agent do it

Paste this into Claude Code, Cursor, Codex, or any coding agent:

```text theme={null}
Read https://memanto.ai/start.md and set me up on Memanto
```

The agent installs the CLI, runs `memanto login` (you approve it in your browser), connects itself, and saves a test memory.

### Option 2: three commands

```bash theme={null}
pip install -U memanto
memanto login        # approve this computer in your browser
memanto connect      # pick your tools and the agent they share
```

Then **open a new session** in each tool you connected. From then on it recalls and remembers on its own.

![Terminal: memanto login signs in through the browser, then memanto connect picks Claude Code and Cursor and connects them to my-agent](https://mintcdn.com/memanto/LZOeY0eZRqAGAcUc/logo/cli/cloud/login-and-connect.svg?fit=max\&auto=format\&n=LZOeY0eZRqAGAcUc\&q=85\&s=fd0f08fbf8ffbdf0125e154277a41ed1)

**1. Sign in**

`memanto login` prints a link and a short code, and opens the link in your browser:

```
To sign in, approve this computer in the Memanto console:
  https://console.memanto.ai/cli/authorize?code=ABCD-EFGH
  Code: ABCD-EFGH
⠋ Waiting for approval in your browser · 9:58 left · Ctrl-C to cancel
```

Sign in (or create an account) in the console, check that the code matches, and click **Approve**. New accounts get Memanto Cloud Pro free for the first month.

![Memanto console asking 'Sign in this computer?' for my-laptop, with the code to compare and Approve and Deny buttons](https://mintcdn.com/memanto/LZOeY0eZRqAGAcUc/logo/cli/cloud/console-approve.png?fit=max\&auto=format\&n=LZOeY0eZRqAGAcUc\&q=85\&s=9c308e9d4101079ea487cf502cd9cb6d)

```
Signed in to Memanto Cloud as you@example.com.
Next: memanto connect to set up your coding tools.
```

The code is valid for 10 minutes. On a machine without a browser (SSH, a container), open the link on any other device.

**2. Connect your tools**

Run `memanto connect` from your project folder. Tools it finds in the project are ticked already; choose the agent they share, or create one:

```
Which tools should use Memanto?
  [x]  1. Claude Code (detected)
  [ ]  2. Codex CLI
  [ ]  3. Pi (coding agent)
  [x]  4. Cursor (detected)
  ...
Numbers separated by commas, or 'all'.
Which agent should these tools share?
   1. my-agent
   n. Create a new agent
```

`memanto connect --yes` skips the questions: it connects every detected tool to your most recent agent (or creates `my-agent`). To connect a single tool, name it: `memanto connect claude-code`. See [`memanto connect`](https://docs.memanto.ai/cli/connect/connect).

**3. Check it works**

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

`Backend` reads `memanto-cloud`, followed by your account, plan, and how much of this month's usage is left. Your memories are in the console at [console.memanto.ai/memory](https://console.memanto.ai/memory). On Memanto Cloud, `memanto ui` opens the console too.

## How your tools work together

Every tool connected to the same agent reads and writes the same memories, on any computer. To keep that easy to follow:

* **Each memory records which tool saved it** (`source`, for example `cursor`) and **which project** it came from, as a `project_<folder>` tag (the git root's folder name). The console's **Connections** page shows each tool and when it was last active.

* **Sessions start caught up.** When a Claude Code, Cursor, or Codex session starts, Memanto adds the memories other tools saved since this tool's last session in the same project:

  ```
  Since your last session (2 new):
  - [DECISION] Auth migrated to JWT, session cookies deprecated (from Cursor)
  - [PREFERENCE] Use 4-space indentation in Python files (from Codex CLI)
  ```

* The MCP `recall` tool takes an optional `project` to search one project only. Without it, tools search every project's memories.

## Signing in and out

| Task | Command |
| - | - |
| Sign in with the browser | `memanto login` |
| Sign in with an API key (CI, headless) | `memanto login --key mk_...` |
| Sign this computer out | `memanto logout` |
| See who is signed in, plan and usage | `memanto status` |

* Your key is saved as `MEMANTO_API_KEY` in `~/.memanto/.env`. It is never written into a tool's config files.
* Every computer you sign in from is listed in the console under **API keys → Computers**, where you can revoke it. Signing in again on the same computer replaces its entry instead of adding another.
* `memanto logout` signs the computer out on Memanto Cloud too (its key stops working) and switches back to the backend you used before. Memories stay on Memanto Cloud. A key you created in the console and used with `--key` stays active; manage it in the console.

## Already using Memanto local?

If you set up Memanto with a Moorcheh API key or on-prem before, that setup is now called **Memanto local**. It keeps working exactly as before, and you can use both.

**1. Sign in**

Run `memanto login`. After you approve, it asks what to do with your local memories:

```
You were using Memanto local with Moorcheh Cloud. What about its memories?
  1  Move them to Memanto Cloud  (recommended; your local copy stays)
  2  Continue on Memanto Cloud without them  (move later with: memanto migrate to-cloud)
```

Moving asks once more: **active memories only** (recommended) or **all, including expired**.

**2. Reconnect nothing**

Tools you connected earlier follow the backend automatically. You don't need to run `memanto connect` again.

Moving copies each local agent to Memanto Cloud, with its memories' type, tags, confidence and provenance. Your local copy is not changed. If an agent name is already taken on Memanto Cloud, the copy is named `<agent>-local`. An interrupted move resumes where it stopped and never sends a memory twice. If your plan's agent limit is reached, the move stops and lists the agents it left behind.

To move later, or from a different local backend:

```bash theme={null}
memanto migrate to-cloud                    # from the backend you used before signing in
memanto migrate to-cloud --from on-prem     # or: --from moorcheh
memanto migrate to-cloud --include-expired  # expired memories too (they stay expired)
```

Prefer clicking? Run `memanto ui --local` and use the **Memanto Cloud** tab on the [Migrate page](https://docs.memanto.ai/ui/migrations.md).

## Switching between Cloud and local

```bash theme={null}
memanto use cloud      # Memanto Cloud (signs you in if needed)
memanto use moorcheh   # Memanto local with Moorcheh Cloud
memanto use on-prem    # Memanto local with Moorcheh on-prem
```

Connected tools follow the switch. Switching never moves or deletes memories; each backend keeps its own agents. See [`memanto use`](https://docs.memanto.ai/cli/auth/use).

## What uses Memanto Cloud

| | Memanto Cloud | Memanto local |
| - | :-: | :-: |
| `memanto` CLI | ✓ | ✓ |
| [Desktop widget](https://docs.memanto.ai/cli/system/widget.md) (`memanto widget on`) | ✓ | ✓ |
| [Cloud API](https://docs.memanto.ai/cloud/api/introduction.md) (`x-api-key`) | ✓ | |
| Coding tools connected with `memanto connect` | ✓ | ✓ |
| [`memanto-mcp`](https://docs.memanto.ai/integrations/mcp) | ✓ | ✓ |
| [Console](https://console.memanto.ai) | ✓ | |
| [Local dashboard](https://docs.memanto.ai/ui/overview.md) (`memanto ui`) | Migrate page only (`--local`) | ✓ |
| [REST server](https://docs.memanto.ai/getting-started/quickstart-api.md) (`memanto serve`) and the [Python](https://docs.memanto.ai/sdk/python.md), [TypeScript](https://docs.memanto.ai/sdk/typescript.md) and [Go](https://docs.memanto.ai/sdk/go.md) SDKs | | ✓ |

The REST server and the SDKs run Memanto local: they use a Moorcheh API key or an on-prem server, as before. To reach Memanto Cloud from your own code, call the [Cloud API](https://docs.memanto.ai/cloud/api/introduction.md) directly.

## Agents

An **agent** is a memory namespace your tools share. On Memanto Cloud:

* Deleting an agent deletes its memories with it; they can't be kept. `memanto agent delete` does this without asking about keeping memories.
* How many agents you can have depends on your plan. See [pricing](https://memanto.ai/#pricing) and the console's **Billing** page.

## Troubleshooting

| Symptom | Fix |
| - | - |
| `No such command 'login'` | Your CLI predates Memanto Cloud. Run `pip install -U memanto`. |
| `The sign-in code expired` | Run `memanto login` again for a new code. |
| `Sign-in was denied` | Someone clicked **Deny** in the console. Run `memanto login` again. |
| `Not signed in to Memanto Cloud. Run: memanto login` | The key was removed or revoked. Sign in again. |
| `Memanto Cloud rejected this API key` | The key passed to `--key` is wrong or revoked. Create a new one in the console under **API keys**. |
| A tool doesn't use memory after connecting | Start a **new** session in that tool; integrations load at session start. |


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.