Cache semântico de LLM é devolver uma resposta já gerada quando chega uma pergunta com o mesmo significado de outra já respondida, mesmo que o texto seja diferente. A implementação que sobrevive à produção segue oito passos: decidir o que é elegível, particionar por escopo, normalizar e vetorizar a pergunta, implementar busca e gravação, calibrar o limiar de similaridade com pares rotulados, projetar a invalidação, medir acerto e acerto falso e, só então, ligar para o usuário depois de um período em modo sombra.
Pontos-chave
- O limiar de similaridade não é um número que se copia de tutorial: ele depende do modelo de embeddings e do seu tráfego, e sai de uma calibração com pares rotulados.
- A métrica que decide o limiar é a precisão do acerto, não a taxa de acerto. Acerto falso é resposta errada entregue com cara de certa.
- Escopo vem antes de vetor: inquilino, modelo, versão do prompt, versão do índice e idioma entram na chave exata, nunca na similaridade.
- Invalidação tem três gatilhos independentes: tempo (TTL), versão (prompt, modelo, índice) e fonte (o documento que sustentava a resposta mudou).
- O ganho de latência esperado é T_lookup + (1 – h) * T_llm. Com taxa de acerto baixa, o cache vira só mais um salto de rede.
- Modo sombra primeiro: registre o que o cache teria respondido, compare com a resposta real e só depois sirva.
Antes de começar: o que você precisa ter em mãos
Quatro itens, e nenhum deles é o banco vetorial. Primeiro, um log de perguntas reais de pelo menos algumas semanas, porque sem ele você não sabe se existe repetição para aproveitar. Segundo, uma suíte de evals que já rode no seu pipeline, para julgar se a resposta reaproveitada continua correta. Terceiro, identificadores de versão para tudo que influencia a resposta: se você ainda não trata prompt como código versionado, resolva isso antes, ou a invalidação vai ser manual. Quarto, um modelo de embeddings com latência previsível, de preferência o mesmo que você já usa na recuperação do seu pipeline de RAG.
Um aviso de quem já ligou cache cedo demais: cache semântico não corrige aplicação lenta por desenho. Se o seu gargalo é tamanho de resposta ou chamadas em série, comece pelo guia de redução de latência em aplicações com LLM e volte aqui depois.
Passo 1: Decida o que pode ser cacheado
O erro que todo mundo comete é cachear tudo e descobrir depois que o usuário B recebeu o saldo do usuário A. Elegibilidade é uma decisão por rota, tomada antes de escrever código. A regra prática: só entra no cache a resposta que seria idêntica para qualquer pessoa dentro do mesmo escopo, feita no mesmo instante.
| Tipo de requisição | Cachear? | Motivo |
|---|---|---|
| Pergunta factual sobre documentação ou política pública da empresa | Sim | Resposta independe de quem pergunta; muda só quando a fonte muda |
| Pergunta que depende de dados da conta (pedido, saldo, histórico) | Não | A resposta carrega dado pessoal e varia por usuário |
| Turno no meio de uma conversa longa | Em geral não | O significado depende do histórico, que não está no vetor da última mensagem |
| Classificação ou extração sobre texto de entrada | Cache exato, não semântico | Entradas parecidas podem ter rótulos diferentes; use hash do texto |
| Geração criativa com temperatura alta | Não | O usuário espera variação |
| Chamada com ferramentas que causam efeito colateral | Não | Reaproveitar a resposta pula a ação |
Passo 2: Defina a chave de escopo antes do vetor
Similaridade serve para comparar perguntas. Ela não serve para separar contextos. Tudo o que muda a resposta sem mudar a pergunta precisa virar uma chave exata, e a busca vetorial acontece só dentro da partição daquela chave.
A chave mínima tem cinco campos: inquilino (ou base de conhecimento), identificador do modelo gerador, versão do prompt de sistema, versão do índice de documentos e idioma. Se a aplicação tem perfis de permissão, o perfil entra também. Na prática, a chave vira um prefixo de coleção, um filtro de metadados ou um namespace, conforme o armazenamento.
O efeito colateral é bom: quando você publica um prompt novo, a versão muda, a partição antiga deixa de ser consultada e expira sozinha. Invalidação por versão sai de graça.
Passo 3: Normalize a pergunta e gere o embedding
Normalização barata aumenta acerto sem mexer no limiar. Aplique, nesta ordem: remoção de espaços duplicados, caixa baixa, remoção de saudações e fechos (“bom dia”, “obrigado”) e padronização de números e datas quando o domínio permitir. Não remova negações nem palavras curtas: “posso” e “não posso” ficam muito próximos no espaço vetorial e são perguntas opostas.
Antes da busca vetorial, consulte um cache exato pelo hash do texto normalizado. É uma leitura de chave e valor, não precisa de embedding e pega as repetições literais sem custo de vetorização.
Sobre o vetor: normalize para norma 1 e use produto interno, que nesse caso equivale ao cosseno. E grave junto de cada entrada o nome do modelo de embeddings. Vetores de modelos diferentes não são comparáveis, nem quando têm a mesma dimensão.
Passo 4: Implemente busca e gravação
O núcleo cabe em poucas linhas. O exemplo abaixo guarda tudo em memória e faz busca exaustiva dentro da partição, o que é suficiente para validar a ideia e para partições pequenas. Em produção, troque a lista por um índice vetorial com filtro de metadados. A interface continua a mesma.
import time
import numpy as np
class CacheSemantico:
def __init__(self, embed, limiar, ttl_s, relogio=time.time):
self.embed, self.limiar = embed, limiar
self.ttl_s, self.relogio = ttl_s, relogio
self.particoes = {} # escopo -> lista de entradas
def _vetor(self, texto):
v = np.asarray(self.embed(texto), dtype=np.float32)
return v / np.linalg.norm(v)
def buscar(self, escopo, pergunta):
v = self._vetor(pergunta)
agora = self.relogio()
vivas = [e for e in self.particoes.get(escopo, []) if e["expira"] > agora]
self.particoes[escopo] = vivas
if not vivas:
return None, 0.0, v
sims = np.stack([e["vetor"] for e in vivas]) @ v
i = int(np.argmax(sims))
acerto = vivas[i] if sims[i] >= self.limiar else None
return acerto, float(sims[i]), v
def gravar(self, escopo, pergunta, resposta, vetor, fontes=()):
self.particoes.setdefault(escopo, []).append({
"pergunta": pergunta, "resposta": resposta, "vetor": vetor,
"fontes": frozenset(fontes),
"expira": self.relogio() + self.ttl_s})
def invalidar_fonte(self, doc_id):
removidas = 0
for escopo, entradas in self.particoes.items():
vivas = [e for e in entradas if doc_id not in e["fontes"]]
removidas += len(entradas) - len(vivas)
self.particoes[escopo] = vivas
return removidas
Três decisões de desenho estão ali de propósito. A função buscar devolve a melhor similaridade mesmo quando não há acerto, porque você vai precisar desse número nos logs para recalibrar. Ela devolve também o vetor, para que a gravação não pague um segundo embedding. E cada entrada carrega o conjunto de fontes, os identificadores dos documentos que sustentaram a resposta, sem o qual a invalidação por fonte do Passo 6 não existe.
O fluxo de uso é: buscar; se houver acerto, responder e registrar; se não, chamar o modelo, validar a resposta e só então gravar. Não grave respostas de erro, recusas, respostas truncadas por limite de tokens nem respostas que falharam em alguma verificação de saída. Cache multiplica o que você coloca nele, inclusive alucinações.
Passo 5: Calibre o limiar de similaridade com pares rotulados
Aqui está a parte que separa cache útil de gerador de incidentes. O limiar é o ponto de corte de um classificador binário (“estas duas perguntas aceitam a mesma resposta?”), e classificador se calibra com dado rotulado.
Monte o conjunto de pares
Tire do log pares de perguntas da mesma partição, cobrindo toda a faixa de similaridade, com mais densidade na zona de dúvida. Para cada par, uma pessoa que conhece o domínio responde uma única questão: a resposta da primeira serviria integralmente para a segunda? Inclua de propósito os pares traiçoeiros: negação, troca de entidade (“plano básico” e “plano avançado”), troca de número e troca de período.
Calcule precisão e cobertura por limiar
def calibrar(pares, limiares):
"""pares: lista de (similaridade, equivalente), rotulada por humanos."""
linhas = []
for t in limiares:
aceitos = [eq for s, eq in pares if s >= t]
vp = sum(aceitos)
precisao = vp / len(aceitos) if aceitos else float("nan")
cobertura = len(aceitos) / len(pares)
linhas.append((t, len(aceitos), vp, precisao, cobertura))
return linhas
Para mostrar a leitura, considere um conjunto hipotético de 20 pares, dos quais 13 foram rotulados como equivalentes. Rodando a função, o resultado é este:
| Limiar | Pares aceitos | Equivalentes entre os aceitos | Precisão | Cobertura |
|---|---|---|---|---|
| 0,85 | 18 | 13 | 13/18 = 72,2% | 18/20 = 90% |
| 0,90 | 13 | 11 | 11/13 = 84,6% | 13/20 = 65% |
| 0,92 | 10 | 9 | 9/10 = 90% | 10/20 = 50% |
| 0,95 | 6 | 6 | 6/6 = 100% | 6/20 = 30% |
Os valores de limiar da tabela são ilustrativos e não valem para o seu sistema: cada modelo de embeddings distribui similaridades de um jeito, e um corte seguro em um modelo pode ser frouxo em outro. O que vale é o procedimento. Fixe primeiro a precisão mínima que o produto tolera e escolha o menor limiar que a atinge. Vinte pares servem para explicar a conta, não para decidir: com amostra pequena, o intervalo de confiança da precisão é largo demais. Rotule centenas de pares e repita a calibração sempre que trocar o modelo de embeddings.
Trate a zona cinzenta
Entre o limiar de aceitação e um limiar inferior, você pode aplicar uma segunda verificação antes de servir: um reranker do tipo cross-encoder ou um modelo pequeno que julgue a equivalência do par. Custa bem menos que a geração completa e recupera cobertura sem sacrificar precisão. Avalie esse juiz com o mesmo conjunto rotulado.
Passo 6: Projete a invalidação
Resposta velha é o segundo jeito de errar com cache. São três gatilhos, e você precisa dos três.
| Gatilho | O que cobre | Como implementar |
|---|---|---|
| Tempo (TTL) | Mudanças que você não consegue detectar | Expiração por entrada, com prazo definido por rota conforme a volatilidade do conteúdo |
| Versão | Troca de prompt, de modelo gerador, de modelo de embeddings ou reindexação completa | Versão dentro da chave de escopo; a partição antiga morre por TTL |
| Fonte | Um documento específico foi alterado ou removido | Índice invertido de documento para entradas; ao atualizar o documento, remover as entradas ligadas a ele |
O método invalidar_fonte do Passo 4 faz a terceira linha percorrendo tudo, o que só serve para demonstração. Com volume, mantenha um mapa de doc_id para chaves de entrada e apague por ele. Dispare a invalidação no mesmo evento que reindexa o documento, não em um job noturno.
Dois cuidados adicionais. Some um desvio aleatório ao TTL para que entradas gravadas juntas não expirem juntas e provoquem uma rajada de chamadas ao modelo. E crie um caminho de remoção manual por pergunta: quando alguém reportar uma resposta errada, o operador precisa conseguir apagar aquela entrada em segundos e marcar o par como exemplo negativo para a próxima calibração.
Passo 7: Meça acerto, acerto falso e economia
Quatro números contam a história inteira. Registre-os por rota e por partição.
- Taxa de acerto (h): requisições servidas pelo cache divididas pelas requisições elegíveis.
- Precisão do acerto: fração dos acertos em que a resposta servida era de fato adequada. Não sai de log: exige amostragem e julgamento, humano ou por juiz automático validado.
- Taxa de acerto falso sobre o tráfego: h * (1 – precisão). É o número que o time de produto precisa aprovar.
- Latência e custo evitados.
As contas, com um cenário hipotético: T_llm = 2.000 ms, T_lookup (embedding mais busca) = 40 ms, h = 0,30 e precisão de 97%.
T_esperado = T_lookup + (1 - h) * T_llm
= 40 + 0,70 * 2000 = 1440 ms (sem cache: 2000 ms)
acerto falso sobre o tráfego = h * (1 - precisão)
= 0,30 * 0,03 = 0,009 = 0,9% das requisições
h de equilíbrio em latência = T_lookup / T_llm = 40 / 2000 = 0,02
Leia a segunda linha com atenção: 97% de precisão parece ótimo e ainda assim entrega resposta inadequada em quase uma a cada cem requisições elegíveis. Se isso é aceitável depende do domínio. Para custo, o raciocínio é o mesmo: custo esperado = C_embedding + (1 – h) * C_llm, com os valores do seu contrato. O artigo sobre tokens, janela de contexto e custo mostra como chegar ao C_llm por requisição.
Guarde também o histograma da melhor similaridade encontrada em cada busca. Se a massa do histograma se desloca, o tráfego mudou ou o modelo de embeddings foi atualizado sem aviso, e o limiar precisa ser revisto.
Passo 8: Ligue em modo sombra antes de servir
Na primeira semana, o cache só observa. Toda requisição vai ao modelo normalmente; em paralelo, você registra se haveria acerto, com qual similaridade e qual resposta seria servida. Depois, compara a resposta do cache com a resposta real em uma amostra, com juiz automático e revisão humana nos casos de discordância.
O modo sombra entrega três coisas que nenhuma planilha entrega: a taxa de acerto real do seu tráfego, a precisão medida em perguntas de verdade e uma lista de acertos falsos para virar exemplos negativos. Se a taxa de acerto ficar perto do h de equilíbrio, pare aí: você acabou de economizar a manutenção de um componente que não se paga.
Passando no crivo, libere por rota, com uma porcentagem pequena do tráfego, um cabeçalho de resposta que indique acerto de cache e um interruptor para desligar sem deploy. Trate o cache como qualquer outro componente do ciclo descrito em MLOps depois que o modelo fica pronto: com painel, alerta e dono.
Erros comuns ao implementar cache semântico
- Copiar o limiar de outro projeto. O número não se transfere entre modelos de embeddings nem entre domínios.
- Otimizar taxa de acerto. Baixar o limiar sempre aumenta o acerto. O que você quer é acerto com precisão acima do piso combinado.
- Colocar o escopo no texto. Concatenar o nome do inquilino à pergunta e torcer para o vetor separar não é isolamento.
- Cachear resposta com dado pessoal. Além do erro funcional, vira um problema de privacidade. Na dúvida, a rota não é elegível.
- Esquecer o modelo de embeddings na versão. Trocar o modelo e manter os vetores antigos gera similaridades sem sentido.
- Não medir precisão depois do lançamento. O tráfego muda. Amostre acertos toda semana.
Perguntas frequentes sobre cache semântico de LLM
Cache semântico é a mesma coisa que cache de prefixo do provedor?
Não. O cache de prefixo reaproveita o processamento de um trecho inicial idêntico do prompt e ainda gera a resposta. O cache semântico pula a geração inteira. Os dois se somam.
Qual limiar de similaridade devo usar?
O menor que atinge a precisão mínima definida para a rota, medido em pares rotulados do seu tráfego, com o seu modelo de embeddings. Qualquer número fora desse procedimento é chute.
Preciso de um banco vetorial dedicado?
Não necessariamente. Partições pequenas aceitam busca exaustiva em memória. Com volume, serve qualquer armazenamento com índice vetorial, filtro de metadados e expiração por entrada, inclusive extensões de bancos relacionais.
Como evito servir resposta desatualizada?
Com os três gatilhos juntos: TTL por rota, versão na chave de escopo e invalidação por documento de origem no mesmo evento da reindexação.
Conclusão: comece pelo log, não pelo banco vetorial
Faça hoje uma coisa só: extraia as perguntas das últimas semanas de uma rota elegível, gere os embeddings e conte quantas têm um vizinho acima de alguns limiares candidatos. Em uma tarde você sabe se existe repetição suficiente. Se existir, rotule os pares, calibre o limiar pela precisão, monte a chave de escopo e rode uma semana em modo sombra. Só depois disso sirva a primeira resposta do cache, com o interruptor ao alcance da mão.
Referências
- Banco de dados em memória com busca vetorial e expiração por chave
- Extensão de busca vetorial para PostgreSQL
- Biblioteca de busca por similaridade em vetores densos
- Biblioteca de embeddings de sentenças e cross-encoders
- Biblioteca de computação numérica em Python
- Padrão aberto de rastreamento e métricas
- Sistema de monitoramento e alertas por séries temporais