Composable building blocks for adding persistent memory to AI applications.
LLM-powered fact extraction, intelligent deduplication, vector search, and queryable structured memory — all in your existing database.

Note: This project is not actively maintained. I built the initial version as a proof of concept. Since then, I started working on a full product based on the structured memory approach. I'll come back to these packages soon.

pnpm add @youcraft/recall @youcraft/recall-adapter-sqlite \
  @youcraft/recall-embeddings-openai @youcraft/recall-extractor-openai

import { createMemory } from '@youcraft/recall'
import { sqliteAdapter } from '@youcraft/recall-adapter-sqlite'
import { openaiEmbeddings } from '@youcraft/recall-embeddings-openai'
import { openaiExtractor } from '@youcraft/recall-extractor-openai'

const memory = createMemory({
  db: sqliteAdapter({ filename: 'memories.db' }),
  embeddings: openaiEmbeddings({ apiKey: process.env.OPENAI_API_KEY! }),
  extractor: openaiExtractor({ apiKey: process.env.OPENAI_API_KEY! }),
})

// Extract memories from a conversation
await memory.extract(
  `User: I'm a software engineer working at Acme Corp.
   Assistant: Nice! What kind of projects do you work on?
   User: Mostly backend stuff in TypeScript.`,
  { userId: 'user_123' }
)

// Query relevant memories
const memories = await memory.query('What does the user do for work?', {
  userId: 'user_123',
  limit: 5,
})
// => [{ content: "User is a software engineer at Acme Corp", ... }]

Most apps today already have their own infrastructure — background jobs, vector databases, workflow engines, and code to store and retrieve embeddings. Why deploy yet another service just for memory?

Recall takes a different approach: composable building blocks that fit into your existing stack.

┌─────────────────────────────────────────────────────┐
│              Your Existing Infrastructure           │
│  ┌───────────┐  ┌───────────┐  ┌─────────────────┐  │
│  │ Background│  │  Vector   │  │    Database     │  │
│  │   Jobs    │  │  Search   │  │ (Postgres/etc)  │  │
│  └─────┬─────┘  └─────┬─────┘  └────────┬────────┘  │
│        │              │                 │           │
│        └──────────────┼─────────────────┘           │
│                       │                             │
│               ┌───────▼───────┐                     │
│               │    Recall     │  ← just a library   │
│               └───────────────┘                     │
└─────────────────────────────────────────────────────┘

Recall is a library you import, not a service you deploy. Pick the pieces you need:

• Choose your database — SQLite for local dev, Postgres for production, MySQL if that's what you have
• Choose your embeddings — OpenAI, Cohere, Voyage, or bring your own
• Choose your extractor — GPT, Claude, or implement the interface
• Use your existing workflows — Inngest, Vercel Workflow DevKit, or any background job system

Structured Memory lets you define Zod schemas and query memories with SQL precision — perfect for tracking payments, workouts, medications, or any structured data.

• LLM-powered extraction — Automatically extract facts from conversations
• Intelligent consolidation — Deduplicate memories with ADD/UPDATE/DELETE/NONE decisions
• Vector similarity search — Find relevant memories using embeddings
• Pluggable architecture — Swap databases, embedding providers, and extractors
• TypeScript-first — Full type safety with comprehensive interfaces
• Zero lock-in — All data stays in your infrastructure

When you call extract(), Recall doesn't just blindly insert new memories. It uses a two-step LLM process:

1. Extract — LLM identifies facts from the conversation
2. Consolidate — For each fact, Recall:
   • Searches for similar existing memories
   • Asks the LLM to decide: ADD, UPDATE, DELETE, or NONE
   • Executes the decision

New fact: "User's name is John Doe"
Existing: [{ id: "abc", content: "User's name is John" }]

LLM Decision: UPDATE (merge into "User's name is John Doe")

This prevents duplicate memories and keeps your memory store clean.

┌─────────────────────────────────────────────────────────────────┐
│                        Your Application                         │
└─────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│                     @youcraft/recall (core)                     │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
│  │   extract() │  │   query()   │  │  list/get/update/delete │  │
│  └─────────────┘  └─────────────┘  └─────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘
          │                   │                     │
          ▼                   ▼                     ▼
┌─────────────────┐  ┌─────────────────┐  ┌─────────────────────┐
│    Extractor    │  │   Embeddings    │  │   Database Adapter  │
│ OpenAI/Anthropic│  │ OpenAI/Cohere/  │  │ SQLite/PostgreSQL/  │
│                 │  │ Voyage          │  │ MySQL               │
└─────────────────┘  └─────────────────┘  └─────────────────────┘

// Extract and store memories from text (with automatic consolidation)
await memory.extract(text, { userId })

// Find relevant memories using vector similarity
await memory.query(context, { userId, limit?, threshold? })

// CRUD operations
await memory.list(userId)                          // List all memories
await memory.get(id)                               // Get single memory
await memory.update(id, { content?, metadata? })   // Update memory
await memory.delete(id)                            // Delete memory
await memory.clear(userId)                         // Clear all user memories

Visit recall-docs-sand.vercel.app for full documentation:

• Quick Start Guide
• Core Concepts
• Structured Memory
• Database Adapters
• Tutorials

P.S. docs are generated by AI.

MIT