Kvalitetsguide för vektorsökningsresultat

Den här guiden ger en systematisk metod för att förbättra hämtningskvaliteten för rag-, sök- och matchningsprogram i realtid med hjälp av Mosaic AI Vector Search. Rekommendationerna sorteras från högsta effekt/lägsta insats till lägsta effekt/högsta ansträngning.

Förutsättningar: Upprätta utvärderingsramverk

Innan du optimerar hämtningskvaliteten måste du ha ett reproducerbart utvärderingssystem.

Definiera svarstidskrav

Upprätta tydliga svarstidsmål baserat på ditt användningsfall:

• RAG-agenter: TTFT-mål (Time to First Token) (t.ex. <2 sek)
• Sökrutor: Helhetstidslatens för att visa resultat (till exempel <100 ms)

Alla optimeringar som du försöker måste uppfylla dessa krav.

Konfigurera automatisk utvärdering

Använd en eller flera av följande metoder:

• Befintlig gyllene datauppsättning: Använd dina märkta frågesvarspar.
• Syntetisk utvärderingsuppsättning: Använd databricks syntetisk datagenerering för att generera testfall automatiskt från dina dokument.
• Utvärdering utan referensdata: Använd utvärderingsdomare för Databricks Agent Evaluation för att bedöma kvalitet utan etiketter.

Nyckeln är att ha ett automatiserat sätt att mäta ändringar – perfekta data krävs inte. Fokusera på relativa förbättringar när du testar olika strategier, inte absoluta poäng. Även en liten syntetisk datamängd kan tala om för dig om omrankning förbättrar kvaliteten med 15% eller om hybridsökning hjälper ditt specifika användningsfall.

Välj kvalitetsmått

Välj dina kvalitetsmått baserat på ditt användningsfall:

Om återkallande är viktigast (behöver all relevant information):

• RAG-agenter: Saknade nyckelkontexter leder till felaktiga svar eller hallucinationer.
• Matchning för kliniska prövningar inom läkemedel: Får inte missa berättigade patienter eller relevanta studier.
• Sökning efter finansiell efterlevnad: Behöver alla relevanta regler, riskfaktorer eller prejudikat.
• Rotorsaksanalys för tillverkning: Måste visa alla relaterade incidenter och felmönster.
• Mått att spåra: Recall@k (till exempel recall@10, recall@50).

Om precision är viktigast (behöver bara de mest relevanta resultaten):

• Entitetsupplösning/fuzzy matchning: Matchning av kundposter, leverantörsnamn eller produkt-SKU:er över system.
• Deduplicering av finansiella tjänster: Identifiera duplicerade transaktioner eller konton med hög konfidens.
• Matchning av leveranskedjedelar: Hitta exakta eller kompatibla komponenter i kataloger.
• Kunskapsbas för teknisk support: Ingenjörer behöver exakta lösningar i toppresultaten.
• Mått att spåra: Precision@k (till exempel precision@3, precision@10).

Balanserade användningsfall (behöver både god träffsäkerhet och precision):

• M&A due diligence: Det går inte att missa risker (återkalla) men behöver relevanta dokument först (precision).
• Sökning efter tidigare patent: Omfattande täckning med de mest relevanta patenten prioriterade.
• Kund 360-matchning: Förena kunddata i flera system.

Steg 1: Aktivera hybridsökning

Kombinera nyckelordsprecision med semantisk förståelse.

När du ska använda:

• Användare söker med specifika termer (produktkoder, tekniska termer).
• Behöver exakt matchning för vissa frågor.
• Vill ha reserv när semantisk sökning missar uppenbara nyckelordsmatchningar.

Påverkan på mått:

• Förbättrar återkallandet genom att fånga både semantiska matchningar och nyckelordsmatchningar.
• Förbättrar precisionen för frågor med specifika termer.

Implementering: Enradsändring i Mosaic AI Vector Search.

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

Mer information finns i Fråga efter ett vektorsökningsindex.

Steg 2: Implementera metadatafiltrering

Detta är din största påverkansfaktor för kvaliteten på dataåterhämtning.

Filtrering minskar sökutrymmet avsevärt och förbättrar både precision och återkallande.

Påverkan på mått:

• Förbättrar precisionen avsevärt genom att eliminera irrelevanta resultat.
• Förbättrar återkallandet i den filtrerade delmängden.
• Kan minska sökutrymmet med 90%+.

Examples

• Teknisk dokumentation: Filtrera efter produktversion, komponent eller modul.
• Bilhandböcker: Filtrera efter märke, modell, år.
• Kundsupport: Filtrera efter produktlinje, region, ärendekategori.

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
)

Val av dynamiskt filter

Programmatisk metod:

# 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

Agentbaserad filtrering med 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
)

Agenten utför automatiskt följande:

1. Extraherar relevanta entiteter från frågan.
2. Genererar lämpliga SQL-liknande filtersträngar.
3. Kör sökningen med både semantisk förståelse och exakt filtrering.

Effekt: Kan minska sökutrymmet med 90%+ samtidigt som relevansen förbättras.

Steg 3: Lägg till omrankning

Enradsändring för ~15% kvalitetsförbättring.

Databricks tillhandahåller en inbyggd reranker som är perfekt för RAG-agenter.

Påverkan på mått:

• Ökar precisionen genom att uppnå hög träffsäkerhet med färre kandidater.
• Fungerar bäst i kombination med tekniker som hybridsökning och filtrering.

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

Mer information finns i Ändra rangordning av frågeresultat.

När man ska använda

Perfekt för:

• RAG-agenter (latensen domineras av LLM-generering).
• Kvalitetsinriktade program.
• Låg till måttlig QPS (~5 QPS utan anpassning).

Inbyggd reranker är inte lämplig för:

• Höga QPS-program (>5 QPS utan ytterligare skalning).
• Realtidssökstaplar som kräver <100 ms svarstid.
• Applikationer där 1,5 sekunders omrankningstid är oacceptabel.

Prestanda: Rankar om 50 resultat på ~1,5 sekunder under typiska arbetsbelastningar. Så snabbt som ~250 msec för kortare segment.

För fall med låg svarstid/icke-RAG-användning

Omrankning kan fortfarande ge betydande kvalitetsförbättringar för sökstaplar och program med hög QPS- du behöver bara en snabbare omrankning. Överväg att distribuera en enkel omrankningsmodell (till exempel cross-encoder/ms-marco-TinyBERT-L-2-v2) som en anpassad modell på Databricks Model Serving för omrankning på under 100 msec.

Steg 4: Förbättra förberedelse av data

I det här avsnittet beskrivs några tekniker som du kan använda för att förbättra förberedelsen av data: segmentering, parsning, tillägg av semantisk kontext och rensning av data.

Segmenteringsstrategi

Segmentstorleksoptimering är fortfarande ett aktivt forskningsområde. Det senaste arbetet från DeepMind (LIMIT) visar att inbäddningar kan misslyckas med att samla in grundläggande information i långa kontexter, vilket gör detta till ett nyanserat beslut.

Startpunkter för experimentering:

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

Viktiga kompromisser att tänka på:

• Mindre segment: Bättre lokalisering av specifik information, men kan förlora kontext.
• Större segment: Mer kontext bevarad, men svårare att hitta relevant information.
• Kontextgränser: Måste passa in i LLM-kontextfönstret när flera segment hämtas.

Mer effektfulla optimeringar: I stället för att överoptimera segmentstorleken fokuserar du på:

1. Informationsextrahering för metadata: Extrahera entiteter, ämnen och kategorier för att möjliggöra exakt filtrering.
2. Högkvalitativ parsning: Använd ai_parse_document för ren, strukturerad text.
3. Semantiska metadata: Lägg till dokumentsammanfattningar och avsnittsrubriker i segment.

Tänk också på följande avancerade metoder. Dessa tekniker kräver mer arbete men kan ha större inverkan:

Semantisk segmentering: Gruppera meningar efter likhet snarare än fast storlek.

• Använd inbäddningar för att hitta naturliga semantiska gränser.
• Håller ihop relaterade idéer.
• Bättre kontextbevarande.
• Se Den ultimata guiden till segmenteringsstrategier för RAG-program.

Förälder-barn segmentering (liten till stor återkallning):

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

Mer information finns i dokumentationen för LangChains överordnade dokumenthämtare.

Dokumentparsning

För PDF-filer och komplexa dokument rekommenderar Databricks att du använder ai_parse_document för högkvalitativ parsning. Dålig parsning (saknade tabeller, bruten formatering) påverkar direkt hämtningskvaliteten.

Berika med semantiska metadata

Lägg till semantisk kontext för att förbättra hämtningen.

Varför detta fungerar:

• Ger ytterligare semantisk signal för inbäddningsmodeller.
• Ger rerankers mer kontext för poängsättning.
• Hjälper till med frågor som refererar till begrepp på dokumentnivå.

Alternativ 1: Inkludera metadata i segment

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

Alternativ 2: Lagra som separata metadatakolumner

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

Datarensning

• Ta bort standardtext (sidhuvuden, sidfötter, sidnummer).
• Bevara dokumentstrukturen (rubriker, listor, tabeller).
• Underhåll semantiska gränser vid segmentering.

Steg 5: Frågeoptimering

Söksfrågeutvidgning

Generera flera frågevariationer för att förbättra återkallandet. Se LangChain guide.

Effekt: Förbättrar återkallandet genom att hitta dokument med olika terminologi.

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

Exempel: "bilunderhåll" söker också efter "bilreparation", "fordonsservice", "automatiskt underhåll"

Fler tekniker finns i:

• Avancerade tekniker för frågeexpansion
• Implementering av multi-query retriever

Omformulering av fråga

För komplexa frågor kan du dela upp eller omformulera. Se OpenAI RAG-strategier.

• Frågor om flera hopp → sekventiella sökningar
• Tvetydiga frågor → flera specifika sökningar
• Se Dekompositionstekniker

Steg 6: Avancerade tekniker för frågor

Optimering av fråga

Använd automatiska tekniker för optimering av frågor som MIPROv2 eller GEPA (finns i DSPy) för att förbättra dina frågor som används för förberedelse av data, frågeskrivning eller var som helst i hämtningssystemet. Knowledge Assistant och Supervisor Agent innehåller GEPA för stora prestandaförbättringar till låg kostnad. Se Skapa toppmoderna företagsagenter 90x billigare med automatiserad snabboptimering.

Mer information finns i Reflective Prompt Evolution med GEPA.

Steg 7: Strategier för anpassningsbar hämtning

React-agentmönster

Skapa agenter som kan samordna hämtningen på ett intelligent sätt:

• Agent bedömer huruvida återhämtning behövs.
• Kan omformulera frågor baserat på inledande resultat.
• Kombinerar hämtning med andra verktyg (kalkylatorer, API:er osv.).
• Försök att hämta misslyckade förfrågningar på nytt med ändrade sökfrågor.
• Implementera med Databricks Mosaic AI Agent Framework.

Exempel på agentförmedlad hämtning

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

Steg 8: Finjustera inbäddningsmodeller

Först: Diagnostisera om du har ett inbäddningsproblem

Snabbtest: Jämför GTE- och OpenAI-inbäddningar på 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

Tolkning:

• Om text-embedding-3-large presterar mycket bättre än gte-large-enkan du överväga finjustering. Du kan uppnå liknande kvalitet med mindre modell.
• Om text-embedding-3-large fungerar ungefär samma som gte-large-enär problemet inte inbäddningsmodellen. Fokusera på andra optimeringar.

När du ska finjustera