Relevância não é permissão: como filtrar buscas vetoriais por acesso antes de relevância no PostgreSQL
Um texto publicado no Planet PostgreSQL em 21 de novembro mostra, em SQL, como usar RLS e pgvector para impedir que buscas semânticas devolvam documentos que o usuário não deveria ver.

- Leitura
- 9 min
- Tabelas
- 1
- Código
- 5
- Fontes
- 1
Um texto publicado no Planet PostgreSQL↳PostgreSQL11 conteúdosPostgreSQL via SSL com GolangData · abr 20195 itens legais sobre data types do PostgreSQLData · mar 20195 serviços gratuitos na cloud para bancos de dados PostgresData · fev 2025Ver tudo em Data → em 21 de novembro mostra, em SQL, como usar RLS e pgvector para impedir que buscas semânticas devolvam documentos que o usuário não deveria ver.
Imagine um assistente interno que responde dúvidas de funcionários a partir de um repositório de documentos compartilhado. Alguém pergunta quando o bônus é pago. A busca vetorial faz exatamente o que foi construída para fazer: encontra os trechos mais parecidos semanticamente com a pergunta. Um deles vem de uma revisão de remuneração que só o RH deveria acessar.
Nenhum modelo alucinou, nenhum índice corrompeu, nenhuma query deu timeout. Tudo funcionou como projetado, e por isso nenhum alerta disparou. Esse é o ponto central do texto publicado no Planet PostgreSQL em 21 de novembro de 2026, que retoma um argumento já defendido pelo autor num artigo seu na Forbes Technology Council.
A busca funcionou perfeitamente. Esse foi o problema.
autor do artigo originalThe retrieval was perfect. That was the problem.
O argumento do autor é direto: um sistema de busca responde "o que é mais relevante", nunca "o que esta pessoa pode ver". Ele descreve quatro padrões de SQL para resolver isso dentro do próprio PostgreSQL, sem depender da aplicação para lembrar de filtrar.
A busca vetorial não sabe quem é dono do dado
Um embedding captura o significado de um trecho de texto. Não captura quem é o dono dele, a qual tenant pertence ou qual regulação o cobre. Um parágrafo de uma FAQ pública e um memorando confidencial de diretoria podem ficar vizinhos no espaço vetorial simplesmente porque falam do mesmo assunto.
A maioria dos pipelines de RAG↳RAG6 conteúdosTécnica RAG com a biblioteca Langchain: tutorial para aplicar agoraData · jun 2024Como avaliar LLMs, RAG e Agentes de IA: Teoria e prática.AI · abr 2026RAG Não É Memória: O Problema Real dos Agentes de IAAI · mai 2026Ver tudo em AI → resolve isso de dois jeitos, segundo o autor, e ambos são frágeis. O primeiro filtra na aplicação, depois da busca: o app traz os top k resultados e descarta os que o usuário não pode ver, até um novo agente ou um script de debug esquecer esse passo. O segundo escreve a permissão direto na cláusula WHERE de quem monta a query, até uma query gerada por LLM esquecer a condição.
Em ambos os casos, permissão é hábito de quem chama a consulta, não propriedade do dado. Quando quem consulta passa a ser um agente de IA, não há mais code review possível sobre aquele caminho. A regra de acesso precisa morar onde o dado mora: dentro do PostgreSQL.
Padrão 1: autoridade na linha, aplicada por RLS
Row Level Security transforma "quem pode ver esta linha" de convenção de código em garantia de banco. Toda consulta contra a tabela, inclusive uma busca por similaridade vetorial, recebe a política anexada automaticamente, não importa quem escreveu o SQL.
O primeiro passo é carregar metadado de autoridade na mesma linha do embedding:
CREATE TABLE doc_chunk (
chunk_id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
tenant_id INTEGER NOT NULL,
sensitivity TEXT NOT NULL DEFAULT 'internal',
allowed_roles TEXT[] NOT NULL,
content TEXT NOT NULL,
embedding VECTOR(1536) NOT NULL
);
CREATE INDEX ON doc_chunk USING hnsw (embedding vector_cosine_ops);Depois vem a política, aplicada a um papel próprio para agentes de IA:
ALTER TABLE doc_chunk ENABLE ROW LEVEL SECURITY;
ALTER TABLE doc_chunk FORCE ROW LEVEL SECURITY;
CREATE POLICY doc_chunk_agent_read ON doc_chunk
FOR SELECT TO ai_agent
USING (
tenant_id = NULLIF(current_setting('app.tenant_id', TRUE), '')::INTEGER
AND allowed_roles && string_to_array(
NULLIF(current_setting('app.user_roles', TRUE), ''), ','
)
);A busca em si fica dentro de uma função SECURITY INVOKER, para que a política valha sempre, e o middleware de confiança (nunca o modelo) define o contexto a cada transação com SET LOCAL.
Três detalhes, segundo o autor, fazem toda a diferença:
FORCE ROW LEVEL SECURITYé obrigatório: sem ele, o dono da tabela ignora a política, e superusuários ou papéis comBYPASSRLSsempre ignoram, então agentes jamais devem conectar como um deles.current_setting(..., TRUE)combinado comNULLIF(..., '')faz o contexto ausente falhar fechado (zero linhas) em vez de aberto (todas as linhas). O autor descobriu rodando o próprio script que, em conexão de pool reaproveitada, umSET LOCALanterior deixa o valor como string vazia em vez deNULL, e''::INTEGERgera erro sem oNULLIF.- Quem define o contexto importa: se o modelo manda SQL bruto na mesma conexão, ele pode alterar o próprio tenant. A saída é manter geração de SQL atrás de uma interface de função fixa, ou validar identidade com uma função
SECURITY DEFINERque checa um token assinado.
Padrão 2: o índice aproximado pode sufocar o filtro
RLS fecha o vazamento, mas abre outro problema mais silencioso. HNSW e IVFFlat são índices aproximados: o pgvector percorre o índice uma vez, monta um conjunto de candidatos e só depois aplica todos os filtros, inclusive a política de RLS. Se a maioria dos vizinhos mais próximos pertence a outros tenants, um LIMIT 10 pode voltar com uma linha, ou nenhuma, sem erro algum.
A versão 0.8.0 do pgvector trouxe varredura iterativa para esse caso exato: o índice continua procurando até reunir linhas suficientes depois do filtro, ou até atingir um limite de segurança.
SET hnsw.iterative_scan = relaxed_order;
SET hnsw.max_scan_tuples = 20000; -- padrãoNo script de demonstração que acompanha o texto (100 mil chunks, 20 tenants, tenant 42 com apenas 2.062 linhas), os números tornam o problema concreto:
| Configuração | Resultado para LIMIT 10 |
|---|---|
hnsw.iterative_scan desligado | 1 linha (39 descartadas pelo filtro de RLS) |
hnsw.iterative_scan = relaxed_order | 10 linhas (568 descartadas pelo filtro) |
O agente pediu dez trechos e recebeu um, sem nenhum alerta. Com a varredura iterativa ligada, o índice continuou procurando até devolver as dez linhas esperadas. relaxed_order permite pequena reordenação em troca de mais recall; strict_order preserva a ordem exata de distância, à custa de mais candidatos descartados.
Um detalhe que o autor só viu olhando o plano: dentro da função, com LIMIT parametrizado, o planejador estimou cerca de 200 linhas em vez de 10, descartou o HNSW e usou o índice B-tree de tenant_id, ordenando exatamente as 2.061 linhas visíveis do tenant em 3 a 4 ms. Para um tenant pequeno esse é o plano certo, com recall perfeito e sem aproximação. Mas o comportamento não é previsível só lendo o texto do SQL: é preciso checar EXPLAIN (ANALYZE, BUFFERS) rodando como o papel do agente, com um contexto real de tenant, e observar a linha Rows Removed by Filter.
Padrão 3: fronteiras físicas para o que nunca pode se misturar
RLS resolve regras finas, mas algumas fronteiras são rígidas demais para depender de filtro: um tenant jamais deve dividir índice com outro, ou registros regulados jamais devem se misturar com o resto. Para esses casos, o autor propõe mudar onde o dado vive, não apenas como ele é filtrado.
Particionar por tenant dá a cada um seu próprio índice HNSW, para que a busca por vizinhos mais próximos rode só sobre os vetores daquele tenant, sem nunca escanear os demais:
CREATE TABLE tenant_chunk (
chunk_id BIGINT GENERATED ALWAYS AS IDENTITY,
tenant_id INTEGER NOT NULL,
embedding VECTOR(1536) NOT NULL,
PRIMARY KEY (tenant_id, chunk_id)
) PARTITION BY LIST (tenant_id);
CREATE TABLE tenant_chunk_t42 PARTITION OF tenant_chunk FOR VALUES IN (42);
CREATE INDEX ON tenant_chunk_t42 USING hnsw (embedding vector_cosine_ops);O comportamento do planejador muda conforme onde o tenant aparece na consulta. Com WHERE tenant_id = 42 explícito, a poda acontece em tempo de planejamento e a busca usa diretamente o índice HNSW da partição tenant_chunk_t42. Quando o tenant vem só da política de RLS, a poda só acontece em tempo de execução (aparece como Subplans Removed: 1), e no experimento descrito no texto o planejador optou por varredura sequencial com ordenação exata sobre as 2.061 linhas, em vez do índice HNSW.
Em resumo: vale manter a política de RLS como rede de segurança, mas passar o tenant explicitamente dá ao planejador o que ele precisa para podar e escolher o índice certo. Índices parciais funcionam de forma parecida para níveis de sensibilidade (WHERE sensitivity = 'public'), quando a classificação é estável e cobre a maioria das consultas: cada candidato que o índice devolve já é elegível, e o filtro não descarta nada.
Padrão 4: provar o que o agente podia ver
Depois de um incidente, dizer "temos RLS" não responde às perguntas de um auditor: quais linhas o agente recuperou para esta resposta, sob qual identidade, e o que mais ele poderia ter recuperado.
O autor recomenda testar a fronteira do jeito que o agente a encontra: rodar como o papel ai_agent, buscar por um trecho restrito a partir de um tenant ou papel que não deveria vê-lo, e verificar que o resultado vem zerado. Todo teste negativo precisa de um par positivo, com o papel correto, para garantir que ausência de resultado não é busca quebrada. Ambos devem rodar em CI junto com as migrações de schema, para que uma política que amplie acesso por engano quebre o build, não apareça num post-mortem.
Além dos testes, uma tabela de rastro registra, na mesma transação da resposta, quais chunks entraram no contexto e sob qual identidade:
CREATE TABLE retrieval_trace (
trace_id BIGINT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
request_id UUID NOT NULL,
db_role TEXT NOT NULL DEFAULT current_user,
tenant_id INTEGER NOT NULL,
user_roles TEXT[] NOT NULL,
chunk_ids BIGINT[] NOT NULL,
retrieved_at TIMESTAMPTZ NOT NULL DEFAULT now()
);O autor associa essa tabela ao princípio "Trace Everything" do framework ORBIT aplicado à recuperação de dados: quando alguém perguntar por que o agente disse o que disse, dá para reconstruir o conjunto exato de evidência, sem depender de inferência sobre o embedding. Para cobertura mais ampla de auditoria, a extensão pgAudit registra atividade de SELECT por papel, deixando rastro mesmo fora da função de busca.
O que isso custa e quando não compensa
Nenhum desses padrões é novidade recente no PostgreSQL: RLS existe desde a versão 9.5, e particionamento por lista é recurso maduro. O que muda é aplicá-los deliberadamente a buscas vetoriais, onde a aproximação do índice interage com o filtro de um jeito que não aparece olhando só o SQL.
Avaliar uma política de RLS por linha tem custo, e vale medir antes de generalizar. Particionar por tenant resolve isolamento rígido, mas multiplica trabalho operacional: cada tenant ganha sua própria partição e, possivelmente, seu próprio índice HNSW para manter. Para tenants pequenos, como o de 2 mil linhas do experimento, um B-tree com ordenação exata entrega recall perfeito mais rápido que um índice aproximado, e dispensar o HNSW ali é decisão sensata, não economia de recurso.
O script completo que acompanha o texto é auto-verificável, roda em cerca de 40 segundos, exige PostgreSQL 16 ou mais recente e pgvector 0.8.0 ou mais recente, além de acesso de superusuário para criar banco e papéis de teste. Para quem administra um pipeline de RAG com dados reais, é um ponto de partida mais honesto do que confiar que a aplicação nunca vai esquecer o filtro.
Fonte: Planet PostgreSQL
Highlights
- Busca vetorial que funciona perfeitamente pode expor dados restritos: a pergunta respondida era qual trecho é mais relevante, não quem pode vê-lo.
- Row Level Security (RLS) no PostgreSQL 0.8.0+ combina com pgvector para garantir acesso antes de relevância em toda query, sem depender da aplicação.
- Varredura iterativa (`hnsw.iterative_scan = relaxed_order`) faz o índice continuar procurando até reunir resultados suficientes após filtro RLS.
- Particionar dados por tenant cria índices HNSW separados por cliente, impedindo que busca aproximada misture dados de diferentes limites de acesso.
- Testes negativos em CI validam que agentes sem permissão devolvem zero linhas, garantindo que a política não falha silenciosamente em produção.
Este artigo foi escrito por Roberto Diniz, colunista de banco de dados. Conteúdo produzido por agente de IA da redação iMasters, sob revisão editorial humana. Saiba como produzimos no expediente.
PostgreSQL em Docker: os cinco defaults do contêiner que derrubam a produção
Um guia do engenheiro Aleksei Aleinikov mostra por que volumes mal montados, memória compartilhada de 64 MB e um timeout de desligamento de 10 segundos respondem pela maioria dos incidentes com PostgreSQL em contêiner, não o Docker em si.














