Creare una query ibrida in Azure AI Search

La ricerca ibrida combina testo (parola chiave) e query vettoriali in una singola richiesta di ricerca. Entrambe le query vengono eseguite in parallelo. I risultati vengono uniti e riordinati in base ai nuovi punteggi di ricerca, usando La fusione di rango reciproco (RRF) per restituire un set di risultati unificato. In molti casi, per test di benchmark, le query ibride con classificazione semantica restituiscono i risultati più rilevanti.

Questo articolo illustra come:

• Configurare una richiesta ibrida di base
• Aggiungere parametri e filtri
• Migliorare la pertinenza usando la classificazione semantica o i pesi vettoriali
• Ottimizzare i comportamenti delle query controllando gli input (maxTextRecallSize)

Al termine di questo articolo, è possibile eseguire query ibride che combinano la ricerca di parole chiave e vettore con la classificazione semantica facoltativa.

Prerequisiti

• Sottoscrizione Azure. Crearne uno gratuitamente.

• Un servizio Azure AI Search. Creare un servizio o find un servizio esistente.

• Indice di ricerca contenente searchable campi vettoriali e non vettoriali. È consigliabile usare la procedura guidata Importa dati per creare rapidamente un indice. In caso contrario, vedere Creare un indice e Aggiungere campi vettoriali a un indice di ricerca.

• Autorizzazioni: per eseguire query su un indice, è necessario eseguire una query nel lettore di dati dell'indice di ricerca . Per creare o aggiornare un indice, è necessario il collaboratore ai dati dell'indice di ricerca. Per altre informazioni, vedere Connettersi usando i ruoli.

• (Facoltativo) Installazione dell'SDK:

  • Python: pip install azure-search-documents
  • C#: dotnet add package Azure.Search.Documents

• (Facoltativo) Se si vuole eseguire la conversione da testo a vettore predefinita di una stringa di query, creare e assegnare un vettore ai campi vettoriali nell'indice di ricerca.

Scegliere un'API, uno strumento e un modello funzionante

• Nel portale di Azure, il Search Explorer (supporta sia la sintassi di ricerca dell'API stabile che quella di anteprima) include una vista JSON che consente di incollare una richiesta ibrida.

• Pacchetti stabili o di anteprima più recenti del Azure SDK (vedere log delle modifiche per il supporto delle funzionalità sdk).

• API REST stabili o una versione recente dell'API di anteprima se si usano funzionalità di anteprima come maxTextRecallSize e countAndFacetMode(preview).

  Per la leggibilità, vengono usati esempi REST per spiegare il funzionamento delle API. È possibile usare un client REST come Visual Studio Code con l'estensione REST per compilare query ibride. È anche possibile usare il Azure SDK. Per altre informazioni, vedere Avvio rapido: Ricerca vettoriale.

Modelli ibridi utilizzabili

Se non si ha familiarità con la ricerca ibrida, selezionare uno schema e affinare a piccoli passi. Non iniziare con richiamo vettoriale massimo, richiamo di testi di grandi dimensioni e rilocalizzazione semantica nella stessa richiesta.

• Ibrido bilanciato (impostazione predefinita): usare questo primo per la maggior parte dei carichi di lavoro. Iniziare con k nell'intervallo da 30 a 50, top nell'intervallo da 10 a 20 e abilitare la classificazione semantica solo quando migliora la pertinenza misurata.

• Recall-first hybrid: Utilizzare questa opzione per le query difficili dove la copertura è l'obiettivo. Aumentare maxTextRecallSize gradualmente e mantenere moderate le impostazioni vettoriali. Si prevede un costo di merge più elevato.

• Ibrido basato sulla precisione: utilizzare per una bassa latenza su larga scala. Mantenere k e top modesti, applicare filtri selettivi ed evitare funzionalità semantiche che non aggiungono valore.

Perché le query sovraccariche vengono limitate

Le query ibride eseguono il recupero di testo e vettore in parallelo e quindi uniscono i risultati con RRF. Se si aumenta il contributo lessicale (ad esempio, modificando il peso ibrido a favore del BM25), si aumenta il numero di candidati di testo che devono essere uniti con candidati vettoriali. Se si combinano queste impostazioni con costose impostazioni vettoriali e reranking semantico, l'utilizzo della CPU e della memoria aumenta rapidamente.

Nelle configurazioni di capacità più piccole, questo lavoro aggiuntivo di merge e rerank può causare:

• Latenza più elevata e picchi p95/p99
• 429 risposte di limitazione della velocità
• Richieste perse o in timeout osservate dal client quando il comportamento di ripetizione dei tentativi non è configurato

Ottimizzazione della sequenza prima dell'espansione del sistema

Ottimizzare le impostazioni di query e vettori prima di aggiungere repliche:

1. Ridurre innanzitutto le impostazioni di ricerca vettoriali costose. Ad esempio, se efSearch e maxConnections vengono impostati in modo aggressivo, ridurli prima del ridimensionamento (ad esempio, ridurre efSearch da circa 800 a 128 a 192 e ridurre maxConnections da 64 a 32).
2. Limitare l'ambito di reranking semantico ai casi che ne traggono vantaggio.
3. Ripetere il test della latenza e i tassi 429 sotto condizioni di carico rappresentative.
4. Ridimensionare le repliche solo se la limitazione persiste dopo l'ottimizzazione.

Usare questa sequenza per migliorare la stabilità prima di controllare i costi prima della scalabilità.

Configurare una query ibrida

Questa sezione illustra la struttura di base di una query ibrida e come configurarne una in L'Esplora delle Ricerche o per l'esecuzione in un client REST.

I risultati vengono restituiti in testo normale, inclusi i vettori nei campi contrassegnati come retrievable. Poiché i vettori numerici non sono utili nei risultati della ricerca, scegliere altri campi nell'indice come proxy per la corrispondenza del vettore. Ad esempio, se un indice ha campi "descriptionVector" e "descriptionText", la query può corrispondere a "descriptionVector", ma il risultato della ricerca può visualizzare "descriptionText". Usare il select parametro per specificare solo campi leggibili dall'utente nei risultati.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "exhaustive": true,
            "k": 10
        },
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "exhaustive": true,
            "k": 10
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Address/City",
    "top": 10
}

import os
from azure.identity import DefaultAzureCredential
from azure.search.documents import SearchClient
from azure.search.documents.models import VectorizedQuery

# Set up the client
endpoint = os.environ["AZURE_SEARCH_ENDPOINT"]
index_name = "hotels-sample"
credential = DefaultAzureCredential()

client = SearchClient(endpoint=endpoint, index_name=index_name, credential=credential)

# Define your vector (typically from an embedding model)
query_vector = [-0.009154141, 0.018708462, ...]  # Your embedding values

# Create the vector query
vector_query = VectorizedQuery(
    vector=query_vector,
    k_nearest_neighbors=10,
    fields="DescriptionVector",
    exhaustive=True
)

# Execute hybrid search
results = client.search(
    search_text="historic hotel walk to restaurants and shopping",
    vector_queries=[vector_query],
    select=["HotelName", "Description", "Address/City"],
    top=10
)

for result in results:
    print(f"{result['HotelName']}: {result['Description']}")

using Azure;
using Azure.Identity;
using Azure.Search.Documents;
using Azure.Search.Documents.Models;

// Set up the client
string endpoint = Environment.GetEnvironmentVariable("AZURE_SEARCH_ENDPOINT");
string indexName = "hotels-sample";

SearchClient client = new SearchClient(
    new Uri(endpoint),
    indexName,
    new DefaultAzureCredential());

// Define your vector (typically from an embedding model)
float[] queryVector = new float[] { -0.009154141f, 0.018708462f, /* ... */ };

// Execute hybrid search
SearchResults<SearchDocument> results = client.Search<SearchDocument>(
    "historic hotel walk to restaurants and shopping",
    new SearchOptions
    {
        VectorSearch = new()
        {
            Queries = {
                new VectorizedQuery(queryVector)
                {
                    KNearestNeighborsCount = 10,
                    Fields = { "DescriptionVector" },
                    Exhaustive = true
                }
            }
        },
        Select = { "HotelName", "Description", "Address/City" },
        Size = 10
    });

await foreach (SearchResult<SearchDocument> result in results.GetResultsAsync())
{
    Console.WriteLine($"{result.Document["HotelName"]}: {result.Document["Description"]}");
}

Impostare maxTextRecallSize e countAndFacetMode

È possibile ottimizzare una query ibrida per controllare la quantità di ogni sottoquery che contribuisce ai risultati combinati. L'impostazione maxTextRecallSize specifica quanti risultati classificati con BM25 sono passati al modello di classificazione ibrida.

Se la richiesta include faccette, usa campi non vettoriali contrassegnati come facetable nell'indice. I campi vettoriali non sono sfaccettabili.

I conteggi dei facet dipendono dal tipo di query:

• In una query di sola testo, i facet conteggiano i documenti che corrispondono alla query di testo.
• In una query esclusivamente vettoriale, i facet conteggiano i documenti k restituiti dalla query vettoriale.
• In una query ibrida, i facet rappresentano sia i risultati vettoriali che i risultati di testo. La componente vettoriale fornisce i k documenti più vicini. La componente testuale fornisce documenti classificati secondo BM25. Il countAndFacetMode parametro determina se i calcoli di conteggio e facet usano tutte le corrispondenze di testo o solo le corrispondenze di testo recuperate per la classificazione.

Se si usa maxTextRecallSize, è anche possibile impostare countAndFacetMode. Questo parametro determina se count e facets includono tutti i documenti che corrispondono alla query di testo o solo i documenti recuperati all'interno della maxTextRecallSize finestra. Il valore predefinito è countAllResults.

Con la modalità predefinita countAllResults, i conteggi e le sfaccettature possono includere documenti del lato testuale che non vengono recuperati per il ranking RRF perché si trovano al di fuori della finestra maxTextRecallSize. L'aumento di maxTextRecallSize incrementa il numero di documenti classificati con BM25 disponibili per l'ordinamento, ma non aumenta il contributo vettoriale oltre k. Usare countRetrievableResults se si desidera che i calcoli di conteggio e facet siano limitati ai documenti recuperati per la classificazione ibrida.

Per impostare queste opzioni, è consigliabile usare l'API REST di anteprima più recente .

1. Usare Search - POST (anteprima) o Search - GET (anteprima) per specificare i parametri di anteprima.

2. Aggiungere un oggetto parametro di query hybridSearch per impostare il numero massimo di documenti richiamati tramite i risultati con classificazione BM25 di una query ibrida. Ha due proprietà:

   • maxTextRecallSize specifica il numero di risultati classificati in BM25 da fornire al classificatore RRF (Reciprocal Rank Fusion) usato nelle query ibride. Il valore predefinito è 1.000. Il valore massimo è 10.000.

   • countAndFacetMode segnala il conteggio e l'ambito del facet per una query ibrida. Il valore predefinito, countAllResults, usa il set di risultati ibrido completo, inclusi tutti i documenti che corrispondono alla query di testo, anche se alcune di queste corrispondenze di testo non vengono recuperate per la classificazione RRF perché non rientrano nella maxTextRecallSize finestra. Usare countRetrievableResults per limitare il conteggio e i facet ai documenti recuperati ai fini del ranking, inclusi i documenti classificati con BM25 maxTextRecallSize e le corrispondenze vettoriali k.

3. Impostare maxTextRecallSize:

   • Diminuire maxTextRecallSize se la ricerca di somiglianza del vettore generalmente offre prestazioni superiori rispetto alla parte testuale della query ibrida.

   • Aumentare maxTextRecallSize se si dispone di un indice di grandi dimensioni e l'impostazione predefinita non acquisisce un numero sufficiente di risultati. Con un set di risultati BM25 con classificazione più grande, è anche possibile impostare top, skipe next per recuperare parti di tali risultati.

Negli esempi REST seguenti vengono illustrati due casi d'uso per la configurazione di maxTextRecallSize.

Il primo esempio riduce maxTextRecallSize a 100, limitando il lato testo della query ibrida a soli 100 documenti. Imposta inoltre countAndFacetMode per includere solo i documenti recuperabili nei calcoli del conteggio e del facet.

POST https://[service-name].search.windows.net/indexes/[index-name]/docs/search?api-version=2026-05-01-preview 

    { 
      "vectorQueries": [ 
        { 
          "kind": "vector", 
          "vector": [1.0, 2.0, 3.0], 
          "fields": "my_vector_field", 
          "k": 10 
        } 
      ], 
      "search": "hello world", 
      "hybridSearch": { 
        "maxTextRecallSize": 100, 
        "countAndFacetMode": "countRetrievableResults" 
      } 
    } 

Il secondo esempio eleva maxTextRecallSize a 5.000. Usa anche top, skip e next per estrarre i risultati da set di risultati di grandi dimensioni. In questo caso, la richiesta esegue il pull dei risultati classificati in BM25 a partire dalla posizione da 1.500 a 2.000 come contributo della query di testo al set di risultati compositi RRF.

POST https://[service-name].search.windows.net/indexes/[index-name]/docs/search?api-version=2026-05-01-preview 

    { 
      "vectorQueries": [ 
        { 
          "kind": "vector", 
          "vector": [1.0, 2.0, 3.0], 
          "fields": "my_vector_field", 
          "k": 10 
        } 
      ], 
      "search": "hello world",
      "top": 500,
      "skip": 1500,
      "next": 500,
      "hybridSearch": { 
        "maxTextRecallSize": 5000, 
        "countAndFacetMode": "countRetrievableResults" 
      } 
    } 

Riferimento: hybridSearch | maxTextRecallSize | countAndFacetMode

Esempi di query ibride

In questa sezione sono disponibili più esempi di query che illustrano i modelli di query ibridi.

Esempio: Ricerca ibrida con filtro

In questo esempio viene aggiunto un filtro, applicato ai filterable campi non vettoriali dell'indice di ricerca.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "k": 10
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "vectorFilterMode": "preFilter",
    "filter": "ParkingIncluded",
    "top": "10"
}

Punti chiave:

• I filtri vengono applicati al contenuto dei campi filtrabili. In questo esempio il campo ParkingIncluded è un valore booleano e viene contrassegnato come filterable nello schema dell'indice.

• Nelle query ibride, i filtri possono essere applicati prima dell'esecuzione della query per ridurre la superficie di query o dopo l'esecuzione della query per ridurre i risultati. "preFilter" è l'impostazione predefinita. Per usare postFilter o strictPostFilter (anteprima), impostare la modalità di elaborazione del filtro come illustrato in questo esempio.

• Quando si esegue il postfiltro dei risultati della query, il numero di risultati potrebbe essere minore di top-n.

Riferimento: filter | vectorFilterMode

Esempio: Ricerca ibrida con filtri destinati alle sottoquery vettoriali (anteprima)

Usando l'API REST di anteprima più recente, è possibile eseguire l'override di un filtro globale sulla richiesta di ricerca applicando un filtro secondario destinato solo alle sottoquery vettoriali in una richiesta ibrida.

Questa funzionalità fornisce un controllo granulare assicurando che i filtri influiscano solo sui risultati della ricerca vettoriale, lasciando invariati i risultati della ricerca basata su parole chiave.

Il filtro di destinazione esegue completamente l'override del filtro globale, inclusi tutti i filtri usati per il filtraggio di sicurezza o la ricerca geospaziale. Nei casi in cui sono necessari filtri globali, ad esempio il taglio della sicurezza, è necessario includere in modo esplicito questi filtri nel filtro di primo livello e in ogni filtro a livello di vettore per garantire che vengano applicati in modo coerente la sicurezza e altri vincoli.

Per applicare filtri vettoriali di destinazione:

• Usare l'API REST latest preview Search Documents o un pacchetto beta Azure SDK che fornisce la funzionalità.

• Modificare una richiesta di query, aggiungendo un nuovo vectorQueries.filterOverride set di parametri a un'espressione di filtro OData.

Ecco un esempio di query ibrida che aggiunge una sostituzione del filtro. Il filtro globale "Rating gt 3" viene sostituito in fase di esecuzione da filterOverride.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-05-01-preview

{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "exhaustive": true,
            "filterOverride": "Address/City eq 'Seattle'",
            "k": 10
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Address/City, Rating",
    "filter": "Rating gt 3",
    "debug": "vector",
    "top": 10
}

Esempio: Ricerca ibrida semantica

Supponendo che la definizione dell'indice includa una configurazione semantica, è possibile formulare una query che include la ricerca vettoriale e la ricerca di parole chiave, con classificazione semantica sul set di risultati unito. Facoltativamente, è possibile aggiungere sottotitoli e risposte.

Ogni volta che si usa la classificazione semantica con vettori, assicurarsi che k sia impostato su 50. Il classificatore semantico usa fino a 50 corrispondenze come input. Specificare meno di 50 priva i modelli di classificazione semantica degli input necessari.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "k": 50
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Tags",
    "queryType": "semantic",
    "semanticConfiguration": "my-semantic-config",
    "captions": "extractive",
    "answers": "extractive",
    "top": "50"
}

Punti chiave:

• Il ranker semantico accetta fino a 50 risultati dalla risposta unita.

• Sono necessari "queryType" e "semanticConfiguration".

• "didascalie" e "risposte" sono facoltative. I valori vengono estratti dal testo integrale nei risultati. Viene restituita una risposta solo se i risultati includono il contenuto con le caratteristiche di una risposta alla query.

Riferimento: queryType | semanticConfiguration | didascalie | risposte

Esempio: Ricerca ibrida semantica con filtro

Ecco l'ultima richiesta nella raccolta. Si tratta della stessa query ibrida semantica dell'esempio precedente, ma con un filtro.

POST https://{{search-service-name}}.search.windows.net/indexes/{{index-name}}/docs/search?api-version=2026-04-01
Content-Type: application/json
api-key: {{admin-api-key}}
{
    "vectorQueries": [
        {
            "vector": [
                -0.009154141,
                0.018708462,
                . . . 
                -0.02178128,
                -0.00086512347
            ],
            "fields": "DescriptionVector",
            "kind": "vector",
            "k": 50
        }
    ],
    "search": "historic hotel walk to restaurants and shopping",
    "select": "HotelName, Description, Tags",
    "queryType": "semantic",
    "semanticConfiguration": "my-semantic-config",
    "captions": "extractive",
    "answers": "extractive",
    "filter": "ParkingIncluded",
    "vectorFilterMode": "preFilter",
    "top": "50"
}

Punti chiave:

• La modalità filtro può influire sul numero di risultati disponibili per il reranker semantico. Come procedura consigliata, è consigliabile assegnare al semantic ranker il numero massimo di documenti (50). Se i prefiltri o i postfiltri sono troppo selettivi, si potrebbe compromettere il ranker semantico fornendo meno di 50 documenti con cui possa operare.

• preFilter viene applicato prima dell'esecuzione della query. Se il prefiltro riduce l'area di ricerca a 100 documenti, la query vettoriale viene eseguita sul DescriptionVector campo per tali 100 documenti, restituendo le corrispondenze k=50 migliori. Questi 50 documenti corrispondenti passano quindi a RRF per i risultati uniti e quindi a semantic ranker.

• postFilter viene applicato dopo l'esecuzione della query. Se k=50 restituisce 50 corrispondenze sul lato della query vettoriale, seguito da un post-filtro applicato alle 50 corrispondenze, i risultati vengono ridotti del numero di documenti che soddisfano i criteri di filtro. Rimangono quindi meno di 50 documenti da passare al ranker semantico. Tenere presente questo aspetto se si usa la classificazione semantica. Il ranker semantico funziona meglio se ha 50 documenti come input.

• strictPostFilter (anteprima) viene applicato ai primi risultati non filtrati k dopo l'esecuzione della query. Restituisce sempre un valore minore o uguale a k documenti. Se k=50 non filtrato restituisce 50 risultati non filtrati e il filtro corrisponde a 30 documenti, nel set di risultati vengono restituiti solo 30 documenti, anche se l'indice contiene più di 30 documenti che corrispondono al filtro. Poiché questa modalità ha la massima riduzione del richiamo, non è consigliabile usarla con il ranker semantico.

Configurare una risposta a una query

Quando configuri la query ibrida, considera la struttura di risposta. Il motore di ricerca classifica i documenti corrispondenti e restituisce i risultati più rilevanti. La risposta è un set di righe appiattito. I parametri della query determinano quali campi si trovano in ogni riga e il numero di righe nella risposta.

Campi in una risposta

I risultati della retrievable ricerca sono costituiti da campi dell'indice di ricerca. Un risultato è o:

• Tutti i retrievable campi (impostazione predefinita dell'API REST).
• Campi elencati in modo esplicito in un select parametro nella query.

Negli esempi di questo articolo è stata usata un'istruzione select per specificare i campi di testo (nonvector) nella risposta.

Numero di risultati

Una query può corrispondere a un numero qualsiasi di documenti, persino a tutti se i criteri di ricerca sono deboli, ad esempio "search=*" per una query null. Poiché raramente è pratico restituire risultati non associati, è consigliabile specificare un valore massimo per la risposta complessiva:

• "top": n risultati per query di sola parola chiave (nessun vettore)
• "k": n risultati per le query solo vettoriali
• "top": n risultati per le query ibride (con o senza semantica) che includono un parametro "search"

Sia k che top sono facoltativi. Non specificato, il numero predefinito di risultati in una risposta è 50. Puoi impostare top e skip per sfogliare più risultati o cambiare il valore predefinito.

Risultati del classificatore semantico

Se stai utilizzando il classificatore semantico in versione di anteprima 2024-05-01-preview o successiva, è consigliabile impostare k e maxTextRecallSize in modo che sommino a un totale di almeno 50. È quindi possibile limitare i risultati restituiti all'utente con il top parametro .

Se si usa il ranker semantico nelle API precedenti, eseguire le operazioni seguenti:

• Per la ricerca solo con parole chiave (nessun vettore), imposta top a 50
• Per la ricerca ibrida, imposta k su 50 per assicurarsi che il ranker semantico ottenga almeno 50 risultati.

Classifica

Vengono creati più set per le query ibride, con o senza il reranking semantico opzionale. La classificazione dei risultati viene calcolata con la Reciprocal Rank Fusion (RRF).

In questa sezione confrontare le risposte tra la ricerca a vettore singolo e la ricerca ibrida semplice per il risultato principale. I diversi algoritmi di classificazione, la metrica di somiglianza di HNSW e RRF in questo caso, producono punteggi con grandezza diversa. Questo comportamento è previsto dalla progettazione. I punteggi RRF possono apparire piuttosto bassi, anche con una corrispondenza di somiglianza elevata. I punteggi inferiori sono una caratteristica dell'algoritmo RRF. In una query ibrida con RRF, più del reciproco dei documenti classificati sono inclusi nei risultati, dato che i documenti classificati RRF hanno un punteggio relativamente più piccolo rispetto alla ricerca vettoriale pura.

Ricerca a vettore singolo: @search.score per i risultati ordinati in base alla somiglianza del coseno (funzione di distanza di somiglianza vettore predefinita).

{
    "@search.score": 0.8399121,
    "HotelId": "49",
    "HotelName": "Swirling Currents Hotel",
    "Description": "Spacious rooms, glamorous suites and residences, rooftop pool, walking access to shopping, dining, entertainment and the city center.",
    "Category": "Luxury",
    "Address": {
    "City": "Arlington"
    }
}

Ricerca ibrida: @search.score per i risultati ibridi classificati con la fusione di rango reciproco.

{
    "@search.score": 0.032786883413791656,
    "HotelId": "49",
    "HotelName": "Swirling Currents Hotel",
    "Description": "Spacious rooms, glamorous suites and residences, rooftop pool, walking access to shopping, dining, entertainment and the city center.",
    "Category": "Luxury",
    "Address": {
    "City": "Arlington"
    }
}

Risolvere i problemi relativi alle query ibride

Usare la tabella seguente per diagnosticare i problemi comuni relativi alle query ibride.

Contenuto correlato

• Panoramica della ricerca ibrida
• Classificazione della ricerca ibrida con RRF
• Procedura di ricerca vettoriale
• Classificazione semantica
• Filtri di ricerca vettoriali
• Esaminare il codice demo vettoriale per Python, C# o JavaScript