Open-Engram

A brain-inspired memory architecture for AI agents.

Open-Engram is an open-source TypeScript library implementing a four-store, biologically-grounded memory architecture. Instead of flat vector-store RAG, it models how brains actually form, consolidate, and retrieve memories — drawing from Standard Consolidation Theory, Complementary Learning Systems, Baddeley's working memory model, and thalamic gating theory.

  Events ──> [ Sensory Buffer ] ──attention gate──> [ Working Memory ]
                                                          │
                                                    eviction = demotion
                                                          │
                                                    [ Episodic Store ]
                                                          │
                                                  consolidation (7-stage)
                                                          │
                                                    [ Semantic Store ]

Why not just RAG?

	Flat RAG	Open-Engram
Storage	Single vector store	4 stores with different retention policies
Eviction	None (grows forever)	RFR scoring, demotion (never discard)
Consolidation	None	7-stage pipeline: batch → dedup → abstract → distill → conflict-resolve → write → archive
Working memory	Entire context window	Capacity-limited with attention gate (Lavie's Load Theory)
Multi-agent	Not built-in	Shared semantic store via PowerSync Sync Streams
Offline	Requires API	Full offline with SQLite + local embeddings

Install

npm install @open-engram/core

Quick Start

import { EngramClient } from '@open-engram/core';

const memory = await EngramClient.create({ agentId: 'my-agent' });

// Ingest an event into sensory buffer
await memory.sense({ content: 'User prefers dark mode', source: 'settings' });

// Attention gate promotes relevant events to working memory
await memory.focus();

// Search across all stores
const results = await memory.recall('user preferences', { limit: 5 });

// Save a fact directly to semantic memory
await memory.remember('User prefers dark mode', { confidence: 0.9 });

// Checkpoint working memory → episodic store
await memory.checkpoint('mid-conversation');

// Run consolidation pipeline (episodic → semantic)
await memory.consolidate();

Storage Backends

// SQLite (offline, single-file)
import { SqliteAdapter } from '@open-engram/adapters-storage';
const storage = new SqliteAdapter({ path: './memory.db' });

// PostgreSQL + pgvector
import { PostgresAdapter } from '@open-engram/adapters-storage-postgres';
const storage = new PostgresAdapter({ connectionString: process.env.DATABASE_URL });

// Supabase
import { SupabaseStorageAdapter } from '@open-engram/adapters-storage-supabase';

// PowerSync (multi-agent sync)
import { PowerSyncAdapter } from '@open-engram/adapters-storage-powersync';

Framework Integrations

Mastra

import { createEngramTools } from '@open-engram/mastra';
const tools = createEngramTools(memory);

Vercel AI SDK

import { createEngramTools, createEngramMiddleware } from '@open-engram/vercel-ai';
const tools = createEngramTools(memory);

LangChain.js

import { createEngramTools, EngramMemory } from '@open-engram/langchain';
const tools = createEngramTools(memory);
const engramMemory = new EngramMemory({ client: memory });

Fully Offline

import { EngramClient } from '@open-engram/core';
import { SQLiteAdapter } from '@open-engram/adapters-storage';
import { OllamaEmbeddingAdapter } from '@open-engram/adapters-embedding/ollama';
import { OllamaLLMAdapter } from '@open-engram/adapters-llm/ollama';

const memory = await EngramClient.create({
  storage: new SQLiteAdapter({ path: './memory.db' }),
  embedding: new OllamaEmbeddingAdapter(),  // nomic-embed-text
  llm: new OllamaLLMAdapter(),              // llama3
  agentId: 'local-agent',
});

No API keys. No network. Full consolidation pipeline runs locally.

Multi-Agent Knowledge Sharing

With PowerSync, multiple agents share a semantic store in real-time:

import { PowerSyncAdapter } from '@open-engram/adapters-storage-powersync';

// Agent 1 discovers a fact
await agent1.remember('Python 3.13 adds JIT compilation', { confidence: 0.95 });

// Agent 2 can immediately recall it via Sync Streams
const results = await agent2.recall('Python JIT');

Demo App

An interactive demo at apps/demo showcases three AI agents (Research, Analysis, Synthesis) sharing knowledge via PowerSync Sync Streams.

cd apps/demo
pnpm dev

Network view (/) — agent cards, architecture diagram, sync stream status, shared knowledge list/graph.

Brain Graph (/graph) — full-page force-directed graph visualizing all four memory stores across all agents:

• Node shapes encode store type: diamonds (sensory), circles (working), rounded rects (episodic), ringed circles (semantic)
• Node color encodes agent: blue (research), purple (analysis), green (synthesis)
• Filter toolbar to toggle stores and agents on/off
• Click any node to inspect its content, confidence, score, and metadata
• Drag nodes to rearrange; physics simulation re-triggers

Multimodal

// Images
await memory.sense({
  content: 'Architecture whiteboard photo',
  contentType: 'image',
  source: 'user',
  media: { mimeType: 'image/png', data: '<base64>' },
});

// Cross-modal retrieval with CLIP
import { ClipEmbeddingAdapter } from '@open-engram/adapters-embedding/clip';
// Text queries find relevant images in shared vector space

Observability

// OpenTelemetry
import { OtelAdapter } from '@open-engram/observability';

// Console logging
import { ConsoleAdapter } from '@open-engram/observability';

// Event bus + audit log
const events = memory.events.getRecent(10);
const log = await memory.auditLog({ limit: 5 });

Packages

Package	Description
@open-engram/core	Core memory architecture — stores, gates, retrieval, consolidation
@open-engram/types	Type definitions and Zod schemas
@open-engram/adapters-storage	SQLite + sqlite-vec
@open-engram/adapters-storage-postgres	PostgreSQL + pgvector
@open-engram/adapters-storage-supabase	Supabase + pgvector RPC
@open-engram/adapters-storage-powersync	PowerSync bi-directional sync
@open-engram/adapters-embedding	OpenAI, Transformers.js, Ollama, CLIP
@open-engram/adapters-llm	OpenAI, Anthropic, Ollama, Mock
@open-engram/mastra	Mastra plugin
@open-engram/vercel-ai	Vercel AI SDK tools + middleware
@open-engram/langchain	LangChain.js tools + BaseMemory
@open-engram/observability	OpenTelemetry + console adapters
@open-engram/fhir	FHIR R4 resource types + text converter
@open-engram/dashboard	Observability dashboard
@open-engram/cli	Developer CLI
@open-engram/benchmarks	Performance benchmark suite

API

Method	Description
sense(event)	Ingest into sensory buffer
focus()	Run attention gate, promote to working memory
recall(query, opts)	Search across episodic + semantic stores
remember(content, opts)	Write to semantic store
checkpoint(label)	Snapshot working memory to episodic store
consolidate()	Run 7-stage distillation pipeline
forget(id)	Remove a record
purge()	Clear all stores
pin(id) / unpin(id)	Protect entries from eviction
status()	Memory stats and store counts
export() / import(data)	Serialize/deserialize full state

Documentation

• API Reference
• Architecture
• Configuration
• Adapters
• Whitepaper
• Changelog

Development

pnpm install
pnpm turbo build
pnpm turbo test          # 661 tests
pnpm turbo typecheck     # zero errors

License

Apache 2.0