memnode
Sign InSign Up

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
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.

Coding assistant

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

Research agent

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

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 →

19 min read

How Memnode Evolved: From a Graph Database to a Memory Reasoning Engine

The honest engineering story of how memnode grew from a file-backed graph and embeddings store into a memory reasoning engine, reconstruc...

9 min read

Episodic and Semantic Memory: The Two-Layer Model Behind Durable Agent Recall

Why a flat vector index fails agents, and how memnode separates episodic memory (what happened) from semantic memory (distilled facts), l...

8 min read

Spreading Activation: Why Graph-Aware Recall Beats Top-K Similarity

Top-k vector similarity is the wrong default for agent recall: similarity is not relevance and it cannot follow the chain of facts a task...

9 min read

Canonization: How a Memory System Decides What It Believes

A naive store treats every recorded fact as equally true forever. memnode gives each memory a status that changes over its lifecycle: pro...

8 min read

Belief Networks for Agents: Holding Contradictions Instead of Overwriting Them

Most agent memory resolves conflicts by overwriting or silent top-k ranking, so an agent asserts a claim its own memory contradicts. memn...

8 min read

Sleep for Machines: Offline Consolidation in an Agent Memory Engine

Recall and writes happen on the hot path, but a memory engine needs a slow clock too. How offline consolidation promotes episodes to fact...