Guia de qualidade de recuperação de pesquisa vetorial

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

Pré-requisitos: Estabelecer quadro de avaliação

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

Definir requisitos de latência

Estabeleça metas de latência claras com base no seu caso de uso:

• Agentes RAG: Tempo até o primeiro destino de token (TTFT) (por exemplo, <2 seg)
• Barras de pesquisa: latência de ponta a ponta para exibir resultados (por exemplo, <100 mseg)

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

Configurar avaliação automatizada

Use uma ou mais das seguintes abordagens:

• Conjunto de dados dourado existente: use seus pares 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 a partir dos seus documentos.
• Avaliação sem verdade de base: use os avaliadores do Databricks Agent Evaluation para avaliar a qualidade sem rótulos.

A chave é ter alguma maneira automatizada de medir as mudanças - dados perfeitos não são necessários. Concentre-se em melhorias relativas ao testar diferentes estratégias, não em pontuações absolutas. Mesmo um pequeno conjunto de dados sintéticos pode dizer se a reclassificação melhora a qualidade em 15% ou se a pesquisa híbrida ajuda o seu caso de uso específico.

Escolha métricas de qualidade

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

Se a recolha for mais importante (necessita de todas as informações relevantes):

• Agentes RAG: A falta de contexto-chave leva a respostas incorretas ou alucinações.
• Correspondência de ensaios clínicos farmacêuticos: Não deve perder pacientes elegíveis ou estudos relevantes.
• Pesquisa de conformidade financeira: precisa de todos os regulamentos, fatores de risco ou precedentes relevantes.
• Análise de causa raiz de fabricação: 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 (necessita apenas dos resultados mais relevantes):

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

Casos de uso equilibrados (precisam de boa recuperação e precisão):

• Due diligence de M&A: Não se pode dar ao luxo de não identificar os riscos (recall), mas é preciso ter documentos relevantes em primeiro lugar (precisão).
• Pesquisa prévia de patentes: Cobertura abrangente com as patentes mais relevantes priorizadas.
• Customer 360 matching: Unificando os dados do cliente em vários sistemas.

Etapa 1: Habilitar a pesquisa híbrida

Combine precisão de palavras-chave com compreensão semântica.

Quando usar:

• Os utilizadores pesquisam com termos específicos (códigos de produtos, termos técnicos).
• Precisa de correspondência exata para determinadas consultas.
• Deseja ter uma alternativa quando a pesquisa semântica falhar em encontrar correspondências óbvias de palavras-chave.

Impacto nas métricas:

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

Implementação: Alteração de uma linha na Pesquisa Vetorial da Mosaic AI.

# 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 vetorial.

Etapa 2: Implementar a filtragem de metadados

Esta é a sua maior alavanca para a qualidade da recuperação de informação.

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

Impacto nas métricas:

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

Examples

• Documentação técnica: filtre por versão do produto, componente ou módulo.
• Manuais do carro: Filtrar por marca, modelo, ano.
• Suporte ao cliente: Filtrar por linha de 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 dinâmica de filtros

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 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 apropriadas semelhantes ao SQL.
3. Executa a pesquisa com compreensão semântica e filtragem precisa.

Impacto: pode reduzir o espaço de pesquisa em 90%+ enquanto melhora a relevância.

Etapa 3: adicionar reclassificação

Mudança de uma linha para ~15% de melhoria na qualidade.

O Databricks fornece um reclassificador integrado que é perfeito para agentes RAG.

Impacto nas métricas:

• Aumenta a precisão ao alcançar um elevado recall 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 Reclassificar os resultados da consulta.

Quando utilizar

Perfeito para:

• Agentes RAG (a latência é dominada pela geração LLM).
• Aplicações que priorizam a qualidade.
• QPS baixo a moderado (~5 QPS fora da caixa).

Reranker integrado não é adequado para:

• Aplicações QPS elevadas (>5 QPS sem escalonamento adicional).
• Barras de pesquisa em tempo real que requerem latência de 100 ms.
• Aplicações em que o tempo de reclassificaçã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 ms para fragmentos mais curtos.

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

A reclassificação ainda pode fornecer melhorias significativas de qualidade para barras de pesquisa e aplicativos de alto QPS - você só precisa de um reclassificador mais rápido. Considere implantar um modelo de reclassificação leve (por exemplo, cross-encoder/ms-marco-TinyBERT-L-2-v2) como um modelo personalizado no Databricks Model Serving para reclassificação sub-100 mseg.

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: fragmentação, análise, adição de contexto semântico e limpeza de dados.

Estratégia de fragmentação

A otimização do tamanho do bloco continua sendo uma área ativa de pesquisa. Um trabalho recente da DeepMind (LIMIT) mostra que as incorporações podem falhar na captura de informações básicas em contextos longos, tornando esta uma decisão matizada.

Pontos de partida para a 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 trocas a considerar:

• Partes menores: melhor localização de informações específicas, mas podem perder contexto.
• Partes maiores: mais contexto preservado, mas mais difícil de identificar informações relevantes.
• Limites de contexto: Devem caber dentro da janela de contexto do LLM ao recuperar vários blocos.

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

1. Extração de informações para metadados: extraia entidades, tópicos e categorias para permitir uma 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 blocos.

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

Fragmentação semântica: agrupe frases por semelhança em vez de tamanho fixo.

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

Segmentação pai-filho (recuperação do menor para o 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 a documentação do recuperador de documentos pai do LangChain.

Análise de documentos

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

Enriqueça com metadados semânticos

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

Por que isso funciona:

• Fornece sinal semântico adicional para modelos de incorporação.
• Dá aos reclassificadores mais contexto para pontuação.
• Ajuda com consultas que fazem referência a conceitos no nível do 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 o clichê (cabeçalhos, rodapés, números de página).
• Preservar a estrutura do documento (cabeçalhos, listas, tabelas).
• Mantenha os limites semânticos ao dividir.

Etapa 5: Otimização da consulta

Expansão da consulta

Gere várias versões de consulta para melhorar a recuperação. Consulte o guia LangChain.

Impacto: melhora a recuperação ao encontrar 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 automóveis" também pesquisa "reparação de automóveis", "manutenção de veículos", "manutenção de automóveis"

Para mais técnicas, consulte:

• Técnicas avançadas de expansão de consulta
• Implementação de sistema de recuperação de múltiplas consultas

Reformulação da consulta

Para consultas complexas, decomponha ou reformule. Consulte Estratégias OpenAI RAG.

• Perguntas multi-hop → buscas sequenciais
• Consultas ambíguas → Várias pesquisas específicas
• Ver Técnicas de decomposição

Etapa 6: Técnicas avançadas de incitação

Otimização imediata

Use técnicas de otimização automática de prompts como MIPROv2 ou GEPA (disponível em DSPy) para melhorar seus prompts usados para preparação de dados, regravação de consultas ou em qualquer lugar em seu sistema de recuperação. O Assistente de Conhecimento e o Agente Supervisor incorporam GEPA para grandes melhorias de desempenho a baixo custo. Veja Criação de agentes empresariais de ponta 90 vezes mais baratos com otimização automática de prompts.

Para obter mais informações, consulte Reflexive Prompt Evolution with GEPA.

Etapa 7: Estratégias de recuperação adaptativas

Padrão do agente React

Crie agentes que possam 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.).
• Repetir recuperações com falha com consultas modificadas.
• Implemente usando o Databricks Mosaic AI Agent Framework.

Exemplos de recuperação 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: Ajuste os modelos de incorporação

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

Teste rápido: Compare as incorporaçõ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 afinar. Você pode alcançar uma qualidade semelhante com o modelo menor.
• Se text-embedding-3-large tiver aproximadamente o mesmo desempenho que gte-large-en, o seu problema não é o modelo de embeddings. Concentre-se em outras otimizações.

Quando afinar