Memanto MCP

by moorcheh-ai

335 downloads

Not rated

GitHub

About

MEMANTO is a memory agent. It remembers, recalls, and answers - so your agents can achieve long-term goals and avoid confusion.

Details

Author: moorcheh-ai
Downloads: 335
Categories: AI, Knowledge Base, Other

- Persistent semantic memory across MCP-compatible agents
- Sub-90 ms retrieval with conflict detection
- Shared memory namespace for multiple agents
- Supports 13 memory types and 6 provenance values
- RAG-based grounded answer tool using memories
- Point-in-time and differential recall capabilities

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name Memanto MCP

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

From the repository

Install with pip install memanto-mcp. Set the MOORCHEH_API_KEY environment variable and optionally MEMANTO_DEFAULT_AGENT_ID. Add the server to your MCP client's configuration file (e.g., claude_desktop_config.json). The server registers seven memory tools by default; four agent‑management tools can be enabled via MEMANTO_EXPOSE_ADMIN=true. Transport can be stdio, sse, or streamable‑http, configured via environment variables or CLI flags (memanto-mcp --transport sse --port 8765).

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "memanto mcp": {
            "memanto": {
                "command": "memanto-mcp",
                "env": {
                    "MOORCHEH_API_KEY": "<your-key>",
                    "MEMANTO_DEFAULT_AGENT_ID": "my-project"
                }
            }
        }
    }
}

McpServers

{
    "memanto": {
        "command": "memanto-mcp",
        "env": {
            "MOORCHEH_API_KEY": "<your-key>",
            "MEMANTO_DEFAULT_AGENT_ID": "my-project"
        }
    }
}

Memanto MCP Server

Persistent semantic memory for any MCP-compatible agent. This package exposes Memanto's memory primitives — remember, recall, answer, and friends — as Model Context Protocol (MCP) tools so any MCP client (Claude Desktop, Cursor, Windsurf, Cline, Continue, Goose, custom agents, …) can plug into long-term memory in a single config line. > One Moorcheh API key → typed semantic memory across every agent that > shares the namespace, with sub-90 ms retrieval, conflict detection, and > zero ingestion latency. ---

Install

bash
pip install memanto-mcp



Requires Python 3.10+ and a Moorcheh API key
(free tier: 100K ops/month).

Quick start (Claude Desktop)


1. Get a Moorcheh API key from the console.
2. Edit

claude_desktop_config.json

 (Settings → Developer → Edit Config):

json
{
  "mcpServers": {
    "memanto": {
      "command": "memanto-mcp",
      "env": {
        "MOORCHEH_API_KEY": "mch_xxxxxxxxxxxxxxxxxx",
        "MEMANTO_DEFAULT_AGENT_ID": "my-assistant"
      }
    }
  }
}



3. Restart Claude Desktop. Ask it to "remember that I prefer concise
   answers" — then in a brand-new chat tomorrow ask "what do I prefer?".

The first call auto-creates the

my-assistant

 agent and namespace; every
subsequent call reuses the same persistent memory.

Quick start (Cursor / Windsurf / Cline / Continue / Goose)


Most clients consume a config file in the
standard MCP shape.
The same JSON snippet works almost verbatim:

json
{
  "mcpServers": {
    "memanto": {
      "command": "memanto-mcp",
      "env": {
        "MOORCHEH_API_KEY": "mch_xxxxxxxxxxxxxxxxxx",
        "MEMANTO_DEFAULT_AGENT_ID": "cursor-workspace"
      }
    }
  }
}



| Client | Config path |
|---|---|
| Claude Desktop |

~/Library/Application Support/Claude/claude_desktop_config.json (macOS) / %APPDATA%\Claude\claude_desktop_config.json

 (Windows) |
| Cursor |

~/.cursor/mcp.json (or per-project .cursor/mcp.json

) |
| Windsurf |

~/.codeium/windsurf/mcp_config.json

 |
| Cline (VS Code) |

~/.config/Code/User/globalStorage/cline.cline/settings/cline_mcp_settings.json

 |
| Continue |

~/.continue/config.json → experimental.modelContextProtocolServers

 |
| Goose |

~/.config/goose/config.yaml

 |

Available tools


The server registers 7 memory tools by default. Set

MEMANTO_EXPOSE_ADMIN=true

 to also expose 4 agent-management tools.

Memory tools (always on)


| Tool | When the agent should call it |
|---|---|
|

remember

 | Persist a single new fact/preference/decision/goal/instruction. |
|

batch_remember

 | Persist up to 100 memories in one call (e.g. extracted from a document). |
|

recall

 | Semantic search — always check here before asking the user to repeat stable info. |
|

recall_recent

 | "What did we just decide?" — newest-first, no query needed. |
|

recall_as_of

 | Point-in-time recall — "what did we know on 2025-11-01?" |
|

recall_changed_since

 | Differential — "what's new since I last checked?" |
|

answer

 | RAG: grounded LLM answer synthesized over the agent's memories. |

Agent admin tools (opt-in)


Enabled when

MEMANTO_EXPOSE_ADMIN=true

:

| Tool | Purpose |
|---|---|
|

create_agent

 | Create a new memory namespace. |
|

list_agents

 | List every agent the API key can see. |
|

get_agent

 | Look up an agent's metadata. |
|

delete_agent

 | Remove an agent's local metadata. |

Memory types accepted by

remember / batch_remember

fact, preference, goal, decision, artifact, learning, event

instruction, relationship, context, observation, commitment

error

.

Provenance values:

explicit_statement, inferred, corrected

validated, observed, imported

.

Configuration


All config is via environment variables (load order: process env →

.env

 file in the working directory).

| Variable | Required | Default | Description |
|---|---|---|---|
|

MOORCHEH_API_KEY

 | yes | — | Moorcheh API key. |
|

MEMANTO_DEFAULT_AGENT_ID | recommended | _none_ | Default agent. When set, tool calls may omit agent_id

. |
|

MEMANTO_AGENT_PATTERN | no | tool | Pattern (support/project/tool

) used when auto-creating the default agent. |
|

MEMANTO_AGENT_AUTO_CREATE | no | true

 | Create the default agent on first use if missing. |
|

MEMANTO_SESSION_DURATION_HOURS

 | no | server default (6) | Session lifetime in hours. |
|

MEMANTO_EXPOSE_ADMIN | no | false

 | Register the 4 agent-management tools. |
|

MEMANTO_MCP_TRANSPORT | no | stdio | stdio, sse, or streamable-http

. |
|

MEMANTO_MCP_HOST | no | 127.0.0.1

 | Bind host for sse/http transports. |
|

MEMANTO_MCP_PORT | no | 8765

 | Bind port for sse/http transports. |
|

MEMANTO_MCP_LOG_LEVEL | no | INFO

 | Log level (logs are always sent to stderr). |

CLI flags (

memanto-mcp --transport sse --port 9000

) override env vars.

Running over HTTP / SSE


For remote clients or multi-process setups, run the server over a network
transport:

``bash

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

Memanto MCP Server

Install

Quick start (Claude Desktop)

Quick start (Cursor / Windsurf / Cline / Continue / Goose)

Available tools

Memory tools (always on)

Agent admin tools (opt-in)

Configuration

Running over HTTP / SSE

Install

More like this

Sequential Thinking

Aws Kb Retrieval Server

Memory

Filesystem

EverArt

Google Drive