mem0-ts

A TypeScript implementation of the mem0 memory system, using OpenAI for embeddings and completions.

Features

• Memory storage and retrieval using vector embeddings
• Fact extraction from text using GPT-4
• SQLite-based history tracking
• Optional graph-based memory relationships
• TypeScript type safety
• Built-in OpenAI integration with default configuration
• In-memory vector store implementation
• Extensible architecture with interfaces for custom implementations

Installation

1. Clone the repository:

git clone <repository-url>
cd mem0-ts

2. Install dependencies:

npm install

3. Set up environment variables:

cp .env.example .env
# Edit .env with your OpenAI API key

4. Build the project:

npm run build

Usage

Basic Example

import { Memory } from "mem0-ts";

// Create a memory instance with default OpenAI configuration
const memory = new Memory();

// Or with minimal configuration (only API key)
const memory = new Memory({
  embedder: {
    config: {
      apiKey: process.env.OPENAI_API_KEY,
    },
  },
  llm: {
    config: {
      apiKey: process.env.OPENAI_API_KEY,
    },
  },
});

// Or with custom configuration
const memory = new Memory({
  embedder: {
    provider: "openai",
    config: {
      apiKey: process.env.OPENAI_API_KEY,
      model: "text-embedding-3-small",
    },
  },
  vectorStore: {
    provider: "memory",
    config: {
      collectionName: "custom-memories",
    },
  },
  llm: {
    provider: "openai",
    config: {
      apiKey: process.env.OPENAI_API_KEY,
      model: "gpt-4-turbo-preview",
    },
  },
});

// Add a memory
await memory.add("The sky is blue", "user123");

// Search memories
const results = await memory.search("What color is the sky?", "user123");

Default Configuration

The memory system comes with sensible defaults:

• OpenAI embeddings with text-embedding-3-small model
• In-memory vector store
• OpenAI GPT-4 Turbo for LLM operations
• SQLite for history tracking

You only need to provide API keys - all other settings are optional.

Methods

• add(messages: string | Message[], userId?: string, ...): Promise<SearchResult>
  • Options include metadata, infer, and expirationDate (a YYYY-MM-DD date after which the memory is treated as expired).
• search(query: string, userId?: string, ...): Promise<SearchResult>
  • Expired memories are omitted unless you pass showExpired: true.
• get(memoryId: string): Promise<MemoryItem | null>
  • Fetching by ID returns the memory even if it has expired.
• getAll(options): Promise<SearchResult>
  • Expired memories are omitted unless you pass showExpired: true.
• update(memoryId: string, config: string | UpdateMemoryOptions): Promise<{ message: string }>
  • UpdateMemoryOptions is { text?, data?, metadata?, expirationDate? }. At least one must be provided; omitted fields are left untouched, and expirationDate: null clears an existing expiry. data is a deprecated alias for text.
  • Passing a bare string is shorthand for { text }, so update(memoryId, "new text") still works.
• delete(memoryId: string): Promise<{ message: string }>
• deleteAll(userId?: string, ...): Promise<{ message: string }>
• history(memoryId: string): Promise<any[]>
• reset(): Promise<void>

// Replace the content
await memory.update(memoryId, { text: "Alex now prefers decaf coffee" });

// Update metadata only, leaving the stored text untouched
await memory.update(memoryId, { metadata: { category: "preferences" } });

// Expire the memory on a given day, or clear an existing expiry
await memory.update(memoryId, { expirationDate: "2030-01-31" });
await memory.update(memoryId, { expirationDate: null });

// Include expired memories in reads
await memory.getAll({ filters: { user_id: "alice" }, showExpired: true });
await memory.search("coffee", {
  filters: { user_id: "alice" },
  showExpired: true,
});

Try the Example

We provide a comprehensive example in examples/basic.ts that demonstrates all the features including:

• Default configuration usage
• In-memory vector store
• PGVector store (with PostgreSQL)
• Qdrant vector store
• Redis vector store
• Memory operations (add, search, update, delete)

To run the example:

npm run example

You can use this example as a template and modify it according to your needs. The example includes:

• Different vector store configurations
• Various memory operations
• Error handling
• Environment variable usage

Development

1. Build the project:

npm run build

2. Clean build files:

npm run clean

Extending

The system is designed to be extensible. You can implement your own:

• Embedders by implementing the Embedder interface
• Vector stores by implementing the VectorStore interface
• Language models by implementing the LLM interface

License

MIT

Contributing

1. Fork the repository
2. Create your feature branch
3. Commit your changes
4. Push to the branch
5. Create a new Pull Request