# Memside Documentation

> Complete public documentation for Memside, an AI continuity and personal memory hub.

This file is generated from the public documentation source. It contains no private application data.

Source: https://docs.memside.com/concepts/how-memside-works/

Memside is an AI continuity and memory hub with a reusable context layer. It
works beside existing AI tools rather than replacing them.

## A simple flow

| Step | What happens |
| --- | --- |
| **Save** | Useful information is saved as a Memory. |
| **Organize** | Tags, Subjects, and Connections keep related information together. |
| **Connect** | A supported AI tool is connected to Memside. |
| **Continue** | Saved information is available in a later chat or work session. |

This flow keeps useful context available without copying every conversation.

Memside Library adds a separate reuse path. Public Templates can be inspected
and then downloaded, added to Memside, or used through supported connected
tools. Import remains selective, and public Template content does not gain
access to private Memories.

## Information that can be saved

Memside can hold:

- notes, decisions, goals, events, links, and references;
- tasks and checkpoints;
- preferences and instructions;
- files and imported text;
- information about people, companies, projects, or other topics;
- links between related Memories.

## Using Memside with an AI tool

A connected AI tool can search or read saved information when it is needed.

For example:

1. Save a project goal, a preferred writing style, and the next task.
2. Start a later session in a supported AI tool.
3. Ask the AI to find the saved project information.
4. Continue from the saved task without repeating the earlier details.

Only selected information is saved. Memside does not require a copy of the
entire conversation.

## Keeping information organized

Several product features help keep saved information clear:

- **Tags** add simple labels.
- **Subjects** group information around a person, company, project, product, or
  other topic.
- **Facts** hold reviewed information about a Subject.
- **Connections** link related Memories.
- **Checkpoints** record the current state of work and what should happen next.

These features are optional. A useful Memory can be saved without setting up
every type of organization.

## Choosing what can be shared

Every Memory has a sensitivity setting:

- **Private** is suitable for normal personal or project information.
- **Public** allows broader use by connected AI tools. It does not create a
  public web page.
- **Secret** keeps the information inside the Memside app and away from
  connected AI tools.

Passwords, recovery codes, payment details, and access keys should not be saved
in Memside.

## What Memside does not do

Memside does not:

- replace an AI client or its current conversation;
- save every chat automatically;
- make stored information public automatically;
- perform actions in another app without the controls provided by that app.
- treat a public Library Template as private account data.

## Next steps

- [Memories](/product/memories/)
- [Checkpoints and tasks](/product/checkpoints-and-tasks/)
- [Connections, Subjects, and Facts](/product/connected-context/)
- [Memside Library](/library/)
- [Connection overview](/connect/mcp-and-api/)

---

Source: https://docs.memside.com/connect/antigravity/

Google Antigravity can use Memside as an MCP server while an agent works inside
the IDE. This gives the agent access to selected Memories, checkpoints,
Operating Rules, and other saved project context.

Antigravity currently uses an MCP configuration file for this setup. A native
remote-server option can be used instead when it is available in the installed
version.

## Before starting

1. Sign in to Memside.
2. Open **Settings > Developer & API**.
3. Create an API key and copy it when shown.
4. Open Google Antigravity.

## Open the MCP configuration

1. Open **Settings**.
2. Select **Open Antigravity user settings**.
3. Open **Customizations**.
4. Select **Open MCP Config**.
5. Confirm that `mcp_config.json` opens.

## Add Memside

Add the following server entry and replace the placeholder with the Memside API
key:

```json
{
  "mcpServers": {
    "memside": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.memside.com/mcp/",
        "--header",
        "Authorization: Bearer mem_sk_example_key"
      ]
    }
  }
}
```

Save the file, close the settings, and restart Antigravity.

Common configuration locations:

- Windows: `%USERPROFILE%\.gemini\antigravity\mcp_config.json`
- macOS: `~/.gemini/antigravity/mcp_config.json`

If Antigravity offers a native OAuth remote-server flow, add `Memside` with
`https://api.memside.com/mcp/` and complete the Memside sign-in instead of
placing an API key in the configuration.

## Confirm the connection

Open the MCP server list and confirm that `memside` is running and its tools
are visible.

Then start with a read-only request:

```text
Use Memside to find the latest checkpoint and explain the next step.
```

## Troubleshooting

- Restart Antigravity after saving the configuration.
- Check that `mcp_config.json` contains valid JSON.
- Confirm that the API key is active.
- Use the built-in MCP server interface if the raw configuration format has
  changed in the installed release.

## Next steps

- [Connection overview](/connect/mcp-and-api/)
- [API keys](/developers/api-keys/)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/connect/chatgpt/

ChatGPT and Codex desktop can connect to Memside through an installed MCP server
and OAuth. This flow does not require a Memside API key to be pasted into the
app.

## Before starting

- Sign in to [Memside](https://www.memside.com) in a browser.
- Use an account with access to Plugins and MCP server installation.
- A workspace administrator may control access for managed accounts.

## Current interface: Option 1

1. Open **Plugin** from the left bar.
2. Select **Settings** in the upper-right corner.
3. Open **MCP**.
4. Select **Install MCP server**.
5. Name the server `Memside`.
6. Set **MCP Server URL** to:

   ```text
   https://api.memside.com/mcp/
   ```

7. Keep **Authentication** set to **OAuth**.
8. Install the server.
9. When prompted, sign in to Memside and approve the connection.

## Current interface: Option 2

1. Open the account **profile** and select **Settings**.
2. Open **Plugins**.
3. Select **Add**.
4. Select **Install MCP server**.
5. Name the server `Memside`.
6. Set **MCP Server URL** to `https://api.memside.com/mcp/`.
7. Keep **Authentication** set to **OAuth**.
8. Install the server, then sign in to Memside and approve the connection.

## Previous interface

Some earlier ChatGPT versions use the following flow:

1. In ChatGPT, open the account **profile** and choose **Settings**.
2. Open **Plugin** or **Security**, depending on the interface shown.
3. Scroll down and turn on **Developer mode**.
4. Close Settings.
5. Open **Plugins** from the left panel.
6. Select the plus button in the upper-right corner.
7. Choose the option to add a custom plugin.
8. Name the plugin `Memside`.
9. Set **MCP Server URL** to:

   ```text
   https://api.memside.com/mcp/
   ```

10. Keep **Authentication** set to **OAuth**.
11. Add the plugin.
12. When prompted, sign in to Memside and approve the connection.

Memside should then appear in the Plugin area.

:::note
Use the flow that matches the interface shown. OpenAI may change these labels or
move the controls in a future app release. Managed workspaces may apply
administrator permissions, and availability can vary by account, region, or
supported surface.
:::

## Test the connection

Start a new chat, enable Memside when the app requests a Plugin or MCP server
choice, and use a simple read request:

> Find the most recent project checkpoint saved in Memside.

Review any request that writes or changes data before approving it.

## Disconnect

Remove or disconnect Memside from the app's Plugin settings. The OAuth
connection can also be revoked from Memside settings. Disconnecting does not
delete the Memside account or saved Memories.

If setup does not finish, see [Troubleshooting](/help/troubleshooting/).

---

Source: https://docs.memside.com/connect/claude-code/

Claude Code can use Memside as a remote MCP server for project continuity. The
connection lets Claude Code load selected Memories, checkpoints, Operating
Rules, and other saved context before planning, editing, or reviewing code.

The setup uses the Claude Code CLI and a Memside API key.

## Before starting

1. Install Claude Code and confirm that the `claude` command works.
2. Sign in to Memside.
3. Open **Settings > Developer & API**.
4. Create an API key and copy it when shown.

## Choose the connection scope

- Use project scope when Memside is needed only for the current project.
- Use user scope when Memside should be available across Claude Code projects.

## Add Memside to the current project

Open a terminal in the project folder and run:

```bash
claude mcp add --transport http --header "Authorization: Bearer mem_sk_example_key" memside https://api.memside.com/mcp/
```

## Add Memside for all projects

Run the same command with user scope:

```bash
claude mcp add --transport http --scope user --header "Authorization: Bearer mem_sk_example_key" memside https://api.memside.com/mcp/
```

## Confirm the connection

1. Run `claude mcp list`.
2. Open Claude Code.
3. Use `/mcp` to check the server status when needed.

Claude Code stores local or user-scope servers in `~/.claude.json`. Project
servers are stored in `.mcp.json` at the project root.

Start with a read-only request:

```text
Use Memside to load the current checkpoint before proposing changes.
```

## Troubleshooting

- Run `claude mcp list` and confirm that `memside` is present.
- Use `/mcp` to inspect the connection state.
- Confirm that the API key is active and the URL ends with `/mcp/`.
- Remove and add the server again if the stored configuration is incorrect.

Memside uses remote HTTP. Local Windows guidance for `npx`-based standard input
and output servers does not apply to this connection.

## Next steps

- [Claude](/connect/claude/)
- [API keys](/developers/api-keys/)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/connect/claude/

Claude can connect to Memside as a remote custom connector. The hosted
connector flow uses OAuth, so no Memside API key is required.

## Add the connector

1. In Claude, open the account **profile** and choose **Settings**.
2. Open **Connectors**.
3. Choose **Add custom connector**.
4. Enter `Memside` as the name.
5. Set **Remote MCP Server URL** to:

   ```text
   https://api.memside.com/mcp/
   ```

6. Add the connector.
7. When prompted, sign in to Memside and approve the OAuth connection.
8. Restart the Claude app once if the connector does not appear immediately.

Once connected to the Claude account, Memside may also be available in Claude
on other supported devices.

## Test the connection

Ask Claude:

> Find the most recent Memside checkpoint and summarize the next actions.

Claude should request only the tools needed for the task. Review write or delete
requests before approving them.

## If desktop authentication loops

Add and connect the same Memside server from
[claude.ai](https://claude.ai) in a browser first. Then restart the desktop app
or sign in again.

For Claude Code, use the separate [Claude Code](/connect/claude-code/) guide.

---

Source: https://docs.memside.com/connect/codex/

Codex can connect to Memside through MCP. The connection allows Codex to load
selected Memories, project checkpoints, Operating Rules, and other saved
context before it plans, edits, or reviews code.

Start with the CLI setup when the installed Codex version provides the `mcp`
command. Use the MCP server screen when working in a Codex surface that exposes
configuration through the interface.

## Before starting

1. Sign in to Memside.
2. Open **Settings > Developer & API**.
3. Create an API key and copy it when shown.
4. Confirm that the installed Codex version supports MCP servers.

## Option 1: Add Memside with the Codex CLI

1. Open a terminal.
2. Add the Memside remote server:

```bash
codex mcp add memside --url https://api.memside.com/mcp/
```

3. List the configured servers:

```bash
codex mcp list
```

4. If Codex requests authentication details, use this bearer header:

```text
Authorization: Bearer mem_sk_example_key
```

5. Restart Codex if the new tools do not appear.

## Option 2: Use the MCP server screen

1. Open **Settings** in Codex.
2. Open **MCP Servers**.
3. Select **Add Server**.
4. Enter `memside` as the server name.
5. If the form supports a remote URL, enter:

```text
https://api.memside.com/mcp/
```

6. Add the bearer authorization header using the Memside API key.
7. Save the server and restart Codex.

If the form accepts only a launch command, use:

- **Command:** `npx`
- **Arguments:** `-y`, `mcp-remote`, `https://api.memside.com/mcp/`,
  `--header`, `Authorization: Bearer mem_sk_example_key`
- **Environment variables:** leave empty unless required by the installed build
- **Environment variable passthrough:** leave empty
- **Working directory on Windows:** `%USERPROFILE%\.codex`

## Configuration file location

Some Codex versions store MCP configuration in:

- Windows: `%USERPROFILE%\.codex\config.toml`
- macOS or Linux: `~/.codex/config.toml`

Use the MCP configuration format supported by the installed Codex release. The CLI or the MCP
server screen is preferred because it writes the correct format for that
version.

## Confirm the connection

Run `codex mcp list` or open the MCP server settings. Confirm that `memside` is
enabled and its tools are available.

Then start with a read-only request:

```text
Use Memside to find the active checkpoint and summarize the current task.
```

## Troubleshooting

- Restart Codex after adding or changing the server.
- Confirm that `codex mcp list` includes `memside`.
- Check that the server URL ends with `/mcp/`.
- Recreate the Memside API key if authentication fails.
- Use the MCP setup path available in the installed Codex surface when the CLI
  command is unavailable.

## Next steps

- [Connection overview](/connect/mcp-and-api/)
- [API keys](/developers/api-keys/)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/connect/cursor/

Cursor can use Memside as a remote MCP server. This allows Cursor agents to
read selected Memories, checkpoints, Operating Rules, and other saved project
context before planning, editing, or reviewing code.

The project configuration below is the simplest place to start. It keeps the
connection limited to one project and can use OAuth when supported by the
installed Cursor version.

## Before starting

- Install a current Cursor version with MCP support.
- Sign in to Memside in the browser used for OAuth.
- Open the project that needs the Memside connection.

## Add Memside to the project

1. Open the project in Cursor.
2. Create the `.cursor` folder if it is not already present.
3. Create or open `.cursor/mcp.json`.
4. Add the following configuration.

```json
{
  "mcpServers": {
    "memside": {
      "type": "streamable-http",
      "url": "https://api.memside.com/mcp/"
    }
  }
}
```

5. Save the file.
6. Open Cursor MCP settings and confirm that `memside` appears.
7. If Cursor opens OAuth, sign in to Memside and approve the connection.
8. Restart Cursor if the tools do not appear.

## Make Memside available in every project

Use the same configuration in the global file:

```text
~/.cursor/mcp.json
```

Use project configuration when Memside is needed only for one workspace. Use
global configuration when the same connection should be available across
Cursor projects.

## API-key authentication

Some Cursor versions require a bearer header instead of OAuth. In that case:

1. Create a Memside API key under **Settings > Developer & API**.
2. Add it only through a secure header or secret setting supported by Cursor.
3. Do not place the real key in a shared repository file.

## Confirm and test the connection

Open Cursor MCP settings and confirm that `memside` is enabled and its tools
are listed. Then run:

```text
Use Memside to find the latest project checkpoint before planning changes.
```

## Troubleshooting

- Restart Cursor after changing `mcp.json`.
- Check that the JSON is valid and the file is in the correct folder.
- Complete the Memside OAuth flow if a browser window opens.
- Confirm that the installed Cursor version supports remote MCP servers.
- Use API-key authentication only through a secure setting supported by Cursor.

## Next steps

- [Connection overview](/connect/mcp-and-api/)
- [API keys](/developers/api-keys/)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/connect/developer-tools/

Memside gives compatible coding tools access to saved project context, checkpoints,
Operating Rules, and other selected Memories. This helps a coding session begin
with the right context and continue work without repeating the same background.

Each tool uses a different setup screen or configuration file. Select the guide
for the app being connected.

## Setup guides

| Tool | Best starting point |
| --- | --- |
| [VS Code](/connect/vscode/) | Add Memside to the user or workspace `mcp.json` configuration |
| [GitHub Copilot](/connect/github-copilot/) | Add Memside through the VS Code MCP configuration |
| [Cursor](/connect/cursor/) | Add a remote server in `.cursor/mcp.json` |
| [Codex](/connect/codex/) | Use the Codex MCP command or MCP server settings |
| [Google Antigravity](/connect/antigravity/) | Open the Antigravity MCP configuration |
| [Claude Code](/connect/claude-code/) | Add the remote server with the Claude CLI |
| [OpenCode](/connect/opencode/) | Add Memside to `opencode.json` |

## Before starting

1. Sign in to Memside.
2. Open **Settings > Developer & API**.
3. Create an API key and copy it when shown.
4. Open the guide for the required coding tool.

Some clients support OAuth and do not require an API key. The app-specific
guide identifies the supported authentication path.

## First connection test

After setup, begin with a read-only request:

```text
Use Memside to find the current project checkpoint and summarize the next step.
```

This confirms that the connection works before any create or update action is
approved.

## Keep API keys safe

- Use secret input fields or local user configuration where available.
- Do not commit a real API key to a repository.
- Do not include a key in screenshots or shared messages.
- Revoke the key in Memside when a device or client should no longer have access.

## Next steps

- [API keys](/developers/api-keys/)
- [Developer quickstart](/developers/)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/connect/github-copilot/

GitHub Copilot Chat in VS Code can use Memside through MCP. This gives Agent
mode access to selected Memories, project checkpoints, Operating Rules, and
other saved context while work continues in a repository.

Copilot uses the MCP configuration provided by VS Code. Memside is therefore
added to VS Code first, then selected from Copilot Chat.

## Before starting

- Install a current VS Code version.
- Install and sign in to GitHub Copilot Chat.
- Confirm that Agent mode and MCP servers are available.
- Create a Memside API key under **Settings > Developer & API**.

## Add Memside to the current project

1. Open the project in VS Code.
2. Create or open `.vscode/mcp.json`.
3. Add the following configuration.

```json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "memside-api-key",
      "description": "Memside API key",
      "password": true
    }
  ],
  "servers": {
    "memside": {
      "type": "http",
      "url": "https://api.memside.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${input:memside-api-key}"
      }
    }
  }
}
```

4. Save the file.
5. Enter the Memside API key when VS Code requests it.
6. Approve the server if a trust prompt appears.
7. Open Copilot Chat.
8. Switch to Agent mode and open the tools menu.
9. Confirm that Memside tools are available.

This configuration uses a password input so the real API key is not stored in
the workspace file.

## Make Memside available across projects

Open the Command Palette and run **MCP: Open User Configuration** or **MCP: Add
Server**. Add the same Memside URL and bearer header to the user-level
configuration.

## Confirm the connection

1. Run **MCP: List Servers**.
2. Select `memside`.
3. Confirm that the server is running and tools were discovered.
4. Return to Copilot Chat in Agent mode.

Start with a read-only request:

```text
Use Memside to load the latest checkpoint and summarize the next action.
```

## Troubleshooting

- Update VS Code and the Copilot Chat extension.
- Confirm that the workspace is trusted.
- Check the `memside` status under **MCP: List Servers**.
- Confirm that the Copilot plan or organization policy permits MCP servers.
- Recreate the Memside API key if the server reports an authentication error.

See [VS Code](/connect/vscode/) for user-level and workspace-level manual setup.

## Next steps

- [VS Code](/connect/vscode/)
- [API keys](/developers/api-keys/)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/connect/grok/

## Before starting

Grok needs access to custom MCP connectors.

Memside server:

```text
https://api.memside.com/mcp/
```

## Setup

1. Open Grok.
2. Open **Settings**.
3. Open **Connectors**.
4. Choose **Add custom connector** or **Add MCP connector**.
5. Choose **OAuth** when authentication is requested.
6. Set the name to `Memside`.
7. Enter `https://api.memside.com/mcp/`.
8. Save the connector.
9. Sign in to Memside through the OAuth window.

Restart Grok once if the connector does not appear immediately.

An API key is not required for this OAuth setup.

## Test

```text
Use Memside to find the Weekend trip plan Memory and summarize the next step.
```

## Notes

Grok labels may change over time. Use the current custom MCP connector flow,
select OAuth, and keep the Memside server URL unchanged.

## Next steps

- [Connection overview](/connect/mcp-and-api/)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/connect/in-app-assistant/

:::caution
Memside uses an externally managed provider model. Model usage and billing are
handled by the selected provider.
:::

## Overview

The in-app assistant provides a chat surface inside Memside. Open it with the
floating **AI** button on the dashboard.

The button can be moved. The assistant window can also be repositioned and
resized.

## Connect a provider

Open **Settings > LLM Configuration**.

Memside supports:

- **Custom (OpenAI-compatible)** providers;
- **Local (Ollama)** for models running on the same computer.

### Custom provider

1. Select **Custom (OpenAI-compatible)**.
2. Choose a provider example when available.
3. Review the provider label, base URL, and model.
4. Enter the provider API key.
5. Select **Save**, then **Test**.

### Local Ollama

1. Start Ollama or the local model server.
2. Select **Local (Ollama)**.
3. Review the base URL and model.
4. No API key is required for Ollama.
5. Select **Save**, then **Test**.

The assistant is ready when the test succeeds.

## Costs

Memside does not bill for the external model. Usage costs and limits are
controlled by the connected provider.

## Assistant modes

The assistant starts in **Chat** mode. Quick Actions provide:

- **Chat** for normal discussion;
- **Create** to draft a Memory;
- **Update** to suggest changes to a Memory;
- **Fetch** to find saved Memories for the conversation.

Modes are selected manually. Create and Update always require review before
changes are saved.

## Assistant controls

- **Attach Bundle** adds the current Memory Bundle to the message.
- **Clear Chat** removes the current assistant conversation.
- **Close** hides the assistant.

The assistant is a convenient way to use a connected model with saved context.
It remains inactive until a provider is configured.

## Next steps

- [Settings](/product/settings/)
- [Memory Bundles](/product/memory-bundles/)
- [Security and Privacy](/help/security-and-privacy/)

---

Source: https://docs.memside.com/connect/mcp-and-api/

## Choose a connection

| Use case | Recommended path |
| --- | --- |
| Hosted AI app such as ChatGPT, Grok, or Claude | MCP with OAuth |
| IDE or coding agent | MCP with a Memside API key |
| JavaScript application | JavaScript SDK |
| Python application | Python SDK |
| Another language or script | REST API |
| Chat inside the Memside app | Bring an AI provider |

## Connection details

| Setting | Value |
| --- | --- |
| MCP server | `https://api.memside.com/mcp/` |
| REST API | `https://api.memside.com` |
| API-key header | `Authorization: Bearer mem_sk_example_key` |

Create and revoke API keys under **Settings > Developer & API**.

:::caution
Treat an API key like a password. Do not put it in a URL, commit it to source
control, or include it in a screenshot or shared message.
:::

## Hosted AI apps

- [ChatGPT](/connect/chatgpt/)
- [Grok](/connect/grok/)
- [Claude](/connect/claude/)

These setup paths use OAuth when supported. OAuth allows sign-in without
pasting an API key into the AI app.

## IDEs and coding agents

- [VS Code](/connect/vscode/)
- [GitHub Copilot](/connect/github-copilot/)
- [Cursor](/connect/cursor/)
- [Codex](/connect/codex/)
- [Google Antigravity](/connect/antigravity/)
- [Claude Code](/connect/claude-code/)
- [OpenCode](/connect/opencode/)

These tools commonly use a Memside API key in a bearer header. Authentication
options can vary by app version.

## In-App Assistant

The Memside in-app assistant uses a provider configured under **Settings > LLM
Configuration**.

See [In-App Assistant](/connect/in-app-assistant/).

## Applications and SDKs

- [Developer quickstart](/developers/)
- [JavaScript SDK](/developers/javascript-sdk/)
- [Python SDK](/developers/python-sdk/)
- [REST API](/developers/api-reference/)

## What connected AI tools can do

Available actions can include:

- search and read Memories;
- create or update Memories;
- save and continue from checkpoints;
- use Tasks, Subjects, Connections, Profile, Rules, and Skills;
- suggest Facts for review.
- search public Library Templates;
- review owned Template status and bounded draft content;
- create, update, review, publish, unpublish, or republish owned Templates.

Two independent settings control whether MCP exposes Memory tools, Library
tools, or both. Library creator actions require a Library creator account and
follow the same ownership and review requirements as the Library website.

Secret Memories remain inside the Memside app. Fact suggestions require review.
Permanent deletion requires AI delete permission and explicit confirmation.

## Test a connection

Start with a read-only request:

```text
Use Memside to find the Weekend trip plan Memory and summarize the next step.
```

Test create, update, and delete actions only after reads work.

For Library discovery, a simple read test is:

```text
Search the Memside Library for a weekly planning Template.
```

## Troubleshooting

See [Troubleshooting](/help/troubleshooting/) for authentication, missing tools,
and client-specific issues.

See [Library access through MCP and API](/library/mcp-and-api/) for the connected
Template workflow.

---

Source: https://docs.memside.com/connect/opencode/

OpenCode can use Memside through MCP to load selected Memories, checkpoints,
Operating Rules, and other saved project context. This helps an OpenCode
session begin with the context needed for planning, coding, or review.

The configuration below uses a local bridge to connect OpenCode to the hosted
Memside MCP server.

## Before starting

1. Install a current OpenCode version.
2. Confirm that Node.js and `npx` are available.
3. Sign in to Memside.
4. Open **Settings > Developer & API**.
5. Create an API key and copy it when shown.

## Open the OpenCode configuration

Open or create `opencode.json`.

Common locations:

- Windows: `%USERPROFILE%\.config\opencode\opencode.json`
- macOS: `~/.config/opencode/opencode.json`

## Add Memside

Add the following entry and replace the placeholder with the Memside API key:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "memside": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "mcp-remote",
        "https://api.memside.com/mcp/",
        "--header",
        "Authorization: Bearer mem_sk_example_key"
      ],
      "enabled": true
    }
  }
}
```

Save the file and restart OpenCode.

If the installed OpenCode version supports OAuth for remote MCP servers, add
Memside as a remote server with `https://api.memside.com/mcp/` and complete the
Memside sign-in instead.

## Confirm the connection

Open the MCP server status in OpenCode. Confirm that `memside` is enabled and
its tools are available.

Then start with a read-only request:

```text
Use Memside to find the active checkpoint and relevant Operating Rules.
```

## Troubleshooting

- Restart OpenCode after changing `opencode.json`.
- Check that the configuration is valid JSON.
- Confirm that Node.js and `npx` are available.
- Confirm that the Memside API key is active.
- Use the native remote OAuth setup when it is available in the installed
  OpenCode version.

## Next steps

- [Connection overview](/connect/mcp-and-api/)
- [API keys](/developers/api-keys/)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/connect/vscode/

VS Code can connect to Memside through MCP when GitHub Copilot Chat and MCP
servers are enabled. The connection lets compatible agent tools read selected
Memories, checkpoints, Operating Rules, and other saved project context.

Memside is currently configured manually because it is not listed in the VS
Code MCP gallery.

## Before starting

The setup requires:

- a current VS Code version with MCP support;
- GitHub Copilot Chat when Memside will be used through Copilot;
- a Memside API key from **Settings > Developer & API**.

## Option 1: Make Memside available across projects

Use the user configuration when the same Memside connection should be available
in every VS Code workspace.

1. Open the Command Palette.
2. Run **MCP: Open User Configuration**.
3. Add the configuration shown below to the opened `mcp.json` file.
4. Save the file.
5. Enter the Memside API key when VS Code requests it.
6. Approve the server if VS Code asks whether it is trusted.

## Option 2: Add Memside to one workspace

Use this option when Memside should be available only in one project.

1. Open the project in VS Code.
2. Create or open `.vscode/mcp.json`.
3. Add the following configuration. The same configuration is used for the
   user-level setup above.

```json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "memside-api-key",
      "description": "Memside API key",
      "password": true
    }
  ],
  "servers": {
    "memside": {
      "type": "http",
      "url": "https://api.memside.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${input:memside-api-key}"
      }
    }
  }
}
```

4. Save the file.
5. Enter the Memside API key when VS Code requests it.
6. Approve the server if VS Code asks whether it is trusted.
7. Open Copilot Chat in Agent mode.

The password input keeps the API key out of the workspace file. A shared
`.vscode/mcp.json` file must never contain a real key.

## Confirm the connection

1. Run **MCP: List Servers**.
2. Select `memside`.
3. Start or restart the server.
4. Confirm that it shows as running.
5. Confirm that tools were discovered.

Then run a read-only test in Copilot Chat:

```text
Use Memside to find the active project checkpoint before starting work.
```

## Troubleshooting

- Update VS Code and the GitHub Copilot extension.
- Confirm that the workspace is trusted.
- Run **MCP: List Servers** and restart `memside`.
- Check whether an organization policy restricts MCP servers.
- Recreate the Memside API key if authentication continues to fail.

## Next steps

- [GitHub Copilot](/connect/github-copilot/)
- [API keys](/developers/api-keys/)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/developers/api-keys/

## Create a key

1. Open **Settings > Developer & API**.
2. Enter a connection name and optionally select an expiry date.
3. Create the API key.
4. Copy it immediately.

The full key is shown only once. An account can keep up to five active API keys.
Revoke an unused key before creating another when the limit has been reached.

## Use the key

Send the key as a bearer token:

```text
Authorization: Bearer mem_sk_example_key
```

Do not place API keys in URLs.

## Environment variables

Windows PowerShell:

```powershell
$env:MEMSIDE_API_KEY = "mem_sk_example_key"
```

macOS or Linux:

```bash
export MEMSIDE_API_KEY="mem_sk_example_key"
```

## Test

```bash
curl https://api.memside.com/context/startup \
  -H "Authorization: Bearer $MEMSIDE_API_KEY"
```

## Safety

- Do not commit API keys to source control.
- Do not paste keys into screenshots, logs, or shared chats.
- Use separate keys for separate tools when practical.
- Revoke a key when it is no longer needed.
- Revoke and replace a key immediately if it is exposed.

## Access boundaries

API keys can use supported public routes. Account management, billing, private
files, and other app-only features are not general API-key routes.

Secret Memories are not available through API-key or normal MCP access.

## Next steps

- [JavaScript SDK](/developers/javascript-sdk/)
- [Python SDK](/developers/python-sdk/)
- [REST API](/developers/api-reference/)

---

Source: https://docs.memside.com/developers/api-reference/

## Base URL

```text
https://api.memside.com
```

## Authentication

```text
Authorization: Bearer mem_sk_example_key
```

Do not send API keys in query strings.

## Context and Memory routes

| Method | Path | Purpose |
| --- | --- | --- |
| `GET` | `/context/startup` | Load startup context. |
| `GET` | `/context/resume` | Continue from a checkpoint. |
| `GET` | `/context/workspace-profile` | Load workspace guidance. |
| `GET` | `/memories` | List Memories. |
| `GET` | `/memories/search` | Search Memories. |
| `GET` | `/memories/batch` | Get several known Memories. |
| `GET` | `/memories/{id}` | Get one Memory. |
| `POST` | `/memories` | Create a Memory. |
| `PATCH` | `/memories/{id}` | Update a Memory. |
| `DELETE` | `/memories/{id}` | Delete a Memory when allowed. |
| `GET` | `/memories/{id}/revisions` | List Memory revisions. |

### Batch-read limits

`GET /memories/batch` accepts between one and eight exact Memory IDs. Duplicate
IDs are returned once. Memory text is bounded to 2,000 characters per returned
Memory and 12,000 characters across the complete response. A body can therefore
be shortened, and later items can return a body-budget error when the total
limit has already been used.

## Subject and connected-context routes

| Method | Path | Purpose |
| --- | --- | --- |
| `GET` | `/subjects` | List or search Subjects. |
| `POST` | `/subjects` | Create a Subject. |
| `GET` | `/subjects/{subject_id}` | Get one Subject. |
| `PATCH` | `/subjects/{subject_id}` | Update one Subject. |
| `POST` | `/subjects/{subject_id}/deletion/prepare` | Prepare a confirmed Subject deletion. |
| `DELETE` | `/subjects/{subject_id}` | Delete a Subject after confirmation. |
| `GET` | `/subjects/{subject_id}/memories` | List Memories linked to a Subject. |
| `GET` | `/memories/{id}/subjects` | List Subjects linked to a Memory. |
| `POST` | `/subjects/{subject_id}/memories` | Link a Memory to a Subject. |
| `DELETE` | `/subjects/{subject_id}/memories/{memory_id}` | Remove a Memory link from a Subject. |
| `GET` | `/subjects/{subject_id}/context` | Load bounded Subject context. |
| `GET` | `/subjects/{subject_id}/facts` | List reviewed Subject Facts. |
| `POST` | `/subjects/{subject_id}/fact-suggestions` | Create a source-backed Fact suggestion. |
| `GET` | `/memories/{id}/context-map` | Load a bounded Context Map. |
| `GET` | `/subjects/{subject_id}/memory-insights` | List pending read-only Memory insights. |

## Library routes

| Method | Path | Purpose |
| --- | --- | --- |
| `GET` | `/library/templates` | Search public Library Templates. |
| `GET` | `/library/creator/status` | Review owned Templates and workflow results. |
| `POST` | `/library/templates/{template_id}/read` | Read bounded owned draft content. |
| `PUT` | `/library/templates/{template_id}/draft` | Replace an owned private draft. |
| `POST` | `/library/templates/workflow` | Create, review, publish, unpublish, or republish an owned Template. |

Read-only keys can use retrieval routes. Read-write keys are required for
changes. Library routes follow the same creator ownership and publication review
rules as the Library website.

## Search example

```bash
curl "https://api.memside.com/memories/search?q=weekend%20trip&limit=5" \
  -H "Authorization: Bearer $MEMSIDE_API_KEY"
```

## Create example

```bash
curl https://api.memside.com/memories \
  -X POST \
  -H "Authorization: Bearer $MEMSIDE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "Weekend trip plan\nHotel confirmed. Choose activities next.",
    "type": "note",
    "sensitivity": "private",
    "tags": ["travel", "planning"]
  }'
```

## Common status codes

| Status | Meaning |
| --- | --- |
| `200` | Request succeeded. |
| `201` | A resource was created. |
| `400` | The request is invalid. |
| `401` | Credentials are missing or invalid. |
| `403` | Access is not allowed. |
| `404` | The resource was not found. |
| `429` | Too many requests. |
| `500` | Server error. |

## Error response

```json
{
  "ok": false,
  "error": {
    "code": "unauthorized",
    "message": "Missing credentials",
    "status": 401,
    "retryable": false
  }
}
```

## App-only features

The public API is intentionally smaller than the Memside app. Account
management, billing, private file access, and other app-only features are not
general API-key routes.

Secret Memories are excluded from public API-key access.

## Source and examples

- [Public API source documentation](https://github.com/memside/memside/blob/main/docs/public-api.md)
- [curl examples](https://github.com/memside/memside/tree/main/examples/curl)
- [JavaScript examples](https://github.com/memside/memside/tree/main/examples/javascript)

## Next steps

- [API keys](/developers/api-keys/)
- [JavaScript SDK](/developers/javascript-sdk/)
- [Python SDK](/developers/python-sdk/)
- [Library access through MCP and API](/library/mcp-and-api/)

---

Source: https://docs.memside.com/developers/

Memside provides JavaScript and Python SDKs, a REST API, and a hosted MCP
server.

## Choose a path

| Use case | Recommended path |
| --- | --- |
| JavaScript or TypeScript application | [JavaScript SDK](/developers/javascript-sdk/) |
| Python application | [Python SDK](/developers/python-sdk/) |
| Another language or a simple script | [REST API](/developers/api-reference/) |
| ChatGPT, Claude, Grok, or an IDE agent | [MCP setup guides](/connect/mcp-and-api/) |

## Before starting

1. Sign in to Memside.
2. Open **Settings > Developer & API**.
3. Create an API key.
4. Copy the key when it is shown.
5. Store it in an environment variable.

Windows PowerShell:

```powershell
$env:MEMSIDE_API_KEY = "mem_sk_example_key"
```

macOS or Linux:

```bash
export MEMSIDE_API_KEY="mem_sk_example_key"
```

## Test the API

```bash
curl https://api.memside.com/context/startup \
  -H "Authorization: Bearer $MEMSIDE_API_KEY"
```

The response should contain JSON from Memside. An invalid key returns an
authentication error.

## Install an SDK

JavaScript:

```bash
npm install memside
```

Python:

```bash
pip install memside
```

## Public source

The SDK source, examples, changelog, support information, and issue tracker are
available in the [Memside public GitHub
repository](https://github.com/memside/memside).

## Next steps

- [API keys](/developers/api-keys/)
- [JavaScript SDK](/developers/javascript-sdk/)
- [Python SDK](/developers/python-sdk/)
- [REST API](/developers/api-reference/)

---

Source: https://docs.memside.com/developers/javascript-sdk/

## Requirements

- Node.js 18 or newer
- a Memside API key

## Install

```bash
npm install memside
```

## Create a client

```js
import { MemsideClient } from "memside";

const memside = new MemsideClient({
  apiKey: process.env.MEMSIDE_API_KEY
});
```

## Load startup context

```js
const startup = await memside.context.startup();
console.log(startup);
```

## Search Memories

```js
const results = await memside.memories.search({
  q: "weekend trip",
  limit: 5
});

console.log(results);
```

## Get one Memory

```js
const memory = await memside.memories.get("memory_id_here");
console.log(memory);
```

## Create a Memory

```js
const created = await memside.memories.create({
  text: "Weekend trip plan\nHotel confirmed. Choose activities next.",
  type: "note",
  sensitivity: "private",
  tags: ["travel", "planning"]
});

console.log(created);
```

Creating, updating, and deleting changes account data. Review the request before
running it.

## Available areas

Context:

- `memside.context.startup()`
- `memside.context.resume()`
- `memside.context.workspaceProfile()`

Memories:

- `memside.memories.list()`
- `memside.memories.search()`
- `memside.memories.get()`
- `memside.memories.getBatch()`
- `memside.memories.create()`
- `memside.memories.update()`
- `memside.memories.delete()`

## Errors

Failed requests throw `MemsideError` with fields such as:

- `status`
- `code`
- `retryable`
- `requestId`
- `details`

```js
import { MemsideClient, MemsideError } from "memside";

try {
  await memside.memories.get("missing_id");
} catch (error) {
  if (error instanceof MemsideError) {
    console.error(error.status, error.code, error.message);
  }
}
```

## Source

[JavaScript SDK on GitHub](https://github.com/memside/memside/tree/main/packages/memside)

## Next steps

- [API keys](/developers/api-keys/)
- [REST API](/developers/api-reference/)
- [Python SDK](/developers/python-sdk/)

---

Source: https://docs.memside.com/developers/python-sdk/

## Requirements

- Python 3.9 or newer
- a Memside API key

## Install

```bash
pip install memside
```

## Create a client

```python
from memside import MemsideClient

client = MemsideClient(api_key="mem_sk_example_key")
```

The client also reads `MEMSIDE_API_KEY` from the environment:

```python
from memside import MemsideClient

client = MemsideClient()
```

## Load startup context

```python
startup = client.context_startup()
print(startup)
```

## Search Memories

```python
results = client.memories_search(q="weekend trip", limit=5)
print(results)
```

## Get one Memory

```python
memory = client.memories_get("memory_id_here")
print(memory)
```

## Create a Memory

```python
created = client.memories_create({
    "text": "Weekend trip plan\nHotel confirmed. Choose activities next.",
    "type": "note",
    "sensitivity": "private",
    "tags": ["travel", "planning"],
})

print(created)
```

Creating, updating, and deleting changes account data. Review the request before
running it.

## Available methods

Context:

- `context_startup()`
- `context_resume()`
- `context_workspace_profile()`

Memories:

- `memories_list()`
- `memories_search()`
- `memories_get()`
- `memories_get_batch()`
- `memories_create()`
- `memories_update()`
- `memories_delete()`

## Errors

Failed requests raise `MemsideError`.

```python
from memside import MemsideClient, MemsideError

try:
    client.memories_get("missing_id")
except MemsideError as error:
    print(error.status, error.code, str(error))
```

## Source

[Python SDK on GitHub](https://github.com/memside/memside/tree/main/packages/python)

## Next steps

- [API keys](/developers/api-keys/)
- [REST API](/developers/api-reference/)
- [JavaScript SDK](/developers/javascript-sdk/)

---

Source: https://docs.memside.com/getting-started/

This guide shows how to save one useful Memory, find it in Memside, and use it
from a connected AI tool.

## Before starting

The setup needs:

- a verified Memside account;
- one piece of information worth keeping;
- a supported AI tool for the optional connection test.

Open [Memside](https://www.memside.com) and sign in.

## 1. Create a Memory

Select **Create Memory** to open the create modal.

Enter a clear title and focused content. For example:

```text
Title: Weekend trip plan

Goal: Plan a three-day city trip.
Completed: The travel dates and hotel are confirmed.
Next step: Choose activities.
```

Choose:

- **Type:** Note
- **Sensitivity:** Private

New Memories start with **Active** status automatically. Status can be changed
later from the edit form.

The optional **Project** field can place the Memory in an existing Project.

Select **Create Memory**.

## 2. Save a checkpoint

A checkpoint records the current state before work pauses or moves to another
AI tool.

Create or edit an eligible Note or Task, then enable **Checkpoint Preset**.
Keep the summary short:

```text
Travel dates and hotel confirmed. Choose activities next.
```

A useful checkpoint normally includes:

- completed work;
- important decisions;
- current blockers;
- the next action;
- relevant links or references.

## 3. Find the Memory in Memside

Search for `Weekend trip plan`.

The result should show the saved Memory with its current status and
sensitivity. Open it and confirm that the title, content, and checkpoint summary
are correct.

## 4. Connect an AI tool

Choose the connection method that matches the AI tool:

- **OAuth** for supported hosted apps such as ChatGPT and Claude.
- **API key** for developer tools and custom applications.

Follow the [Connection overview](/connect/mcp-and-api/) before adding a
connection.

## 5. Test the connection

Send a simple request from the connected AI:

```text
Search Memside for the Weekend trip plan checkpoint.
Summarize the completed work and next step.
```

The response should identify:

- the confirmed travel dates and hotel;
- choosing activities as the next step.

Review any request that creates, changes, or deletes data before approval.

## Continue learning

- [How Memside works](/concepts/how-memside-works/)
- [Memories](/product/memories/)
- [Checkpoints and tasks](/product/checkpoints-and-tasks/)
- [Memside Library](/library/) for reusable AI Templates

---

Source: https://docs.memside.com/help/help-and-future/

## Where to start

Choose the page that matches the task:

- [Connection overview](/connect/mcp-and-api/) for MCP and AI setup.
- [Developer quickstart](/developers/) for API and SDK use.
- [Settings](/product/settings/) for account controls, imports, providers, and
  permissions.
- [User AI Profile](/product/user-ai-profile/) for reusable preferences.
- [AI Skills](/product/ai-skills/) for reusable instructions.
- [Search and Filters](/product/search-and-filters/) for finding saved context.
- [Troubleshooting](/help/troubleshooting/) for common problems.

## Report a problem

Email [support@memside.com](mailto:support@memside.com).

Include the affected app, operating system, approximate time, exact error text,
and safe reproduction steps. Remove API keys, tokens, and private content from
screenshots or logs.

## Product direction

Current product direction includes:

- smoother connections with AI tools and external workflows;
- better continuity and retrieval;
- richer import and organization options;
- continued improvement of the personal memory hub.

Future-looking notes describe direction, not fixed delivery promises.

## Next steps

- [Troubleshooting](/help/troubleshooting/)
- [Support](/help/support/)
- [Security and Privacy](/help/security-and-privacy/)

---

Source: https://docs.memside.com/help/security-and-privacy/

## Overview

Memside uses privacy-conscious defaults:

- saved data belongs to the account;
- AI sharing is intentional;
- external connections, exports, and deletions remain controlled.

Memside does not send saved content to an AI provider unless a connected tool
or provider is used.

## Saved data

Memside stores the Memories, notes, tasks, attachments, and other information
that is intentionally saved.

That information remains private to the account unless it is exported or used
through a connected service.

## Connected AI providers

Memside supports externally managed AI providers and connected AI tools.

When the in-app assistant, MCP, or API is used, only the information involved
in that request is sent to the chosen provider or tool. Memside does not
automatically send the entire Memory collection.

## Safe connection habits

- Connect only trusted tools and servers.
- Review requests that create, update, export, or delete information.
- Keep API keys out of URLs, public files, screenshots, and shared messages.
- Revoke keys and disconnect OAuth connections when they are no longer needed.
- Review the terms and privacy policy of each external AI provider.

## API keys and AI Permissions

API keys are shown in full only when they are created. They can be revoked from
Settings.

AI deletion is controlled separately. When **AI delete permission** is off,
connected AI tools cannot request deletion. When it is on, each deletion still
requires confirmation.

## Account access

Memside uses sign-in and authenticated sessions. Sign out after using a shared
computer.

Revoke any API key or connection that should no longer remain active.

Memside and Memside Library use the same account identity with separate
application sessions. Coordinated sign-out clears both product sessions. Public
Library browsing does not expose private Memories, drafts, imports, personal
lists, or account notifications.

## Library content

Published Templates and creator pages are public. Private drafts and personal
Library activity require authentication.

Catalog review reduces risk but does not guarantee that every published
instruction is appropriate for every workflow. Template files should be read
before download, import, or use. License information remains attached to the
published Template.

Authenticated downloads create privacy-bounded activity records used for
account metrics and catalog ranking. Public creator metrics do not reveal
downloader identities.

## Encryption

Memside uses encryption in transit and applies encryption at rest to protected
user-authored content and other sensitive information where appropriate.

Operational and security information may still be processed to provide,
protect, troubleshoot, and maintain the service.

Passwords, recovery codes, payment details, and access keys should not be saved
in Memories.

## Export and deletion

Memories can be exported as CSV or Markdown from **Settings > Import &
Export**.

Individual Memories can be deleted. The full account can be permanently removed
from **Settings > Delete Account**. Account deletion also removes owned Library
Templates and account-linked Library data. Independent private imports already
created by other accounts are not changed.

## Policies

Open **Settings > Legal** for the current Privacy Policy and Terms.

## Next steps

- [Sensitivity levels](/product/memories/#sensitivity-levels)
- [Settings](/product/settings/)
- [Memside Library](/library/)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/help/support/

For account, product, privacy, billing, or connection help, email
[support@memside.com](mailto:support@memside.com).

## Include

- a short description of the expected and observed behavior;
- the affected AI client or browser;
- the operating system and app version, when relevant;
- the approximate date and time of the issue;
- the exact error text;
- safe reproduction steps.

Screenshots are useful when they do not expose private content.

## Do not include

- passwords or recovery codes;
- Memside API keys;
- OAuth or session tokens;
- private Memory content unless it is essential and the disclosure risk has
  been considered;
- unrelated personal or customer data.

If a secret was exposed, revoke or rotate it before contacting support.

## Security and privacy reports

Use the same email address and make the subject clear, for example
`Security report: short description`. Include the smallest safe reproduction
and the potential impact. Testing must not access or change another account's
data.

## Useful links

- [Memside app](https://www.memside.com)
- [Memside Library](https://library.memside.com)
- [Public developer repository](https://github.com/memside/memside)
- [Troubleshooting](/help/troubleshooting/)

---

Source: https://docs.memside.com/help/troubleshooting/

## Start with these checks

1. Confirm that sign-in works at [Memside](https://www.memside.com).
2. Refresh the page or restart the connected AI tool.
3. Check the Settings page for the affected feature.
4. Test a simple read or search before testing a change.
5. Record the exact error text and approximate time.

## In-app assistant is not responding

- Open **Settings > LLM Configuration**.
- Confirm the provider details are saved.
- Select **Test**.
- Check the provider account for usage or billing limits.
- Retry after the test succeeds.

## Cannot save a Memory or upload a file

- Check **Settings > Usage & Metrics** for Memory and storage usage.
- Confirm required fields are complete.
- Check the attachment size and file format.

## Cannot find a Memory

- Search for a distinctive word from the title or content.
- Clear Status, Type, Tags, and date filters.
- Check Completed and Archived Memories.
- Secret Memories are unavailable to connected AI tools.
- Confirm the correct Memside account is being used.

## Calendar or text import fails

- Open **Settings > Import & Export**.
- Calendar import requires an `.ics` file.
- **Chat or long text** works with pasted text and supported ChatGPT JSON
  exports.
- CSV import should start with the template on the same page.
- Check required fields and date format before retrying.

## Unauthorized or invalid API key

- Copy the complete key without extra spaces.
- Use `Authorization: Bearer YOUR_KEY`.
- Do not put the key in a URL.
- Confirm the key is active under **Settings > Developer & API**.
- Revoke and replace a key that may have been exposed.

## MCP connects but tools do not appear

- Confirm the client supports remote HTTP MCP.
- Restart the client.
- Enable the Memside server and approve tools when required.
- Check **Settings > AI Permissions** for the Memory and Library MCP controls.
- For command-based setup, confirm Node.js and `npx` are installed.
- Remove duplicate or outdated Memside server entries.

## Library sign-in or logout does not complete

- Open the Library from the main Memside navigation and allow the shared sign-in
  flow to complete.
- Refresh both applications after a recently completed deployment.
- Confirm that cookies are permitted for `memside.com` application hosts.
- Retry sign-out from the page that displays the error.
- Record the exact error text and approximate time if the problem continues.

## Add to Memside is unavailable

- Confirm that the Template is still public.
- Confirm that the Memside and Library sessions use the same account.
- Review account capacity for Memories, Profiles, and other selected items.
- Reopen the Template page and start a new import review.
- A selected AI Skill remains a draft until separate review is completed.

## Template review does not complete

- Reopen the Template review page to load the persistent result.
- **Review needed** or **Review failed** requires attention to the listed
  finding.
- **Review delayed** can be retried without discarding unchanged work.
- File changes must be saved before another review is submitted.

## ChatGPT or Codex MCP installation controls are missing

For the current interface, try either route:

- open **Plugin** from the left bar, then select **Settings > MCP > Install MCP
  server**; or
- open **Profile > Settings > Plugins**, select **Add**, then select **Install
  MCP server**.

In an earlier ChatGPT interface, enable **Developer mode** under **Plugin** or
**Security**, close Settings, open **Plugins** from the left panel, select the
plus button, and choose the custom-plugin option.

Managed workspaces may require administrator approval. Availability can also
vary by account, region, or supported surface. OpenAI may change labels or move
these controls in a future release.

## ChatGPT is connected but unavailable in a chat

- Confirm Memside is available in the Plugin area.
- Start a new chat and enable the plugin if requested.
- Disconnect and reconnect when an earlier OAuth connection has become stale.

## Claude authentication loops

Try adding and authenticating Memside from
[claude.ai](https://claude.ai) first. Then restart Claude desktop or sign in
again.

Confirm the server URL is:

```text
https://api.memside.com/mcp/
```

## Subject or Connection looks out of date

- Refresh the page and reopen the Memory.
- Subject membership and direct Connections are different.
- Archived and Completed Memories can keep confirmed Connections.
- Deleting a Subject removes its links but preserves Memories.
- A suggested Fact is not Current until it is accepted.

## A change or deletion was rejected

The connected AI tool may require approval.

For AI deletion:

1. Enable **AI delete permission** in Settings.
2. Let the AI tool prepare the exact confirmation.
3. Review and approve the specific deletion.

Account deletion and API-key management remain app actions.

## Direct API request fails

- Use `https://api.memside.com` as the base URL.
- Send `Content-Type: application/json` with JSON request bodies.
- Check the HTTP status and response body.
- Avoid automatic retries for create, update, or delete requests unless the
  integration prevents duplicate changes.

## Still not resolved?

Contact [Memside Support](/help/support/) with the app name, operating system,
approximate time, exact error text, and safe reproduction steps.

Remove API keys, tokens, and private information from screenshots or logs.

---

Source: https://docs.memside.com/

## What is Memside?

Memside is an **AI continuity and personal memory hub**. It gives one place to
save the context that matters so it can be reused across different AI tools,
chats, and devices without starting from zero each time.

Instead of repeating the same project details, background, or instructions in
every new conversation, they can be kept in Memside and shared when needed.
That makes it easier to continue work across chat apps and AI coding tools such
as ChatGPT, Codex, Claude, Antigravity, OpenCode, and Claude Code, as well as
other AI clients, without losing context.

Memside is built for both **non-technical users** and **developers**:

- Save notes, tasks, links, events, checkpoints, and other useful context in one
  place.
- Decide which AI tools can read or update that context.
- Reduce repeated prompts, repeated token usage, and repeated explanation.
- Discover and reuse public AI working setups through Memside Library.

Memside is not just a note-taking app, and it is not another AI chatbot. It is
the memory layer that helps AI tools work with the same reliable context while
keeping saved information organized, portable, and under the account owner's
control.

## What is AI continuity?

AI continuity means AI tools can continue from useful saved context instead of
starting fresh every time.

It does not mean saving every chat or pushing a full history into every AI tool.
It means keeping the context that still matters, such as rules, preferences,
checkpoints, decisions, notes, and task state, so the next AI session can
understand what changed and what should happen next.

Memside supports AI continuity by giving that reusable context a separate place
outside one chat or one provider. When work moves between chats, models, apps,
or devices, the right context can be reused without repeating the whole
background again.

## What is a personal memory hub?

A personal memory hub is one place to keep AI context that should be reused
across tools.

In Memside, that can include a User AI Profile, reusable prompts, Operating
Rules, project notes, task checkpoints, decisions, links, and other saved
Memories. The goal is not to replace documents or notes apps. The goal is to
keep the context that helps AI work more consistently.

This is useful when context is scattered across old chats, documents, prompts,
and reminders. Memside keeps the important parts organized, searchable, and
ready for connected AI tools when needed.

## How is Memside different from built-in AI memory?

Built-in AI memory can be helpful inside one AI app, especially for remembering
preferences or useful facts.

Memside is different because it is designed for selected context that can move
across connected AI tools. It can be used for project checkpoints, Operating
Rules, task state, notes, and decisions that should not stay trapped inside one
provider's memory.

This helps reduce vendor lock-in. If useful working context only lives inside
one AI app, switching tools becomes harder. Memside provides a user-controlled
memory hub for context that may need to be reused elsewhere.

## Does Memside save every chat?

No. Memside is designed around selected memory, not automatic full-chat
archiving.

Saving every chat can create context bloat because old ideas, temporary
instructions, and outdated decisions may get mixed with the context that
actually matters. Memside works better when the reusable parts are saved:
rules, checkpoints, decisions, notes, task state, and useful project context.

The account owner stays in control of what becomes a Memory. That keeps saved
information cleaner and makes it easier for connected AI tools to find the
right context later.

## What is PMX?

**PMX**, the Protocol for Memory Exchange, is the structured memory format used
by Memside. It gives each Memory a clear shape, with fields for information such
as title, body, tags, dates, attachments, and sensitivity.

That structure matters because AI tools work better when important context is
organized instead of buried in long chat history. A PMX Memory can tell an AI
what the Memory is about, when it happened, how sensitive it is, and how it
should be used.

In practical terms, PMX helps Memside support:

- cleaner search and filtering;
- more reliable memory retrieval;
- easier updates and history tracking;
- better portability across different AI tools and apps.

The goal is simple: saved memory should not be locked inside one provider or
one chat thread. PMX helps Memside keep saved context reusable,
understandable, and easier to carry across tools.

## What is Memside Library?

[Memside Library](https://library.memside.com) is the public catalog for
reusable AI working setups called Templates. A Template can combine
instructions, examples, reference material, and supporting text files for a
particular task.

The Library and the private memory application serve different purposes.
Memside stores private continuity context. The Library provides public,
versioned Templates that can be inspected, downloaded, published, or added to
Memside through an explicit review flow.

Public Template pages can be explored without signing in. Personal actions,
private drafts, imports, and creator workflows require the shared Memside
account.

## Next steps

- [Quickstart](/getting-started/)
- [How Memside works](/concepts/how-memside-works/)
- [Memories](/product/memories/)
- [Memside Library](/library/)
- [Add a Template to Memside](/library/add-to-memside/)
- [Connection overview](/connect/mcp-and-api/)

---

Source: https://docs.memside.com/library/add-to-memside/

## Purpose

**Add to Memside** copies selected content from an exact published Template
version into the private Memside account. The public Template remains unchanged,
and the imported items can be reviewed before the action is confirmed.

This reduces repeated setup. Instead of recreating useful instructions and
context manually, selected content can become a Profile, Rule, Skill, or Memory
in the feature designed for that purpose. Connected AI tools can then use the
approved content consistently under existing permissions.

## Import review

The review page presents the Template version, available items, and current
account capacity. Selection remains explicit. Unselected files do not become
private Memside objects.

Supported Template content can be recognized as:

- Memories;
- User AI Profiles;
- Operating Rules;
- AI Skills;
- ordinary reference files.

An ordinary file remains reference material unless it matches a supported item
and is selected for that purpose.

## Result of an import

Imported content follows the safety state of its destination:

- selected Memories are added as active private Memories;
- a selected User AI Profile is reviewed during import and becomes an available
  Profile;
- a selected Operating Rule is reviewed during import and becomes active;
- a selected AI Skill is saved as a draft and requires separate review before
  activation;
- reference files remain supporting content rather than silently becoming a
  Profile, Rule, or Skill.

The first eligible imported Profile becomes the Default when no Profile already
holds that role. Existing Profile choices and explicit availability settings are
preserved.

## Source information

Imported Memories retain a source reference to the originating Template,
version, and item. This provides context without making the private Memory
public or linking the creator to later private edits.

A completed import creates a private notification and returns to the Memory
dashboard with the new items available.

## Repeating an import

Repeating the same Template version does not duplicate private items that still
exist. A later import can add newly selected items or recreate selected items
that were previously removed.

A different published version is treated as a distinct release and is reviewed
before import.

## Update and safety notices

The import review includes a **Notify me about updates** option. When enabled,
Memside can show notices about a newer release, removal from the public Library,
or a security concern affecting the imported version.

Notices identify the installed version and explain any recommended action. A
notice never replaces or edits private imported items automatically. An
ordinary new Template version does not send an email. A critical security
notice may also be delivered to the account email address so that urgent action
is less likely to be missed.

## Capacity and availability

Normal account limits still apply. An imported Profile cannot be added when the
current Profile capacity is already in use. The import review shows applicable
capacity before confirmation.

## Safety guidance

Template content should be read before import. Public review reduces catalog
risk but does not guarantee that every instruction is appropriate for every
workflow. Imported content remains subject to Memside permissions, destination
controls, and connected-AI access settings.

## Related pages

- [Find and use Templates](/library/find-and-use-templates/)
- [User AI Profiles](/product/user-ai-profile/)
- [Profile, Rules, and Skills](/product/profile-rules-skills/)
- [AI Skills](/product/ai-skills/)

---

Source: https://docs.memside.com/library/create-and-publish/

## Creator workflow

Template creation has five practical stages:

1. create the Template details;
2. add and organize files;
3. review the complete draft;
4. run the automated publication review and publish;
5. maintain the listing, content, versions, and visibility.

New Templates begin as private drafts. Public visibility starts only after a
successful review and an explicit publish action.

## Before creating a Template

A Library creator account requires a unique username. The username appears on
public Template and creator pages. It must contain 5 to 30 characters and cannot
be changed after it is set. The shared Memside account controls the display name
and profile picture.

Prepare content that is safe to publish. Remove private information, account
credentials, access tokens, confidential material, and content without clear
permission for redistribution.

## Detailed guides

### 1. Create the listing

Add the name, description, category, tags, and license. These fields explain
what the Template contains and help Library search and discovery.

[Create a Template](/library/create-template/)

### 2. Build the file structure

Write content in the editor, create folders, upload several files, or upload a
complete folder structure. Supported Word files are converted into editable
content for review.

[Manage Template files and folders](/library/manage-template-files/)

### 3. Review and publish

Inspect the draft, run the automated publication review, address any findings,
and publish the approved version.

[Review and publish a Template](/library/review-and-publish/)

### 4. Maintain the Template

Update metadata, publish a new file version, discard private changes, unpublish
a listing, or republish eligible content.

[Edit, version, and unpublish Templates](/library/maintain-templates/)

### 5. Review activity

Open **Settings > Usage & Metrics** in Memside to view complete Template
downloads, individual file downloads, and the most downloaded owned files.

[Usage and metrics](/product/usage-and-metrics/)

## Simple example structure

A small weekly-planning Template could contain:

```text
README.md
instructions.md
examples/
  simple-week.md
```

The README explains the purpose, `instructions.md` defines the process, and the
example demonstrates the expected format. Additional folders are useful only
when they make the setup easier to understand.

## Connected creator workflows

Owned Templates can also be managed through supported MCP tools or the Library
REST API. Connected workflows follow the same ownership, review, and
publication requirements as the website.

- [Use Library with MCP](/library/use-with-mcp/)
- [Use the Library API](/library/use-with-api/)

---

Source: https://docs.memside.com/library/create-template/

## The two-step creation flow

Creating a Template has two required workspace steps:

1. **Add details** to describe and classify the Template.
2. **Add files** to build the reusable content.

The first step creates the private Template record. The second step prepares
the files and folders that can later be submitted for review. Neither step
makes the Template public.

## Step 1: Add Template details

1. Sign in to Memside Library.
2. Open the account menu and select **Create Template**.
3. Complete **Step 1 of 2: Add details**.
4. Select **Next** to create the private draft and open the file workspace.

The Template is not public at this stage. Draft details and files remain in the
owned Template area until publication succeeds.

## Name

Enter a clear name of up to **120 characters**. The name should identify the
task or setup without relying on unexplained abbreviations.

Examples:

- `Weekly Planning Guide`
- `Simple Document Review`

Avoid names that imply an official relationship, guaranteed result, or
capability that the files do not provide.

## Description

Enter a description of up to **350 characters**. A useful description states:

- the intended task;
- the main contents;
- the expected result or audience.

Example:

```text
A small set of instructions and examples for turning weekly priorities into a clear plan with tasks, owners, and target dates.
```

## Category

Select the category that most closely matches the primary purpose. Categories
cover common areas such as writing, productivity, research, software
development, design, learning, business, and other general uses.

Choose one category based on the main outcome. Tags can describe secondary
topics. A correct category improves browsing and keeps search results relevant.

## Tags

Tags are optional search and identification terms. Add up to **5 tags**, with a
maximum of **30 characters per tag**.

Use short, specific terms such as:

- `weekly planning`
- `meeting notes`
- `document review`

Tags are case-insensitive, so equivalent capitalization does not create a new
tag. Avoid repeating the category or adding unrelated popular terms.

## License

The selected license tells visitors how the published files may be reused.
Three choices are available:

| License | Practical meaning |
| --- | --- |
| **No license** | No specific reuse permission is attached. Copyright rules still apply. |
| **CC BY 4.0** | Copying, adapting, and commercial use are allowed when appropriate credit is provided. |
| **CC0 1.0** | Copying, adapting, and commercial use are allowed without required permission or credit. |

Select only a license that the creator has authority to grant. The displayed
summary is general information and is not legal advice.

## Step 2: Add files and folders

Memside creates a private draft and opens **Step 2 of 2**. A root `README.md`
is provided as the standard introduction. Files and folders can then be added
before review.

Step 2 supports the following actions:

- **New file** or **Add text** creates a file manually in the selected folder.
- **New folder** creates a folder for related content.
- **Upload files** adds one or more supported files to the selected folder.
- **Upload folder** adds all supported files and subfolders from a selected
  local folder at once.
- **Edit** and **Preview** switch between source editing and rendered content.
- **Upload content** replaces the selected file from a supported upload.
- **Save** keeps the latest private draft changes.
- **Review** saves the draft and opens the publication review flow.

Supported uploads are Markdown (`.md`), plain text (`.txt`), and Microsoft Word
(`.docx`). Word files are converted into editable content and should be checked
before addition. The detailed file guide covers upload behavior, content limits,
folder handling, replacement confirmation, and visibility.

[Manage Template files and folders](/library/manage-template-files/)

## Visibility after Step 2

The draft remains visible only in the owned Template area. Files do not appear
in public Library search or on a public creator page until automated review
succeeds and **Publish** is selected.

Saving is not publication. Selecting **Review** also does not publish the
Template; it begins the required review process.

## Correct a detail later

Open **My Templates**, select the Template, choose **Edit**, and open the
**Details** tab. Metadata can be changed before publication. After publication,
eligible metadata-only changes can be published without creating a new file
version.

## Next step after files are ready

[Review and publish a Template](/library/review-and-publish/)

---

Source: https://docs.memside.com/library/find-and-use-templates/

## Explore the catalog

The Library homepage presents public Templates in discovery collections such as
Featured, Sponsored, Popular, and New. Category navigation provides another way
to narrow the catalog.

Sponsored placement identifies promotion. It does not replace publication
review or change the content shown on a Template page.

## Search and filters

Search matches public Template titles, descriptions, creator names, categories,
tags, file paths, and readable file content. Available filters can limit results
by category, tag, or license. Results can be ordered by newest, oldest, or star
count.

A simple generic search might use `meeting notes` and then select a productivity
category. The result set contains only public Templates that match the current
catalog filters.

## Template pages

A public Template page contains the information needed to evaluate a release:

- title and description;
- creator identity and verification indicator, when applicable;
- category, tags, and license;
- published version and release information;
- review status;
- a folder and file view;
- readable Markdown or text content;
- download and Add to Memside actions.

Files can be inspected before any download or import. This supports a deliberate
review of instructions and reference material before reuse.

## Creator pages

A public creator page lists the creator's published Templates. A creator page
becomes publicly discoverable after at least one approved Template is available.

A verification badge indicates that the Library has verified the creator
account. It is an identity indicator, not an endorsement of every instruction or
claim inside a Template.

## Starred Templates

The star action saves a public Template to the signed-in account's **Starred**
list. Removing the star removes it from that list without changing the public
Template.

## Downloads

An individual Markdown or text file can be downloaded in its original format or
as a Word document. A complete Template can be downloaded as a ZIP archive of
the original files or as one Word document.

Copy and download actions require authentication. Downloaded material remains
subject to the license displayed on the Template page.

## Reports

A signed-in account can report a public Template when content appears unsafe,
misleading, unlawful, or otherwise unsuitable for the catalog. A report records
the selected reason and an optional concise explanation for review.

Reporting does not immediately change public content. The Template remains
subject to the Library review process.

## Versions and updates

Published file content is immutable for a specific version. File changes require
a new review and produce a new published version. Eligible title, description,
category, tag, or license corrections can update the current public listing
without creating a file-content version.

The latest approved release is shown by default. Exact published versions remain
stable for downloads and imports that reference them.

## Related pages

- [Why Templates help](/library/why-templates/)
- [Memside Library](/library/)
- [Add a Template to Memside](/library/add-to-memside/)
- [Create and publish Templates](/library/create-and-publish/)

---

Source: https://docs.memside.com/library/

## Overview

[Memside Library](https://library.memside.com) is the public catalog for reusable
AI working setups called **Templates**. A Template can combine instructions,
reference material, examples, and supporting text files for a particular task or
workflow.

The Library complements the private Memside memory application:

| Product | Main purpose |
| --- | --- |
| **Memside** | Stores private Memories, preferences, rules, Skills, and continuity context. |
| **Memside Library** | Provides reusable Templates that can be inspected, downloaded, published, or added to Memside. |

Public catalog pages can be explored without signing in. An account is required
for personal actions such as starring a Template, downloading a complete
Template, importing selected content, or publishing a Template.

## What is a Template?

A Template is a versioned collection of reusable content. It can contain:

- Markdown and plain-text files;
- folders that organize related files;
- instructions, examples, and reference material;
- a title, description, category, tags, and license information;
- publication and review information.

Every published version is preserved as a stable release. Later file changes
create a new version after review. This keeps an earlier published setup
available as the same release that was originally inspected or imported.

Templates can also provide a practical starting point when the best way to
configure an AI task is unclear. A well-structured Template shows how
instructions, examples, and reference material can work together, reducing
setup time and repeated experimentation.

See [Why Templates help](/library/why-templates/) for selection guidance and
generic examples.

## Main Library areas

- **Explore** presents public Templates, collections, categories, and search.
- **Template pages** present descriptions, files, version information, creator
  details, downloads, and Add to Memside.
- **Creator pages** collect the public Templates published by one creator.
- **My Templates** contains Templates owned by the signed-in account.
- **Private** contains owned Templates that are not currently public.
- **Starred** contains saved public Templates.

## Shared Memside account

Memside and the Library use the same account identity while maintaining separate
application sessions. Opening the Library from a signed-in Memside session can
continue through the shared sign-in flow without another credential prompt.

Profile details are managed in Memside and displayed consistently across both
products. A Memside node avatar is used until a profile picture is uploaded in
Memside.

Signing out from either product completes coordinated sign-out across the
Memside product family.

## Public and private content

Published Template pages and public creator pages are intended for discovery.
Private drafts, personal lists, account information, imports, notifications,
and unpublished work require authentication and are not public catalog content.

## Next steps

- [Why Templates help](/library/why-templates/)
- [Find and use Templates](/library/find-and-use-templates/)
- [Add a Template to Memside](/library/add-to-memside/)
- [Create and publish Templates](/library/create-and-publish/)
- [Library access through MCP and API](/library/mcp-and-api/)

---

Source: https://docs.memside.com/library/maintain-templates/

## Open an owned Template

Open the account menu, select **My Templates**, choose the relevant Template,
and select **Edit**. Owned Templates remain available from this area when they
are private, published, or unpublished.

## Edit listing details

Use the **Details** tab to change the name, description, category, tags, or
license. Save and publish the change after checking the public meaning of every
field.

Eligible metadata-only changes update the listing without creating a new file
version. Examples include correcting a description or improving tags while the
published files remain unchanged.

## Edit files and folders

Use the **Content** tab for file text, file names, additions, removals, or folder
changes. These changes create a private draft beside the current public
version.

Content changes must pass review again. Publishing the approved draft creates
the next immutable version automatically.

## When a new version is needed

A version update is appropriate when published files change, including:

- correcting an instruction or example;
- adding or removing a file;
- reorganizing folders;
- changing a reusable Profile, Rule, or Skill;
- updating content for a changed workflow.

There is no separate manual version-upgrade control. The version number advances
when reviewed file-content changes are published. Metadata-only changes do not
advance it.

Release notes should briefly explain meaningful differences. Example:

```text
Added a short planning example and clarified the weekly review steps.
```

## Discard private changes

Use **Discard changes** when an unpublished edit should not continue. This
restores the latest published details and files. The public version remains
unchanged throughout the draft process.

## Unpublish a Template

Unpublishing is appropriate when:

- published guidance is outdated or misleading;
- a replacement requires more work;
- the material should no longer appear in public discovery;
- a rights, privacy, or safety concern needs investigation.

To unpublish:

1. Open the public owned Template page.
2. Select **Unpublish**.
3. Review the confirmation.
4. Confirm the action.

The Template moves to a private state and remains accessible through **My
Templates**. Ownership and version history are retained.

## Republish

An eligible unchanged release can be republished. If file content changed while
private, the updated draft must complete review before a new version can become
public.

## Review download activity

Open Memside and go to **Settings > Usage & Metrics**. The Library area shows
complete Template downloads, individual file downloads, and a list of the most
downloaded files from owned public Templates.

Metrics do not reveal downloader identities. See [Usage and
metrics](/product/usage-and-metrics/) for the complete guide.

## Maintenance checklist

Periodically check:

- whether the description still matches the files;
- whether examples remain accurate and generic;
- whether external links still work;
- whether the selected license remains appropriate;
- whether recent feedback indicates a confusing instruction;
- whether a file update needs a new reviewed version.

---

Source: https://docs.memside.com/library/manage-template-files/

## Open the content workspace

The content workspace opens after **Step 1 of 2** or from **My Templates > Edit
> Content**. The file tree appears beside the editor. New Templates contain a
root `README.md` that cannot be deleted or moved.

Use the README to explain the Template purpose, included files, setup steps, and
any important limitations.

## Add a file manually

1. Select the root or destination folder in the file tree.
2. Select **New file** in the file tree, or **Add text** in an empty folder.
3. Enter a file name.
4. Add the content in the editor.
5. Select **Save**.

When a manually created file name has no extension, `.md` is added. Markdown is
recommended for headings, lists, examples, and other structured instructions.

Example:

```text
instructions.md
```

could contain:

```markdown
# Weekly plan

1. List the three main outcomes.
2. Break each outcome into small tasks.
3. Add an owner and target date to every task.
```

## Add a folder manually

1. Select the root or an existing folder.
2. Select **New folder**.
3. Enter the folder name.
4. Add files inside the new folder.

Folders are useful for separating examples, reference material, Profiles,
Operating Rules, or Skills. Deep structures are rarely necessary for small
Templates.

## Upload several files

1. Select the destination folder.
2. Select **Upload files**.
3. Choose one or more supported files.
4. Review converted Word content when applicable.
5. Confirm the files and save the draft.

Multiple selected files are added to the chosen destination. Existing file
names should be reviewed carefully to prevent an unintended replacement.

## Upload a complete folder structure

1. Select **Upload folder**.
2. Choose the local folder in the system picker.
3. Review the detected files and nested folders.
4. Confirm the upload and save the draft.

The contents and useful subfolders are preserved. The selected outer wrapper
folder is not added as an unnecessary extra level.

This option is suitable for adding all folders and supported files at once.
Unsupported files are not accepted as Template content.

## Supported uploads

| Type | Extension | Behavior |
| --- | --- | --- |
| Markdown | `.md` | Added as editable Markdown. |
| Plain text | `.txt` | Added as editable text. |
| Microsoft Word | `.docx` | Converted into editable content for review before addition. |

Word conversion can change tables, spacing, or complex formatting. Inspect the
converted text and file name before selecting **Add file**.

## Public content limits

A Template can contain up to **100 files**. Each text or converted file can be
up to **250 KB**, and the complete Template can be up to **2 MB**. A Word upload
can be up to **5 MB** before conversion, while the converted result must remain
within the text-file limit.

Large source material is usually clearer when reduced to the parts needed for
the Template.

## Edit and preview content

Select a file in the tree, then use:

- **Edit** to change the source content;
- **Preview** to inspect rendered Markdown;
- **Upload content** to replace the selected file from a supported upload;
- **Save** to preserve the current change.

When replacement content has a different file name, the workspace presents the
available naming choice. Replacing existing content requires confirmation.

## Visibility while editing

New drafts are private. For an already published Template, later draft changes
also remain private until review and publication. The currently published
version remains available while the next version is prepared.

## Content checklist

Before review, confirm that:

- the README explains the purpose and use;
- every file supports the stated purpose;
- examples are generic and understandable;
- no secrets, credentials, private data, or confidential text are present;
- external links use trusted HTTPS destinations;
- redistribution rights are clear;
- the Template stays within the file and size limits.

## Next step

[Review and publish a Template](/library/review-and-publish/)

---

Source: https://docs.memside.com/library/mcp-and-api/

## One Memside connection

The authenticated Memside MCP connection can provide Memory tools, Library
tools, or both. Separate settings control the two groups:

- **Access Memories through MCP**
- **Access Library through MCP**

Both controls are enabled by default and can be changed independently. The
available MCP tool list follows the current settings.

## Library operations

The connected Library tools support five public capabilities:

| Tool | Purpose |
| --- | --- |
| `search_templates` | Search reviewed public Templates. |
| `get_creator_status` | Review owned Templates and recent workflow results. |
| `read_template` | Read a bounded owned draft. |
| `write_draft` | Replace the current private draft after confirming its latest revision. |
| `manage_template_workflow` | Create, submit, retry, publish, unpublish, or republish a Template. |

Creator actions require an existing Library creator account. Public search does
not grant access to private drafts or private Memside Memories.

## API keys

The same Memside API key can use the corresponding versioned REST operations.
Read-only keys support retrieval operations. Read-write keys are required for
draft changes and publication workflow actions.

The public REST groups are:

| Method | Path | Purpose |
| --- | --- | --- |
| `GET` | `/library/templates` | Search public Templates. |
| `GET` | `/library/creator/status` | Review owned Template status. |
| `POST` | `/library/templates/{template_id}/read` | Read bounded owned draft content. |
| `PUT` | `/library/templates/{template_id}/draft` | Replace an owned private draft. |
| `POST` | `/library/templates/workflow` | Run an owned Template workflow action. |

MCP visibility settings control MCP tool availability. API-key mode continues
to follow the access mode assigned to the key.

## Public catalog access

The Library also provides anonymous read-only discovery for public Templates.
Anonymous access can search and read public catalog content but cannot star,
download a complete Template, read private drafts, or perform creator actions.

## Safety and consistency

Connected creator workflows use the same validation, review, ownership, and
publication rules as the Library website. A connected tool cannot bypass review
or publish content that the account does not own.

Draft writes require the latest known revision. This prevents an older tool
state from silently replacing newer work. Repeated workflow requests are handled
safely, and user-visible results remain available through creator status.

## Generic examples

Public discovery:

> Search the Library for a simple weekly planning Template.

Creator status:

> List the current Template drafts and summarize any review state that needs attention.

Draft changes should remain narrow and explicit:

> Update the instructions file in the selected private Template draft, then return the review status without publishing.

## Detailed setup and workflows

The connected access guides separate conversational MCP use from direct REST
requests:

- [Use Library with MCP](/library/use-with-mcp/) covers permission setup, tool
  discovery, public search, owned draft work, review, and publication prompts.
- [Use the Library API](/library/use-with-api/) covers API keys, authentication,
  route groups, read examples, and safe write-workflow guidance.

## Related pages

- [Connection overview](/connect/mcp-and-api/)
- [API keys](/developers/api-keys/)
- [Create and publish Templates](/library/create-and-publish/)
- [Find and use Templates](/library/find-and-use-templates/)
- [AI permissions](/product/ai-permissions/)

---

Source: https://docs.memside.com/library/review-and-publish/

## Before starting review

At least one file and a category are required. Save all current changes, then
select **Review** from the Template workspace.

The review page presents the details and file structure being prepared for
publication. Read the complete draft as a visitor would see it.

## Automated publication review

Memside runs an automated safety review before publication. The review is
designed to detect material that can be easy to miss during editing, including:

- exposed passwords, API keys, access tokens, private keys, or similar secrets;
- unsafe or misleading links;
- suspicious file names or paths;
- instructions that request credentials or private information;
- prompt injection or instructions that attempt unsafe external actions;
- risks spread across several files.

Findings identify the affected file and line when that information is
available. The scan helps reduce accidental publication of unsafe material, but
it is not a guarantee. Creator review remains necessary before publication.

The review does not make private Memories public. It evaluates the submitted
Template draft for publication readiness.

## Review states

| State | Meaning | Next action |
| --- | --- | --- |
| **Draft in progress** | The current draft has not completed review. | Finish editing and start review. |
| **Review in progress** | Automated checks are running. | Wait for the result. |
| **Ready to publish** | The reviewed draft can be published. | Complete the final confirmation and select **Publish**. |
| **Review needed** | One or more findings require attention. | Read the findings, edit the affected files, and run review again. |
| **Review failed** | The current content cannot be published. | Correct the reported problem before another review. |
| **Review delayed** | Review is temporarily unavailable. | Retry without discarding unchanged work. |

Changing a reviewed draft makes the previous result stale. Run review again so
the result covers the current files.

## Address a finding

1. Read the finding and note the file and line when shown.
2. Select **Edit files**.
3. Remove or rewrite the unsafe content.
4. Save the draft.
5. Return to review and submit the updated draft.

Example: if an example file contains a realistic-looking API key, replace it
with an obvious placeholder such as `example_api_key` and run review again.

## Publish

After the status becomes **Ready to publish**:

1. Review the Template name, description, category, license, and files.
2. Confirm that the material can be published and shared.
3. Select **Publish**.

Publication creates an immutable numbered version and makes the Template
discoverable through the public Library. A publication notification records the
Template name, version, and destination.

## What visitors can see

Public visitors can open the Template page, read the description, inspect the
file tree, and view published content. A signed-in account is required for
actions such as copying, downloading, starring, reporting, or adding content to
Memside.

## After publication

Open the public Template page to verify the README, file order, rendered
content, license, category, tags, creator details, and version number. Content
corrections require a new reviewed version; eligible metadata-only corrections
can be published without a file-version change.

## Next step

[Edit, version, and unpublish Templates](/library/maintain-templates/)

---

Source: https://docs.memside.com/library/use-with-api/

## When to use the API

The REST API is suitable for applications and scripts that need direct,
versioned requests. MCP is usually a better fit for conversational AI clients.
Both paths apply the same ownership, review, and publication rules.

Base URL:

```text
https://api.memside.com
```

## Create an API key

1. Open **Settings > Developer & API**.
2. Select the API-key creation action.
3. Choose **Read-only** for retrieval or **Read-write** for creator changes.
4. Create the key and store the displayed value securely.

The full value is displayed once. API keys must not be placed in source files,
public repositories, screenshots, query strings, or Template content.

Send the key in the authorization header:

```text
Authorization: Bearer mem_sk_example_key
```

## Library route groups

| Method | Path | Use |
| --- | --- | --- |
| `GET` | `/library/templates` | Search public Templates. |
| `GET` | `/library/creator/status` | List owned Templates and workflow results. |
| `POST` | `/library/templates/{template_id}/read` | Read selected content from an owned draft. |
| `PUT` | `/library/templates/{template_id}/draft` | Replace an owned private draft. |
| `POST` | `/library/templates/workflow` | Create, review, publish, unpublish, or republish an owned Template. |

Read-only keys can use retrieval operations. Draft changes and workflow actions
require a read-write key.

## Search example

The following request searches the public catalog without exposing private
drafts:

```bash
curl "https://api.memside.com/library/templates?query=weekly%20planning&limit=5" \
  -H "Authorization: Bearer mem_sk_example_key"
```

Use category or tag filters when a broad term returns unrelated results. Search
responses provide public listing information suitable for presenting a result
list before any later action.

## Creator status example

```bash
curl "https://api.memside.com/library/creator/status" \
  -H "Authorization: Bearer mem_sk_example_key"
```

Check creator status before a write or publication request. It provides the
owned Template state needed to avoid acting on an outdated draft.

## Safe draft workflow

Draft replacement is designed for complete, intentional updates rather than an
unverified partial overwrite. A reliable sequence is:

1. read the owned draft and its current revision;
2. prepare the complete replacement file set;
3. validate file names, content limits, and the required root README;
4. send the draft update with the current revision information;
5. read the draft again and verify the saved result;
6. submit for review in a separate workflow request.

The public API contract documents the required request fields. Avoid copying a
response or draft revision from an older run into a later update.

## Publication workflow

Creation, review submission, retry, publication, unpublication, and
republication are explicit workflow actions. Do not combine draft editing and
publication into an assumed single step.

Before publication, confirm:

- the current review state is **Ready to publish**;
- the selected license is correct;
- all files are intended for public visibility;
- release notes describe meaningful file changes;
- the current draft is the same draft that completed review.

## Errors and retries

Common responses include:

| Status | Meaning |
| --- | --- |
| `400` | The request or Template state is invalid. |
| `401` | The API key is missing or invalid. |
| `403` | The key mode or account does not allow the action. |
| `404` | The Template or route was not found. |
| `409` | The draft or workflow state changed and must be refreshed. |
| `429` | The request limit was reached. Retry after the indicated delay. |

For a conflict, read current creator status and the latest draft before making
another write. Do not retry a state-changing request blindly.

## Key activity and revocation

Open **Settings > Developer & API** and select **Activity** beside a key to view
recent request actions, results, times, and request references. Memory content
is not shown in this activity list.

Revoke a key that is no longer needed or might have been exposed, then update
the relevant application with a new key.

## Related pages

- [REST API reference](/developers/api-reference/)
- [API keys](/developers/api-keys/)
- [Use Library with MCP](/library/use-with-mcp/)
- [Review and publish a Template](/library/review-and-publish/)

---

Source: https://docs.memside.com/library/use-with-mcp/

## What MCP access provides

Memside exposes five Library tools through the same authenticated MCP connection
used for Memory features. Library access can be enabled without enabling Memory
access.

The connected tools can:

- search public reviewed Templates;
- show owned Templates and current workflow states;
- read selected content from an owned private draft;
- replace an owned private draft with revision protection;
- create, review, publish, unpublish, or republish an owned Template.

Connected workflows cannot bypass ownership checks or publication review.

## Enable Library tools

1. Open Memside.
2. Open **Settings > AI Permissions**.
3. Enable **Access Library through MCP**.
4. Leave **Access Memories through MCP** enabled or disabled according to the
   intended connection scope.
5. Reconnect the AI client or start a new conversation if its tool list was
   already loaded.

Library tools and Memory tools are independent. See [AI
permissions](/product/ai-permissions/) for example configurations.

## Connect an MCP client

1. Open **Settings > Developer & API**.
2. Copy the Memside MCP server URL.
3. Add the URL to a supported AI client.
4. Complete the Memside sign-in and authorization flow when requested.
5. Start a new client conversation and test a read-only Library search.

Client-specific setup is available for [ChatGPT](/connect/chatgpt/),
[Claude](/connect/claude/), [VS Code](/connect/vscode/),
[Cursor](/connect/cursor/), [Codex](/connect/codex/), and other supported tools.

## Available Library tools

| Tool | Use |
| --- | --- |
| `search_templates` | Find public Templates by ordinary terms, category, or tag. |
| `get_creator_status` | List owned Templates and inspect review or workflow status. |
| `read_template` | Read selected files from an owned draft before making changes. |
| `write_draft` | Save a complete replacement draft after checking the latest revision. |
| `manage_template_workflow` | Create, submit, retry review, publish, unpublish, or republish. |

Search is a public discovery action. Draft reads and creator actions require an
owned Template. Creating a Template requires a Library creator account.

## Search public Templates

Start with a narrow request that states the task and any useful filter.

```text
Search the Memside Library for a weekly planning Template. Return the three most relevant results with their descriptions and licenses.
```

```text
Find public Templates tagged document review and summarize what each one contains. Do not import or download anything.
```

Search does not expose private drafts or private Memories.

## Inspect owned work

Use creator status before editing or publishing:

```text
List the owned Library Templates. Show which drafts are waiting for review, ready to publish, or need changes.
```

Then request only the files needed for the task:

```text
Read README.md and instructions.md from the selected private Template draft. Summarize the current structure without changing it.
```

## Create a draft through MCP

A safe connected creation sequence is:

1. request creation with a name, description, category, tags, and license;
2. inspect the returned private Template status;
3. read the new draft and its root README;
4. prepare the complete intended file tree;
5. request a draft write without review or publication;
6. read the saved draft again and verify every file.

Example:

```text
Create a private Template named Simple Weekly Plan in the Personal Productivity category. Use the CC BY 4.0 license and tags weekly planning and tasks. Do not submit it for review.
```

Follow with a bounded content request:

```text
Add a concise README, an instructions file, and one generic example to the private draft. Show the final file list and keep the Template private.
```

## Review and publish through MCP

Publication remains a separate explicit action. A useful sequence is:

```text
Submit the selected private Template for publication review. Do not publish it. Return the review state and any finding locations.
```

After the result is ready:

```text
Show the reviewed Template name, version candidate, license, and file list. Publish only if the current state is Ready to publish.
```

If review finds a problem, edit the draft and submit it again. A changed draft
must receive a current review result before publication.

## Unpublish or republish

Use explicit wording for visibility changes:

```text
Unpublish the selected owned Template and return its resulting visibility. Do not delete it.
```

```text
Check whether the selected unpublished Template can be republished unchanged. Report the status before taking action.
```

## Troubleshooting

- Missing Library tools: enable Library MCP access and reconnect the client.
- Creator action unavailable: complete the Library creator username setup.
- Draft changed elsewhere: read the latest draft again before writing.
- Review state delayed: request a retry after the current status is confirmed.
- Write rejected: confirm that the connection has read-write access.

## Related pages

- [Connection overview](/connect/mcp-and-api/)
- [Create and publish Templates](/library/create-and-publish/)
- [Use the Library API](/library/use-with-api/)

---

Source: https://docs.memside.com/library/why-templates/

## A practical starting point

An AI tool often performs better when it receives clear instructions, useful
reference material, and a consistent working structure. Creating that setup
from an empty page can require repeated experimentation. A Template provides a
ready-made starting point that can be inspected, adapted, and reused.

Templates are especially useful when the best way to organize an AI setup is
unclear. Instead of deciding every file name, instruction, and example from
scratch, a suitable Template can demonstrate a complete structure. This reduces
setup time and makes important guidance less likely to be omitted.

## What a Template can provide

A Template can combine several kinds of reusable material:

- a `README.md` that explains the purpose and setup;
- instructions that define a role, process, or output style;
- examples that show an expected result;
- reference notes, checklists, or reusable text;
- Profile, Operating Rule, or AI Skill candidates for Memside.

The files remain visible before any copy, download, or import. This makes the
Template an inspectable resource rather than an opaque configuration.

## Common uses

### Improve consistency

A recurring task can use the same instructions and quality checks each time.
For example, a meeting-summary Template might define a short format containing
decisions, action items, owners, and due dates.

### Reduce trial and error

A well-structured Template can show how to separate instructions, examples, and
reference material. For example, a document-review Template might contain one
file for review criteria and another file with a short sample response.

### Share a repeatable setup

Published Templates make a reusable approach available as a versioned resource.
Recipients can inspect the files, download selected material, or add eligible
content to Memside without reconstructing the setup manually.

### Adapt rather than start over

A Template is a starting point, not a locked configuration. Downloaded or
imported content can be adjusted for the relevant task, audience, and connected
AI tool.

## Choosing a suitable Template

Before use, check:

1. whether the stated purpose matches the intended task;
2. whether the files are understandable and narrowly relevant;
3. whether the examples match the expected level of detail;
4. whether the license permits the intended use;
5. whether the latest version contains the needed changes;
6. whether any instruction requests data or actions that should remain private.

No Template guarantees optimal performance for every model or task. Results can
vary by connected tool, model, available context, and the quality of the source
material. A short review and a small trial are recommended before regular use.

## Next steps

- [Find and use Templates](/library/find-and-use-templates/)
- [Add a Template to Memside](/library/add-to-memside/)
- [Create and publish Templates](/library/create-and-publish/)

---

Source: https://docs.memside.com/product/ai-permissions/

## Open AI Permissions

Open **Settings > AI Permissions**. Each switch controls a separate capability,
so Memory access, Library access, Profiles, guarded changes, and deletion can be
configured independently.

Changing a switch affects connected clients. It does not delete saved Memories,
Profiles, Templates, or API keys.

## Why separate controls help AI

A connected AI works more predictably when the available tools match the task.
Separate controls allow a connection to search Library Templates without
receiving Memory tools, or use Memories without receiving creator workflow
tools. Profile access and destructive actions can remain disabled when they are
not needed.

This limits unnecessary access and makes the available capability set easier to
understand. Permissions define what a connected tool may request; they do not
instruct the AI to use every enabled feature.

## Access Memories through MCP

When enabled, connected MCP clients can see the Memside Memory tool group. When
disabled, those tools are removed from the available MCP tool list.

Disable this setting when a connected client should use Library Templates but
should not access Memories.

## Access Library through MCP

When enabled, connected MCP clients can see the five Library tools for public
search and owned creator workflows. When disabled, Library tools are removed
from the MCP tool list while Memory tools can remain available.

Example configuration for public Template discovery only:

```text
Access Memories through MCP: Off
Access Library through MCP: On
```

## Allow connected AI access to Profiles

The **AI Profile - Allow Connected AI Tool Access** switch is the account-level
control for Profile retrieval through supported MCP and API clients.

Profile access requires both:

1. the account-level switch to be enabled; and
2. **Available to AI** to be enabled on the selected Profile.

Turning off the account-level switch blocks all connected Profile reads without
changing the saved setting on each Profile.

## Require MCP approval for Memory changes

**Memory Changes - Require MCP Approval** is a Beta control for supported MCP
clients. When enabled, supported clients present an approval prompt before a
guarded Memory change is applied.

Client support varies during Beta. A client that does not support the approval
flow cannot apply a guarded change. This control applies to MCP, not ordinary
website editing.

## Allow AI deletion requests

**Memory Deletion - Allow AI Requests** permits a connected AI tool to request
permanent Memory deletion. Every deletion still requires the explicit
confirmation phrase generated for that specific Memory.

Keep this setting disabled when deletion through connected tools is not needed.
Enabling the switch does not authorize silent or bulk deletion.

## Common configurations

### Read Memories and search Library

Enable Memory access and Library access. Keep deletion disabled unless a clear
workflow requires it.

### Use Library without Memory access

Disable Memory access and enable Library access. This exposes Library tools
without exposing the Memory tool group.

### Keep Profiles private from connected tools

Disable account-level Profile access. Saved Profiles remain available for
management inside Memside.

### Maximum confirmation for Memory changes

Enable the MCP approval requirement and keep deletion requests disabled.

## After changing permissions

Some clients cache their tool list. Start a new conversation or reconnect the
Memside integration if a newly enabled tool does not appear or a disabled tool
remains visible.

## Related pages

- [User AI Profile](/product/user-ai-profile/)
- [Connection overview](/connect/mcp-and-api/)
- [Use Library with MCP](/library/use-with-mcp/)
- [Security and Privacy](/help/security-and-privacy/)

---

Source: https://docs.memside.com/product/ai-skills/

## What are AI Skills?

AI Skills store reusable instructions.

They are suitable for guidance that should be applied repeatedly, such as
writing rules, review steps, coding standards, or project instructions.

AI Skills are separate from normal Memories. Memories store saved context.
Skills store reusable instructions.

## Why Skills help AI

A short preference can describe an expected style, but a repeatable task often
needs an ordered method. A Skill gives a connected AI a reusable process with
the steps, checks, and expected result kept together.

This can reduce missed steps and inconsistent execution across conversations.
For example, a document-review Skill can require clarity checks, factual claim
identification, and a final change summary every time it is used.

Skills remain inspectable and can be kept as drafts until the instructions are
understood and ready for activation.

Account limits apply to the number of saved AI Skills and to AI-assisted
refactors. The current allowance is shown in **Settings > AI Skills** and can
change when account plans are introduced or updated. Manual review and editing
remain available without presenting a fixed allowance in this guide.

## Supported sources

- **SKILL.md**
- **AGENTS.md**
- **CLAUDE.md**
- generic Markdown or text guidance
- a Memside AI Skill JSON export
- a selected AI Skill from a published Library Template

The original source is preserved. An imported Skill starts as a draft so it can
be reviewed before activation.

Library Template imports follow the same boundary. A selected Skill is saved as
a draft even when other reviewed Template items become active during import.

## Import a Skill

1. Open **Settings > AI Skills**.
2. Choose the source type.
3. Import or paste the instruction source.
4. Review the structured result.
5. Save it as a draft.
6. Activate it only after review.

## Improved versions

A Skill can have one improved version:

- **Detailed** keeps fuller instructions.
- **Compact** keeps a shorter version.

Use **Improve with Memside AI** when available. **Manual refactor prompt**
copies a prompt that can be used in another AI tool.

## Use with connected AI tools

A connected AI tool can:

- list available Skills;
- read a selected Skill;
- read the original source when needed;
- use the improved version when available;
- save an improved draft for review.

Activation remains separate from editing. This makes it possible to import,
improve, and review a Skill before it becomes active.

## Generic example

A writing review Skill might require:

```text
Check spelling and clarity.
Keep paragraphs short.
List factual claims that need verification.
Do not change the intended meaning.
```

## Next steps

- [User AI Profile](/product/user-ai-profile/)
- [Operating Rules and AI Skills](/product/profile-rules-skills/)
- [Connect an AI](/connect/mcp-and-api/)
- [Add a Template to Memside](/library/add-to-memside/)

---

Source: https://docs.memside.com/product/checkpoints-and-tasks/

## Checkpoints

A checkpoint is not a separate Memory type. It is a Note or Task marked with the
**Checkpoint Preset** so it can support startup and resume continuity.

Use a Note checkpoint for a compact project or session summary. Use a Task
checkpoint when structured progress and next actions matter.

### Write a strong checkpoint

Include:

- the goal and current priority;
- completed work and the current state;
- durable decisions and constraints;
- blockers and failed approaches;
- environment or repository references;
- the recommended next action.

Keep the checkpoint summary short and high signal. Full supporting detail can
remain in the Memory body or linked references.

## Task Details

Task Memories can store structured fields for:

- status and progress;
- ordered next steps;
- parent and child tasks;
- dependencies and assignment;
- blockers and completion criteria;
- outputs, results, decisions, questions, and references.

Updates use Memory version history and conflict-safe expected versions so stale
writers do not silently overwrite newer task state.

## Working across AI tools

When resuming:

1. ask the AI to load the latest checkpoint for the known project;
2. let it inspect previews and references;
3. fetch only the full memories needed for the current action;
4. verify live repository or external state before making changes.

The checkpoint transfers continuity. It does not replace current code, current
documents, or the user's latest instruction as the source of truth.

---

Source: https://docs.memside.com/product/connected-context/

## What are Connections?

Connections keep related information together without combining Memories or
changing their content.

Open the **More actions** menu on a Memory and select **Connections**. The
window has two main areas:

- **Related memories** connects two specific Memories.
- **Subjects** groups several Memories around the same person, company, project,
  product, place, or topic.

Each Memory keeps its own content, status, sensitivity, tags, and history.
Removing a Connection does not delete either Memory.

## Choose the right option

| Option | What it does | Generic example |
| --- | --- | --- |
| **Tag** | Adds a lightweight label for filtering. | Add `travel` to trip notes, bookings, and packing lists. |
| **Subject** | Groups many Memories around the same person, company, project, product, place, or topic. | Group meeting notes, tasks, and preferences under a customer called `Greenfield Bakery`. |
| **Direct link** | Connects two specific Memories when their individual relationship matters. | Link a purchase decision directly to the comparison note that supports it. |
| **Fact** | Keeps a reviewed detail about a Subject. | Save `Prefers email contact` as a reviewed Fact for a customer. |

A simple rule:

- Use a **Tag** to label.
- Use a **Subject** to group Memories around the same thing.
- Use a **direct link** to connect two particular Memories.
- Use a **Fact** for a reviewed detail that should remain easy to find.

## Direct memory links

Use a direct link when two particular Memories have a meaningful relationship.

Two relationship choices are available:

- **Related to** for a general connection.
- **Depends on** when one Memory relies on another.

For example, a task called `Choose a new phone` can depend on a Memory called
`Phone budget and requirements`. The two Memories remain separate, but their
relationship is clear.

Unlinking removes only the relationship. It does not change or delete either
Memory.

## Subjects

A **Subject** is a reusable name for who or what one or more Memories are about.

Subjects can represent:

- a person;
- a company or customer;
- a project;
- a product;
- a candidate;
- a place;
- a research topic.

For example, a small business can create a Subject called `Greenfield Bakery`
and link:

- a first meeting note;
- a product enquiry;
- a follow-up task;
- a support request;
- an account review.

The same Subject keeps these separate Memories organized around one customer.

From the **Subjects** area in Connections, it is possible to:

- link an existing Subject;
- create and link a new Subject;
- reuse the same Subject across other Memories;
- edit a Subject's name or type;
- unlink it from one Memory;
- delete the Subject.

Deleting a Subject removes the Subject and its organization links. It does not
delete the Memories linked to it.

## Facts

A **Fact** is a reviewed detail about a Subject that is useful across more than
one Memory.

Examples include:

- a contact preference;
- a product requirement;
- an agreed decision;
- a renewal month;
- a current status;
- a known risk.

For the fictional `Greenfield Bakery` Subject, useful Facts could be:

- `Prefers email contact`
- `Interested in the standard plan`
- `Next review is in October`

Each Fact keeps a link to the Memory where the information came from. The source
Memory is not rewritten.

Open a linked Subject and select **Facts**. The Facts window separates
information into:

- **Current** for active reviewed Facts.
- **Review** for suggestions that still need a decision.
- **History** for Facts that are no longer current.

Facts can be added, edited, moved to History, restored, or deleted. Suggestions
from a connected AI stay in Review until they are accepted, edited, or
rejected.

## Related and suggested Memories

The **Related memories** area separates confirmed links from suggestions:

- **Linked memories** are Connections that have been confirmed.
- **Suggested memories** are possible matches found by Memside.

Select **Link** when a suggestion is useful. Select **Reject** when the
Memories are not related.

A suggestion does not become a confirmed Connection until it is linked.

## Context Map

The **Context Map** provides a visual view around one Memory. It can show:

- direct memory links;
- Subjects and their linked Memories;
- an active checkpoint;
- useful suggestions.

Confirmed Connections use solid lines. Suggestions use dashed lines. On smaller
screens, the same information appears as grouped cards.

The Context Map is for viewing. Use **Connections** to link, unlink, accept, or
reject information.

## Using Connections with agents and applications

Subjects and Facts are useful when several AI agents or applications need to
work with the same organized context.

The Subject acts as the shared topic. Memories hold the original notes, tasks,
events, or decisions. Facts hold reviewed details that should remain consistent
across work.

### Sales and CRM

A sales agent can save a call summary under a customer Subject. A follow-up
agent can find the same Subject, read the latest task, and use reviewed Facts
such as contact preference or product interest.

### Customer support

A support agent can link an issue to the same customer or product Subject.
Another agent can see the earlier support note without mixing it into the sales
Memory.

### Recruitment

Interview notes, availability, role preferences, and follow-up tasks can be
grouped under a candidate Subject. Reviewed Facts can keep important details
consistent across recruiting steps.

### Projects and research

Planning notes, decisions, tasks, references, and checkpoints can share one
project or research Subject. Different agents can work on separate tasks while
using the same reviewed context.

This pattern can also support personal planning, education, property
management, account management, and other applications.

## A simple multi-agent pattern

1. Create one Subject for the customer, candidate, project, product, or topic.
2. Link each relevant Memory to that Subject.
3. Add only reviewed details as Facts.
4. Use direct links when two specific Memories have an additional relationship.
5. Let each connected agent find the Subject and use only the context needed
   for its task.
6. Review suggested Facts before making them Current.

Connected agents can help create Subjects, link Memories, and suggest Facts
when those actions are enabled. Important changes remain visible for review and
confirmation.

## Next steps

- [Memories](/product/memories/)
- [Checkpoints and tasks](/product/checkpoints-and-tasks/)
- [Search, Context Map, and Insights](/product/find-and-review/)
- [Connection overview](/connect/mcp-and-api/)

---

Source: https://docs.memside.com/product/find-and-review/

## Search and filters

Use text search, semantic search, types, status, tags, sensitivity, and dates to
narrow the Memory dashboard. Search results show a short preview before a
Memory is opened.

Clear titles and focused content make Memories easier to find.

## Related Context

Related Context shows Memories that may help with the current item. A result can
appear because it:

- has a direct Connection;
- belongs to the same Subject;
- is referenced by a task or checkpoint;
- shares useful tags or related content.

Confirmed Connections are kept separate from suggestions. Suggestions that are
not useful can be dismissed.

## Context Map

The Context Map is a read-only, memory-centered view. It can show direct links,
Subject groups, active checkpoints, and useful suggestions. Solid connections
represent confirmed structure; suggestions remain visually separate.

Use Connections, not the map, when the task is to link, unlink, accept, or reject
context.

## Memory Insights

Memory Insights highlights information that may need attention, such as
duplicate Facts, changed source Memories, or Subjects without Facts.

Each item can be reviewed, resolved, or dismissed. Supported changes can also
be undone.

Insights do not silently rewrite memories or promote AI-generated content.

---

Source: https://docs.memside.com/product/memories/

## What is a Memory?

A Memory is the basic building block of Memside. It is any piece of context
that should remain available for personal reference and, when allowed, for
connected AI tools.

That can include a note, task, event, idea, goal, wishlist, Operating Rule, or a
checkpoint for work that should continue later.

Each Memory is stored in a structured format so it can be searched, filtered,
updated, and reused more reliably than information buried inside long chat
history. This helps Memside support continuity across different AI apps and
coding tools.

## Create a Memory

Creating a Memory is simple:

1. Sign in to Memside.
2. Select **Create Memory** to open the create modal.
3. Choose the Memory type that best matches the information being saved.
4. Add the main content in the text area.
5. Add optional details such as a title, Project, tags, dates, sensitivity,
   attachments, checkpoint details, or Task Details.
6. Select **Create Memory**.

The Memory is saved to the dashboard. It can then be searched, edited, used by
connected AI tools, or used later to continue work.

## Details to add

The most important field is the main text content. This is where the note,
instruction, task details, event description, or other useful context is
stored.

Other useful details include:

- **Title** for quick recognition and cleaner search results.
- **Project** for placing the Memory in one optional Project.
- **Tags** for grouping related Memories.
- **Sensitivity** to control how the Memory can be used.
- **Occurred** date for when something happened.
- **Due Date** when a task or event has a deadline.
- **Attachments** when the Memory needs files, screenshots, or documents.

When creating a **Task**, **Task Details** can add structured progress and
continuation information. When creating an **Operating Rule**, Memside shows
fields for where the rule applies and how important it is.

## Edit a Memory

Open the card's **More actions** menu and select **View / Edit**. The edit form
contains the current Memory details and the same optional Project selector used
when creating a Memory.

Selecting a different Project moves the Memory to that Project. Clearing the
field removes the Project assignment. **Manage Projects** can create or rename
Projects without leaving the form. An unused Project can also be deleted;
linked Memories must be removed from a Project first.

Add a short change note when the reason for an edit may be useful later. Saving
creates a new version and keeps the earlier version in History.

## Memory types

Memory type helps Memside organize information and show the right fields:

- **Note** for general information, meeting notes, links, research, or saved
  context.
- **Task** for action items or ongoing work that may need progress, next steps,
  or checkpoint support.
- **Event** for something tied to a date or time.
- **Shopping List** for items to buy or compare.
- **Wishlist** for things to remember for a later purchase or plan.
- **Prompt** for prompts that should be reused across AI tools.
- **Idea** for early concepts, rough thoughts, or brainstorming.
- **Goal** for a target or outcome to track.
- **Log** for dated entries, progress notes, or records.
- **Operating Rule** for a standing instruction that should apply in relevant
  AI work.

For most uses, **Note** and **Task** cover everyday needs. Use an **Operating
Rule** for a lasting instruction rather than a one-time note.

## Task Details

**Task Details** are optional fields for Task Memories. They are useful when a
task needs clearer progress and continuation information instead of looking
like a plain note.

Task Details can be enabled while creating or editing a Task. They include:

- required **Goal** and **Status** fields;
- optional **Progress**, **Priority**, **Assigned To**, and up to three ordered
  **Next Steps**;
- optional **Subtasks** for separate pieces of work;
- an advanced section for parent tasks, dependencies, Operating Rules,
  blockers, completion criteria, outputs, results, notes, decisions, questions,
  and references.

Use Task Details when a task needs a clearer working state for later use. Leave
them off when the task is simple and the main text is enough.

## Operating Rules

An **Operating Rule** is a standing instruction that Memside can share with
connected AI tools when it is relevant.

Use an Operating Rule for guidance that should continue over time, such as
writing preferences, workflow rules, project constraints, or repeatable
instructions.

Operating Rule fields include:

- **Rule Title**
- **Instruction Text**
- **Scope Level**, such as Global, Workspace, or Project
- **Scope Reference** when the rule belongs to a specific workspace or project
- **Priority**
- optional **Applies To Modes**

This helps the right instructions appear in the right work instead of requiring
the same explanation in every fresh AI chat.

## Scope Level and Scope Reference

Scope tells Memside where an Operating Rule should apply:

- **Global** applies everywhere and does not need a Scope Reference.
- **Workspace** applies inside one workspace area.
- **Project** applies inside one project area.

For Workspace or Project, **Scope Reference** identifies the specific place.
Use a stable, recognizable name and use the same name consistently.

Generic examples:

- Workspace: `Personal planning`
- Project: `Home renovation`

A Scope Reference is not a Tag or Subject. It helps Memside choose when an
Operating Rule applies. It does not group Memories or create a visible
Connection.

## Checkpoint Preset and Checkpoint Summary

A checkpoint is not a separate Memory type. It is a **Note** or **Task** marked
with the **Checkpoint Preset** so the saved state can be used when work
continues later.

The checkpoint flow is useful when returning to work without rewriting the same
background. A checkpoint can save what has been completed, what matters now,
and what should happen next.

Only Note and Task Memories can be marked as checkpoints:

- Use a **Note** for a compact project or session summary.
- Use a **Task** when structured Task Details such as progress and next steps
  are also needed.

When **Checkpoint Preset** is enabled, Memside shows a **Checkpoint Summary**
field. Keep this summary short and focused so the next AI session can understand
the current state quickly.

## Sensitivity levels

Every Memory has a **sensitivity** setting. Sensitivity controls how the Memory
can be used and whether connected AI tools can access it.

### Private

**Private** is the default for most Memories. Use it for normal personal or
project context that a connected AI tool may need when asked.

Examples include meeting notes, project decisions, travel plans, or an active
task.

### Secret

**Secret** is the strictest setting. Use it for information that should remain
inside the Memside app and should not be available through normal AI-sharing
flows.

If a connected AI tool needs the Memory later, change its sensitivity to
**Private** or **Public** first.

Passwords, recovery codes, payment details, and access keys should not be saved
in Memside, even as Secret Memories.

### Public

**Public** Memories are still owned by the account holder. They are easier for
connected AI tools to notice through lightweight hints. This helps an AI
recognize open topics, interests, wishes, or ongoing items that may be relevant.
The AI can then open the full Memory when more information is needed.

Public does not make the Memory visible to other users or publish it on the
internet.

For example, a laptop shortlist, a wishlist item, or an open research topic can
be Public. A connected AI may notice it and offer relevant help.

In short:

- Use **Private** for normal saved context that an AI may need when asked.
- Use **Secret** for app-only information that connected AI tools must not
  access.
- Use **Public** for open interests or pending items that an AI may be able to
  help with.

Memside does not currently provide a visible expiry setting for Public
Memories.

## Tags

Tags are keywords added to a Memory to group related information and make it
easier to find.

Generic examples include **travel**, **shopping**, **health**, and **books**.

Tags help with:

- filtering related Memories;
- building cleaner search results;
- keeping related context grouped together;
- helping AI tools find the right saved context later.

Multiple tags can be added to one Memory.

Tags are lightweight labels. A **Subject** groups Memories around a particular
person, company, project, product, place, or topic. A **Connection** links two
specific Memories.

## Attachments

Documents, screenshots, and images can be attached directly to a Memory.

Memside can:

- extract text from supported documents;
- read text inside images with OCR;
- make file content easier to search;
- show previews inside the app.

This allows a Memory to include both a written note and its supporting files.

Current limits:

- **Size:** up to **25 MB** per file.
- **Total quota:** **500 MB** of attachment storage per account.
- **Formats:** common types such as **.pdf**, **.txt**, **.jpg**, **.png**, and
  **.docx**.

## Length guidance

There is no need to over-optimize every Memory, but shorter and clearer entries
work better for search and AI continuity.

- **Title:** keep it short and recognizable.
- **Body:** there is no strict limit for normal use, but focused text is easier
  to search and reuse.
- **Operating Rule Instruction Text:** maximum **4,000 characters**.
- **Checkpoint Summary:** keep it short and focused.
- **Task Details:** require a Goal and Status when enabled.
- **Task resume instructions:** maximum **500 characters**.

For large source material, use attachments or the text importer instead of
placing everything in one Memory.

## Occurred and Updated dates

These dates mean different things:

- **Occurred** is when something happened or is meant to happen.
- **Updated** is when the Memory was last edited in Memside.

For example, meeting notes written today for a meeting held yesterday can show
yesterday as **Occurred** and today as **Updated**.

Keeping both dates makes sorting, filtering, and finding context more accurate.

## Due Date

The **Due Date** is optional. It is useful for tasks or events with a deadline,
milestone, reminder point, or follow-up date.

Examples include:

- a task that must be completed this week;
- a renewal or payment date;
- an event happening in the future.

Leave the field empty when the Memory is not time-bound.

## Tips for useful Memories

A useful Memory is short, specific, and easy to recognize later. Clear titles,
useful tags, focused checkpoint summaries, and Task Details only when they add
real value make Memories easier to search and reuse.

## Next steps

- [Checkpoints and tasks](/product/checkpoints-and-tasks/)
- [Connections, Subjects, and Facts](/product/connected-context/)
- [Search, Context Map, and Insights](/product/find-and-review/)

---

Source: https://docs.memside.com/product/memory-bundles/

## What is a Memory Bundle?

A Memory Bundle collects saved context and prepares it for an AI conversation.

Use it to gather the required Memories, choose how they appear, and then copy
the result into another AI tool or use it with the Memside in-app assistant.

This helps an AI start with relevant context in one organized block instead of
reconstructing background from several messages. Filters and formatting keep
the bundle focused so unrelated Memories do not consume attention or context.

## Continuity options

A bundle can include:

- **AI Profile** for the enabled User AI Profile.
- **Rule section** for matching Operating Rules.
- **Task details** for available checkpoint or Task information.
- **Preamble** for a short instruction at the top.
- **Secret** Memories only when the Secret option is intentionally enabled.

Bundle choices are remembered on the current device. Select **Build Bundle**
after changing the settings.

## Templates

Templates control how each Memory appears:

- **Title + Body**
- **Body Only**
- **Full Detail**
- **Custom**

Use **Custom** to choose individual fields.

## Preamble

A preamble adds a short instruction at the top of the bundle.

Choose a built-in option, turn the preamble off, or write a custom instruction.

## Date range

Limit a bundle with the **From** and **To** fields, or use:

- **Today**
- **Last 7 days**
- **Last 30 days**
- **All time**

## Sorting

Order bundle content by **Updated** or **Occurred** date.

Use Updated for recently changed information. Use Occurred to preserve the
order in which events happened.

## Secret Memories

Secret Memories are excluded by default.

Enable **Secret** only when the bundle intentionally needs that information.
Review the bundle before copying it into another tool.

## Main actions

- **Reset Filters** restores the default setup.
- **Build Bundle** generates content from the current settings.
- **Clear Memories** empties the bundle text.
- **Copy** copies the current text.

The bundle can be edited before it is copied. A size label shows **Compact**,
**Medium**, or **Large**.

## Build from selected Memories

Select specific Memory cards, then choose **Build Bundle** from the selection
bar.

Only the selected Memories are used, together with the current bundle settings.

## Next steps

- [User AI Profile](/product/user-ai-profile/)
- [Operating Rules and AI Skills](/product/profile-rules-skills/)
- [In-App Assistant](/connect/in-app-assistant/)

---

Source: https://docs.memside.com/product/memory-dashboard/

## Browse saved Memories

Saved Memories appear in the main area of the dashboard. This is where
Memories can be browsed, searched, opened, edited, and managed.

Memories are shown as responsive cards. The layout adjusts to the available
screen size.

## Dashboard controls

The application header shows Memory usage, the theme switch, the notification
bell, a Library link, and the profile menu. Profile, Settings, My Templates,
Docs, and Logout are available from the profile menu.

The workspace toolbar keeps the main actions together:

- **Create Memory** opens the create modal;
- **Memory Bundle** opens the bundle workspace;
- the search field finds saved Memories;
- **Filters** narrows the list;
- **Sort** changes the card order;
- **AI Search** switches between exact text search and meaning-based search.

## Information shown on a card

A Memory card can show:

- a selection checkbox;
- the Memory type, Checkpoint marker, or Operating Rule marker;
- the number of confirmed Connections, when available;
- the title and a preview of the main text;
- a confidence percentage;
- up to three attachments, followed by a count for additional files;
- an optional Project and up to three tags;
- status and sensitivity;
- created and updated dates, plus a due date when one is set;
- the current version and source;
- the **More actions** menu.

Memories created from a Library Template show a Template source label with the
originating version and item name. The label records provenance without making
the private Memory public.

Fields without a value are not shown. Selecting the connection count opens the
related Memories and Subjects.

## Confidence

The confidence percentage helps Memside and connected AI tools identify
Memories that may be useful.

It works in the background and does not need to be adjusted manually.

## Sort Memories

Use the **Sort** menu above the cards. Memories can be ordered by occurred date,
last updated date, due date, or title.

## View and edit

To edit a Memory:

1. Open its **More actions** menu.
2. Select **View / Edit**.
3. Update the required fields.
4. Select or clear the optional **Project** field when needed.
5. Add a change note when useful.
6. Save the changes.

The form changes based on Memory type:

- Standard Memories show title, content, tags, status, dates, sensitivity, and
  attachments. The optional Project field places the Memory in one Project.
- Operating Rules show rule title, instruction, scope, and priority.
- Notes and Tasks can use Checkpoint Preset and Checkpoint Summary.
- Tasks can enable Task Details for progress and continuation information.

Every save creates a new version, so the earlier state remains in History.

## History

Every saved change creates version history.

To open it:

1. Open **More actions**.
2. Select **History**.

History shows earlier versions, saved dates, a summary of changed fields, and
an older content preview. Task Memories can also show changes to progress and
next steps.

## Restore a version

To restore an earlier version:

1. Open **History**.
2. Find the required version.
3. Select **Restore**.

The earlier content becomes a new current version. Existing history is not
removed.

## Archive and complete

**Archive** removes a Memory from the active working list without deleting it.
Use it for information that is finished, paused, or no longer needed in the
main view.

**Completed** marks a Memory, usually a Task, as done. It remains available for
reference.

## Delete a Memory

Deleting a Memory permanently removes it and its version history.

From the app:

1. Open **More actions**.
2. Select **Delete**.
3. Confirm the warning.

AI deletion is optional and controlled in **Settings > AI Permissions**. Even
when it is enabled, each deletion requires explicit confirmation.

## Next steps

- [Search and Filters](/product/search-and-filters/)
- [Connections, Subjects, and Facts](/product/connected-context/)
- [Settings](/product/settings/)
- [Add a Template to Memside](/library/add-to-memside/)

---

Source: https://docs.memside.com/product/notifications/

## Overview

Notifications provide private status updates from Memside and Memside Library.
They can confirm completed actions or identify work that requires attention.

Examples include:

- a completed Template import;
- a Template review or publication result;
- an account action that produced a durable status update.

Notification content belongs to the signed-in account and is not part of a
public Template or creator page.

## Header bell

The header bell shows a red indicator when unread notifications exist. Its
popover presents the newest items from both products.

Selecting a notification marks it as read while keeping the current page open.
A separate destination action is shown when the notification has a related page.
The popover also supports marking all items as read and clearing read items.

## Notification center

Open **Settings > Notifications** for the complete account history. The center
supports:

- **All**, **Memories**, and **Library** source filters;
- an **Unread** filter;
- individual read actions;
- **Mark all read**;
- **Clear read**;
- **Load more** for older results.

Read and clear actions are applied to the product that owns each notification,
while the page presents one combined history.

## Privacy

Notification history is loaded for the active signed-in session. Private
notification content is not stored as a permanent browser cache. Signing out
clears the active presentation state.

## Related pages

- [Settings](/product/settings/)
- [Add a Template to Memside](/library/add-to-memside/)
- [Create and publish Templates](/library/create-and-publish/)

---

Source: https://docs.memside.com/product/profile-rules-skills/

## User AI Profile

User AI Profiles store general preferences and guidance for connected AI
tools. An account can contain multiple purpose-specific Profiles, with one
Default.

Profiles are suitable for writing style, communication preferences, work
habits, and guidance that applies across many chats. They help an AI reuse
stable preferences without mixing guidance for unrelated activities.

See [User AI Profile](/product/user-ai-profile/).

## Operating Rules

Operating Rules are standing instructions.

They help an AI apply a clear requirement consistently and at the correct
scope. A Project rule can stay with one project instead of affecting every
conversation.

Generic examples:

- use short paragraphs;
- confirm before sending a message;
- follow a review checklist;
- apply a rule only inside one project.

Rules can be Global, Workspace, or Project specific. A Scope Reference identifies
the Workspace or Project where a rule applies.

Operating Rules are created as a Memory type. See
[Memories](/product/memories/#operating-rules).

## AI Skills

AI Skills are reusable instruction packs imported from supported instruction
files or text.

Skills remain separate from Memories. They can be reviewed and improved before
activation. A Skill helps an AI follow a repeatable multi-step method for a
specific task rather than relying on a short general preference.

Published Library Templates can provide Profile, Rule, and Skill candidates.
Add to Memside keeps selection explicit: reviewed Profiles and Rules can become
available after import, while Skills remain drafts until separately reviewed.

See [AI Skills](/product/ai-skills/).

## Choose the right feature

| Feature | Best for |
| --- | --- |
| **User AI Profile** | General preferences used across AI tools. |
| **Operating Rule** | A standing instruction with an optional Workspace or Project scope. |
| **AI Skill** | A reusable instruction pack for a specific kind of work. |

Example selection:

- a preferred concise response style belongs in a Profile;
- a requirement to confirm before an external action belongs in an Operating
  Rule;
- a complete document-review process belongs in an AI Skill.

## Next steps

- [User AI Profile](/product/user-ai-profile/)
- [AI Skills](/product/ai-skills/)
- [Memory Bundles](/product/memory-bundles/)
- [Add a Template to Memside](/library/add-to-memside/)

---

Source: https://docs.memside.com/product/search-and-filters/

## Where to find search

The search bar and filter controls appear above the main Memory list. Use them
to find saved information, narrow a large list, and focus on current work.

## Universal Search

The main search box is the fastest way to find a Memory. Enter a word or phrase
to search saved content.

For example, search for `meeting` to find meeting notes and follow-up tasks.

## AI Search

AI Search finds Memories by meaning, not only by exact wording.

For example, searching for `finance` may find a Memory titled `Quarterly
budget`.

For a name, code, or exact phrase, use a more specific term or combine search
with filters.

## Sort results

Use the **Sort** menu above the Memory cards. Available options organize results
by occurred date, last updated date, due date, or title.

## Filters

Filters can narrow results by:

- **Status**, such as Active, Completed, or Archived;
- **Sensitivity**, such as Private, Public, or Secret;
- **Memory Type**, such as Note, Task, Event, or Operating Rule;
- **Due Date** for time-based work;
- **Tags** for a topic or group.

Tag matching supports:

- **AND** to require all selected tags;
- **OR** to allow any selected tag.

The filter button shows a count when filters are active.

## A simple search pattern

1. Start with one broad search term.
2. Check the first results.
3. Add Status, Type, or Tags only if the list remains too broad.
4. Clear filters before starting a different search.

For example, search for `trip`, filter by **Active**, then add the tag
`planning`.

## Next steps

- [Memory Dashboard](/product/memory-dashboard/)
- [Context Map and Insights](/product/find-and-review/)
- [Memories](/product/memories/)

---

Source: https://docs.memside.com/product/settings/

## Overview

Settings is the control center for the Memside account.

The available pages cover profile details, usage, appearance, notifications,
imports, AI providers, connected access, exports, and permissions.

## Profile

Open **Settings > Profile** to review:

- username, display name, email, and optional website or biography;
- the account profile picture;
- password and connected sign-in providers.

The same account profile is used across Memside and Memside Library. A Memside
node avatar appears until a profile picture is uploaded in Memside.

## Usage & Metrics

Open **Settings > Usage & Metrics** to review account capacity and
privacy-bounded Library activity. Available Library information can include
complete Template downloads, individual file downloads, and grouped Template
or file names. Downloader identities are not displayed.

Recently loaded Library metrics can remain visible while a refresh completes.

See [Usage and metrics](/product/usage-and-metrics/).

## Appearance

Open **Settings > Appearance** to select **System**, **Light**, or **Dark** and
choose an accent colour. The accent is used for primary actions, links, toggles,
focus rings, and selected controls. Memory types and status colours remain
unchanged. Appearance choices do not affect Memories or account data.

## AI Permissions

Open **Settings > AI Permissions** to control:

- access to the saved User AI Profile;
- access to Memory tools through MCP;
- access to Library tools through MCP;
- approval prompts for supported MCP Memory changes during Beta;
- requests from connected AI tools to delete Memories.

Memory and Library access can be enabled independently. Deletion still requires
explicit confirmation when AI deletion is enabled.

See [AI permissions](/product/ai-permissions/) for each switch, common
configurations, and the interaction between account-level and Profile-level
access.

## User AI Profile

Open **Settings > User AI Profile** to manage multiple purpose-specific
Profiles, select one Default, control individual AI availability, and link
relevant Memories.

## AI Skills

Open **Settings > AI Skills** to import, review, activate, edit, or remove saved
instruction packs.

## Notifications

Open **Settings > Notifications** to review the complete private notification
history from Memside and the Library. Filters are available for source and
unread state. Notifications can be marked as read, and read notifications can
be cleared.

The header bell presents the newest items. Opening an item marks it as read
without changing the current page unless a separate action link is selected.

See [Notifications](/product/notifications/).

## LLM Configuration

Open **Settings > LLM Configuration** to connect the provider used by the
in-app assistant.

Available paths:

- **Custom (OpenAI-compatible)** for hosted providers;
- **Local (Ollama)** for models running on the same computer.

After saving the details, select **Test**.

See [In-App Assistant](/connect/in-app-assistant/) for complete setup.

## Developer & API

Open **Settings > Developer & API** to access:

- the Memside MCP server URL;
- API keys that can be created and revoked;
- read-only or read-write key access;
- the API key list and connection activity;
- independent Memory and Library MCP tool controls.

The full value of a new API key is shown only once. Save it immediately and do
not place it in a shared file.

Each API key has an **Activity** action. The activity window shows up to 25
recent requests with the action, result, time, and request reference. Memory
content is not shown in this list.

See [Connection overview](/connect/mcp-and-api/) and
[Developer quickstart](/developers/).

## Import & Export

Open **Settings > Import & Export** for all one-time imports and portable
exports.

Import options:

- **Calendar file** accepts an `.ics` file and creates Event Memories.
- **Chat or long text** accepts pasted conversations, documents, and long notes.
- **CSV file** imports multiple new Memories from the provided template.

Chat or long text import supports an optional title, a large text field, an
optional tag, and a split count for creating several Memories. Supported
ChatGPT JSON exports can also be converted into readable text.

Export options:

- **CSV** for spreadsheets;
- **Markdown** for readable notes.

CSV import:

1. Download the CSV template.
2. Add title, content, type, status, sensitivity, tags, and optional dates.
3. Use `DD-MM-YYYY` for dates.
4. Upload the CSV.
5. Review and confirm the import.

CSV import creates new Memories. It does not overwrite existing Memories.

## What's New

Open **Settings > What's New** for the latest product changes and a link to the
full changelog.

## Legal

Open **Settings > Legal** for the current Privacy Policy and Terms.

## Delete Account

Open **Settings > Delete Account** to permanently remove the account, saved
Memories, settings, owned Library Templates, and account-linked Library data. A
final confirmation appears before deletion.

This action cannot be undone.

## Next steps

- [AI permissions](/product/ai-permissions/)
- [User AI Profile](/product/user-ai-profile/)
- [AI Skills](/product/ai-skills/)
- [Notifications](/product/notifications/)
- [Usage and metrics](/product/usage-and-metrics/)
- [Memside Library](/library/)
- [Library access through MCP and API](/library/mcp-and-api/)
- [Security and Privacy](/help/security-and-privacy/)

---

Source: https://docs.memside.com/product/usage-and-metrics/

## Account capacity

Memside presents current usage against applicable account limits. Capacity can
include saved Memories and attachment storage.

An account limit currently applies to saved Memories. The applicable capacity
is displayed in **Settings > Usage & Metrics** and may change with future
account plans.

The usage display helps explain why a new Memory, Profile, import, or attachment
cannot be added. Removing eligible private content can make capacity available
again.

To view capacity:

1. Open Memside.
2. Open **Settings**.
3. Select **Usage & Metrics**.
4. Review **Memory quota** and **Storage space**.

## Template download metrics

Creator-facing Library metrics can include:

- complete Template download totals;
- individual file download totals;
- grouped Template names;
- grouped downloaded file names.

**Template downloads** counts complete downloads of owned public Templates.
**File downloads** counts individual file downloads. These values separate a
complete package download from interest in one particular file.

## Find the most downloaded files

1. Open **Settings > Usage & Metrics**.
2. Move to the Library metrics area.
3. Review **Most downloaded files**.
4. Select **Show more** when more than the initial entries are available.

Each entry identifies the file path, Template name, and download count. The list
can help identify the most useful examples, instructions, or reference files.

Example: repeated downloads of `examples/simple-week.md` can indicate that the
example is useful enough to keep prominent and current.

The information is limited to owned Template activity and does not expose
downloader identities. Complete-Template popularity uses authenticated,
privacy-bounded activity rather than raw anonymous page visits.

Metrics do not show downloader names, email addresses, account identifiers, or
the contents of downloaded files.

## Refresh behavior

Recently loaded Library metrics can be reused briefly while moving between
Settings pages. Existing values can remain visible during a refresh so the page
does not return to an empty state unnecessarily.

Metrics are informational and do not change Template ownership, publication,
review, or ranking controls.

## Interpreting the totals

A download count indicates retrieval, not a guaranteed successful outcome or
endorsement. Compare totals over time and keep descriptions, examples, and
release notes accurate. A file with few downloads can still be essential to the
complete Template.

## Related pages

- [Settings](/product/settings/)
- [Memside Library](/library/)
- [Create and publish Templates](/library/create-and-publish/)

---

Source: https://docs.memside.com/product/user-ai-profile/

## What is the User AI Profile?

A User AI Profile stores guidance that can be reused across connected AI tools.
An account can contain multiple purpose-specific Profiles, with one Profile
designated as the **Default** when Profiles exist.

It can include:

- work preferences;
- writing style;
- coding style;
- communication preferences;
- general project guidance.

Each Profile can include:

- a title;
- optional guidance describing when it is useful;
- working and communication preferences;
- up to five linked non-Secret Memories;
- an individual availability setting for connected AI tools.

## Why Profiles help AI

An AI tool does not automatically know stable preferences from a different
conversation or application. Repeating the same context manually can be slow,
inconsistent, and easy to forget. A Profile provides an explicit, reusable
description of how work should be approached.

Multiple Profiles keep unrelated preferences separate. Planning guidance does
not need to affect a writing task, and technical conventions do not need to
appear in a general conversation. A connected AI can load the Default Profile
as a baseline or a named Profile for a particular activity.

Profiles can help an AI:

- use a consistent communication or output style;
- understand the purpose of a task more quickly;
- apply stable working preferences across supported tools;
- avoid asking for the same general guidance in every conversation;
- select task-appropriate guidance without loading unrelated preferences.

Profiles provide preferences and context. They do not run automatically, grant
new permissions, or replace instructions in the current conversation.

## Create a Profile

1. Open **Settings > User AI Profile**.
2. Select **Add profile**.
3. Add a Profile title of up to **60 characters**.
4. Optionally describe when the Profile should be used, up to **240 characters**.
5. Add preferences and working style, up to **1,500 characters**.
6. Choose whether to set the Profile as **Default**.
7. Choose whether it is **Available to AI**.
8. Select **Save**.

The title and preferences are required. The first Profile is set as Default.

### Field example

```text
Title: General planning
When should this be used?: Planning tasks, priorities, and follow-up
Preferences and working style:
Use short sections and plain language.
Separate decisions from action items.
Ask for confirmation before destructive or external actions.
```

Use stable preferences rather than one-time task details. A project deadline or
temporary request fits better in a Memory or the current conversation.

## Edit a Profile

1. Open **Settings > User AI Profile**.
2. Select the Profile name.
3. Change the relevant fields or availability setting.
4. Select **Save**.

## Default and Available to AI

These settings have different purposes:

| Setting | Effect |
| --- | --- |
| **Default** | Selects the Profile used when no specific available Profile is requested. |
| **Available to AI** | Allows a connected AI client to retrieve that individual Profile. |

A Default Profile can remain unavailable to connected AI tools. The
account-level Profile permission in **Settings > AI Permissions** must also be
enabled. See [AI permissions](/product/ai-permissions/).

## Linked Memories

Up to **5** non-Secret Memories can be linked.

Choose the Memory type, select a title, then select **Add**. Remove a linked
Memory with the **X** button.

Linked Memories remain separate. They help an AI find related notes, Operating
Rules, or checkpoints without placing everything in the Profile description.

Secret Memories cannot be linked. Linking does not copy the full Memory into
the Profile, change its sensitivity, or publish it. Removing a link does not
delete the Memory.

### Add a linked Memory

1. Select the Profile.
2. Open the linked Memories area.
3. Choose a Memory type and then a Memory.
4. Select **Add**.

### Remove a linked Memory

Select the **X** beside the link. Only the relationship is removed.

## Generic example

A Profile can contain:

```text
Prefer short summaries with clear action points.
Use simple language and explain unfamiliar terms.
Confirm before sending or deleting anything.
```

Profiles work best for stable, reusable guidance. Project-specific instructions
fit better in an Operating Rule or a project Memory.

## Use multiple Profiles

Each Profile should have one clear purpose. Descriptive names and a short
**When should this be used?** field help a connected AI choose the relevant
guidance.

| Profile example | Suitable guidance | Example request |
| --- | --- | --- |
| **General planning** | Priorities, action format, decision handling, and follow-up style. | `Use the General planning Profile to prepare a weekly plan.` |
| **Writing and editing** | Tone, paragraph length, reading level, and review expectations. | `Load the Writing and editing Profile before revising this note.` |
| **Technical work** | Code style, testing expectations, change summaries, and approval boundaries. | `Apply the Technical work Profile to this implementation plan.` |
| **Research** | Source quality, uncertainty, citation style, and comparison format. | `Use the Research Profile and compare the available evidence.` |

Only stable guidance belongs in a Profile. Temporary task details remain in the
current conversation, a project Memory, or an Operating Rule with a suitable
scope.

## Profiles from Library Templates

A published Template can provide a Profile candidate through **Add to
Memside**. The selected content is reviewed during import. A first eligible
imported Profile becomes the Default when no Profile already holds that role.

An imported Profile can be merged into an existing Profile. Existing choices
and explicit availability settings are preserved unless a change is confirmed.
Current account capacity still applies.

Imported Profile content must be checked before it is made available to AI. If
an imported Profile overlaps an existing one, **Merge into another** can combine
the imported content into a selected destination for review.

## Use a Profile with connected AI

1. Confirm that **Available to AI** is enabled for the intended Profile.
2. Open **Settings > AI Permissions** and enable connected Profile access.
3. Connect an AI client through MCP or use an eligible API key.
4. Ask the connected tool to load the Default Profile or a named Profile.

Example prompts:

```text
Load the Default Memside Profile before preparing the plan.
```

```text
Use the General planning Profile and summarize the working preferences that apply.
```

Connected tools can list available Profiles without receiving the content of
Profiles marked unavailable. Saved preferences never override the current
conversation, safety requirements, or system instructions.

## Delete a Profile

1. Select the Profile in **Settings > User AI Profile**.
2. Select **Delete**.
3. Review the confirmation and complete the action.

A Default Profile cannot be deleted until another Profile is set as Default.
Linked Memories are not deleted with the Profile.

## Boundaries

A User AI Profile provides guidance. It does not override system instructions,
safety controls, account permissions, or the current conversation.

## Next steps

- [Operating Rules and AI Skills](/product/profile-rules-skills/)
- [AI Skills](/product/ai-skills/)
- [Memory Bundles](/product/memory-bundles/)
- [Add a Template to Memside](/library/add-to-memside/)
- [AI permissions](/product/ai-permissions/)