Guia de qualidade de recuperação de busca vetorial

Este guia fornece uma abordagem sistemática para melhorar a qualidade de recuperação para aplicativos de RAG, pesquisa e correspondência em tempo real usando a Pesquisa Vetorial de IA do Mosaico. As recomendações são ordenadas do maior impacto/menor esforço para o menor impacto/maior esforço.

Pré-requisitos: estabelecer estrutura de avaliação

Antes de otimizar a qualidade da recuperação, você deve ter um sistema de avaliação reproduzível.

Definir requisitos de latência

Estabeleça destinos claros de latência com base em seu caso de uso:

• Agentes RAG: meta de TTFT (tempo para o Primeiro Token) (por exemplo, <2 segundos)
• Barras de pesquisa: latência de ponta a ponta para exibir resultados (por exemplo, <100 ms)

Qualquer otimização que você tentar deve atender a esses requisitos.

Configurar a avaliação automatizada

Use uma ou mais das seguintes abordagens:

• Conjunto de dados dourado existente: use os pares de consulta-resposta rotulados.
• Conjunto de avaliação sintética: use a geração de dados sintéticos do Databricks para gerar automaticamente casos de teste de seus documentos.
• Avaliação sem verdade de base: use os juízes do Databricks Agent Evaluation para avaliar a qualidade sem rótulos.

A chave é ter uma maneira automatizada de medir as alterações – dados perfeitos não são necessários. Concentre-se em melhorias relativas à medida que você testa diferentes estratégias, não pontuações absolutas. Até mesmo um pequeno conjunto de dados sintético pode informar se o reclassificador melhora a qualidade em 15% ou se a pesquisa híbrida ajuda seu caso de uso específico.

Escolher métricas de qualidade

Escolha as métricas de qualidade com base no caso de uso:

Se o recall for o mais importante (precisa de todas as informações relevantes):

• Agentes RAG: o contexto chave ausente leva a respostas incorretas ou alucinações.
• Correspondência de ensaios clínicos farmacêuticos: Não é possível perder pacientes qualificados ou estudos relevantes.
• Pesquisa de conformidade financeira: precisa de todos os regulamentos relevantes, fatores de risco ou precedentes.
• Análise de causa raiz de manufatura: deve revelar todos os incidentes relacionados e padrões de falha.
• Métrica a ser rastreada: Recall@k (por exemplo, recall@10, recall@50).

Se a precisão for mais importante (precisa apenas dos resultados mais relevantes):

• Resolução de entidade/correspondência difusa: Correspondência de registros de clientes, nomes de fornecedores ou SKUs de produtos entre sistemas.
• Eliminação de duplicação de serviços financeiros: identificando transações duplicadas ou contas com alta confiança.
• Correspondência de partes da cadeia de suprimentos: localizando componentes exatos ou compatíveis entre catálogos.
• Base de dados de conhecimento de suporte técnico: os engenheiros precisam da solução exata nos principais resultados.
• Métrica a ser rastreada: Precision@k (por exemplo, precision@3, precision@10).

Casos de uso equilibrados (precisam de um bom recall [capacidade de recuperação] e precisão):

• M&A due diligence: não pode perder riscos (recall), mas precisa de documentos relevantes primeiro (precisão).
• Pesquisa de arte anterior de patentes: cobertura abrangente com as patentes mais relevantes prioritárias.
• Conciliação do Cliente 360: Unificando os dados do cliente em vários sistemas.

Etapa 1: habilitar a pesquisa híbrida

Combine a precisão da palavra-chave com a compreensão semântica.

Quando usar:

• Os usuários pesquisam com termos específicos (códigos do produto, termos técnicos).
• Precisa de correspondência exata para determinadas consultas.
• Deseja uma opção de retorno quando a pesquisa semântica perder correspondências de palavra-chave óbvias.

Impacto nas métricas:

• Melhora o recall capturando correspondências semânticas e de palavra-chave.
• Melhora a precisão de consultas com termos específicos.

Implementação: mudança de uma linha na Pesquisa Vetorial de IA da Mosaic.

# Enable hybrid search
results = index.similarity_search(
    query_text="error code E404",
    query_type="HYBRID"  # Combines vector and keyword search
)

Para obter mais informações, consulte Consultar um índice de pesquisa de vetor.

Etapa 2: Implementar a filtragem de metadados

Essa é a sua maior alavanca para a qualidade de recuperação.

A filtragem reduz drasticamente o espaço de pesquisa e melhora a precisão e o recall.

Impacto nas métricas:

• Melhora drasticamente a precisão eliminando resultados irrelevantes.
• Melhora o recall dentro do subconjunto filtrado.
• Pode reduzir o espaço de pesquisa em 90%+.

Exemplos

• Documentação técnica: filtrar por versão do produto, componente ou módulo.
• Manuais de carro: Filtrar por marca, modelo, ano.
• Suporte ao cliente: Filtrar por linha do produto, região, categoria de problema.

Implementation

# Vector Search with metadata filtering
results = index.similarity_search(
    query_text="brake system maintenance",
    filters='make = "Toyota" AND model = "Camry" AND year = 2023',
    num_results=10
)

Seleção de filtro dinâmico

Abordagem programática:

# Parse query for filter criteria
def extract_filters(user_query):
    filter_parts = []
    if "Toyota" in user_query:
        filter_parts.append('make = "Toyota"')
    if "2023" in user_query:
        filter_parts.append('year = 2023')
    return " AND ".join(filter_parts) if filter_parts else None

Filtragem baseada em agente com o Databricks:

from databricks_ai_bridge.agents.tools.vector_search import VectorSearchTool

# Create the vector search tool
vector_search_tool = VectorSearchTool(
    index_name="catalog.schema.car_manuals_index",
    # Optional: specify columns to return
    columns=["content", "make", "model", "year", "chunk_id"],
    # Optional: set number of results
    num_results=10,
    # Optional: add additional parameters as needed
    additional_parameters={
        "query_type": "HYBRID"  # Enable hybrid search
    }
)

# The tool automatically handles filter generation based on the agent's understanding
# Agent analyzes "brake issues in my 2023 Toyota Camry" and generates appropriate filters

# For LangChain agents:
from langchain.agents import create_react_agent

agent = create_react_agent(
    tools=[vector_search_tool],
    llm=your_llm,
    prompt=your_prompt
)

O agente automaticamente:

1. Extrai entidades relevantes da consulta.
2. Gera cadeias de caracteres de filtro semelhantes a SQL apropriadas.
3. Executa a pesquisa com compreensão semântica e filtragem precisa.

Impacto: pode reduzir o espaço de pesquisa em 90%+ ao mesmo tempo em que melhora a relevância.

Etapa 3: Adicionar reordenamento

Alteração de uma linha para ~15% de aumento na qualidade.

O Databricks fornece um reclassificador interno perfeito para agentes RAG.

Impacto nas métricas:

• Aumenta a precisão ao alcançar uma alta taxa de recuperação com menos candidatos.
• Funciona melhor quando combinado com técnicas como pesquisa híbrida e filtragem.

Implementation

# Python SDK
results = index.similarity_search(
    query_text="How to create a Vector Search index",
    num_results=10,
    columns=["id", "text", "parent_doc_summary"],
    reranker={
        "model": "databricks_reranker",
        "parameters": {
            "columns_to_rerank": ["text", "parent_doc_summary"]
        }
    }
)

Para obter mais informações, consulte os resultados da consulta Rerank.

Quando usar

Perfeito para:

• Agentes RAG (a latência é dominada pela geração de LLM).
• Aplicativos com foco na qualidade.
• QPS de baixo a moderado (~5 QPS nas configurações padrão).

O reclassificador integrado não é adequado para:

• Aplicações com alta QPS (>5 QPS sem escalonamento adicional).
• Barras de pesquisa em tempo real que exigem latência de 100 ms.
• Aplicações onde o tempo de reordenação de 1,5s é inaceitável.

Desempenho: Reclassifica 50 resultados em ~1,5 segundos em cargas de trabalho típicas. Tão rápido quanto ~250 msec para partes mais curtas.

Para casos de uso de baixa latência e não RAG

Reranqueamento ainda pode proporcionar melhorias significativas de qualidade para barras de pesquisa e aplicativos com alta quantidade de QPS – você só precisa de um sistema de reranqueamento mais rápido. Considere implantar um modelo de reclassificador leve (por exemplo, cross-encoder/ms-marco-TinyBERT-L-2-v2) como um modelo personalizado no Databricks Model Serving para o reclassificador de msec sub-100.

Etapa 4: Melhorar a preparação de dados

Esta seção descreve algumas técnicas que você pode usar para melhorar a preparação de dados: agrupamento, análise, adição de contexto semântico e limpeza de dados.

Estratégia de agrupamento

A otimização do tamanho dos blocos permanece sendo um campo de pesquisa ativo. O trabalho recente do DeepMind (LIMIT) mostra que as inserções podem falhar ao capturar informações básicas em contextos longos, tornando essa uma decisão matizada.

Pontos de partida para experimentação:

# Common configurations to test
small_chunks = 256   # Better for precise fact retrieval
medium_chunks = 512  # Balanced approach
large_chunks = 1024  # More context per chunk

Principais compensações a serem consideradas:

• Partes menores: melhor localização de informações específicas, mas pode perder o contexto.
• Partes maiores: mais contexto preservado, mas mais difícil de identificar informações relevantes.
• Limites de contexto: Deve caber dentro da janela de contexto LLM ao recuperar múltiplos fragmentos.

Otimizações mais impactantes: em vez de otimizar demais o tamanho da parte, concentre-se em:

1. Extração de informações para metadados: extraia entidades, tópicos e categorias para habilitar a filtragem precisa.
2. Análise de alta qualidade: use ai_parse_document para texto limpo e estruturado.
3. Metadados semânticos: adicione resumos de documentos e cabeçalhos de seção a partes.

Considere também as abordagens avançadas a seguir. Essas técnicas exigem mais esforço, mas podem ter um impacto maior:

Agrupamento semântico: agrupar frases por similaridade em vez de tamanho fixo.

• Use inserções para encontrar limites semânticos naturais.
• Mantém as ideias relacionadas juntas.
• Melhor preservação de contexto.
• Consulte o guia final para estratégias de agrupamento para aplicativos RAG.

Agrupamento pai-filho (recuperação de menor para maior):

# Record child and parent chunks in your source table
for parent_chunk in create_chunks(doc, size=2048):  # Large for context
    for child_chunk in create_chunks(parent_chunk, size=512):  # Small for precision
        source_table.append({"text": child_chunk, "parent_text": parent_chunk})

# Search children, return parents
results = index.similarity_search(
    query_text="Is attention all you need?",
    num_results=10,
    columns=["text", "parent_text"]
)

Consulte os documentos sobre o recuperador de documentos principal do LangChain.

Análise de documentos

Para PDFs e documentos complexos, o Databricks recomenda usar ai_parse_document para análise de alta qualidade. A análise ruim (tabelas ausentes, formatação interrompida) afeta diretamente a qualidade da recuperação.

Enriquecer com metadados semânticos

Adicione contexto semântico para melhorar a recuperação.

Por que isso funciona:

• Fornece sinal semântico adicional para inserir modelos.
• Dá aos reclassificadores mais contexto para pontuação.
• Ajuda com consultas que fazem referência a conceitos de nível de documento.

Opção 1: Incluir metadados em partes

# Prepend document summary to each chunk
chunk_with_context = f"""
Document: {doc_title}
Summary: {doc_summary}
Section: {section_name}
{chunk_content}
"""

Opção 2: Armazenar como colunas de metadados separadas

# Store semantic metadata for reranker to use
metadata = {
    "doc_summary": "Technical manual for brake system maintenance",
    "section": "Emergency brake adjustment procedures",
    "keywords": ["brake", "safety", "adjustment"]
}

Limpeza de dados

• Remova clichês (cabeçalhos, rodapés, números de página).
• Preservar a estrutura do documento (títulos, listas, tabelas).
• Mantenha limites semânticos ao agrupar.

Etapa 5: Otimização de consulta

Expansão da consulta

Gere várias variações de consulta para melhorar o recall. Consulte o guia do LangChain.

Impacto: melhora o recall encontrando documentos com terminologia diferente.

# Use LLM to expand query with synonyms and related terms
def expand_query(user_query):
    prompt = f"""Generate 3 variations of this search query including synonyms:
    Query: {user_query}
    Return only the variations, one per line."""

    variations = llm.generate(prompt).split('\n')

    # Search with original + variations
    all_results = []
    for query in [user_query] + variations:
        results = index.similarity_search(query_text=query, num_results=10)
        all_results.extend(results)

    # Deduplicate and return
    return deduplicate_results(all_results)

Exemplo: "manutenção de carros" também pesquisa por "reparo de automóvel", "manutenção de veículo", "manutenção de automóvel"

Para obter mais técnicas, consulte:

• Técnicas avançadas de expansão de consulta
• Implementação de multi-query retriever

Reformulação de consulta

Para consultas complexas, divida ou reformule. Consulte as estratégias de RAG do OpenAI.

• Perguntas de múltiplos passos → Pesquisas sequenciais
• Consultas ambíguas → várias pesquisas específicas
• Ver técnicas de decomposição

Etapa 6: Técnicas avançadas de comando

Otimização de prompt

Use técnicas automáticas de otimização de prompt, como MIPROv2 ou GEPA (disponíveis no DSPy) para melhorar seus prompts usados para preparação de dados, reescrita de consulta ou em qualquer parte do seu sistema de recuperação de informações. O Assistente de Conhecimento e o Supervisor Agent incorporam o GEPA para grandes melhorias de desempenho a baixo custo. Consulte Como criar agentes empresariais de última geração 90x mais baratos com otimização de prompt automatizada.

Para obter mais informações, consulte Evolução de Solicitações Reflexivas com GEPA.

Etapa 7: estratégias de recuperação adaptável

Padrão de Agente React

Compilar agentes que podem orquestrar a recuperação de forma inteligente:

• O agente avalia se a recuperação é necessária.
• Pode reformular consultas com base nos resultados iniciais.
• Combina a recuperação com outras ferramentas (calculadoras, APIs etc.).
• Tente novamente as recuperações que falharam usando consultas modificadas.
• Implementar usando o Databricks Mosaic AI Agent Framework.

Exemplos de recuperação de agente

# Agent decides when to search and what filters to apply
# Based on conversation context and user intent
agent = create_agent(
    tools=[vector_search_tool, calculator, web_search],
    instructions="Retrieve relevant docs only when needed, apply appropriate filters"
)

Etapa 8: ajustar modelos de inserção

Primeiro: diagnosticar se você tem um problema de incorporação

Teste rápido: comparar as inserções GTE vs OpenAI no Databricks.

# Test with both embedding models
# Databricks native: gte-large-en-v1.5
gte_results = gte_index.similarity_search(query)

# OpenAI: text-embedding-3-large (3072 dims)
openai_results = openai_index.similarity_search(query)

# If OpenAI text-embedding-3-large significantly outperforms GTE:
# - Fine-tuning a smaller model could match or exceed OpenAI quality
# - You have an embedding model problem, not a data problem

Interpretação:

• Se text-embedding-3-large tiver um desempenho muito melhor do que gte-large-en, considere o ajuste fino. Você pode obter uma qualidade semelhante com um modelo menor.
• Se text-embedding-3-large executar aproximadamente o mesmo que gte-large-en, o problema não será o modelo de inserção. Concentre-se em outras otimizações.

Quando ajustar