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.
| Requisiti | Dove 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
| Aspetto | Ricerca EmbeddingList | Ricerca a livello di elemento |
|---|---|---|
| Sottocampo di destinazione | chunks[emb_list_vector] | chunks[emb] |
| Dati di query | Un elenco di embedding contenente uno o più vettori. | Un vettore regolare. |
| Famiglia di metriche | MAX_SIM*, come ad esempio MAX_SIM_COSINE. | Metriche vettoriali regolari, come COSINE, IP o L2. |
| Cosa rappresenta un risultato | Un'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 risultati | A livello di entità. | A livello di elemento Struct. |
| Offset | Non applicabile. | Identifica la posizione, a partire da zero, dell’elemento Struct corrispondente al momento della restituzione. |
| Uso tipico | ColBERT, ColPali e altri modelli di recupero a interazione tardiva. | Recupero a livello di chunk, di passaggio, di clip, di patch o di fatto. |
Esegui la ricerca EmbeddingList
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.
Eseguire una ricerca a livello di elemento
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 risultato | Ricerca EmbeddingList | Ricerca 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 punteggio | Punteggio 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. |
offset | Non applicabile. | Posizione a partire da zero dell'elemento Struct corrispondente al momento della restituzione. |
| Chiavi primarie ripetute | Non 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 richiesti | Restituiti 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.embinvece della sintassi richiesta per il percorso del sottocampochunks[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
limitrestituisca 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
Per limitare la ricerca a livello di elemento tramite condizioni scalari, consultare Ricerca filtrata con StructArray.
Per effettuare ricerche in base a punteggi o limiti di distanza, consultare Ricerca per intervallo con StructArray.
Per restituire al massimo un risultato per entità padre dopo una ricerca a livello di elemento, consultare Ricerca raggruppata con StructArray.
Per combinare la ricerca StructArray con altre ricerche vettoriali, consultare Ricerca ibrida con StructArray.
Per esaminare i tipi di dati, le metriche, i filtri e i limiti specifici della versione supportati, consultare Limiti di StructArray.