Ricerca vettoriale di base con StructArray

Utilizza questa pagina per eseguire una ricerca vettoriale sui sottocampi vettoriali all'interno di un campo StructArray. StructArray supporta due modalità di ricerca vettoriale di base: la ricerca EmbeddingList, che valuta un elenco di embedding memorizzato in ciascuna entità, e la ricerca a livello di elemento, che effettua la ricerca su ciascun elemento Struct in modo indipendente.

Questa pagina utilizza la raccolta " tech_articles " descritta nella sezione "Creazione di un campo StructArray". La raccolta presenta un campo StructArray denominato " chunks". Ogni chunk contiene testo, metadati scalari, un sottocampo vettoriale denominato " emb_list_vector " con un indice per la ricerca EmbeddingList e un sottocampo vettoriale denominato " emb " con un indice per la ricerca a livello di elemento.

Prima di iniziare

Assicurarsi che lo schema della collezione, i dati e gli indici siano già stati preparati. I vettori di esempio hanno quattro dimensioni. Ogni esempio di ricerca inizializza un client e attende il caricamento di tech_articles prima di eseguire la ricerca. Per cURL, installare jq per verificare la risposta relativa allo stato di caricamento.

RequisitiDove prepararlo
Creare un campo StructArray, ad esempio chunks.Creazione di un campo StructArray
Inserire entità il cui campo chunks contenga oggetti Struct.Inserire dati nei campi StructArray
Creare un indice ` MAX_SIM* ` su ` chunks[emb_list_vector] ` per la ricerca in `EmbeddingList`.Indicizzare i campi StructArray
Creare un indice vettoriale-metrico regolare su chunks[emb] per la ricerca a livello di elemento.Indicizzazione dei campi StructArray

Avviso

Un campo vettoriale o un sottocampo vettoriale accetta un solo indice. Se sono necessarie sia la ricerca EmbeddingList che quella a livello di elemento, creare due sottocampi vettoriali separati. In questa pagina, chunks[emb_list_vector] è indicizzato per la ricerca EmbeddingList, mentre chunks[emb] è indicizzato per la ricerca a livello di elemento.

Scegliere una modalità di ricerca

AspettoRicerca EmbeddingListRicerca a livello di elemento
Sottocampo di destinazionechunks[emb_list_vector]chunks[emb]
Dati di queryUn elenco di embedding contenente uno o più vettori.Un vettore regolare.
Famiglia di metricheMAX_SIM*, come ad esempio MAX_SIM_COSINE.Metriche vettoriali regolari, come COSINE, IP o L2.
Cosa rappresenta un risultatoUn'entità corrispondente il cui sottocampo vettoriale StructArray è simile all'elenco di embedding della query.Un elemento Struct corrispondente all’interno del campo StructArray.
Granularità dei risultatiA livello di entità.A livello di elemento Struct.
OffsetNon applicabile.Identifica la posizione, a partire da zero, dell’elemento Struct corrispondente al momento della restituzione.
Uso tipicoColBERT, ColPali e altri modelli di recupero a interazione tardiva.Recupero a livello di chunk, di passaggio, di clip, di patch o di fatto.

Utilizzare la ricerca EmbeddingList quando la query stessa contiene più vettori e il sottocampo vettoriale StructArray di destinazione è indicizzato con una metrica di MAX_SIM*. Il risultato è una corrispondenza a livello di entità.

from pymilvus import MilvusClient
from pymilvus.client.embedding_list import EmbeddingList

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

client.load_collection(collection_name="tech_articles")

query = EmbeddingList()
query.add([0.12, 0.21, 0.32, 0.44])
query.add([0.18, 0.23, 0.29, 0.36])

results = client.search(
    collection_name="tech_articles",
    data=[query],
    anns_field="chunks[emb_list_vector]",
    limit=3,
    output_fields=[
        "doc_id",
        "title",
        "category",
        "chunks[text]",
        "chunks[section]",
    ],
)

for hits in results:
    for hit in hits:
        print(hit["doc_id"], hit["distance"], hit["entity"])
import io.milvus.v2.service.collection.request.LoadCollectionReq;
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.EmbeddingList;
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;

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

client.loadCollection(LoadCollectionReq.builder()
        .collectionName("tech_articles")
        .build());

EmbeddingList query = new EmbeddingList();
query.add(new FloatVec(Arrays.asList(0.12f, 0.21f, 0.32f, 0.44f)));
query.add(new FloatVec(Arrays.asList(0.18f, 0.23f, 0.29f, 0.36f)));

SearchResp resp = client.search(SearchReq.builder()
        .collectionName("tech_articles")
        .annsField("chunks[emb_list_vector]")
        .data(Collections.singletonList(query))
        .limit(3)
        .outputFields(Arrays.asList("doc_id", "title", "category", "chunks[text]", "chunks[section]"))
        .build());

for (List<SearchResp.SearchResult> hits : resp.getSearchResults()) {
    for (SearchResp.SearchResult hit : hits) {
        System.out.println(hit.getId() + " " + hit.getScore() + " " + hit.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 {
    panic(err)
}

loadTask, err := cli.LoadCollection(ctx, milvusclient.NewLoadCollectionOption("tech_articles"))
if err != nil {
    panic(err)
}
if err := loadTask.Await(ctx); err != nil {
    panic(err)
}

query := entity.FloatVectorArray{
    {0.12, 0.21, 0.32, 0.44},
    {0.18, 0.23, 0.29, 0.36},
}

results, err := cli.Search(ctx, milvusclient.NewSearchOption(
    "tech_articles",
    3,
    []entity.Vector{query},
).WithANNSField("chunks[emb_list_vector]").WithOutputFields("doc_id", "title", "category", "chunks[text]", "chunks[section]"))
if err != nil {
    panic(err)
}

for _, result := range results {
    for i := 0; i < result.ResultCount; i++ {
        id, err := result.IDs.Get(i)
        if err != nil { panic(err) }
        fmt.Println(id, result.Scores[i])
        for _, field := range result.Fields {
            value, err := field.Get(i)
            if err != nil { panic(err) }
            fmt.Println(field.Name(), value)
        }
    }
}
use milvus::v2::prelude::*;

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

client.load_collection(LoadCollectionRequest::builder()
    .collection_name("tech_articles")
    .sync(true)
    .build()?).await?;

let query = EmbeddingList::new().vectors(vec![
    vec![0.12, 0.21, 0.32, 0.44],
    vec![0.18, 0.23, 0.29, 0.36],
]);

let response = client
    .search(
        SearchRequest::builder()
            .collection_name("tech_articles")
            .vector_field("chunks[emb_list_vector]")
            .vectors(SearchVectors::EmbeddingLists(vec![query]))
            .output_fields(["doc_id", "title", "category", "chunks[text]", "chunks[section]"])
            .limit(3)
            .build()?,
    )
    .await?;

for result in response.results() {
    for row in result.rows()? {
        println!("{:?}", row.to_entity_row()?);
    }
}
#include <stdexcept>
#include <iostream>
#include "milvus/MilvusClientV2.h"

auto client = milvus::MilvusClientV2::Create();
auto status = client->Connect(milvus::ConnectParam("http://localhost:19530").WithToken("root:Milvus"));
if (!status.IsOk()) {
    throw std::runtime_error(status.Message());
}

status = client->LoadCollection(milvus::LoadCollectionRequest()
    .WithCollectionName("tech_articles").WithSync(true));
if (!status.IsOk()) { throw std::runtime_error(status.Message()); }

milvus::EmbeddingList query;
query.AddFloatVector({0.12, 0.21, 0.32, 0.44});
query.AddFloatVector({0.18, 0.23, 0.29, 0.36});

auto request = milvus::SearchRequest()
                   .WithCollectionName("tech_articles")
                   .WithLimit(3)
                   .WithAnnsField("chunks[emb_list_vector]")
                   .AddEmbeddingList(std::move(query))
                   .AddOutputField("doc_id")
                   .AddOutputField("title")
                   .AddOutputField("category")
                   .AddOutputField("chunks[text]")
                   .AddOutputField("chunks[section]");

milvus::SearchResponse response;
status = client->Search(request, response);
if (!status.IsOk()) {
    throw std::runtime_error(status.Message());
}

for (auto& result : response.Results().Results()) {
    milvus::EntityRows output_rows;
    status = result.OutputRows(output_rows);
    if (!status.IsOk()) { throw std::runtime_error(status.Message()); }
    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",
});

await client.loadCollection({ collection_name: "tech_articles" });

const query = [
  [0.12, 0.21, 0.32, 0.44],
  [0.18, 0.23, 0.29, 0.36],
];

const results = await client.search({
  collection_name: "tech_articles",
  data: query,
  anns_field: "chunks[emb_list_vector]",
  limit: 3,
  output_fields: [
    "doc_id",
    "title",
    "category",
    "chunks[text]",
    "chunks[section]",
  ],
});

console.log(JSON.stringify(results.results, null, 2));
using System;
using System.Linq;
using System.Text.Json;
using Milvus.Client.V2.Requests.Collection;
using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Responses.Dql;
using Milvus.Client.V2.Types;

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

await client.LoadCollectionAsync(new LoadCollectionReq
{
    CollectionName = "tech_articles",
    Sync = true
});

var query = new EmbeddingList();
query.Add(new ReadOnlyMemory<float>(new[] { 0.12f, 0.21f, 0.32f, 0.44f }));
query.Add(new ReadOnlyMemory<float>(new[] { 0.18f, 0.23f, 0.29f, 0.36f }));

SearchResp results = await client.SearchAsync(new SearchReq
{
    CollectionName = "tech_articles",
    VectorFieldName = "chunks[emb_list_vector]",
    EmbeddingLists = new[] { query },
    Limit = 3,
    Parameters = new SearchParameters
    {
        OutputFields = { "doc_id", "title", "category", "chunks[text]", "chunks[section]" }
    }
});
foreach (var result in results.SingleResults!)
{
    for (int i = 0; i < result.Scores.Count; i++)
        Console.WriteLine(JsonSerializer.Serialize(result.GetRow(i)));
}
set -euo pipefail

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --fail-with-body --silent --show-error --request POST \
  --url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/load" \
  --header "Authorization: Bearer ${TOKEN}" \
  --header "Content-Type: application/json" \
  --data-raw '{"collectionName":"tech_articles"}' | jq -e '.code == 0' >/dev/null

loaded=false
for attempt in $(seq 1 60); do
  state=$(curl --fail-with-body --silent --show-error --request POST \
    --url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/get_load_state" \
    --header "Authorization: Bearer ${TOKEN}" \
    --header "Content-Type: application/json" \
    --data-raw '{"collectionName":"tech_articles"}' | jq -er 'if .code == 0 then .data.loadState else error("load-state request failed") end')
  if [ "$state" = "LoadStateLoaded" ]; then
    loaded=true
    break
  fi
  sleep 1
done
[ "$loaded" = true ] || { echo "Collection did not finish loading" >&2; exit 1; }

curl --request POST \
  --url "http://localhost:19530/v2/vectordb/entities/search" \
  --header "Authorization: Bearer root:Milvus" \
  --header "Content-Type: application/json" \
  --data-raw '{
    "collectionName": "tech_articles",
    "data": [
      [
        [0.12, 0.21, 0.32, 0.44],
        [0.18, 0.23, 0.29, 0.36]
      ]
    ],
    "annsField": "chunks[emb_list_vector]",
    "limit": 3,
    "outputFields": [
      "doc_id",
      "title",
      "category",
      "chunks[text]",
      "chunks[section]"
    ]
  }'

In questa modalità di ricerca, l’ limit controlla il numero di entità restituite per ciascuna query. L’output può includere sottocampi StructArray, ma il risultato stesso rappresenta l’entità padre corrispondente piuttosto che un singolo elemento Struct specifico.

Per una guida completa in stile ColBERT o ColPali, consulta Ricerca con elenchi di embedding. Questa pagina tratta solo il comportamento di base della ricerca su StructArray.

Utilizzare la ricerca a livello di elemento quando ogni elemento Struct deve partecipare alla ricerca vettoriale in modo indipendente. La query è un vettore regolare e il sottocampo vettoriale di destinazione deve essere indicizzato con una metrica vettoriale regolare.

from pymilvus import MilvusClient

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

client.load_collection(collection_name="tech_articles")

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,
    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.service.collection.request.LoadCollectionReq;
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;

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

client.loadCollection(LoadCollectionReq.builder()
        .collectionName("tech_articles")
        .build());

SearchResp resp = client.search(SearchReq.builder()
        .collectionName("tech_articles")
        .annsField("chunks[emb]")
        .data(Collections.singletonList(new FloatVec(Arrays.asList(0.19f, 0.24f, 0.30f, 0.37f))))
        .limit(5)
        .outputFields(Arrays.asList("doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]"))
        .build());

for (List<SearchResp.SearchResult> hits : resp.getSearchResults()) {
    for (SearchResp.SearchResult hit : hits) {
        System.out.println("doc_id: " + hit.getId()
                + " distance: " + hit.getScore()
                + " offset: " + hit.getElementOffset()
                + " entity: " + hit.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 {
    panic(err)
}

loadTask, err := cli.LoadCollection(ctx, milvusclient.NewLoadCollectionOption("tech_articles"))
if err != nil {
    panic(err)
}
if err := loadTask.Await(ctx); err != nil {
    panic(err)
}

// Go client/v3.0.0 does not expose element offsets in ResultSet.
results, err := cli.Search(ctx, milvusclient.NewSearchOption(
    "tech_articles",
    5,
    []entity.Vector{entity.FloatVector{0.19, 0.24, 0.30, 0.37}},
).WithANNSField("chunks[emb]").WithOutputFields("doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]"))
if err != nil {
    panic(err)
}

for _, result := range results {
    for i := 0; i < result.ResultCount; i++ {
        id, err := result.IDs.Get(i)
        if err != nil { panic(err) }
        fmt.Println("doc_id:", id, "distance:", result.Scores[i])
        for _, field := range result.Fields {
            value, err := field.Get(i)
            if err != nil { panic(err) }
            fmt.Println(field.Name(), value)
        }
    }
}
use milvus::v2::prelude::*;

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

client.load_collection(LoadCollectionRequest::builder()
    .collection_name("tech_articles")
    .sync(true)
    .build()?).await?;

let query_vector = vec![0.19, 0.24, 0.30, 0.37];

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

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

auto client = milvus::MilvusClientV2::Create();
auto status = client->Connect(milvus::ConnectParam("http://localhost:19530").WithToken("root:Milvus"));
if (!status.IsOk()) {
    throw std::runtime_error(status.Message());
}

status = client->LoadCollection(milvus::LoadCollectionRequest()
    .WithCollectionName("tech_articles").WithSync(true));
if (!status.IsOk()) { throw std::runtime_error(status.Message()); }

auto request = milvus::SearchRequest()
                   .WithCollectionName("tech_articles")
                   .WithLimit(5)
                   .WithAnnsField("chunks[emb]")
                   .WithFloatVectors({{0.19, 0.24, 0.30, 0.37}})
                   .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()) {
    throw std::runtime_error(status.Message());
}

for (auto& result : response.Results().Results()) {
    milvus::EntityRows output_rows;
    status = result.OutputRows(output_rows);
    if (!status.IsOk()) { throw std::runtime_error(status.Message()); }
    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",
});

await client.loadCollection({ collection_name: "tech_articles" });

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

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

console.log(JSON.stringify(results.results, null, 2));
using System;
using System.Linq;
using System.Text.Json;
using Milvus.Client.V2.Requests.Collection;
using Milvus.Client.V2;
using Milvus.Client.V2.Requests.Dql;
using Milvus.Client.V2.Responses.Dql;
using Milvus.Client.V2.Types;

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

await client.LoadCollectionAsync(new LoadCollectionReq
{
    CollectionName = "tech_articles",
    Sync = true
});

var queryVector = new ReadOnlyMemory<float>(new[] { 0.19f, 0.24f, 0.30f, 0.37f });

SearchResp results = await client.SearchAsync(new SearchReq
{
    CollectionName = "tech_articles",
    VectorFieldName = "chunks[emb]",
    Vectors = new[] { queryVector },
    Limit = 5,
    Parameters = new SearchParameters
    {
        OutputFields = { "doc_id", "title", "chunks[text]", "chunks[section]", "chunks[page]", "chunks[quality_score]" }
    }
});
foreach (var result in results.SingleResults!)
{
    for (int i = 0; i < result.Scores.Count; i++)
        Console.WriteLine(JsonSerializer.Serialize(result.GetRow(i)));
}
// One query: ElementIndices aligns with its hit order.
Console.WriteLine(JsonSerializer.Serialize(results.ElementIndices));
set -euo pipefail

export CLUSTER_ENDPOINT="http://localhost:19530"
export TOKEN="root:Milvus"

curl --fail-with-body --silent --show-error --request POST \
  --url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/load" \
  --header "Authorization: Bearer ${TOKEN}" \
  --header "Content-Type: application/json" \
  --data-raw '{"collectionName":"tech_articles"}' | jq -e '.code == 0' >/dev/null

loaded=false
for attempt in $(seq 1 60); do
  state=$(curl --fail-with-body --silent --show-error --request POST \
    --url "${CLUSTER_ENDPOINT}/v2/vectordb/collections/get_load_state" \
    --header "Authorization: Bearer ${TOKEN}" \
    --header "Content-Type: application/json" \
    --data-raw '{"collectionName":"tech_articles"}' | jq -er 'if .code == 0 then .data.loadState else error("load-state request failed") end')
  if [ "$state" = "LoadStateLoaded" ]; then
    loaded=true
    break
  fi
  sleep 1
done
[ "$loaded" = true ] || { echo "Collection did not finish loading" >&2; exit 1; }

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

Nella ricerca a livello di elemento, ogni risultato rappresenta un elemento Struct corrispondente. Il valore ` offset ` è la posizione (a partire da zero) di quell’elemento nel campo StructArray. La stessa entità può apparire più di una volta se più di un elemento Struct corrisponde alla query. Il valore ` limit ` si applica ai risultati a livello di elemento, non alle entità padre univoche.

Interpretazione dei risultati

Elemento del risultatoRicerca EmbeddingListRicerca a livello di elemento
Chiave primaria (doc_id in questo schema)Chiave primaria dell'entità corrispondente.Chiave primaria dell’entità che contiene l’elemento Struct corrispondente.
distance o punteggioPunteggio o distanza tra l'elenco di embedding della query e l'elenco di embedding memorizzato.Punteggio o distanza tra il vettore della query e il vettore dell’elemento Struct corrispondente.
offsetNon applicabile.Posizione a partire da zero dell'elemento Struct corrispondente al momento della restituzione.
Chiavi primarie ripetuteNon previsto per una singola query poiché i risultati sono a livello di entità.Possibile, poiché più elementi Struct nella stessa entità possono corrispondere.
Campi di output StructArray richiestiRestituiti dall’entità corrispondente.Restituiti con la forma di corrispondenza a livello di elemento supportata dall’API e dall’SDK di destinazione.

Gli esempi in Python utilizzano PyMilvus 3.0.2 e accedono alla chiave primaria tramite il nome dello schema, doc_id. Gli accessori dei risultati variano a seconda dell’SDK. Il client Go v3.0.0 non espone gli offset degli elementi in ResultSet; altri esempi mostrano gli offset solo tramite l’interfaccia dei risultati supportata dal proprio SDK.

Errori comuni

  • Utilizzo di chunks.emb invece della sintassi richiesta per il percorso del sottocampo chunks[emb].

  • Utilizzo di una query EmbeddingList su un sottocampo vettoriale indicizzato con una metrica vettoriale standard.

  • Utilizzo di una query vettoriale standard su un sottocampo vettoriale indicizzato con una metrica MAX_SIM*.

  • Aspettarsi che la ricerca a livello di elemento limit restituisca altrettante entità padre univoche. Restituisce invece i risultati a livello di elemento.

  • Aspettarsi che la ricerca EmbeddingList restituisca un offset specifico dell’elemento. Restituisce invece corrispondenze a livello di entità.

  • Riutilizzo di un unico sottocampo vettoriale per entrambe le modalità di ricerca. Utilizzare sottocampi vettoriali separati poiché ogni sottocampo vettoriale accetta un solo indice.

Prossimi passi

  1. Per limitare la ricerca a livello di elemento tramite condizioni scalari, consultare Ricerca filtrata con StructArray.

  2. Per effettuare ricerche in base a punteggi o limiti di distanza, consultare Ricerca per intervallo con StructArray.

  3. Per restituire al massimo un risultato per entità padre dopo una ricerca a livello di elemento, consultare Ricerca raggruppata con StructArray.

  4. Per combinare la ricerca StructArray con altre ricerche vettoriali, consultare Ricerca ibrida con StructArray.

  5. Per esaminare i tipi di dati, le metriche, i filtri e i limiti specifici della versione supportati, consultare Limiti di StructArray.

Tradotto daDeepL

Prova Milvus gestito gratuitamente

Zilliz Cloud è senza problemi, basato su Milvus e 10 volte più veloce.

Inizia
Feedback

Questa pagina è stata utile?