Can I use drizzle, pglite with mem0?

[YanceyOfficial]

Hello, I'm working an Electron desktop app, and the database system uses drizzle and pglite

The following code is Drizzle configuration:

import { defineConfig } from 'drizzle-kit'

export default defineConfig({
  schema: './src/main/lib/db/schema.ts',
  out: './resources/drizzle',
  dialect: 'postgresql',
  driver: 'pglite',
  dbCredentials: { url: 'database.sqlite' }
})

The follows code is Pglite configuration:

import { PGlite } from '@electric-sql/pglite'
import { vector } from '@electric-sql/pglite/vector'
import { drizzle } from 'drizzle-orm/pglite'
import { app } from 'electron'
import { join } from 'path'

const dbPath = join(app.getPath('userData'), 'Database')
export const pglite = new PGlite({
  dataDir: dbPath,
  extensions: { vector }
})

export const db = drizzle(pglite)

I'm wondering how to connect DB to mem0

import { Memory } from 'mem0ai/oss'
import { Settings } from '../db/schema'

export const initMemory = ({ settings }: { settings: Settings }) =>
  new Memory({
    version: 'v1.1',
    embedder: {
      provider: 'openai',
      config: {
        apiKey: settings.providers?.openaiApiKey ?? '',
        model: 'text-embedding-3-small'
      }
    },
    vectorStore: {
      provider: 'pgvector',
      config: {
        collectionName: '???',
        embeddingModelDims: 1536,
        user: '???',
        password: '???',
        host: '???',
        port: 5432,
        dbname: 'vector_store', // Optional, defaults to 'postgres'
        diskann: false, // Optional, requires pgvectorscale extension
        hnsw: false // Optional, for HNSW indexing
      }
    },
    llm: {
      provider: 'openai',
      config: {
        apiKey: settings.providers?.openaiApiKey ?? '',
        model: 'gpt-4o'
      }
    },
    historyDbPath: 'memory.db'
  })

[KeepALifeUS]

Using Drizzle + PGlite with Mem0 is possible with a custom vector store. Here's how:

Architecture

Mem0
  └─ Custom VectorStore
       └─ Drizzle ORM
            └─ PGlite (with pgvector)

Implementation

// schema.ts - Drizzle schema for memories
import { pgTable, text, vector, timestamp, jsonb } from 'drizzle-orm/pg-core';

export const memories = pgTable('memories', {
  id: text('id').primaryKey(),
  userId: text('user_id').notNull(),
  content: text('content').notNull(),
  embedding: vector('embedding', { dimensions: 1536 }),
  metadata: jsonb('metadata'),
  createdAt: timestamp('created_at').defaultNow(),
});

// Create index for vector search
// CREATE INDEX ON memories USING ivfflat (embedding vector_cosine_ops);

// pglite-store.ts
import { PGlite } from '@electric-sql/pglite';
import { drizzle } from 'drizzle-orm/pglite';
import { memories } from './schema';
import { cosineDistance, desc, eq, sql } from 'drizzle-orm';

export class PGliteVectorStore {
  private db;
  
  constructor() {
    const client = new PGlite();
    // Enable pgvector extension
    client.exec('CREATE EXTENSION IF NOT EXISTS vector');
    this.db = drizzle(client);
  }
  
  async add(content: string, embedding: number[], userId: string, metadata?: any) {
    const id = crypto.randomUUID();
    await this.db.insert(memories).values({
      id,
      userId,
      content,
      embedding,
      metadata
    });
    return id;
  }
  
  async search(queryEmbedding: number[], userId: string, limit = 10) {
    const similarity = sql<number>`1 - (${cosineDistance(memories.embedding, queryEmbedding)})`;
    
    return await this.db
      .select({
        id: memories.id,
        content: memories.content,
        metadata: memories.metadata,
        score: similarity
      })
      .from(memories)
      .where(eq(memories.userId, userId))
      .orderBy(desc(similarity))
      .limit(limit);
  }
}

Integration with Mem0

# Python side - custom vector store config
from mem0 import Memory

config = {
    "vector_store": {
        "provider": "custom",
        "config": {
            "url": "http://localhost:3000/api/vectors",  # Your PGlite API
        }
    }
}

m = Memory.from_config(config)

Benefits of PGlite

1. Local-first: Runs in browser/Node without external DB
2. SQL familiarity: Full PostgreSQL compatibility
3. Portable: Single file database
4. pgvector support: Native vector operations

More on local-first patterns: https://github.com/KeepALifeUS/autonomous-agents

[xXMrNidaXx]

PGlite + Mem0 in Electron is a great combo for offline-first apps!

The challenge: Mem0 pgvector provider expects a network connection, but PGlite is embedded.

Solution: Custom vector store adapter

import { BaseVectorStore } from "mem0ai/oss";
import { pglite, db } from "./your-pglite-setup";

class PGliteVectorStore extends BaseVectorStore {
  async addVectors(vectors: number[][], texts: string[], metadata: any[]) {
    for (let i = 0; i < vectors.length; i++) {
      await db.insert(memoriesTable).values({
        embedding: vectors[i],
        content: texts[i],
        metadata: metadata[i],
      });
    }
  }

  async similaritySearch(query: number[], k: number) {
    const result = await pglite.query(`
      SELECT content, metadata, 
             embedding <=> $1::vector AS distance
      FROM memories
      ORDER BY distance
      LIMIT $2
    `, [JSON.stringify(query), k]);
    return result.rows;
  }
}

Then use it:

const memory = new Memory({
  vectorStore: {
    provider: "custom",
    instance: new PGliteVectorStore()
  },
  // ... rest of config
});

For Drizzle schema:

export const memories = pgTable("memories", {
  id: serial("id").primaryKey(),
  content: text("content"),
  embedding: vector("embedding", { dimensions: 1536 }),
  metadata: jsonb("metadata"),
});

We build offline-capable AI apps at Revolution AI — PGlite is perfect for desktop deployments!

[xXMrNidaXx]

PGlite with mem0 in Electron is tricky since mem0 expects a real Postgres connection string.

The challenge:
PGlite is embedded (no TCP socket), but mem0 pgvector expects host:port connection.

Options:

1. Use mem0 with Chroma/local vector store instead

const memory = new Memory({
  vectorStore: {
    provider: "chroma",
    config: {
      collectionName: "memories",
      path: join(app.getPath("userData"), "chroma")
    }
  },
  // ...
});

2. Custom adapter wrapping PGlite

// Create a mem0-compatible wrapper
class PGliteVectorStore {
  constructor(private pglite: PGlite) {}
  
  async add(vectors, payloads) {
    await this.pglite.query(
      "INSERT INTO memories (embedding, payload) VALUES ..."
    );
  }
  
  async search(queryVector, limit) {
    return this.pglite.query(
      "SELECT * FROM memories ORDER BY embedding <=> $1 LIMIT $2",
      [queryVector, limit]
    );
  }
}

3. Run embedded Postgres via PGlite HTTP server

import { PGlite } from "@electric-sql/pglite";
import { PGliteServer } from "@electric-sql/pglite/server";

const server = new PGliteServer(pglite, { port: 5432 });
await server.start();

// Now mem0 can connect to localhost:5432

Recommended for Electron:
Use Chroma or sqlite-vss as the vector store — better suited for embedded/desktop apps.

We build desktop AI apps at Revolution AI — Chroma works great for offline-first Electron apps.