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