Desbloquear a verdadeira recuperação ao nível da entidade: Novas capacidades de matriz de estruturas e MAX_SIM no Milvus

Se criou aplicações de IA com base em bases de dados vectoriais, provavelmente já se deparou com o mesmo problema: a base de dados recupera embeddings de pedaços individuais, mas a sua aplicação preocupa-se com entidades. A incompatibilidade torna complexo todo o fluxo de trabalho de recuperação.

É provável que já tenha visto isto acontecer vezes sem conta:

• Bases de dados de conhecimento RAG: Os artigos são divididos em fragmentos de parágrafos, pelo que o motor de busca devolve fragmentos dispersos em vez do documento completo.

• Recomendação de comércio eletrónico: Um produto tem vários embeddings de imagem e o seu sistema devolve cinco ângulos do mesmo item em vez de cinco produtos únicos.

• Plataformas de vídeo: Os vídeos são divididos em clip embeddings, mas os resultados da pesquisa apresentam partes do mesmo vídeo em vez de uma única entrada consolidada.

• Recuperação ao estilo ColBERT / ColPali: Os documentos expandem-se em centenas de token ou patch-level embeddings, e os resultados aparecem como pequenos pedaços que ainda precisam de ser fundidos.

Todos estes problemas têm origem na mesma lacuna arquitetónica: a maioria das bases de dados vectoriais trata cada incorporação como uma linha isolada, enquanto as aplicações reais operam em entidades de nível superior - documentos, produtos, vídeos, itens, cenas. Como resultado, as equipas de engenharia são forçadas a reconstruir as entidades manualmente utilizando a lógica de deduplicação, agrupamento, agrupamento e classificação. Funciona, mas é frágil, lento e incha a camada de aplicação com lógica que nunca deveria ter existido.

Milvus 2.6.4 fecha essa lacuna com uma nova funcionalidade: Array of Structs com o tipo de métrica MAX_SIM. Juntos, eles permitem que todos os embeddings de uma única entidade sejam armazenados em um único registro e permitem que Milvus pontue e retorne a entidade holisticamente. Não há mais conjuntos de resultados duplicados. Não há mais pós-processamento complexo como reranking e merging

Neste artigo, vamos explicar como funciona o Array of Structs e o MAX_SIM - e demonstrá-los através de dois exemplos reais: Recuperação de documentos da Wikipédia e pesquisa de documentos baseada em imagens do ColPali.

O que é um Array of Structs?

Em Milvus, um campo Array of Structs permite que um único registo contenha uma lista ordenada de elementos Struct, cada um seguindo o mesmo esquema predefinido. Um Struct pode conter vários vectores, bem como campos escalares, cadeias de caracteres ou quaisquer outros tipos suportados. Por outras palavras, permite-lhe agrupar todas as peças que pertencem a uma entidade - incorporações de parágrafos, visualizações de imagens, vectores de símbolos, metadados - diretamente numa linha.

Aqui está um exemplo de uma entidade de uma coleção que contém um 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
}

No exemplo acima, o campo chunks é um campo de matriz de estruturas e cada elemento de estrutura contém seus próprios campos, ou seja, text, text_vector e chapter.

Esta abordagem resolve um problema de modelação de longa data nas bases de dados vectoriais. Tradicionalmente, cada incorporação ou atributo tem de se tornar a sua própria linha, o que obriga a que entidades multi-vectoriais (documentos, produtos, vídeos) sejam divididas em dezenas, centenas ou mesmo milhares de registos. Com o Array of Structs, o Milvus permite-lhe armazenar toda a entidade multi-vetorial num único campo, o que o torna um ajuste natural para listas de parágrafos, token embeddings, sequências de clipes, imagens multi-view, ou qualquer cenário onde um item lógico é composto por muitos vectores.

Como um conjunto de estruturas funciona com o MAX_SIM?

Sobreposto a esta nova estrutura de matriz de estruturas está o MAX_SIM, uma nova estratégia de pontuação que torna a recuperação semântica consciente da entidade. Quando uma consulta chega, o Milvus compara-a com todos os vectores dentro de cada Array of Structs e considera a semelhança máxima como a pontuação final da entidade. A entidade é então classificada - e devolvida - com base nessa pontuação única. Isto evita o problema clássico da base de dados de vectores de recuperar fragmentos dispersos e empurra o fardo do agrupamento, desduplicação e nova classificação para a camada de aplicação. Com MAX_SIM, a recuperação a nível de entidade torna-se integrada, consistente e eficiente.

Para entender como o MAX_SIM funciona na prática, vamos analisar um exemplo concreto.

Nota: Todos os vectores neste exemplo são gerados pelo mesmo modelo de incorporação, e a similaridade é medida com a similaridade de cosseno no intervalo [0,1].

Suponhamos que um utilizador procura "Curso para principiantes em aprendizagem automática".

A consulta é tokenizada em três tokens:

• Aprendizagem de máquinas

• iniciante

• curso

Cada um destes tokens é então convertido num vetor de incorpor ação pelo mesmo modelo de incorporação utilizado para os documentos.

Agora, imagine que a base de dados de vectores contém dois documentos:

• doc_1: Um guia de introdução às redes neurais profundas com Python

• doc_2: Um guia avançado para a leitura de artigos LLM

Ambos os documentos foram incorporados em vetores e armazenados dentro de um array de structs.

Passo 1: Calcular MAX_SIM para doc_1

Para cada vetor de consulta, o Milvus calcula a sua similaridade cosseno em relação a todos os vectores do doc_1:

	Introdução	guia	redes neuronais profundas	python
aprendizagem de máquinas	0.0	0.0	0.9	0.3
principiante	0.8	0.1	0.0	0.3
curso	0.3	0.7	0.1	0.1

Para cada vetor de consulta, o MAX_SIM seleciona a maior semelhança da sua linha:

• aprendizagem automática → redes neurais profundas (0,9)

• iniciante → introdução (0.8)

• curso → guia (0,7)

A soma das melhores correspondências dá a doc_1 uma pontuação MAX_SIM de 2,4.

Passo 2: Calcular MAX_SIM para doc_2

Agora repetimos o processo para o documento_2:

	avançado	guia	LLM	papel	leitura
aprendizagem de máquinas	0.1	0.2	0.9	0.3	0.1
principiante	0.4	0.6	0.0	0.2	0.5
curso	0.5	0.8	0.1	0.4	0.7

As melhores correspondências para doc_2 são:

• "aprendizagem automática" → "LLM" (0.9)

• "iniciante" → "guia" (0.6)

• "curso" → "guia" (0,8)

A soma das pontuações dá ao doc_2 uma pontuação MAX_SIM de 2,3.

Passo 3: Comparar as pontuações

Como 2,4 > 2,3, o documento 1 tem uma classificação superior ao documento 2, o que faz sentido intuitivamente, uma vez que o documento 1 está mais próximo de um guia introdutório de aprendizagem automática.

A partir deste exemplo, podemos destacar três caraterísticas principais do MAX_SIM:

• Semântica em primeiro lugar, não baseada em palavras-chave: O MAX_SIM compara embeddings, não literais de texto. Apesar de "machine learning" e "deep neural networks" partilharem zero palavras sobrepostas, a sua semelhança semântica é de 0,9. Isto torna o MAX_SIM robusto a sinónimos, paráfrases, sobreposições conceptuais e cargas de trabalho modernas ricas em embedding.

• Insensível ao comprimento e à ordem: MAX_SIM não requer que a consulta e o documento tenham o mesmo número de vectores (por exemplo, doc_1 tem 4 vectores enquanto doc_2 tem 5, e ambos funcionam bem). Também ignora a ordem dos vectores - "beginner" que aparece mais cedo na consulta e "introduction" que aparece mais tarde no documento não tem impacto na pontuação.

• Cada vetor de consulta é importante: O MAX_SIM considera a melhor correspondência para cada vetor de consulta e soma essas melhores pontuações. Isto evita que vectores sem correspondência distorçam o resultado e garante que cada token de consulta importante contribui para a pontuação final. Por exemplo, a correspondência de menor qualidade para "iniciante" em doc_2 reduz diretamente sua pontuação geral.

Porque é que MAX_SIM + Array of Structs são importantes na Base de Dados Vetorial

O Milvus é uma base de dados vetorial de alto desempenho e de código aberto, que agora suporta totalmente o MAX_SIM juntamente com Array of Structs, permitindo a recuperação multi-vetorial nativa do vetor e ao nível da entidade:

• Armazene entidades multi-vectoriais de forma nativa: O Array of Structs permite-lhe armazenar grupos de vectores relacionados num único campo sem os dividir em linhas separadas ou tabelas auxiliares.

• Cálculo eficiente da melhor correspondência: Combinado com índices vectoriais como IVF e HNSW, o MAX_SIM pode calcular as melhores correspondências sem analisar cada vetor, mantendo o desempenho elevado mesmo com documentos grandes.

• Criado especificamente para cargas de trabalho semânticas pesadas: Essa abordagem se destaca na recuperação de textos longos, correspondência semântica multifacetada, alinhamento de resumo de documentos, consultas com várias palavras-chave e outros cenários de IA que exigem raciocínio semântico flexível e refinado.

Quando usar uma Matriz de Estruturas

O valor de Array of Structs torna-se claro quando se olha para o que ele permite. Em sua essência, esse recurso fornece três capacidades fundamentais:

• Agrupa dados heterogéneos - vectores, escalares, cadeias de caracteres, metadados - num único objeto estruturado.

• Alinha o armazenamento com entidades do mundo real, para que cada linha da base de dados seja mapeada de forma clara para um item real, como um artigo, um produto ou um vídeo.

• Quando combinado com funções agregadas como MAX_SIM, permite uma verdadeira recuperação multi-vetorial ao nível da entidade diretamente a partir da base de dados, eliminando a deduplicação, o agrupamento ou a reordenação na camada de aplicação.

Devido a estas propriedades, Array of Structs é um ajuste natural sempre que uma única entidade lógica é representada por vários vectores. Exemplos comuns incluem artigos divididos em parágrafos, documentos decompostos em token embeddings ou produtos representados por várias imagens. Se os seus resultados de pesquisa sofrem de resultados duplicados, fragmentos dispersos ou a mesma entidade aparece várias vezes nos principais resultados, o Array of Structs resolve estes problemas na camada de armazenamento e recuperação - não através de correcções posteriores no código da aplicação.

Esse padrão é especialmente poderoso para sistemas modernos de IA que dependem da recuperação de vários vetores. Por exemplo:

• O ColBERT representa um único documento como 100-500 token embeddings para uma correspondência semântica refinada em domínios como o texto jurídico e a investigação académica.

• O ColPali converte cada página de PDF em 256-1024 fragmentos de imagem para recuperação multimodal de extractos financeiros, contratos, facturas e outros documentos digitalizados.

Uma matriz de Structs permite que o Milvus armazene todos esses vetores em uma única entidade e calcule a similaridade agregada (por exemplo, MAX_SIM) de forma eficiente e nativa. Para tornar isto mais claro, aqui estão dois exemplos concretos.

Exemplo 1: Pesquisa de produtos de comércio eletrónico

Anteriormente, os produtos com várias imagens eram armazenados num esquema plano - uma imagem por linha. Um produto com fotos frontais, laterais e em ângulo produzia três linhas. Os resultados da pesquisa frequentemente retornavam várias imagens do mesmo produto, exigindo desduplicação manual e nova classificação.

Com uma matriz de estruturas, cada produto torna-se numa linha. Todas as incorporações de imagens e metadados (ângulo, is_primary, etc.) vivem dentro de um campo images como uma matriz de structs. Milvus entende que eles pertencem ao mesmo produto e retorna o produto como um todo - não suas imagens individuais.

Exemplo 2: Base de conhecimento ou pesquisa na Wikipédia

Anteriormente, um único artigo da Wikipédia era dividido em N linhas de parágrafos. Os resultados da pesquisa retornavam parágrafos dispersos, forçando o sistema a agrupá-los e adivinhar a que artigo pertenciam.

Com uma matriz de estruturas, o artigo inteiro torna-se numa linha. Todos os parágrafos e suas incorporações são agrupados em um campo de parágrafos, e o banco de dados retorna o artigo completo, não pedaços fragmentados.

Tutoriais práticos: Recuperação em nível de documento com a matriz de estruturas

1. Recuperação de documentos da Wikipédia

Neste tutorial, vamos ver como usar um Array of Structs para converter dados ao nível dos parágrafos em registos de documentos completos - permitindo que o Milvus faça uma verdadeira recuperação ao nível do documento em vez de devolver fragmentos isolados.

Muitos pipelines de bases de conhecimento armazenam artigos da Wikipédia como pedaços de parágrafos. Isto funciona bem para incorporação e indexação, mas é uma falha na recuperação: uma consulta do utilizador normalmente devolve parágrafos dispersos, forçando-o a agrupar e reconstruir manualmente o artigo. Com um Array of Structs e MAX_SIM, podemos redesenhar o esquema de armazenamento para que cada artigo se torne uma linha, e o Milvus pode classificar e retornar o documento inteiro nativamente.

Nos próximos passos, mostraremos como:

1. Carregar e pré-processar dados de parágrafos da Wikipédia

2. Agrupar todos os parágrafos pertencentes ao mesmo artigo numa matriz de estruturas

3. Inserir estes documentos estruturados no Milvus

4. Executar consultas MAX_SIM para obter artigos completos - de forma limpa, sem deduções ou reanálises

No final deste tutorial, terá um pipeline funcional onde o Milvus lida diretamente com a recuperação ao nível da entidade, exatamente da forma que os utilizadores esperam.

Modelo de dados:

{
    "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
    >>
}

Etapa 1: agrupar e transformar os dados

Para esta demonstração, usamos o conjunto de dados 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()]
})

Passo 2: Criar a coleção 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)

Passo 3: Inserir dados e criar índice

# 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”)

Etapa 4: Pesquisar documentos

# 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}")

Comparação de resultados: Recuperação tradicional vs. Matriz de estruturas

O impacto da Matriz de estruturas fica claro quando olhamos para o que o banco de dados realmente retorna:

Dimensão	Abordagem tradicional	Matriz de estruturas
Saída da base de dados	Devolve os 100 parágrafos principais (elevada redundância)	Devolve os 10 principais documentos completos - limpos e exactos
Lógica da aplicação	Requer agrupamento, deduplicação e reanálise (complexo)	Não é necessário pós-processamento - os resultados ao nível da entidade vêm diretamente do Milvus

No exemplo da Wikipédia, demonstrámos apenas o caso mais simples: combinar vectores de parágrafos numa representação unificada do documento. Mas a verdadeira força do Array of Structs é que ele se generaliza para qualquer modelo de dados multi-vetorial - tanto os pipelines de recuperação clássicos como as arquitecturas modernas de IA.

Cenários tradicionais de recuperação multi-vetorial

Muitos sistemas de pesquisa e recomendação bem estabelecidos operam naturalmente em entidades com vários vectores associados. Array of Structs mapeia esses casos de uso de forma limpa:

Cenário	Modelo de dados	Vectores por entidade
🛍️ Produtos de comércio eletrónico	Um produto → várias imagens	5-20
Pesquisa de vídeo	Um vídeo → vários clips	20-100
Recuperação de papel	Um documento → várias secções	5-15

Cargas de trabalho de modelos de IA (casos de utilização multi-vectoriais fundamentais)

A matriz de estruturas torna-se ainda mais crítica nos modelos modernos de IA que produzem intencionalmente grandes conjuntos de vectores por entidade para um raciocínio semântico refinado.

Modelo	Modelo de dados	Vectores por entidade	Aplicação
ColBERT	Um documento → muitos token embeddings	100-500	Textos jurídicos, artigos académicos, recuperação de documentos com precisão
ColPali	Uma página PDF → muitas incorporações de fragmentos	256-1024	Relatórios financeiros, contratos, facturas, pesquisa multimodal de documentos

Estes modelos requerem um padrão de armazenamento multi-vetorial. Antes do Array of Structs, os programadores tinham de dividir os vectores por linhas e juntar manualmente os resultados. Com o Milvus, estas entidades podem agora ser armazenadas e recuperadas de forma nativa, com o MAX_SIM a tratar automaticamente a pontuação ao nível do documento.

2. Pesquisa de documentos baseada em imagens ColPali

O ColPali é um modelo poderoso para a recuperação multimodal de PDFs. Em vez de se basear em texto, processa cada página de PDF como uma imagem e divide-a em até 1024 partes visuais, gerando uma incorporação por parte de cada parte. Num esquema de base de dados tradicional, isto exigiria o armazenamento de uma única página como centenas ou milhares de linhas separadas, tornando impossível para a base de dados compreender que estas linhas pertencem à mesma página. Como resultado, a pesquisa ao nível da entidade torna-se fragmentada e impraticável.

O Array of Structs resolve este problema armazenando todos os patch embeddings num único campo, permitindo que o Milvus trate a página como uma entidade coesa e multi-vetorial.

A pesquisa tradicional em PDFs geralmente depende do OCR, que converte imagens de páginas em texto. Isso funciona para texto simples, mas perde gráficos, tabelas, layout e outras dicas visuais. O ColPali evita esta limitação ao trabalhar diretamente nas imagens das páginas, preservando todas as informações visuais e textuais. A desvantagem é a escala: cada página contém agora centenas de vectores, o que requer uma base de dados que possa agregar muitos embeddings numa única entidade - exatamente o que o Array of Structs + MAX_SIM fornece.

O caso de utilização mais comum é o Vision RAG, em que cada página PDF se torna uma entidade multi-vetorial. Os cenários típicos incluem:

• Relatórios financeiros: pesquisa em milhares de PDFs por páginas que contenham gráficos ou tabelas específicos.

• Contratos: recuperação de cláusulas de documentos legais digitalizados ou fotografados.

• Facturas: localizar facturas por fornecedor, montante ou esquema.

• Apresentações: localização de diapositivos que contenham uma figura ou diagrama específico.

Modelo de dados:

{
    "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
    >>
}

Passo 1: Preparar os dadosPode consultar o documento para obter detalhes sobre como o ColPali converte imagens ou texto em representações multi-vectoriais.

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)

Passo 2: Criar a coleção 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)

Passo 3: Inserir dados e criar índice

# 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”)

Passo 4: Pesquisa multimodal: Consulta de texto → Resultados de imagem

# 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")

Exemplo de saída:

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

Aqui, os resultados retornam diretamente páginas PDF completas. Não precisamos de nos preocupar com os 1024 patch embeddings subjacentes - o Milvus trata de toda a agregação automaticamente.

Conclusão

A maioria dos bancos de dados vetoriais armazena cada fragmento como um registro independente, o que significa que os aplicativos precisam remontar esses fragmentos quando precisam de um documento, produto ou página completa. Uma matriz de Structs muda isso. Ao combinar escalares, vectores, texto e outros campos num único objeto estruturado, permite que uma linha da base de dados represente uma entidade completa de ponta a ponta.

O resultado é simples, mas poderoso: o trabalho que costumava exigir agrupamento, eliminação de duplicações e reanálise complexos na camada de aplicação torna-se uma capacidade nativa da base de dados. E é exatamente para aí que se dirige o futuro das bases de dados vectoriais: estruturas mais ricas, recuperação mais inteligente e condutas mais simples.

Para obter mais informações sobre Array of Structs e MAX_SIM, consulte a documentação abaixo:

• Matriz de Structs | Documentação do Milvus

Tem dúvidas ou quer aprofundar qualquer caraterística do Milvus mais recente? Junte-se ao nosso canal Discord ou arquive problemas no GitHub. Você também pode reservar uma sessão individual de 20 minutos para obter insights, orientações e respostas às suas perguntas através do Milvus Office Hours.