Vector databases: guia prático para devs de IA

O Problema que Vector Databases Resolvem

Sistemas de IA baseados em LLMs frequentemente precisam buscar informação relevante em uma base de dados — contratos, documentos, base de conhecimento, histórico de conversas. A busca tradicional (SQL LIKE, full-text search) funciona com palavras-chave exatas. Mas "qual é a política de férias?" e "quais são os direitos de descanso dos funcionários?" são semânticamente equivalentes e lexicamente completamente diferentes.

Vector databases resolvem isso armazenando representações numéricas de significado (embeddings) e permitindo busca por similaridade semântica — não por palavra-chave.

Como Funciona: Embeddings e Similaridade

Um embedding é um vetor de números (geralmente 1.536 dimensões para o text-embedding-3-small da OpenAI) que representa o significado de um texto. Textos com significado similar têm vetores próximos no espaço multidimensional.

from openai import OpenAI

client = OpenAI()

def gerar_embedding(texto: str) -> list[float]:
    response = client.embeddings.create(
        model="text-embedding-3-small",  # Mais barato e rápido
        input=texto
    )
    return response.data[0].embedding

# Embeddings de textos similares ficam próximos
embedding_ferias = gerar_embedding("política de férias")
embedding_descanso = gerar_embedding("direitos de descanso dos funcionários")
# Similaridade cosseno ≈ 0.89 (muito similar)

embedding_pizza = gerar_embedding("receita de pizza")
# Similaridade com ferias ≈ 0.12 (muito diferente)

pgvector: Vector DB Dentro do PostgreSQL

Para a maioria dos projetos, a solução mais simples é adicionar capacidade vetorial ao PostgreSQL existente com a extensão pgvector.

-- Habilitar extensão
CREATE EXTENSION IF NOT EXISTS vector;

-- Tabela com coluna vetorial
CREATE TABLE documentos (
  id SERIAL PRIMARY KEY,
  conteudo TEXT,
  embedding vector(1536),  -- Dimensão do text-embedding-3-small
  metadata JSONB,
  criado_em TIMESTAMPTZ DEFAULT NOW()
);

-- Índice para busca eficiente (HNSW é mais rápido para queries)
CREATE INDEX ON documentos USING hnsw (embedding vector_cosine_ops);

import psycopg2
import numpy as np
from openai import OpenAI

client = OpenAI()
conn = psycopg2.connect(DATABASE_URL)

def indexar_documento(conteudo: str, metadata: dict):
    embedding = gerar_embedding(conteudo)
    
    with conn.cursor() as cur:
        cur.execute(
            "INSERT INTO documentos (conteudo, embedding, metadata) VALUES (%s, %s, %s)",
            (conteudo, embedding, psycopg2.extras.Json(metadata))
        )
    conn.commit()

def buscar_similares(query: str, limite: int = 5) -> list[dict]:
    query_embedding = gerar_embedding(query)
    
    with conn.cursor() as cur:
        cur.execute(
            """
            SELECT conteudo, metadata, 1 - (embedding <=> %s::vector) AS similaridade
            FROM documentos
            ORDER BY embedding <=> %s::vector
            LIMIT %s
            """,
            (query_embedding, query_embedding, limite)
        )
        return [{"conteudo": row[0], "metadata": row[1], "score": row[2]} 
                for row in cur.fetchall()]

# Uso
indexar_documento("Funcionários têm direito a 30 dias de férias por ano.", {"fonte": "rh_policy.pdf"})
resultados = buscar_similares("quantos dias de descanso eu tenho direito?")

Quando usar pgvector: Projeto já usa PostgreSQL, volume moderado (até alguns milhões de vetores), prefere não adicionar nova infraestrutura, Supabase (que inclui pgvector nativamente).

Pinecone: Vector Database Gerenciado

Pinecone é a opção managed mais popular — sem infraestrutura para gerenciar, escala automática e interface simples.

from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key=os.environ["PINECONE_API_KEY"])

# Criar índice
pc.create_index(
    name="base-conhecimento",
    dimension=1536,
    metric="cosine",
    spec=ServerlessSpec(cloud="aws", region="us-east-1")
)

index = pc.Index("base-conhecimento")

# Inserir vetores
def indexar_lote(documentos: list[dict]):
    vetores = []
    for doc in documentos:
        embedding = gerar_embedding(doc["conteudo"])
        vetores.append({
            "id": doc["id"],
            "values": embedding,
            "metadata": {"conteudo": doc["conteudo"], **doc["metadata"]}
        })
    index.upsert(vectors=vetores)

# Buscar
def buscar_pinecone(query: str, filtro: dict = None) -> list:
    embedding = gerar_embedding(query)
    resultado = index.query(
        vector=embedding,
        top_k=5,
        include_metadata=True,
        filter=filtro  # Ex: {"departamento": "rh"} — filtra por metadados
    )
    return resultado.matches

Quando usar Pinecone: Volume grande (dezenas de milhões de vetores), necessidade de filtragem por metadados complexa, equipe sem capacidade de gerenciar infraestrutura de banco de dados.

Chroma: Vector DB Local para Desenvolvimento

Chroma é ideal para prototipagem e desenvolvimento local — sem infraestrutura, funciona in-memory ou persiste em disco.

import chromadb

client = chromadb.PersistentClient(path="./chroma_db")
collection = client.get_or_create_collection("documentos")

# Inserir (Chroma faz embedding automaticamente se configurado)
collection.add(
    documents=["Férias: 30 dias por ano.", "Benefícios: plano de saúde após 90 dias."],
    metadatas=[{"fonte": "rh.pdf"}, {"fonte": "rh.pdf"}],
    ids=["doc1", "doc2"]
)

# Buscar
resultados = collection.query(
    query_texts=["quantos dias de férias?"],
    n_results=3
)

Comparativo

Critério	pgvector	Pinecone	Chroma	Weaviate
Setup	Médio	Fácil	Muito fácil	Médio
Infraestrutura	PostgreSQL	Gerenciado	Local/Self-hosted	Self-hosted
Escala	Milhões	Bilhões	Protótipos	Grandes
Custo	PostgreSQL	Pay-per-use	Free	Self-hosted
Filtros por metadado	Via SQL	Sim	Limitado	Avançado
Melhor para	Projetos com PostgreSQL	Produção em escala	Dev/Prototipagem	Dados híbridos

Conclusão

Para a maioria dos projetos de IA com RAG, pgvector é a primeira escolha — aproveita a infraestrutura PostgreSQL existente, tem performance adequada para a maioria dos volumes e elimina a necessidade de um serviço adicional. Para projetos que precisam escalar para dezenas de milhões de vetores ou têm necessidades complexas de filtragem, Pinecone oferece a solução gerenciada mais madura. Chroma é ideal para prototipagem e desenvolvimento.

A SystemForge implementa sistemas RAG com vector databases para empresas que precisam que seus sistemas de IA respondam com base em dados proprietários. Fale com nosso time para entender qual abordagem faz sentido para seu caso.