Raggruppamento dei risultati di ricerca con StructArray

Utilizzare questa pagina per raggruppare i risultati della ricerca a livello di elemento StructArray in base all'entità padre. La ricerca a livello di elemento può restituire più risultati provenienti dalla stessa entità quando diversi elementi Struct corrispondono alla query. Il raggruppamento comprime tali risultati a livello di elemento in modo che ciascuna entità padre appaia al massimo una volta.

Questa pagina utilizza la raccolta " tech_articles " descritta in "Creazione di un campo StructArray". La raccolta presenta un campo StructArray denominato " chunks". Il sottocampo vettoriale " chunks[emb] " è indicizzato per la ricerca a livello di elemento con una metrica vettoriale regolare.

Gli esempi utilizzano la dimensione predefinita del gruppo pari a uno.

Prima di eseguire questi esempi, creare la raccolta, inserire i dati di esempio, creare gli indici vettoriali richiesti e caricare la raccolta. Utilizzare vettori a 4 dimensioni per i campi qui mostrati. Ogni blocco di codice presuppone la connessione e le variabili degli esempi precedenti nello stesso linguaggio, a meno che non le definisca nuovamente.

Come si applica il raggruppamento a StructArray

Modalità di ricercaComportamento del raggruppamentoComportamento dei risultati
Ricerca EmbeddingListNon supportato.Non applicabile.
Ricerca a livello di elementoSupportata tramite raggruppamento sulla chiave primaria.Restituisce al massimo un risultato per entità padre. I metadati a livello di elemento vengono conservati, pertanto l'indice o l'offset dell'elemento selezionato può essere restituito quando esposto dall'API o dall'SDK.
Ricerca ibridaSupportata solo quando tutte le sotto-ricerche hanno come obiettivo campi vettoriali a livello di elemento all'interno dello stesso campo StructArray.Le sotto-ricerche a livello di elemento vengono raggruppate in base alla chiave primaria prima della gestione del risultato finale.

Utilizzare il raggruppamento quando la ricerca a livello di elemento non raggruppata restituisce troppe entità padre duplicate. Se si desidera che ogni elemento Struct corrispondente venga considerato come un singolo risultato, utilizzare la ricerca vettoriale di base con StructArray senza l'opzione ` group_by_field`.

Prima di iniziare

Preparare la raccolta, i dati e gli indici prima di eseguire la ricerca con raggruppamento.

RequisitiDettagli
Sottocampo vettoriale a livello di elementoUtilizzare un sottocampo vettoriale StructArray, ad esempio chunks[emb], indicizzato con una metrica vettoriale regolare.
Query vettoriale regolareUtilizzare un vettore di query regolare, non un EmbeddingList.
Raggruppamento per chiave primariaUtilizzare la chiave primaria della collezione come group_by_field, ad esempio doc_id.
Nessun parametro di intervalloNon combinare la ricerca per raggruppamento con parametri di ricerca per intervallo come radius o range_filter.

Per la configurazione dell’indice, consultare Campi StructArray dell’indice.

L'esempio seguente effettua prima la ricerca nei singoli chunk, quindi raggruppa i risultati a livello di elemento in base alla chiave primaria dell'entità padre.

from pymilvus import MilvusClient

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus",
)

query_vector = [0.19, 0.24, 0.30, 0.37]

results = client.search(
    collection_name="tech_articles",
    data=[query_vector],
    anns_field="chunks[emb]",
    limit=5,
    group_by_field="doc_id",
    output_fields=[
        "doc_id",
        "title",
        "chunks[text]",
        "chunks[section]",
        "chunks[page]",
        "chunks[quality_score]",
    ],
)

for hits in results:
    for hit in hits:
        print(
            "doc_id:", hit["doc_id"],
            "distance:", hit["distance"],
            "offset:", hit.get("offset"),
            "entity:", hit["entity"],
        )
import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.response.SearchResp;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

MilvusClientV2 client = new MilvusClientV2(ConnectConfig.builder()
        .uri("http://localhost:19530")
        .token("root:Milvus")
        .build());

FloatVec queryVector = new FloatVec(new float[]{0.19f, 0.24f, 0.30f, 0.37f});

SearchResp searchResp = client.search(SearchReq.builder()
        .collectionName("tech_articles")
        .annsField("chunks[emb]")
        .data(Collections.singletonList(queryVector))
        .topK(5)
        .groupByFieldName("doc_id")
        .outputFields(Arrays.asList(
                "doc_id", "title", "chunks[text]", "chunks[section]",
                "chunks[page]", "chunks[quality_score]"))
        .build());

for (List<SearchResp.SearchResult> results : searchResp.getSearchResults()) {
    for (SearchResp.SearchResult result : results) {
        System.out.println("doc_id: " + result.getId()
                + ", distance: " + result.getScore()
                + ", offset: " + result.getElementOffset()
                + ", entity: " + result.getEntity());
    }
}
import (
    "context"
    "fmt"

    "github.com/milvus-io/milvus/client/v3/entity"
    "github.com/milvus-io/milvus/client/v3/milvusclient"
)

ctx := context.Background()

cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "http://localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    fmt.Println(err.Error())
    return
}
defer cli.Close(ctx)

queryVector := []float32{0.19, 0.24, 0.30, 0.37}

resultSets, err := cli.Search(ctx, milvusclient.NewSearchOption(
    "tech_articles",
    5,
    []entity.Vector{entity.FloatVector(queryVector)},
).WithANNSField("chunks[emb]").
    WithGroupByField("doc_id").
    WithOutputFields("doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]"))
if err != nil {
    fmt.Println(err.Error())
    return
}

for _, resultSet := range resultSets {
    fmt.Println("IDs: ", resultSet.IDs.FieldData().GetScalars())
    fmt.Println("Scores: ", resultSet.Scores)
    fmt.Println("doc_id: ", resultSet.GetColumn("doc_id").FieldData().GetScalars())
}
use milvus::v2::prelude::*;

let config = ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus");
let client = ClientV2::new(&config).await?;

let response = client.search(
    SearchRequest::builder()
        .collection_name("tech_articles")
        .vector_field("chunks[emb]")
        .vectors(SearchVectors::Float(vec![vec![0.19, 0.24, 0.30, 0.37]]))
        .output_fields(["doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]"])
        .limit(5)
        .group_by_field("doc_id")
        .build()?,
).await?;

for result in response.results() {
    for row in result.rows()? {
        println!("doc_id: {:?}, distance: {:?}, offset: {:?}, entity: {:?}",
            row.get("doc_id")?, row.get("score")?, row.element_offset(), row.to_entity_row()?);
    }
}
#include "milvus/MilvusClientV2.h"
#include <iostream>
#include <vector>

auto client = milvus::MilvusClientV2::Create();

milvus::ConnectParam connect_param{"http://localhost:19530", "root:Milvus"};
auto status = client->Connect(connect_param);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}

std::vector<float> query_vector = {0.19f, 0.24f, 0.30f, 0.37f};

milvus::SearchRequest request;
request.WithCollectionName("tech_articles")
       .WithAnnsField("chunks[emb]")
       .AddFloatVector(query_vector)
       .WithLimit(5)
       .WithGroupByField("doc_id")
       .AddOutputField("doc_id")
       .AddOutputField("title")
       .AddOutputField("chunks[text]")
       .AddOutputField("chunks[section]")
       .AddOutputField("chunks[page]")
       .AddOutputField("chunks[quality_score]");

milvus::SearchResponse response;
status = client->Search(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}

for (const auto& result : response.Results().Results()) {
    milvus::EntityRows output_rows;
    status = result.OutputRows(output_rows);
    if (!status.IsOk()) {
        std::cout << status.Message() << std::endl;
    }
    for (const auto& row : output_rows) {
        std::cout << row << std::endl;
    }
}
import { MilvusClient } from "@zilliz/milvus2-sdk-node";

const client = new MilvusClient({ address: "http://localhost:19530", token: "root:Milvus" });

const query_vector = [0.19, 0.24, 0.30, 0.37];

const res = await client.search({
  collection_name: "tech_articles",
  data: query_vector,
  anns_field: "chunks[emb]",
  limit: 5,
  group_by_field: "doc_id",
  output_fields: ["doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]"],
});

for (const hit of res.results) {
  console.log("doc_id:", hit.doc_id, "distance:", hit.score, "offset:", hit.offset);
}
using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Responses.Dql;
using Milvus.Client.V2.Types;

MilvusClientV2 client = new(new ConnectConfig
{
    Uri = "http://localhost:19530",
    ApiKey = "root:Milvus"
});
await client.ConnectAsync();

float[] queryVector = [0.19f, 0.24f, 0.30f, 0.37f];

SearchResp results = await client.SearchAsync(new SearchReq
{
    CollectionName = "tech_articles",
    VectorFieldName = "chunks[emb]",
    Vectors = [queryVector],
    Limit = 5,
    Parameters = new SearchParameters
    {
        GroupByField = "doc_id",
        OutputFields = { "doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]" }
    }
});

foreach (long id in results.Ids.LongIds ?? [])
{
    Console.WriteLine($"doc_id: {id}");
}
export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "tech_articles",
    "data": [
        [0.19, 0.24, 0.30, 0.37]
    ],
    "annsField": "chunks[emb]",
    "limit": 5,
    "groupingField": "doc_id",
    "outputFields": ["doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]"]
}'

Senza il raggruppamento, lo stesso doc_id può comparire più volte se diversi chunk corrispondono alla query. Con group_by_field="doc_id", ogni entità padre compare al massimo una volta. Il raggruppamento preserva i metadati a livello di elemento, quindi il risultato raggruppato può comunque includere l’indice o l’offset dell’elemento Struct selezionato quando l’API o l’SDK lo espongono.

Aggiungere filtri scalari

È possibile combinare la ricerca con raggruppamento con il filtraggio scalare di StructArray. Utilizzare ` element_filter ` quando la condizione scalare deve limitare quali elementi Struct partecipano alla ricerca vettoriale a livello di elemento.

query_vector = [0.19, 0.24, 0.30, 0.37]

filter_expr = (
    'category == "search" && '
    'element_filter(chunks, '
    '$[section] == "index" && '
    '$[quality_score] > 0.9)'
)

results = client.search(
    collection_name="tech_articles",
    data=[query_vector],
    anns_field="chunks[emb]",
    filter=filter_expr,
    limit=5,
    group_by_field="doc_id",
    output_fields=[
        "doc_id",
        "title",
        "category",
        "chunks[text]",
        "chunks[section]",
        "chunks[quality_score]",
    ],
)
import io.milvus.v2.service.vector.request.SearchReq;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.response.SearchResp;
import java.util.Arrays;
import java.util.Collections;

FloatVec queryVector = new FloatVec(new float[]{0.19f, 0.24f, 0.30f, 0.37f});

String filterExpr = "category == \"search\" && "
        + "element_filter(chunks, "
        + "$[section] == \"index\" && "
        + "$[quality_score] > 0.9)";

SearchResp searchResp = client.search(SearchReq.builder()
        .collectionName("tech_articles")
        .annsField("chunks[emb]")
        .data(Collections.singletonList(queryVector))
        .filter(filterExpr)
        .topK(5)
        .groupByFieldName("doc_id")
        .outputFields(Arrays.asList(
                "doc_id", "title", "category",
                "chunks[text]", "chunks[section]", "chunks[quality_score]"))
        .build());
import (
    "fmt"

    "github.com/milvus-io/milvus/client/v3/entity"
    "github.com/milvus-io/milvus/client/v3/milvusclient"
)

queryVector := []float32{0.19, 0.24, 0.30, 0.37}

filterExpr := "category == \"search\" && " +
    "element_filter(chunks, " +
    "$[section] == \"index\" && " +
    "$[quality_score] > 0.9)"

resultSets, err := cli.Search(ctx, milvusclient.NewSearchOption(
    "tech_articles",
    5,
    []entity.Vector{entity.FloatVector(queryVector)},
).WithANNSField("chunks[emb]").
    WithFilter(filterExpr).
    WithGroupByField("doc_id").
    WithOutputFields("doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"))
if err != nil {
    fmt.Println(err.Error())
    return
}

for _, resultSet := range resultSets {
    fmt.Println("IDs: ", resultSet.IDs.FieldData().GetScalars())
    fmt.Println("Scores: ", resultSet.Scores)
    fmt.Println("doc_id: ", resultSet.GetColumn("doc_id").FieldData().GetScalars())
}
use milvus::v2::prelude::*;

let config = ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus");
let client = ClientV2::new(&config).await?;

let filter_expr = "category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9)";

let response = client.search(
    SearchRequest::builder()
        .collection_name("tech_articles")
        .vector_field("chunks[emb]")
        .vectors(SearchVectors::Float(vec![vec![0.19, 0.24, 0.30, 0.37]]))
        .filter(filter_expr)
        .output_fields(["doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"])
        .limit(5)
        .group_by_field("doc_id")
        .build()?,
).await?;

for result in response.results() {
    for row in result.rows()? {
        println!("doc_id: {:?}, distance: {:?}, offset: {:?}, entity: {:?}",
            row.get("doc_id")?, row.get("score")?, row.element_offset(), row.to_entity_row()?);
    }
}
std::vector<float> query_vector = {0.19f, 0.24f, 0.30f, 0.37f};

std::string filter_expr = "category == \"search\" && "
                          "element_filter(chunks, "
                          "$[section] == \"index\" && "
                          "$[quality_score] > 0.9)";

milvus::SearchRequest request;
request.WithCollectionName("tech_articles")
       .WithAnnsField("chunks[emb]")
       .AddFloatVector(query_vector)
       .WithFilter(filter_expr)
       .WithLimit(5)
       .WithGroupByField("doc_id")
       .AddOutputField("doc_id")
       .AddOutputField("title")
       .AddOutputField("category")
       .AddOutputField("chunks[text]")
       .AddOutputField("chunks[section]")
       .AddOutputField("chunks[quality_score]");

milvus::SearchResponse response;
status = client->Search(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}
const query_vector = [0.19, 0.24, 0.30, 0.37];

const filter_expr = 'category == "search" && element_filter(chunks, $[section] == "index" && $[quality_score] > 0.9)';

const res = await client.search({
  collection_name: "tech_articles",
  data: query_vector,
  anns_field: "chunks[emb]",
  filter: filter_expr,
  limit: 5,
  group_by_field: "doc_id",
  output_fields: ["doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"],
});
using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Responses.Dql;
using Milvus.Client.V2.Types;

MilvusClientV2 client = new(new ConnectConfig
{
    Uri = "http://localhost:19530",
    ApiKey = "root:Milvus"
});
await client.ConnectAsync();

float[] queryVector = [0.19f, 0.24f, 0.30f, 0.37f];

string filterExpr = "category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9)";

SearchResp results = await client.SearchAsync(new SearchReq
{
    CollectionName = "tech_articles",
    VectorFieldName = "chunks[emb]",
    Vectors = [queryVector],
    Limit = 5,
    Parameters = new SearchParameters
    {
        Expression = filterExpr,
        GroupByField = "doc_id",
        OutputFields = { "doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]" }
    }
});
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "tech_articles",
    "data": [
        [0.19, 0.24, 0.30, 0.37]
    ],
    "annsField": "chunks[emb]",
    "filter": "category == \"search\" && element_filter(chunks, $[section] == \"index\" && $[quality_score] > 0.9)",
    "limit": 5,
    "groupingField": "doc_id",
    "outputFields": ["doc_id", "title", "category", "chunks[text]", "chunks[section]", "chunks[quality_score]"]
}'

Il predicato di primo livello seleziona le entità candidate. Il predicato ` element_filter ` limita la ricerca vettoriale a livello di elemento agli elementi Struct corrispondenti. Il raggruppamento raggruppa quindi i risultati corrispondenti in base alla chiave primaria.

Il raggruppamento ibrido con StructArray è una funzionalità a livello di elemento. È supportato solo quando tutte le sotto-ricerche hanno come obiettivo campi vettoriali a livello di elemento all’interno dello stesso campo StructArray. Non utilizzare richieste a livello di EmbeddingList in una ricerca ibrida raggruppata su StructArray.

L’esempio seguente presuppone che il campo StructArray chunks abbia due sottocampi vettoriali a livello di elemento, chunks[emb] e chunks[code_emb], ed entrambi siano indicizzati con COSINE. Definire e popolare il sottocampo aggiuntivo a 4 dimensioni code_emb durante la creazione della collezione; esso non è incluso nello schema di base collegato sopra.

from pymilvus import AnnSearchRequest, RRFRanker

query_vector = [0.19, 0.24, 0.30, 0.37]
code_query_vector = [0.18, 0.23, 0.29, 0.36]

index_chunk_req = AnnSearchRequest(
    data=[query_vector],
    anns_field="chunks[emb]",
    param={"metric_type": "COSINE"},
    limit=10,
    expr='element_filter(chunks, $[section] == "index")',
)

code_chunk_req = AnnSearchRequest(
    data=[code_query_vector],
    anns_field="chunks[code_emb]",
    param={"metric_type": "COSINE"},
    limit=10,
    expr='element_filter(chunks, $[has_code] == true)',
)

results = client.hybrid_search(
    collection_name="tech_articles",
    reqs=[index_chunk_req, code_chunk_req],
    ranker=RRFRanker(),
    limit=5,
    group_by_field="doc_id",
    output_fields=[
        "doc_id",
        "title",
        "chunks[text]",
        "chunks[section]",
    ],
)
import io.milvus.v2.common.IndexParam;
import io.milvus.v2.service.vector.request.AnnSearchReq;
import io.milvus.v2.service.vector.request.HybridSearchReq;
import io.milvus.v2.service.vector.request.data.FloatVec;
import io.milvus.v2.service.vector.request.ranker.RRFRanker;
import io.milvus.v2.service.vector.response.SearchResp;
import java.util.Arrays;
import java.util.Collections;

FloatVec queryVector = new FloatVec(new float[]{0.19f, 0.24f, 0.30f, 0.37f});
FloatVec codeQueryVector = new FloatVec(new float[]{0.18f, 0.23f, 0.29f, 0.36f});

AnnSearchReq indexChunkReq = AnnSearchReq.builder()
        .vectorFieldName("chunks[emb]")
        .vectors(Collections.singletonList(queryVector))
        .metricType(IndexParam.MetricType.COSINE)
        .limit(10)
        .filter("element_filter(chunks, $[section] == \"index\")")
        .build();

AnnSearchReq codeChunkReq = AnnSearchReq.builder()
        .vectorFieldName("chunks[code_emb]")
        .vectors(Collections.singletonList(codeQueryVector))
        .metricType(IndexParam.MetricType.COSINE)
        .limit(10)
        .filter("element_filter(chunks, $[has_code] == true)")
        .build();

SearchResp searchResp = client.hybridSearch(HybridSearchReq.builder()
        .collectionName("tech_articles")
        .searchRequests(Arrays.asList(indexChunkReq, codeChunkReq))
        .ranker(RRFRanker.builder().build())
        .limit(5)
        .groupByFieldName("doc_id")
        .outFields(Arrays.asList("doc_id", "title", "chunks[text]", "chunks[section]"))
        .build());
use milvus::v2::prelude::*;

let config = ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus");
let client = ClientV2::new(&config).await?;

let index_chunk_req = SubSearchRequest::builder()
    .vector_field("chunks[emb]")
    .vectors(SearchVectors::Float(vec![vec![0.19, 0.24, 0.30, 0.37]]))
    .filter("element_filter(chunks, $[section] == \"index\")")
    .limit(10)
    .build()?;

let code_chunk_req = SubSearchRequest::builder()
    .vector_field("chunks[code_emb]")
    .vectors(SearchVectors::Float(vec![vec![0.18, 0.23, 0.29, 0.36]]))
    .filter("element_filter(chunks, $[has_code] == true)")
    .limit(10)
    .build()?;

let response = client.hybrid_search(
    HybridSearchRequest::builder()
        .collection_name("tech_articles")
        .sub_requests(vec![index_chunk_req, code_chunk_req])
        .rerank(RRFRerank::new())
        .limit(5)
        .group_by_field("doc_id")
        .output_fields(["doc_id", "title", "chunks[text]", "chunks[section]"])
        .build()?,
).await?;

for result in response.results() {
    for row in result.rows()? {
        println!("doc_id: {:?}, distance: {:?}, offset: {:?}, entity: {:?}",
            row.get("doc_id")?, row.get("score")?, row.element_offset(), row.to_entity_row()?);
    }
}
std::vector<float> query_vector = {0.19f, 0.24f, 0.30f, 0.37f};
std::vector<float> code_query_vector = {0.18f, 0.23f, 0.29f, 0.36f};

auto index_chunk_req = std::make_shared<milvus::SubSearchRequest>();
index_chunk_req->WithAnnsField("chunks[emb]")
                .AddFloatVector(query_vector)
                .WithFilter("element_filter(chunks, $[section] == \"index\")")
                .WithLimit(10);

auto code_chunk_req = std::make_shared<milvus::SubSearchRequest>();
code_chunk_req->WithAnnsField("chunks[code_emb]")
               .AddFloatVector(code_query_vector)
               .WithFilter("element_filter(chunks, $[has_code] == true)")
               .WithLimit(10);

milvus::HybridSearchRequest request;
request.WithCollectionName("tech_articles")
       .AddSubRequest(index_chunk_req)
       .AddSubRequest(code_chunk_req)
       .WithRerank(std::make_shared<milvus::RRFRerank>(60))
       .WithLimit(5)
       .WithGroupByField("doc_id")
       .AddOutputField("doc_id")
       .AddOutputField("title")
       .AddOutputField("chunks[text]")
       .AddOutputField("chunks[section]");

milvus::HybridSearchResponse response;
status = client->HybridSearch(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
    return 1;
}
using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Responses.Dql;
using Milvus.Client.V2.Types;

MilvusClientV2 client = new(new ConnectConfig
{
    Uri = "http://localhost:19530",
    ApiKey = "root:Milvus"
});
await client.ConnectAsync();

float[] queryVector = [0.19f, 0.24f, 0.30f, 0.37f];
float[] codeQueryVector = [0.18f, 0.23f, 0.29f, 0.36f];

AnnSearchReq indexChunkReq = new()
{
    VectorFieldName = "chunks[emb]",
    Vectors = [queryVector],
    MetricType = MetricType.Cosine,
    Limit = 10,
    Expression = "element_filter(chunks, $[section] == \"index\")"
};

AnnSearchReq codeChunkReq = new()
{
    VectorFieldName = "chunks[code_emb]",
    Vectors = [codeQueryVector],
    MetricType = MetricType.Cosine,
    Limit = 10,
    Expression = "element_filter(chunks, $[has_code] == true)"
};

SearchResp results = await client.HybridSearchAsync(new HybridSearchReq
{
    CollectionName = "tech_articles",
    SearchRequests = [indexChunkReq, codeChunkReq],
    Reranker = new RrfReranker(),
    Limit = 5,
    Parameters = new SearchParameters
    {
        GroupByField = "doc_id",
        OutputFields = { "doc_id", "title", "chunks[text]", "chunks[section]" }
    }
});
curl --request POST \
--url "${CLUSTER_ENDPOINT}/v2/vectordb/entities/hybrid_search" \
--header "Authorization: Bearer ${TOKEN}" \
--header "Content-Type: application/json" \
-d '{
    "collectionName": "tech_articles",
    "search": [
        {
            "annsField": "chunks[emb]",
            "data": [[0.19, 0.24, 0.30, 0.37]],
            "limit": 10,
            "filter": "element_filter(chunks, $[section] == \"index\")"
        },
        {
            "annsField": "chunks[code_emb]",
            "data": [[0.18, 0.23, 0.29, 0.36]],
            "limit": 10,
            "filter": "element_filter(chunks, $[has_code] == true)"
        }
    ],
    "rerank": { "strategy": "rrf", "params": {} },
    "limit": 5,
    "groupingField": "doc_id",
    "outputFields": ["doc_id", "title", "chunks[text]", "chunks[section]"]
}'

Il codice sorgente del client Go fornito con Milvus 3.0.2 non espone il raggruppamento ibrido finale tramite NewHybridSearchOption. L'impostazione di WithGroupByField su ciascuna sotto-richiesta non configura il raggruppamento ibrido finale. Anche NodeJS 3.0.6 omette il campo di primo livello group_by_field dai parametri di classificazione ibrida. Per questo esempio, utilizzare una delle API sopra indicate.

In questo esempio, entrambe le sotto-richieste hanno come obiettivo campi vettoriali a livello di elemento all’interno dello stesso campo StructArray, chunks. Una ricerca ibrida non supporta il raggruppamento a livello di elemento se mescola campi vettoriali normali, campi StructArray diversi o richieste a livello di EmbeddingList.

Interpretazione dei risultati raggruppati

Elemento del risultatoSignificato
Chiave primaria (doc_id in questi esempi)Chiave primaria dell’entità padre raggruppata.
distance o punteggioPunteggio o distanza dell’elemento Struct selezionato per quell’entità padre.
offsetPosizione a partire da zero dell’elemento Struct selezionato al momento della restituzione.
Chiavi primarie ripetuteNon previsto in caso di raggruppamento in base alla chiave primaria.
limitSi applica ai risultati raggruppati dell’entità padre.

Limitazioni

  • La ricerca con raggruppamento si applica solo alla ricerca vettoriale StructArray a livello di elemento. La ricerca EmbeddingList e la ricerca ibrida a livello di EmbeddingList non supportano il raggruppamento.

  • Utilizzare la chiave primaria come group_by_field. Il raggruppamento a livello di elemento StructArray non è un raggruppamento generico su campi scalari arbitrari.

  • Non combinare la ricerca con raggruppamento con la ricerca per intervallo.

  • Non utilizzare una query di tipo " EmbeddingList " o una metrica " MAX_SIM* " per la ricerca raggruppata.

  • Il raggruppamento ibrido è supportato solo quando tutte le sotto-ricerche hanno come obiettivo campi vettoriali a livello di elemento all’interno dello stesso campo StructArray.

  • Il raggruppamento ibrido non è supportato quando la ricerca ibrida combina un campo vettoriale normale, un campo StructArray diverso o una richiesta a livello di EmbeddingList.

Errori comuni

  • Utilizzo del raggruppamento con ` chunks[emb_list_vector]`, che è destinato alla ricerca EmbeddingList.

  • Raggruppamento in base a un campo scalare non chiave primaria.

  • Raggruppamento in base a più campi. Il raggruppamento StructArray a livello di elemento supporta solo il raggruppamento in base alla chiave primaria.

  • Aspettarsi che i risultati raggruppati rappresentino ogni elemento Struct corrispondente. Il raggruppamento restituisce al massimo un risultato per entità padre.

  • Supporre che la ricerca raggruppata a livello di elemento ricalcoli un punteggio di tipo " MAX_SIM* " in stile EmbeddingList. Il raggruppamento comprime i risultati a livello di elemento; non modifica il modello di punteggio.

  • Combinazione dell’ group_by_field con radius o range_filter.

Prossimi passi

  1. Per imparare innanzitutto la ricerca a livello di elemento non raggruppata, leggi Ricerca vettoriale di base con StructArray.

  2. Per aggiungere filtri scalari alla ricerca raggruppata, leggi Ricerca filtrata con StructArray.

  3. Per utilizzare limiti di punteggio o di distanza al posto del raggruppamento, leggi Ricerca per intervallo con StructArray.

  4. Per verificare i limiti di ricerca di StructArray, leggi Limiti di StructArray.