Building Enterprise Context Memory with Supabase Vector & Hybrid Search

By Deepak Bagada, CEO at SaaSNext

The Evolution of Agentic Memory

One of the biggest challenges in building robust AI agents is managing state and memory. Simple vector databases that rely solely on dense embeddings often fail at exact keyword retrieval (like user IDs, product SKUs, or specific terminology). In 2026, the industry standard has shifted to Hybrid Search—combining the semantic understanding of dense vectors with the exact-match precision of sparse vectors (BM25 or SPLADE).

Supabase, leveraging PostgreSQL's pgvector and robust text search capabilities, provides the perfect unified architecture for this.

Why Hybrid Search?

Dense embeddings (like those from OpenAI's text-embedding-3-large) map text to a high-dimensional space based on meaning. If you search for 'Apple', it might return 'Microsoft' because they are both tech companies. Sparse search (BM25) maps text based on word frequency. If you search for 'Apple', it ensures the word 'Apple' is in the result.

Hybrid search uses Reciprocal Rank Fusion (RRF) to combine both results, ensuring the AI agent receives context that is both semantically relevant and factually precise.

Implementing Hybrid Search in Supabase

1. Database Setup

First, enable the pgvector extension and create a table for your agent's memory chunks.

create extension if not exists vector;

create table agent_memory (
  id uuid primary key default gen_random_uuid(),
  agent_id text not null,
  content text not null,
  metadata jsonb,
  embedding vector(3072),
  fts tsvector generated always as (to_tsvector('english', content)) stored
);

-- Create HNSW index for fast vector search
create index on agent_memory using hnsw (embedding vector_cosine_ops);
-- Create GIN index for fast full-text search
create index on agent_memory using gin (fts);

2. The Reciprocal Rank Fusion (RRF) Function

To perform hybrid search, we write a custom Postgres function that executes both searches and merges them.

create or replace function hybrid_search(
  query_text text,
  query_embedding vector(3072),
  match_count int,
  full_text_weight float default 1,
  semantic_weight float default 1,
  rrf_k int default 50
) returns setof agent_memory
language sql
as $$
with full_text as (
  select id, row_number() over(order by ts_rank_cd(fts, websearch_to_tsquery(query_text)) desc) as rank_ix
  from agent_memory
  where fts @@ websearch_to_tsquery(query_text)
  limit match_count
),
semantic as (
  select id, row_number() over(order by embedding <=> query_embedding) as rank_ix
  from agent_memory
  order by embedding <=> query_embedding
  limit match_count
)
select
  am.*
from agent_memory am
join (
  select
    coalesce(semantic.id, full_text.id) as id,
    coalesce(1.0 / (rrf_k + semantic.rank_ix), 0.0) * semantic_weight +
    coalesce(1.0 / (rrf_k + full_text.rank_ix), 0.0) * full_text_weight as score
  from semantic
  full outer join full_text on semantic.id = full_text.id
  order by score desc
  limit match_count
) ranks on am.id = ranks.id;
$$

Optimizing for Production

When scaling to millions of memory fragments, consider partitioning your Postgres tables by agent_id or tenant_id. Additionally, employ a chunking strategy that preserves context boundaries—using semantic chunking rather than fixed token lengths.

By leveraging Supabase for hybrid search, you consolidate your tech stack, reduce latency, and dramatically improve the recall capabilities of your autonomous agents.

View the Supabase Starter Kit