Wire Mnueron memory into your apps, agents, and editor.

Same one-line install as the user track for the CLI. Then add the SDK for the language your app is in.

# CLI (configures Claude Desktop / Cursor / Codex / Cline etc.)
npm install -g mnueron
mnueron setup

# Python SDK
pip install mnueron

# .NET / C# SDK — single file drop-in
# Copy sdks/csharp/MnueronClient.cs from the repo into your project.

# TypeScript / Node — direct REST or import the same MCP client we ship
npm install mnueron

The same two-mode model from the user track applies. As a developer you'll typically run local during development and hosted in production.

# Local (default) — memories live in ~/.mnueron/memories.db
mnueron stats

# Hosted — sign up at /signup, mint a token in /account-settings/tokens
export MNUERON_API_URL=https://api.mnueron.com
export MNUERON_API_TOKEN=mnu_xxx
mnueron stats   # now talks to the cloud

Your SDK reads the same env vars, so a single deploy can flip between local-dev and hosted-prod by swapping the environment. No SDK-side rewiring.

The mnueron setupwizard auto-detects most of these. If a tool wasn't found, register it explicitly:

mnueron setup --only cursor
mnueron setup --only cline
mnueron setup --only windsurf
# Continue.dev: same MCP config shape; add via your config.yaml under mcpServers

For Continue.dev, the config is YAML rather than JSON. Add:

mcpServers:
  - name: mnueron
    command: node
    args:
      - "/usr/local/lib/node_modules/mnueron/dist/cli.js"
      - "--mcp-stdio"

OpenAI's agentic Codex CLI speaks MCP, so the wiring is the same shape as Claude Desktop. Codex reads ~/.codex/config.toml (or the per-project equivalent).

# ~/.codex/config.toml

[mcp_servers.mnueron]
command = "mnueron"
args = ["--mcp-stdio"]

# If you're using hosted mode, the env vars need to be on Codex's process:
[mcp_servers.mnueron.env]
MNUERON_API_URL   = "https://api.mnueron.com"
MNUERON_API_TOKEN = "mnu_xxx"

Restart Codex. In any session, ask Codex what tools it has and you should see the six memory tools. From there Codex picks them up automatically when it should remember or recall.

If you're on Pro+ and want LLM calls billed to your own vendor account (vs. the shared Mnueron pool), paste your key at /account-settings/keys. Two cards: OpenAI and Anthropic. Test, then Save.

The canonical Mnueron pattern: pull relevant memory before the LLM call, save anything worth remembering after. Provider- agnostic — swap OpenAI for Anthropic / Mistral / Gemini freely.

Python

from mnueron import Mnueron
from openai import OpenAI

mem = Mnueron()              # picks up MNUERON_API_URL + MNUERON_API_TOKEN from env
llm = OpenAI()

def chat(user_id: str, message: str) -> str:
    # 1. Recall what we know about this user
    context = mem.search(message, namespace=f"user-{user_id}", k=5)
    context_str = "\n".join(m.content for m in context)

    # 2. Call any LLM (OpenAI shown; swap freely)
    resp = llm.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {"role": "system", "content": f"What you know about this user:\n{context_str}"},
            {"role": "user", "content": message},
        ],
    )
    answer = resp.choices[0].message.content

    # 3. Save anything worth remembering
    mem.save(extract_facts(answer), namespace=f"user-{user_id}", source="auto")
    return answer

.NET / C#

using Mnueron;

using var mem = new MnueronClient();           // env-driven config
var context = await mem.SearchAsync(message, $"user-{userId}", k: 5);
// ...call any LLM API with context injected into the prompt
await mem.SaveAsync(newFact, $"user-{userId}");

REST (any language)

curl -X POST https://api.mnueron.com/v1/recall \
  -H "Authorization: Bearer $MNUERON_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"user preferences","namespace":"user-42","k":5}'

The SDK is environment-driven. Set MNUERON_API_URL and MNUERON_API_TOKENin your platform's project settings, deploy as usual. Memory follows users across your function instances because storage is centralized.

# Vercel CLI example
vercel env add MNUERON_API_TOKEN production
vercel env add MNUERON_API_URL production
vercel deploy

From your terminal, with the Python SDK installed:

from mnueron import Mnueron
mem = Mnueron()

# Save a project convention
mem.save(
    content="Always use Tailwind v4 utility classes; rounded-2xl for cards, rounded-md for buttons.",
    namespace="my-project",
    tags=["css", "convention"],
)

# In a fresh shell or new chat, recall it
hits = mem.search("css preference", namespace="my-project", k=3)
print(hits[0].content)
# → "Always use Tailwind v4 utility classes; rounded-2xl for cards, rounded-md for buttons."

Now open Claude Desktop (or Cursor / Codex) and ask "what's my CSS preference for my-project?" — the LLM client will call memory_recall via MCP and surface the same memory you saved from Python. One source of truth across every tool.