Memnode MCP Server

Hosted + Local Agent Memory

Persistent memory for AI agents, without inventing your own stack.

memnode gives agents long-term memory through a hosted API or a local MCP server. You get inspectable recall, provenance, scoped tokens, and shared tenants instead of stitching memory together from prompts and vectors by hand.

Use it for coding assistants, support agents, and research workflows that need durable recall, visible lineage, and a clean correction path across sessions.

Start freeRead quickstart

Inspect every memoryHosted + localCorrect with lineagePredictable pricing

Record -> Recall -> Lineage

Inspect the memory your agent is actually using

TypeScriptPythonMCP

npm install @memnode/client

import { MemnodeClient } from '@memnode/client'

const client = new MemnodeClient({
  apiKey: process.env.MEMNODE_API_KEY,
})

const stored = await client.record({
  entity: 'repo:memnox',
  text: 'This repo uses Zod to validate API payloads.',
  source: {
    kind: 'repo_convention',
    path: 'app/api/users/route.ts',
  },
})

const recalled = await client.recall({
  query: 'How do we validate request payloads?',
  entity: 'repo:memnox',
})

const lineage = await client.lineage({
  nodeId: recalled.results[0].node_id,
})

Returned proof

recall[0].answer
"Use Zod validation in the route layer."

recall[0].why
"Matched repo_convention memory from app/api/users/route.ts"

lineage.chain
observed -> canonical -> corrected

Why it matters

Black-box memory fails quietly. Inspectable memory does not.

When an agent recalls the wrong thing, you need the source, the correction chain, and the current winning memory. That is the real wedge, not just "persistent memory."

Example lineage

Observed

repo_convention from app/api/users/route.ts

Canonical

Use Zod in the route layer for request validation

Corrected

Superseded older yup-based convention after migration

Hosted flow

1. Sign up with Supabase Auth and create an account.
2. Provision one hosted tenant through the control plane.
3. Create a scoped API token and call the Rust data plane over HTTP.

Typed provenance

Memories carry observed, reported, inferred, or hypothesized status instead of collapsing into one flat blob.

Hosted tenants

Provision a shared hosted tenant in the dashboard, mint API tokens, and keep quota and billing in one place.

Local MCP stays

The hosted product does not replace local usage. You can still run `memnode mcp` over stdio on your own machine.

Rust data plane

A signed-control-plane path, multi-tenant registry, and hot-path token cache keep hosted latency practical.

Example Shapes

Three concrete ways teams use memnode

See all use cases →

Conversational assistant

Persist user preferences and past turns across restarts using the standard recall -> answer -> record loop.

Learn more →

Coding assistant

Store project conventions as typed entities instead of free-form notes, then recall them as structured context.

Learn more →

Research agent

Track claims with explicit provenance so later answers can separate reported facts from inferred conclusions.

Learn more →

Start free, keep local in reserve

The hosted SaaS is for fast onboarding, quota-managed tenants, and shared team workflows. The local mode stays available when you need offline or self-managed memory instead.

PricingCreate account

Latest writings

All articles →

10 min read

The Consolidation Loop: How Agents Turn Context Into Durable Memory

A pattern is hardening across long-running agents in 2026: every N actions, pause and consolidate the working context into durable memory...

10 min read

Context Bleed: Why Long-Running Agents Need Per-Project Memory Isolation

When one agent works across many projects, its memory bleeds: a convention from project A surfaces in project B, a stale credential reapp...

11 min read

Stop Gluing Three Databases Together for Agent Memory

The typical 2026 agent-memory stack is a vector database for similarity, a graph database for relationships, a relational store for state...

10 min read

Context Engineering for AI Agents: Memory Is the Half Nobody Automates

Context engineering replaced prompt engineering as the 2026 buzzword, but most of the effort goes into sliding windows and summarization....

11 min read

Is RAG Dead for Agents? Retrieval vs Memory in 2026

The "RAG is dead" claim is loud in 2026 and overstated. Naive top-k retrieval over static chunks is the wrong tool for agent memory, but...

11 min read

The AI Memory Wars: How ChatGPT, Claude and Gemini Remember You - and the Black-Box Problem

In 2026 memory became the battleground between ChatGPT, Claude and Gemini. An honest, technical comparison of three approaches - opaque v...