Status: early release. The option shape may still change before 1.0. The memory layers underneath are the ones the ZenBrain paper describes and the benchmarks measure.

ZenBrain as Vercel AI SDK middleware. Recall what is relevant before the model call, store the turn after it. Works with any provider the AI SDK supports, because it never touches the provider.

npm install @zensation/ai-sdk @zensation/core @zensation/adapter-sqlite ai @ai-sdk/openai

This package is ESM. require() loads it on Node 22.12 and later; on Node 22.0–22.11, use import.

import { generateText, wrapLanguageModel } from 'ai';
import { openai } from '@ai-sdk/openai';
import { MemoryCoordinator } from '@zensation/core';
import { SqliteAdapter } from '@zensation/adapter-sqlite';
import { zenbrainMemory } from '@zensation/ai-sdk';

const coordinator = new MemoryCoordinator({
  storage: new SqliteAdapter({ filename: './memory.db' }),
});

const model = wrapLanguageModel({
  model: openai('gpt-5'),
  middleware: zenbrainMemory({ coordinator }),
});

await generateText({ model, prompt: 'Anna moved to Hamburg in March.' });

// A later call, possibly days later, in a different process:
const { text } = await generateText({ model, prompt: 'Where does Anna live?' });

Between the two calls nothing was passed by hand. The second prompt arrives at the model with a system message in front of it:

Relevant memories from earlier sessions:
- Anna moved to Hamburg in March.

Zero runtime dependencies

The middleware is a plain object; wrapLanguageModel is called by you. Nothing here is imported from ai at runtime — only its types are. So this package has no runtime dependencies; its peers ai, @ai-sdk/provider and @zensation/core are the packages your application already uses (npm 7 and later installs a peer that is missing):

Package	Runtime dependencies
`@zensation/ai-sdk`	0
`@zensation/core`	1 (`@zensation/algorithms`)
`@zensation/algorithms`	0

That table is checked in CI on every push against the packed tarballs rather than the source tree.

Options

zenbrainMemory({
  coordinator,                     // required — you own its lifecycle

  recall: {                        // or false to switch searching off
    limit: 5,                      // how many memories to inject
    layers: ['semantic', 'core'],  // which layers to search
    minConfidence: 0.6,            // drop anything below this
  },

  store: {                         // or false to switch writing off
    user: true,                    // store the user's message (default)
    assistant: false,              // store the reply too (default off)
    context: 'work',               // context domain; kept with episodes only
  },

  header: 'Relevant memories from earlier sessions:',
  role: 'system',                  // or 'user': see "Three defaults worth knowing"

  onError: (err, phase) => console.warn(`[zenbrain] ${phase} failed`, err),
});

Three defaults worth knowing

Memories arrive as a system message. That is the strongest place in the prompt, and it is also why it needs a decision: whatever a user once said comes back with system authority when it is recalled. If text you do not trust can reach memory, pass role: 'user'. The memories then travel as a user message directly before the latest user turn, as context rather than instruction. store.shouldStore keeps such turns out of memory in the first place.

Replies are not stored by default. A model's answer is derived from the question and cheap to regenerate; storing both sides doubles the volume and fills semantic memory with your own model's phrasing. Turn it on with store: { assistant: true } when the answer carries information the question does not.

Failures are swallowed. If recall or store throws, the call goes through anyway, unmodified. A memory layer that breaks a chat is worse than one that forgets. Pass onError to see what is being hidden — without it, failures are silent by design.

Where the memory lands

Routing on store is automatic, first match wins: wording such as "How to", "Steps:" or "workflow:" makes a procedure, an emotional weight above 0.5 (detected from the text) an episode, anything else a semantic fact. A plain narrated event with little emotion is a fact, and a numbered list without such wording is too. Which layer a memory lands in decides how it is searched; when you consolidate, episodes with an emotional weight above 0.5, among the 100 most recent, become facts. The seven layers and the algorithms behind them are documented in the main README.

Consolidation does not run on its own. Call coordinator.consolidate() on a schedule that suits your application.

What this release does not do

No embedding provider is configured unless you pass one. Recall then ranks lexically rather than semantically: folded token overlap, rarer words weighted higher, a bonus for an adjacent phrase, over the most recent 500 episodes and facts. It matches wording, not meaning — synonyms need an EmbeddingProvider, which is also the configuration the published benchmarks were measured with.
No relevance threshold. When nothing matches the prompt, recall falls back to the most recent memories (score 0), and this release injects them like any other result.
Streaming stores on flush. The turn is written once the stream completes. An aborted or failed stream stores nothing, not even the user's turn.
Only text is read. File and tool parts of a message are ignored when building the recall query and when storing.
One recall per call. There is no re-retrieval mid-generation.

Streaming

streamText works the same way and passes the stream through untouched:

const result = streamText({
  model: wrapLanguageModel({
    model: openai('gpt-5'),
    middleware: zenbrainMemory({ coordinator, store: { assistant: true } }),
  }),
  prompt: 'Which theme should I use?',
});

for await (const chunk of result.textStream) process.stdout.write(chunk);

About ZenBrain

ZenBrain is a seven-layer, neuroscience-derived memory architecture for LLM agents, built in TypeScript and published under Apache-2.0; @zensation/algorithms and @zensation/core have no third-party dependencies. The benchmark results, and the configuration they were measured in, are reported in the paper; the reproduction packages are on Zenodo.

Works out of the box without an embedding provider — lexical ranking, nothing extra to install. The paper's measurements used nomic-embed-text as the embedding provider.