Sbloccare il vero recupero a livello di entità: Nuove funzionalità Array-of-Structs e MAX_SIM in Milvus

Se avete costruito applicazioni di intelligenza artificiale su database vettoriali, probabilmente avete riscontrato lo stesso problema: il database recupera embedding di singoli pezzi, ma la vostra applicazione si interessa alle entità. Questo disallineamento rende complesso l'intero flusso di lavoro di recupero.

È probabile che questa situazione si ripeta più volte:

• Basi di conoscenza RAG: Gli articoli sono raggruppati in embedding di paragrafi, quindi il motore di ricerca restituisce frammenti sparsi invece del documento completo.

• Raccomandazioni di e-commerce: Un prodotto ha più incorporazioni di immagini e il sistema restituisce cinque angolazioni dello stesso articolo anziché cinque prodotti unici.

• Piattaforme video: I video sono suddivisi in embedding di clip, ma i risultati della ricerca mostrano fette dello stesso video anziché un'unica voce consolidata.

• Recupero in stile ColBERT / ColPali: I documenti si espandono in centinaia di incorporazioni a livello di token o di patch, e i risultati vengono restituiti come piccoli pezzi che devono ancora essere uniti.

Tutti questi problemi derivano dalla stessa lacuna architettonica: la maggior parte dei database vettoriali tratta ogni incorporazione come una riga isolata, mentre le applicazioni reali operano su entità di livello superiore: documenti, prodotti, video, oggetti, scene. Di conseguenza, i team di ingegneri sono costretti a ricostruire le entità manualmente, utilizzando logiche di deduplicazione, raggruppamento, separazione e riclassificazione. Funziona, ma è fragile, lento e gonfia il livello dell'applicazione con una logica che non avrebbe mai dovuto essere presente.

Milvus 2.6.4 colma questa lacuna con una nuova funzionalità: Array of Structs con il tipo metrico MAX_SIM. Insieme, consentono di memorizzare tutte le incorporazioni di una singola entità in un unico record e permettono a Milvus di valutare e restituire l'entità in modo olistico. Niente più insiemi di risultati duplicati. Niente più complesse post-elaborazioni come reranking e merging.

In questo articolo spiegheremo come funzionano Array of Structs e MAX_SIM e li dimostreremo attraverso due esempi reali: Il recupero di documenti di Wikipedia e la ricerca di documenti basata su immagini di ColPali.

Che cos'è un array di strutture?

In Milvus, un campo Array of Structs consente a un singolo record di contenere un elenco ordinato di elementi Struct, ognuno dei quali segue lo stesso schema predefinito. Una struttura può contenere vettori multipli, campi scalari, stringhe o qualsiasi altro tipo supportato. In altre parole, consente di raggruppare tutti i pezzi che appartengono a un'entità - embedding di paragrafi, viste di immagini, vettori di token, metadati - direttamente in una riga.

Ecco un esempio di entità di una collezione che contiene un campo Array of Structs.

{
    'id': 0,
    'title': 'Walden',
    'title_vector': [0.1, 0.2, 0.3, 0.4, 0.5],
    'author': 'Henry David Thoreau',
    'year_of_publication': 1845,
    // highlight-start
    'chunks': [
        {
            'text': 'When I wrote the following pages, or rather the bulk of them...',
            'text_vector': [0.3, 0.2, 0.3, 0.2, 0.5],
            'chapter': 'Economy',
        },
        {
            'text': 'I would fain say something, not so much concerning the Chinese and...',
            'text_vector': [0.7, 0.4, 0.2, 0.7, 0.8],
            'chapter': 'Economy'
        }
    ]
    // hightlight-end
}

Nell'esempio precedente, il campo chunks è un campo Array of Structs e ogni elemento Struct contiene i propri campi, ovvero text, text_vector e chapter.

Questo approccio risolve un problema di modellazione di lunga data nei database vettoriali. Tradizionalmente, ogni incorporazione o attributo deve diventare una riga a sé stante, il che costringe le entità multivettore (documenti, prodotti, video) a essere suddivise in decine, centinaia o addirittura migliaia di record. Con Array of Structs, Milvus consente di memorizzare l'intera entità multivettore in un unico campo, il che lo rende naturale per gli elenchi di paragrafi, le incorporazioni di token, le sequenze di clip, le immagini multi-view o qualsiasi scenario in cui un elemento logico è composto da molti vettori.

Come funziona un array di strutture con MAX_SIM?

Sopra questa nuova struttura ad array di strutture si trova MAX_SIM, una nuova strategia di punteggio che rende il reperimento semantico consapevole delle entità. Quando arriva una query, Milvus la confronta con ogni vettore all'interno di ogni array di strutture e prende la massima somiglianza come punteggio finale dell'entità. L'entità viene quindi classificata e restituita in base a questo singolo punteggio. In questo modo si evita il classico problema del database vettoriale, che consiste nel recuperare frammenti sparsi, e si sposta l'onere del raggruppamento, della deduplicazione e della riclassificazione nel livello dell'applicazione. Con MAX_SIM, il recupero a livello di entità diventa integrato, coerente ed efficiente.

Per capire come funziona MAX_SIM nella pratica, vediamo un esempio concreto.

Nota: tutti i vettori di questo esempio sono generati dallo stesso modello di incorporazione e la somiglianza è misurata con la somiglianza del coseno nell'intervallo [0,1].

Supponiamo che un utente cerchi "Corso di apprendimento automatico per principianti".

La query è stata tokenizzata in tre token:

• apprendimento automatico

• principiante

• corso

Ciascuno di questi token viene poi convertito in un vettore di incorporamento dallo stesso modello di incorporamento utilizzato per i documenti.

Immaginiamo che il database dei vettori contenga due documenti:

• doc_1: Guida introduttiva alle reti neurali profonde con Python

• doc_2: Una guida avanzata alla lettura dei documenti di un LLM.

Entrambi i documenti sono stati incorporati in vettori e memorizzati in un array di strutture.

Passo 1: Calcolo di MAX_SIM per doc_1

Per ogni vettore di query, Milvus calcola la sua somiglianza di coseno rispetto a ogni vettore di doc_1:

	Introduzione	guida	reti neurali profonde	python
apprendimento automatico	0.0	0.0	0.9	0.3
principiante	0.8	0.1	0.0	0.3
corso	0.3	0.7	0.1	0.1

Per ogni vettore di query, MAX_SIM seleziona la somiglianza più alta dalla sua riga:

• apprendimento automatico → reti neurali profonde (0,9)

• principiante → introduzione (0,8)

• corso → guida (0,7)

Sommando le migliori corrispondenze si ottiene per doc_1 un punteggio MAX_SIM di 2,4.

Passo 2: Calcolo di MAX_SIM per il documento_2

Ora ripetiamo il processo per il documento_2:

	avanzato	guida	LLM	carta	lettura
apprendimento automatico	0.1	0.2	0.9	0.3	0.1
principiante	0.4	0.6	0.0	0.2	0.5
corso	0.5	0.8	0.1	0.4	0.7

Le migliori corrispondenze per il doc_2 sono:

• "machine learning" → "LLM" (0,9)

• "principiante" → "guida" (0,6)

• "corso" → "guida" (0,8)

La somma dei punteggi dà al doc_2 un punteggio MAX_SIM di 2,3.

Passo 3: confrontare i punteggi

Poiché 2,4 > 2,3, il doc_1 si classifica più in alto del doc_2, il che ha un senso intuitivo, poiché il doc_1 è più vicino a una guida introduttiva all'apprendimento automatico.

Da questo esempio, possiamo evidenziare tre caratteristiche fondamentali di MAX_SIM:

• Prima di tutto semantica, non basata su parole chiave: MAX_SIM confronta gli embeddings, non i letterali di testo. Anche se "machine learning" e "deep neural networks" hanno zero parole in comune, la loro somiglianza semantica è pari a 0,9. Questo rende MAX_SIM robusto rispetto ai sinonimi. Questo rende MAX_SIM robusto ai sinonimi, alle parafrasi, alle sovrapposizioni concettuali e ai moderni carichi di lavoro ricchi di embedding.

• Insensibile alla lunghezza e all'ordine: MAX_SIM non richiede che la query e il documento abbiano lo stesso numero di vettori (ad esempio, il documento_1 ha 4 vettori mentre il documento_2 ne ha 5, ed entrambi funzionano bene). Inoltre, non tiene conto dell'ordine dei vettori: "principiante" che compare prima nella query e "introduzione" che compare dopo nel documento non hanno alcun impatto sul punteggio.

• Ogni vettore della query è importante: MAX_SIM prende la migliore corrispondenza per ogni vettore della query e somma i punteggi migliori. In questo modo si evita che i vettori non abbinati influenzino il risultato e si garantisce che ogni token di query importante contribuisca al punteggio finale. Ad esempio, la corrispondenza di qualità inferiore per "principiante" in doc_2 riduce direttamente il punteggio complessivo.

Perché MAX_SIM + Array di strutture sono importanti nel database vettoriale

Milvus è un database vettoriale open-source ad alte prestazioni e ora supporta pienamente MAX_SIM insieme ad Array of Structs, consentendo il reperimento di entità multivettoriali a livello vettoriale:

• Memorizzare entità multivettore in modo nativo: Array of Structs consente di memorizzare gruppi di vettori correlati in un unico campo senza dividerli in righe separate o tabelle ausiliarie.

• Calcolo efficiente del best-match: In combinazione con indici vettoriali come IVF e HNSW, MAX_SIM può calcolare le migliori corrispondenze senza scansionare ogni vettore, mantenendo alte le prestazioni anche con documenti di grandi dimensioni.

• Costruito appositamente per carichi di lavoro ad alto contenuto semantico: Questo approccio eccelle nel reperimento di testi lunghi, nella corrispondenza semantica multi-sfaccettata, nell'allineamento documento-sommario, nelle query con più parole chiave e in altri scenari di intelligenza artificiale che richiedono un ragionamento semantico flessibile e a grana fine.

Quando usare un array di strutture

Il valore di Array of Structs diventa chiaro quando si guarda a ciò che consente. Nel suo nucleo, questa funzione fornisce tre funzionalità fondamentali:

• Riunisce dati eterogenei - vettori, scalari, stringhe, metadati - in un unico oggetto strutturato.

• Allinea l'archiviazione alle entità del mondo reale, in modo che ogni riga del database corrisponda perfettamente a un elemento reale, come un articolo, un prodotto o un video.

• Se combinato con funzioni di aggregazione come MAX_SIM, consente di recuperare un vero e proprio multivettore a livello di entità direttamente dal database, eliminando la deduplicazione, il raggruppamento o il reranking nel livello applicativo.

Grazie a queste proprietà, Array of Structs è una soluzione naturale ogni volta che una singola entità logica è rappresentata da più vettori. Esempi comuni sono gli articoli suddivisi in paragrafi, i documenti scomposti in token embeddings o i prodotti rappresentati da più immagini. Se i risultati di una ricerca soffrono di duplicazioni, frammenti sparsi o la stessa entità appare più volte tra i primi risultati, Array of Structs risolve questi problemi a livello di archiviazione e recupero, non attraverso patch a posteriori nel codice dell'applicazione.

Questo pattern è particolarmente potente per i moderni sistemi di intelligenza artificiale che si basano sul recupero di più vettori. Ad esempio:

• ColBERT rappresenta un singolo documento come 100-500 token embeddings per una corrispondenza semantica a grana fine in domini come il testo legale e la ricerca accademica.

• ColPali converte ogni pagina PDF in 256-1024 patch di immagini per il recupero cross-modale di bilanci, contratti, fatture e altri documenti scansionati.

Un array di strutture consente a Milvus di memorizzare tutti questi vettori sotto un'unica entità e di calcolare la somiglianza aggregata (ad esempio, MAX_SIM) in modo efficiente e nativo. Per rendere più chiaro questo concetto, ecco due esempi concreti.

Esempio 1: Ricerca di prodotti di e-commerce

In precedenza, i prodotti con più immagini venivano memorizzati in uno schema piatto: un'immagine per riga. Un prodotto con immagini frontali, laterali e angolate produceva tre righe. I risultati della ricerca spesso restituivano più immagini dello stesso prodotto, richiedendo la deduplicazione e la riclassificazione manuale.

Con un array di strutture, ogni prodotto diventa una riga. Tutte le incorporazioni delle immagini e i metadati (angolo, is_primary, ecc.) vivono all'interno di un campo images come array di strutture. Milvus capisce che appartengono allo stesso prodotto e restituisce il prodotto nel suo complesso, non le singole immagini.

Esempio 2: Base di conoscenza o ricerca su Wikipedia

In precedenza, un singolo articolo di Wikipedia era suddiviso in N righe di paragrafi. I risultati della ricerca restituivano paragrafi sparsi, costringendo il sistema a raggrupparli e a indovinare a quale articolo appartenessero.

Con un array di strutture, l'intero articolo diventa una riga. Tutti i paragrafi e i loro incorporamenti sono raggruppati in un campo paragrafo e il database restituisce l'articolo completo, non pezzi frammentati.

Esercitazioni pratiche: Recupero a livello di documento con l'array di strutture

1. Recupero dei documenti di Wikipedia

In questa esercitazione vedremo come utilizzare un Array of Structs per convertire i dati a livello di paragrafo in record di documenti completi, consentendo a Milvus di eseguire un vero e proprio recupero a livello di documento, invece di restituire frammenti isolati.

Molte pipeline di basi di conoscenza memorizzano gli articoli di Wikipedia come pezzi di paragrafo. Questo funziona bene per l'incorporazione e l'indicizzazione, ma non per il recupero: una query dell'utente restituisce tipicamente paragrafi sparsi, costringendo l'utente a raggruppare e ricostruire manualmente l'articolo. Con un array di strutture e MAX_SIM, possiamo riprogettare lo schema di memorizzazione in modo che ogni articolo diventi una riga e Milvus possa classificare e restituire l'intero documento in modo nativo.

Nei prossimi passi mostreremo come:

1. Caricare e preelaborare i dati dei paragrafi di Wikipedia

2. raggruppare tutti i paragrafi appartenenti allo stesso articolo in un array di strutture

3. Inserire questi documenti strutturati in Milvus

4. Eseguire query MAX_SIM per recuperare gli articoli completi, in modo pulito, senza deduplicazione o reranking.

Alla fine di questo tutorial, avrete una pipeline funzionante in cui Milvus gestisce direttamente il recupero a livello di entità, esattamente nel modo in cui gli utenti si aspettano.

Modello dei dati:

{
    "wiki_id": int,                  # WIKI ID(primary key） 
    "paragraphs": ARRAY<STRUCT<      # Array of paragraph structs
        text:VARCHAR                 # Paragraph text
        emb: FLOAT_VECTOR(768)       # Embedding for each paragraph
    >>
}

Passo 1: raggruppare e trasformare i dati

Per questa dimostrazione, utilizziamo il set di dati Simple Wikipedia Embeddings.

import pandas as pd
import pyarrow as pa
# Load the dataset and group by wiki_id
df = pd.read_parquet(“train-*.parquet”)
grouped = df.groupby(‘wiki_id’)
# Build the paragraph array for each article
wiki_data = []
for wiki_id, group in grouped:
wiki_data.append({
‘wiki_id’: wiki_id,
‘paragraphs’: [{‘text’: row[‘text’], ‘emb’: row[‘emb’]}
for _, row in group.iterrows()]
})

Fase 2: Creare la raccolta Milvus

from pymilvus import MilvusClient, DataType
client = MilvusClient(uri=“http://localhost:19530”)
schema = client.create_schema()
schema.add_field(“wiki_id”, DataType.INT64, is_primary=True)
# Define the Struct schema
struct_schema = client.create_struct_field_schema()
struct_schema.add_field(“text”, DataType.VARCHAR, max_length=65535)
struct_schema.add_field(“emb”, DataType.FLOAT_VECTOR, dim=768)
schema.add_field(“paragraphs”, DataType.ARRAY,
element_type=DataType.STRUCT,
struct_schema=struct_schema, max_capacity=200)
client.create_collection(“wiki_docs”, schema=schema)

Fase 3: inserimento dei dati e costruzione dell'indice

# Batch insert documents
client.insert("wiki_docs", wiki_data)
# Create an HNSW index
index_params = client.prepare_index_params()
index_params.add_index(
field_name="paragraphs[emb]",
index_type=“HNSW”,
metric_type=“MAX_SIM_COSINE”,
params={“M”: 16, “efConstruction”: 200}
)
client.create_index(“wiki_docs”, index_params)
client.load_collection(“wiki_docs”)

Fase 4: Ricerca dei documenti

# Search query
import cohere
from pymilvus.client.embedding_list import EmbeddingList
# The dataset uses Cohere’s multilingual-22-12 embedding model, so we must embed the query using the same model.
co = cohere.Client(f"<>")
query = ‘Who founded Youtube’
response = co.embed(texts=[query], model=‘multilingual-22-12’)
query_embedding = response.embeddings
query_emb_list = EmbeddingList()
for vec in query_embedding[0]:
query_emb_list.add(vec)
results = client.search(
collection_name=“wiki_docs”,
data=[query_emb_list],
anns_field="paragraphs[emb]",
search_params={
“metric_type”: “MAX_SIM_COSINE”,
“params”: {“ef”: 200, “retrieval_ann_ratio”: 3}
},
limit=10,
output_fields=[“wiki_id”]
)
# Results: directly return 10 full articles!
for hit in results[0]:
print(f"Article {hit[‘entity’][‘wiki_id’]}: Score {hit[‘distance’]:.4f}")

Confronto dei risultati: Recupero tradizionale vs. Array di strutture

L'impatto di Array of Structs diventa chiaro quando si guarda a ciò che il database effettivamente restituisce:

Dimensione	Approccio tradizionale	Array di strutture
Output del database	Restituisce i primi 100 paragrafi (elevata ridondanza)	Restituisce i primi 10 documenti completi - puliti e accurati
Logica applicativa	Richiede il raggruppamento, la deduplicazione e il reranking (complesso)	Non è necessaria alcuna post-elaborazione - i risultati a livello di entità provengono direttamente da Milvus

Nell'esempio di Wikipedia, abbiamo dimostrato solo il caso più semplice: la combinazione di vettori di paragrafi in una rappresentazione unificata del documento. Ma il vero punto di forza di Array of Structs è che è generalizzabile a qualsiasi modello di dati multivettoriale, sia alle classiche pipeline di recupero che alle moderne architetture di intelligenza artificiale.

Scenari di recupero multivettoriale tradizionali

Molti sistemi di ricerca e raccomandazione consolidati operano naturalmente su entità con più vettori associati. Array of Structs si adatta perfettamente a questi casi d'uso:

Scenario	Modello di dati	Vettori per entità
🛍️ Prodotti di e-commerce	Un prodotto → più immagini	5-20
🎬 Ricerca video	Un video → più clip	20-100
📖 Ricerca carta	Un documento → più sezioni	5-15

Carichi di lavoro dei modelli di intelligenza artificiale (casi d'uso chiave multivettoriali)

L'array di strutture diventa ancora più critico nei moderni modelli di IA che producono intenzionalmente grandi insiemi di vettori per entità per un ragionamento semantico a grana fine.

Modello	Modello di dati	Vettori per entità	Applicazione
ColBERT	Un documento → molte incorporazioni di token	100-500	Testo legale, documenti accademici, recupero di documenti a grana fine
ColPali	Una pagina PDF → molte incorporazioni di patch	256-1024	Rapporti finanziari, contratti, fatture, ricerca di documenti multimodale

Questi modelli richiedono uno schema di archiviazione multivettore. Prima di Array of Structs, gli sviluppatori dovevano dividere i vettori tra le righe e ricucire manualmente i risultati. Con Milvus, queste entità possono essere memorizzate e recuperate in modo nativo, con MAX_SIM che gestisce automaticamente il punteggio a livello di documento.

2. Ricerca di documenti basata su immagini ColPali

ColPali è un potente modello per il recupero cross-modale di PDF. Invece di basarsi sul testo, elabora ogni pagina PDF come un'immagine e la suddivide in un massimo di 1024 patch visive, generando un embedding per ogni patch. In uno schema di database tradizionale, ciò richiederebbe la memorizzazione di una singola pagina come centinaia o migliaia di righe separate, rendendo impossibile per il database capire che queste righe appartengono alla stessa pagina. Di conseguenza, la ricerca a livello di entità diventa frammentata e poco pratica.

Array of Structs risolve questo problema in modo pulito, memorizzando tutti i patch embeddings all'interno di un singolo campo, consentendo a Milvus di trattare la pagina come un'entità coesa e multivettoriale.

La ricerca tradizionale nei PDF dipende spesso dall'OCR, che converte le immagini delle pagine in testo. Questo funziona per il testo semplice, ma perde grafici, tabelle, layout e altri elementi visivi. ColPali evita questa limitazione lavorando direttamente sulle immagini delle pagine, conservando tutte le informazioni visive e testuali. Il compromesso è la scala: ogni pagina contiene ora centinaia di vettori, il che richiede un database in grado di aggregare molte incorporazioni in un'unica entità, esattamente ciò che fornisce Array of Structs + MAX_SIM.

Il caso d'uso più comune è Vision RAG, dove ogni pagina PDF diventa un'entità multivettore. Gli scenari tipici includono:

• Rapporti finanziari: ricerca in migliaia di PDF di pagine contenenti grafici o tabelle specifiche.

• Contratti: recupero di clausole da documenti legali scansionati o fotografati.

• Fatture: ricerca di fatture per fornitore, importo o layout.

• Presentazioni: individuazione delle diapositive che contengono una particolare figura o diagramma.

Modello di dati:

{
    "page_id": int,                     # Page ID (primary key) 
    "page_number": int,                 # Page number within the document 
    "doc_name": VARCHAR,                # Document name
    "patches": ARRAY<STRUCT<            # Array of patch objects
        patch_embedding: FLOAT_VECTOR(128)  # Embedding for each patch
    >>
}

Fase 1: Preparare i datiPer i dettagli su come ColPali converte le immagini o il testo in rappresentazioni multivettoriali, potete consultare il documento.

import torch
from PIL import Image
from colpali_engine.models import ColPali, ColPaliProcessor
model_name = “vidore/colpali-v1.3”
model = ColPali.from_pretrained(
model_name,
torch_dtype=torch.bfloat16,
device_map=“cuda:0”,  # or “mps” if on Apple Silicon
).eval()
processor = ColPaliProcessor.from_pretrained(model_name)
# Example: 2 documents, 5 pages each, total 10 images
images = [
Image.open(“path/to/your/image1.png”),
Image.open(“path/to/your/image2.png”),
…
Image.open(“path/to/your/image10.png”)
]
# Convert each image into multiple patch embeddings
batch_images = processor.process_images(images).to(model.device)
with torch.no_grad():
image_embeddings = model(**batch_images)

Fase 2: Creare la collezione Milvus

from pymilvus import MilvusClient, DataType
client = MilvusClient(uri=“http://localhost:19530”)
schema = client.create_schema()
schema.add_field(“page_id”, DataType.INT64, is_primary=True)
schema.add_field(“page_number”, DataType.INT64)
schema.add_field(“doc_name”, DataType.VARCHAR, max_length=500)
# Struct Array for patches
struct_schema = client.create_struct_field_schema()
struct_schema.add_field(“patch_embedding”, DataType.FLOAT_VECTOR, dim=128)
schema.add_field(“patches”, DataType.ARRAY,
element_type=DataType.STRUCT,
struct_schema=struct_schema, max_capacity=2048)
client.create_collection(“doc_pages”, schema=schema)

Fase 3: Inserire i dati e costruire l'indice

# Prepare data for insertion
page_data=[
    {
        "page_id": 0,
        "page_number": 0,
        "doc_name": "Q1_Financial_Report.pdf",
        "patches": [
            {"patch_embedding": emb} for emb in image_embeddings[0]
        ],
    },
    ...,
    {
        "page_id": 9,
        "page_number": 4,
        "doc_name": "Product_Manual.pdf",
        "patches": [
            {"patch_embedding": emb} for emb in image_embeddings[9]
        ],
    },
]
client.insert(“doc_pages”, page_data)
# Create index
index_params = client.prepare_index_params()
index_params.add_index(
field_name="patches[patch_embedding]",
index_type=“HNSW”,
metric_type=“MAX_SIM_IP”,
params={“M”: 32, “efConstruction”: 200}
)
client.create_index(“doc_pages”, index_params)
client.load_collection(“doc_pages”)

Fase 4: Ricerca intermodale: Interrogazione del testo → Risultati dell'immagine

# Run the search
from pymilvus.client.embedding_list import EmbeddingList
queries = [
“quarterly revenue growth chart”    

]
# Convert the text query into a multi-vector representation
batch_queries = processor.process_queries(queries).to(model.device)
with torch.no_grad():
query_embeddings = model(**batch_queries)
query_emb_list = EmbeddingList()
for vec in query_embeddings[0]:
query_emb_list.add(vec)
results = client.search(
collection_name=“doc_pages”,
data=[query_emb_list],
anns_field="patches[patch_embedding]",
search_params={
“metric_type”: “MAX_SIM_IP”,
“params”: {“ef”: 100, “retrieval_ann_ratio”: 3}
},
limit=3,
output_fields=[“page_id”, “doc_name”, “page_number”]
)
print(f"Query: '{queries[0]}'")
for i, hit in enumerate(results, 1):
entity = hit[‘entity’]
print(f"{i}. {entity[‘doc_name’]} - Page {entity[‘page_number’]}")
print(f"   Score: {hit[‘distance’]:.4f}\n")

Esempio di output:

Query: 'quarterly revenue growth chart'
1. Q1_Financial_Report.pdf - Page 2
   Score: 0.9123
2. Q1_Financial_Report.pdf - Page 1
Score: 0.7654
3. Product_Manual.pdf - Page 1
Score: 0.5231

Qui i risultati restituiscono direttamente le pagine PDF complete. Non è necessario preoccuparsi delle 1024 patch embeddings sottostanti: Milvus gestisce automaticamente l'aggregazione.

Conclusione

La maggior parte dei database vettoriali memorizza ogni frammento come un record indipendente, il che significa che le applicazioni devono riassemblare i frammenti quando hanno bisogno di un documento, un prodotto o una pagina completa. Un array di strutture cambia questa situazione. Combinando scalari, vettori, testo e altri campi in un unico oggetto strutturato, permette a una riga di database di rappresentare un'entità completa da capo a fondo.

Il risultato è semplice ma potente: il lavoro che prima richiedeva complessi raggruppamenti, deduplicazioni e riordini nel livello applicativo diventa una capacità nativa del database. Il futuro dei database vettoriali è proprio questo: strutture più ricche, recupero più intelligente e pipeline più semplici.

Per ulteriori informazioni su Array of Structs e MAX_SIM, consultate la documentazione qui sotto:

• Array of Structs | Documentazione Milvus

Avete domande o volete un approfondimento su una qualsiasi funzione dell'ultima versione di Milvus? Unitevi al nostro canale Discord o inviate problemi su GitHub. È anche possibile prenotare una sessione individuale di 20 minuti per ottenere approfondimenti, indicazioni e risposte alle vostre domande tramite Milvus Office Hours.