Supabase Vector - Búsqueda vectorial con PostgreSQL

Qué es Supabase Vector

Supabase Vector es una función de búsqueda vectorial que utiliza la extensión de PostgreSQL pgvector. Permite implementar búsqueda semántica y RAG (Retrieval Augmented Generation) necesarios para aplicaciones de AI/ML en tu base de datos PostgreSQL existente.

Configuración

Habilitar pgvector

-- Habilitar la extensión pgvector
CREATE EXTENSION IF NOT EXISTS vector;

-- Crear tabla con columna de vectores
CREATE TABLE documents (
  id BIGSERIAL PRIMARY KEY,
  content TEXT,
  embedding VECTOR(1536), -- Dimensiones de OpenAI ada-002
  metadata JSONB,
  created_at TIMESTAMPTZ DEFAULT NOW()
);

Crear índices

-- Índice IVFFlat (rápido, búsqueda aproximada)
CREATE INDEX ON documents
USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100);

-- Índice HNSW (mayor precisión)
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);

Generación y almacenamiento de vectores

Usando OpenAI Embeddings

import { createClient } from '@supabase/supabase-js';
import OpenAI from 'openai';

const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
const openai = new OpenAI();

async function addDocument(content: string, metadata: object) {
  // Generar Embedding
  const embeddingResponse = await openai.embeddings.create({
    model: 'text-embedding-ada-002',
    input: content
  });

  const embedding = embeddingResponse.data[0].embedding;

  // Guardar en Supabase
  const { error } = await supabase
    .from('documents')
    .insert({
      content,
      embedding,
      metadata
    });

  if (error) throw error;
}

Búsqueda vectorial

Búsqueda por similitud

async function searchSimilar(query: string, limit = 5) {
  // Generar Embedding de la consulta
  const embeddingResponse = await openai.embeddings.create({
    model: 'text-embedding-ada-002',
    input: query
  });

  const queryEmbedding = embeddingResponse.data[0].embedding;

  // Búsqueda vectorial
  const { data, error } = await supabase.rpc('match_documents', {
    query_embedding: queryEmbedding,
    match_threshold: 0.7,
    match_count: limit
  });

  return data;
}

Función SQL para búsqueda

CREATE OR REPLACE FUNCTION match_documents(
  query_embedding VECTOR(1536),
  match_threshold FLOAT,
  match_count INT
)
RETURNS TABLE (
  id BIGINT,
  content TEXT,
  metadata JSONB,
  similarity FLOAT
)
LANGUAGE plpgsql
AS $$
BEGIN
  RETURN QUERY
  SELECT
    documents.id,
    documents.content,
    documents.metadata,
    1 - (documents.embedding <=> query_embedding) AS similarity
  FROM documents
  WHERE 1 - (documents.embedding <=> query_embedding) > match_threshold
  ORDER BY documents.embedding <=> query_embedding
  LIMIT match_count;
END;
$$;

Construcción de aplicación RAG

async function askQuestion(question: string) {
  // 1. Buscar documentos relevantes
  const relevantDocs = await searchSimilar(question, 3);

  // 2. Construir contexto
  const context = relevantDocs
    .map(doc => doc.content)
    .join('\n\n');

  // 3. Generar respuesta con LLM
  const response = await openai.chat.completions.create({
    model: 'gpt-4',
    messages: [
      {
        role: 'system',
        content: `Responde la pregunta usando el siguiente contexto.
        Si no hay información en el contexto, responde "No lo sé".

        Contexto:
        ${context}`
      },
      { role: 'user', content: question }
    ]
  });

  return {
    answer: response.choices[0].message.content,
    sources: relevantDocs
  };
}

Búsqueda híbrida

Combina búsqueda vectorial con búsqueda de texto completo.

CREATE OR REPLACE FUNCTION hybrid_search(
  query_text TEXT,
  query_embedding VECTOR(1536),
  match_count INT
)
RETURNS TABLE (
  id BIGINT,
  content TEXT,
  similarity FLOAT
)
LANGUAGE plpgsql
AS $$
BEGIN
  RETURN QUERY
  SELECT
    d.id,
    d.content,
    (
      0.5 * (1 - (d.embedding <=> query_embedding)) +
      0.5 * ts_rank(to_tsvector('spanish', d.content), plainto_tsquery('spanish', query_text))
    ) AS similarity
  FROM documents d
  WHERE to_tsvector('spanish', d.content) @@ plainto_tsquery('spanish', query_text)
  ORDER BY similarity DESC
  LIMIT match_count;
END;
$$;

Integración con Edge Functions

// supabase/functions/embed-and-search/index.ts
import { serve } from 'https://deno.land/std@0.168.0/http/server.ts';
import { createClient } from 'https://esm.sh/@supabase/supabase-js@2';

serve(async (req) => {
  const { query } = await req.json();

  // Generar Embedding con API de OpenAI
  const embeddingRes = await fetch('https://api.openai.com/v1/embeddings', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${Deno.env.get('OPENAI_API_KEY')}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: 'text-embedding-ada-002',
      input: query
    })
  });

  const { data } = await embeddingRes.json();
  const embedding = data[0].embedding;

  // Buscar en Supabase
  const supabase = createClient(
    Deno.env.get('SUPABASE_URL')!,
    Deno.env.get('SUPABASE_SERVICE_ROLE_KEY')!
  );

  const { data: results } = await supabase.rpc('match_documents', {
    query_embedding: embedding,
    match_threshold: 0.7,
    match_count: 5
  });

  return new Response(JSON.stringify(results), {
    headers: { 'Content-Type': 'application/json' }
  });
});

Consejos de rendimiento

Resumen

Supabase Vector implementa búsqueda vectorial aprovechando las fortalezas de PostgreSQL. Puedes agregar funciones de IA a tu base de datos existente, facilitando la construcción de aplicaciones RAG.