# AI use cases for Mneme (slow-stack/mneme)

Repo: [slow-stack/mneme](https://github.com/slow-stack/mneme) | Use cases: 4 | Page: https://dedupedai.com/use-cases/slow-stack-mneme/

dsh-mneme is a cross-session memory plugin for DeepSeek Harness that stores memories locally in SQLite with Markdown mirrors and can also serve them to MCP clients and a standalone daemon.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Give Claude Code or Cursor a shared memory via MCP: https://dedupedai.com/use-cases/slow-stack-mneme/give-coding-agents-shared-memory-via-mcp/
- Read and write memory from scripts with DSH closed: https://dedupedai.com/use-cases/slow-stack-mneme/serve-memory-to-scripts-without-dsh-open/
- Run memory search fully offline with local embeddings: https://dedupedai.com/use-cases/slow-stack-mneme/run-memory-search-fully-offline/
- Keep memories separate across agents and workspaces: https://dedupedai.com/use-cases/slow-stack-mneme/keep-memories-separate-per-agent-and-workspace/

## How to give Claude Code or Cursor a shared memory via MCP with Mneme

Repo: [slow-stack/mneme](https://github.com/slow-stack/mneme) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Mount the six memory tools from the Mneme MCP server so coding agents read and write the same memory store.

**Who it is for:** A developer who uses Claude Code, Cursor, or Codex daily and repeats project context in every new session.

**The problem:** Each coding agent starts blank, so preferences and project decisions must be re-explained for every tool.

**The outcome:** The coding agent can save, search, and update memories in the same local library that DSH uses, through the memory_save and memory_search tools.

### Steps

1. Install the plugin and open the web interface: `dsh plugin --profile web add @modusensus/dsh-mneme` then `dsh web`
2. In DSH, open 设置 → 外部访问 API and generate a token
3. Install the MCP package globally: `npm i -g mneme-memory` (inferred, check the README)
4. In your project root, create .mcp.json with {"mcpServers": {"mneme-memory": {"command": "mneme-mcp", "env": {"MNEME_TOKEN": "<your-token>"}}}}
5. Restart Claude Code or Cursor and confirm the memory_save, memory_search, memory_list, memory_get, memory_update, and memory_delete tools are listed

### Prompt to paste into your agent

```text
In the dsh-mneme repo, use the mneme-memory MCP server to call memory_save with the text '<fact about the target project>', then call memory_search for '<keyword>'. Expected output: the new memory id and its text returned by search. Verify that memory_get on that id returns the same text.
```

### Caveat

The MCP data path goes through the plugin's API on 127.0.0.1:8790, so DSH must be running with the plugin installed for the tools to work.

Risk, credentials: The MNEME_TOKEN value grants read and write access to your memory library, so keep it out of shared repositories and committed .mcp.json files.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/slow-stack-mneme/give-coding-agents-shared-memory-via-mcp/

## How to read and write memory from scripts with DSH closed with Mneme

Repo: [slow-stack/mneme](https://github.com/slow-stack/mneme) | Difficulty: Advanced | Time: 45 minutes | Basis: From the README

Run the standalone daemon so third-party scripts and your own panel reach the same memory library.

**Who it is for:** A developer building a script, web bridge, or custom panel that needs memory access while DSH is not open.

**The problem:** Memory is only reachable while DSH runs, which blocks integrations that work at other times.

**The outcome:** A resident daemon on 127.0.0.1:8790 serves the memory library, and your script reads and writes it with the same token used by the DSH panel and CLI.

### Steps

1. Install the package globally: `npm i -g @modusensus/dsh-mneme`
2. Start the daemon: `dsh-mneme-serve`
3. Copy the token used by the DSH panel and CLI into your script's configuration
4. Send an authenticated HTTP request from your script to 127.0.0.1:8790 to list recent memories and confirm a response (inferred, check the README)

### Prompt to paste into your agent

```text
In the dsh-mneme repo, start the daemon with dsh-mneme-serve and send one authenticated request to 127.0.0.1:8790 using the token in <token-file>. Expected output: a successful response listing memories. Verify that the daemon refuses to start if port 8790 is already in use.
```

### Caveat

The first phase of the daemon has no LLM, so consolidation and distillation still depend on the DSH host, and the port cannot be shared with DSH external access.

Risk, credentials: The daemon uses the same token as the DSH panel and CLI, so anyone who obtains it can read and change the memory library.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/slow-stack-mneme/serve-memory-to-scripts-without-dsh-open/

## How to run memory search fully offline with local embeddings with Mneme

Repo: [slow-stack/mneme](https://github.com/slow-stack/mneme) | Difficulty: Beginner | Time: 15 minutes | Basis: From the README

Switch the embedding provider to local so semantic recall needs no API key.

**Who it is for:** A user who wants recall to work without sending data to an external embedding service or needing an API key.

**The problem:** Semantic search normally depends on an external embedding provider, which conflicts with keeping memory on the machine.

**The outcome:** Retrieval uses a local embedding model and reranking, and keyword and BM25 search keep working when no embedding is set.

### Steps

1. Install the plugin: `dsh plugin --profile web add @modusensus/dsh-mneme`
2. Start DSH with `dsh web`
3. Open 设置 → 记忆库设置 and change embedProvider from openai to local
4. Open the status panel and check that the vector index is building before relying on semantic recall (inferred, check the README)

### Prompt to paste into your agent

```text
In the dsh-mneme repo, set embedProvider to local in the memory library settings, save one test memory, then run a semantic search for a paraphrase of it. Expected output: the test memory returned in the results. Verify that no API key field is required for the search to succeed.
```

### Caveat

Setting embedProvider to local keeps retrieval offline, but consolidation and summaries still use your configured host model unless you clear the dream and summarize provider settings as the README describes.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/slow-stack-mneme/run-memory-search-fully-offline/

## How to keep memories separate across agents and workspaces with Mneme

Repo: [slow-stack/mneme](https://github.com/slow-stack/mneme) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Turn on scope isolation so memories from one project do not leak into another project's sessions.

**Who it is for:** A developer running several agents or projects that should not share context with each other.

**The problem:** One memory pool mixes preferences and decisions from unrelated projects, so answers pick up the wrong context.

**The outcome:** Each memory is tagged with the agent and workspace that wrote it, the current session's scope is preferred in retrieval, and strict mode hides explicitly scoped memories from other scopes.

### Steps

1. Open 设置 → 记忆库设置 in DSH
2. Turn on scopeEnabled
3. Save one memory in workspace A and one in workspace B from separate sessions (inferred, check the README)
4. Turn on strictScope if explicitly scoped memories must be fully hidden from other scopes, then run a search from workspace B to confirm workspace A memories are down-weighted or hidden

### Prompt to paste into your agent

```text
In the dsh-mneme repo, enable scopeEnabled, save a memory tagged to workspace A and another to workspace B, then search from workspace B. Expected output: workspace B memory ranked first and any workspace A memory down-weighted or hidden if strictScope is on. Verify the search result list for the scope tags.
```

### Caveat

strictScope only hides memories that were explicitly declared to a scope, because automatic carrier tagging only lowers their weight in retrieval.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/slow-stack-mneme/keep-memories-separate-per-agent-and-workspace/