Guia de qualidade de recuperação de pesquisa de AI

Para melhorar a qualidade de recuperação da Pesquisa de AI, siga estas técnicas em ordem, do maior impacto e menor esforço ao menor impacto e maior esforço. Essas técnicas são úteis para RAG em tempo real, busca e aplicativos de correspondência.

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

Antes de otimizar a qualidade de recuperação, é preciso ter um sistema de avaliação reprodutível.

importante

Caso não haja avaliação configurada, o procedimento deve ser interrompido aqui e a configuração realizada primeiramente. A otimização sem medição é pura especulação.

Definir requisitos de latência

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

• Agentes RAG : Meta de Tempo até o Primeiro Token (TTFT) (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 estes requisitos.

Configurar avaliação automatizada

Use uma ou mais das seguintes abordagens:

• Existing golden dataset : Use seus pares de pergunta-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 de seus documentos.
• Avaliação livre de Ground-truth : use os juízes da Databricks Agent Evaluation para avaliar a qualidade sem rótulos.

O principal é ter uma forma automatizada para medir as alterações, e dados perfeitos não são necessários. Deve-se focar nas **melhorias relativas** ao testar diferentes estratégias, e não nos resultados absolutos. Mesmo um pequeno dataset sintético pode indicar se a reranking melhora a qualidade em 15% ou se a busca híbrida auxilia o seu caso de uso específico.

Selecionar métricas de qualidade

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

Se a recuperação for o mais importante (é necessário ter toda a informação relevante):

• Agentes RAG: A falta de contexto principal leva a respostas incorretas ou alucinações.
• Farma: Correspondência de Ensaio Clínico : Não é possível perder pacientes elegíveis ou estudos relevantes.
• Busca de compliance financeiro: Necessita de todas as regulamentações relevantes, fatores de risco ou precedentes.
• Análise de causa raiz industrial : deve revelar todos os incidentes relacionados e padrões de falha.
• Métrica a ser acompanhada: Recuperação@k (por exemplo, Recuperação@10, Recuperação@50).

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

• Resolução de entidades/correspondência aproximada: Correspondência de registros de clientes, nomes de fornecedores ou SKUs de produtos entre sistemas.
• Deduplicação de serviço Financeiros : Identificação de transações ou account duplicadas com alta confiança.
• Correspondência de peças na cadeia de suprimentos : localização de componentes exatos ou compatíveis entre catálogos.
• Base de conhecimento de suporte técnico : Engenheiros precisam da solução exata nos resultados principais.
• Métrica a ser acompanhada : Precisão@k (por exemplo, Precisão@3, Precisão@10).

Casos de uso equilibrados (que exigem tanto boa revocação quanto boa precisão):

• M&A due diligence : Os riscos não podem ser ignorados (identificação), mas são necessários documentos relevantes primeiro (precisão).
• Pesquisa de anterioridade de patentes : Cobertura abrangente com as patentes mais relevantes priorizadas.
• Correspondência de Cliente 360 : Unificação dos dados do cliente em diversos sistemas.

Etapa 1: habilitar pesquisa híbrida

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

Quando usar :

• Os usuários pesquisam com termos específicos (códigos de produto, termos técnicos).
• Requer correspondência exata para certas consultas.
• É desejável um fallback quando a busca semântica falha em encontrar correspondências óbvias de palavras-chave.

Impacto em métricas :

• Melhora a **recuperação** ao abranger correspondências semânticas e por palavra-chave.
• Melhora a precisão de queries com termos específicos.

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

Python

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

o passo 2: Implementar filtragem de metadados

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

A filtragem reduz drasticamente o espaço de busca e melhora tanto a precisão quanto a revocação.

Impacto em métricas :

• Melhora drasticamente a Precisão ao eliminar resultados irrelevantes.
• Melhora a **revocação** no subconjunto filtrado.
• Pode reduzir o espaço de pesquisa em mais de 90%.

Exemplos

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

Implementação

Python

# AI 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 filtro

Abordagem programática:

Python

# 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 agentes com Databricks :

Python

from databricks_ai_bridge.agents.tools.vector_search import VectorSearchTool

# Create the AI 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 strings de filtro apropriadas semelhantes a SQL.
3. Executa a busca com compreensão semântica e filtragem precisa.

Impacto : pode reduzir o espaço de busca em mais de 90% e melhorar a relevância.

Passo 3: adicionar reclassificação

Mudança de uma linha para aproximadamente 15% de melhoria da qualidade.

Databricks fornece um reranker integrado perfeito para agentes RAG.

Impacto em métricas :

• Aumenta a precisão ao atingir alta revocação com menos candidatos.
• Funciona melhor quando combinado com técnicas como pesquisa híbrida e filtragem.

Implementação

Python

# Python SDK
results = index.similarity_search(
    query_text="How to create an AI 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 resultados da consulta.

Quando usar

Perfeito para :

• Agentes RAG (a latência é dominada pela geração de LLM).
• Aplicativos de primeira qualidade.
• QPS de baixo a moderado (aproximadamente 5 QPS pronto para uso).

Reclassificador integrado não adequado para :

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

Desempenho : Reordena 50 resultados em cerca de 1,5 segundos em cargas de trabalho típicas. Tão rápido quanto ~250 ms para blocos mais curtos.

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

A reclassificação ainda pode proporcionar melhorias significativas na qualidade para barras de pesquisa e aplicações de alto QPS — basta um reorganizador 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 em menos de 100 ms.

Etapa 4: Melhorar a preparação de dados

Esta seção descreve algumas técnicas que podem ser utilizadas para aprimorar 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 fragmento continua sendo uma área ativa de pesquisa. Trabalhos recentes da DeepMind (LIMIT) mostram que embeddings não conseguem capturar informações básicas em contextos longos, tornando-a uma decisão com nuances.

Pontos de partida para experimentação :

Python

# 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 trade-offs a considerar:

• Partes menores: Melhor localização de informações específicas, mas pode perder o contexto.
• Maiores fragmentos : Mais contexto preservado, mas mais difícil de identificar informação relevante.
• Limites de contexto : deve caber na janela de contexto do LLM ao recuperar várias partes.

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

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

Também considere as seguintes abordagens avançadas. Estas técnicas requerem mais esforço, mas podem ter um impacto maior:

Segmentação Semântica : agrupe as frases por similaridade, em vez de por 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 de Estratégias de Fragmentação para Aplicativos RAG.

Fragmentação pai-filho (recuperação do menor para o maior):

Python

# 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 "Recuperador de Documentos Pai da LangChain".

Análise de documentos

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

Enriquecer com metadados semânticos

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

Por que isto funciona :

• Fornece sinal semântico adicional para modelos de incorporação.
• Proporciona aos reorganizadores mais contexto para pontuação.
• Auxilia em consultas que fazem referência a conceitos em nível de documento.

Opção 1: Incluir metadados em fragmentos

Python

# 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

Python

# 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"]
}

importante

Esta abordagem requer processamento downstream para utilizar os metadados:

• Para metadados semânticos: Use reclassificação com o parâmetro columns_to_rerank para considerar essas colunas.
• Para metadados somente de palavras-chave: use a pesquisa híbrida (modo de texto completo) para corresponder a esses campos.

Limpeza de dados

• Remover boilerplate (cabeçalhos, rodapés, números de página).
• Preserve a estrutura do documento (cabeçalhos, listas, tabelas).
• Manter os limites semânticos durante a segmentação.

Etapa 5: Otimização de query

Expansão de consulta

Gerar múltiplas variações de consulta para melhorar a recuperação. Consulte o guia do LangChain.

Impacto : Melhora a recuperação ao encontrar documentos com terminologia diferente.

Python

# 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 "reparo de automóveis", "serviço de veículos", "manutenção automática"

Para mais técnicas, consulte:

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

Reformulação de consulta

Para queries complexas, divida ou reformule. Consulte Estratégias RAG da OpenAI.

• Perguntas “multi-hop” → Buscas sequenciais
• Consultas ambíguas → Múltiplas pesquisas específicas
• Veja Técnicas de decomposição

Passo 6: técnicas avançadas de prompt

Otimização de prompt

Use técnicas automáticas de otimização de prompt como MIPROv2 ou GEPA (disponíveis em DSPy) para melhorar seus prompts usados para preparação de dados, reescrita de consulta ou em qualquer lugar em seu sistema de recuperação. Acesse Construção de agentes empresariais de ponta 90 vezes mais baratos com otimização automática de prompt.

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

Passo 7: estratégias de recuperação adaptáveis

Padrão de agente do React

Crie agentes que possam orquestrar a recuperação de forma inteligente:

• O agente raciocina sobre a necessidade de recuperação.
• É possível reformular consultas com base nos resultados iniciais.
• Combina recuperação com outras ferramentas (calculadoras, APIs, etc.).
• Reexecutar recuperações com falha com queries modificadas.
• Implementar usando Agentes personalizados.

Exemplos de recuperação de agentes

Python

# 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"
)

O passo 8: Ajuste modelos de incorporação

Primeiro: diagnostique se há um problema de incorporação.

Teste rápido : compare incorporações GTE vs OpenAI no Databricks.

Python

# 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 alcançar qualidade similar com um modelo menor.
• Se text-embedding-3-large tiver um desempenho aproximadamente igual ao de gte-large-en, o seu problema não é o modelo de incorporação. Foque em outras otimizações.

Quando fazer ajustes finos

importante

O ajuste fino deve ser considerado um último recurso e só deve ser considerado quando os seguintes critérios forem atendidos:

1. Você já tentou os passos 1–7.
2. A OpenAI supera significativamente o GTE em seus testes.
3. Você possui vocabulário específico do domínio ou caso de uso.

nota

Você não precisa de dados de treinamento rotulados, você pode usar a geração de dados sintéticos como mostrado no blog de ajuste fino de embeddings do Databricks.