Supabase - Mem0

Supabase is an open-source Firebase alternative that provides a PostgreSQL database with pgvector extension for vector similarity search. It offers a powerful and scalable solution for storing and querying vector embeddings. Create a Supabase account and project, then get your connection string from Project Settings > Database. See the docs for details.

Usage

import os
from mem0 import Memory

os.environ["OPENAI_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "supabase",
        "config": {
            "connection_string": "postgresql://user:password@host:port/database",
            "collection_name": "memories",
            "index_method": "hnsw",  # Optional: defaults to "auto"
            "index_measure": "cosine_distance"  # Optional: defaults to "cosine_distance"
        }
    }
}

m = Memory.from_config(config)
messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
]
m.add(messages, user_id="alice", metadata={"category": "movies"})

import { Memory } from "mem0ai/oss";

const config = {
    vectorStore: {
      provider: "supabase",
      config: {
        collectionName: "memories",
        embeddingModelDims: 1536,
        supabaseUrl: process.env.SUPABASE_URL || "",
        supabaseKey: process.env.SUPABASE_KEY || "",
        tableName: "memories",
      },
    },
}

const memory = new Memory(config);

const messages = [
    {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
    {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
    {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
    {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
]

await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });

SQL Migrations for TypeScript Implementation

The following SQL migrations are required to enable the vector extension and create the memories table:

-- Enable the vector extension
create extension if not exists vector;

-- Create the memories table
create table if not exists memories (
  id text primary key,
  embedding vector(1536),
  metadata jsonb,
  created_at timestamp with time zone default timezone('utc', now()),
  updated_at timestamp with time zone default timezone('utc', now())
);

-- Create the vector similarity search function
create or replace function match_vectors(
  query_embedding vector(1536),
  match_count int,
  filter jsonb default '{}'::jsonb
)
returns table (
  id text,
  similarity float,
  metadata jsonb
)
language plpgsql
as $$
begin
  return query
  select
    t.id::text,
    1 - (t.embedding <=> query_embedding) as similarity,
    t.metadata
  from memories t
  where case
    when filter::text = '{}'::text then true
    else t.metadata @> filter
  end
  order by t.embedding <=> query_embedding
  limit match_count;
end;
$$;

Go to Supabase and run the above SQL migrations in the SQL Editor.

Config

Here are the parameters available for configuring Supabase:

Python
TypeScript

Parameter	Description	Default Value
`connection_string`	PostgreSQL connection string (required)	None
`collection_name`	Name for the vector collection	`mem0`
`embedding_model_dims`	Dimensions of the embedding model	`1536`
`index_method`	Vector index method to use	`auto`
`index_measure`	Distance measure for similarity search	`cosine_distance`

Parameter	Description	Default Value
`collectionName`	Name for the vector collection	`mem0`
`embeddingModelDims`	Dimensions of the embedding model	`1536`
`supabaseUrl`	Supabase URL	None
`supabaseKey`	Supabase key	None
`tableName`	Name for the vector table	`memories`

Index Methods

The following index methods are supported:

auto: Automatically selects the best available index method
hnsw: Hierarchical Navigable Small World graph index (faster search, more memory usage)
ivfflat: Inverted File Flat index (good balance of speed and memory)

Distance Measures

Available distance measures for similarity search:

cosine_distance: Cosine similarity (recommended for most embedding models)
l2_distance: Euclidean distance
l1_distance: Manhattan distance
max_inner_product: Maximum inner product similarity

Best Practices

Index Method Selection:
- Use hnsw for fastest search performance when memory is not a constraint
- Use ivfflat for a good balance of search speed and memory usage
- Use auto if unsure, it will select the best method based on your data
Distance Measure Selection:
- Use cosine_distance for most embedding models (OpenAI, Hugging Face, etc.)
- Use max_inner_product if your vectors are normalized
- Use l2_distance or l1_distance if working with raw feature vectors
Connection String:
- Always use environment variables for sensitive information in the connection string
- Format: postgresql://user:password@host:port/database

​Usage

​SQL Migrations for TypeScript Implementation

​Config

​Index Methods

​Distance Measures

​Best Practices