Desbloquear la verdadera recuperación a nivel de entidad: Nuevas funciones Array-of-Structs y MAX_SIM en Milvus

Si ha creado aplicaciones de IA sobre bases de datos vectoriales, probablemente se haya encontrado con el mismo problema: la base de datos recupera incrustaciones de fragmentos individuales, pero su aplicación se centra en entidades. El desajuste hace que todo el flujo de trabajo de recuperación sea complejo.

Es probable que haya visto esta situación una y otra vez:

• Bases de conocimiento RAG: Los artículos se dividen en párrafos, por lo que el motor de búsqueda devuelve fragmentos dispersos en lugar del documento completo.

• Recomendaciones de comercio electrónico: Un producto tiene varias imágenes incrustadas y el sistema devuelve cinco ángulos del mismo artículo en lugar de cinco productos únicos.

• Plataformas de vídeo: Los vídeos se dividen en incrustaciones de clips, pero los resultados de búsqueda muestran fragmentos del mismo vídeo en lugar de una única entrada consolidada.

• Recuperación al estilo ColBERT / ColPali: Los documentos se expanden en cientos de incrustaciones a nivel de token o parche, y los resultados se obtienen en trozos minúsculos que todavía hay que combinar.

Todos estos problemas tienen su origen en la misma carencia arquitectónica: la mayoría de las bases de datos vectoriales tratan cada incrustación como una fila aislada, mientras que las aplicaciones reales operan con entidades de nivel superior: documentos, productos, vídeos, elementos, escenas. Como resultado, los equipos de ingeniería se ven obligados a reconstruir las entidades manualmente utilizando la lógica de deduplicación, agrupación, bucketing y reordenación. Funciona, pero es frágil, lento y sobrecarga su capa de aplicación con lógica que nunca debería haber vivido allí en primer lugar.

Milvus 2.6.4 cierra esta brecha con una nueva característica: Array of Structs con el tipo métrico MAX_SIM. Juntos, permiten que todas las incrustaciones de una única entidad se almacenen en un único registro y permiten a Milvus puntuar y devolver la entidad de forma holística. Se acabaron los conjuntos de resultados duplicados. Se acabaron los complejos postprocesamientos, como el reordenamiento y la fusión.

En este artículo, veremos cómo funcionan Array of Structs y MAX_SIM, y lo demostraremos con dos ejemplos reales: La recuperación de documentos de Wikipedia y la búsqueda de documentos basada en imágenes de ColPali.

¿Qué es una matriz de estructuras?

En Milvus, un campo Array of Structs permite que un único registro contenga una lista ordenada de elementos Struct, cada uno de los cuales sigue el mismo esquema predefinido. Una Struct puede contener múltiples vectores, así como campos escalares, cadenas o cualquier otro tipo admitido. En otras palabras, le permite agrupar todas las piezas que pertenecen a una entidad (incrustaciones de párrafos, vistas de imágenes, vectores de tokens, metadatos) directamente dentro de una fila.

He aquí un ejemplo de entidad de una colección que 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
}

En el ejemplo anterior, el campo chunks es un campo Array of Structs, y cada elemento Struct contiene sus propios campos, a saber, text, text_vector y chapter.

Este enfoque resuelve un antiguo problema de modelado en las bases de datos vectoriales. Tradicionalmente, cada incrustación o atributo tiene que convertirse en su propia fila, lo que obliga a dividir las entidades multivectoriales (documentos, productos, vídeos) en docenas, cientos o incluso miles de registros. Con Array of Structs, Milvus le permite almacenar toda la entidad multivectorial en un único campo, lo que lo convierte en un ajuste natural para listas de párrafos, incrustaciones de tokens, secuencias de clips, imágenes multivista o cualquier escenario en el que un elemento lógico esté compuesto por muchos vectores.

¿Cómo funciona una matriz de estructuras con MAX_SIM?

Encima de esta nueva estructura de matriz de estructuras se encuentra MAX_SIM, una nueva estrategia de puntuación que hace que la recuperación semántica sea consciente de la entidad. Cuando llega una consulta, Milvus la compara con cada vector dentro de cada matriz de estructuras y toma la máxima similitud como puntuación final de la entidad. A continuación, la entidad se clasifica -y se devuelve- en función de esa única puntuación. De este modo se evita el problema clásico de las bases de datos vectoriales de recuperar fragmentos dispersos y se traslada la carga de agrupar, desagregar y volver a clasificar a la capa de aplicación. Con MAX_SIM, la recuperación a nivel de entidad se vuelve integrada, consistente y eficiente.

Para entender cómo funciona MAX_SIM en la práctica, veamos un ejemplo concreto.

Nota: Todos los vectores de este ejemplo son generados por el mismo modelo de incrustación, y la similitud se mide con la similitud coseno en el rango [0,1].

Supongamos que un usuario busca "Curso de aprendizaje automático para principiantes".

La consulta se tokeniza en tres tokens:

• Aprendizaje automático

• principiante

• curso

A continuación, cada uno de estos tokens se convierte en un vector de incrustación mediante el mismo modelo de incrustación utilizado para los documentos.

Ahora, imaginemos que la base de datos de vectores contiene dos documentos:

• doc_1: Guía de introducción a las redes neuronales profundas con Python

• doc_2: Guía avanzada para la lectura de trabajos LLM

Ambos documentos han sido embebidos en vectores y almacenados dentro de un Array de Structs.

Paso 1: Calcular MAX_SIM para doc_1

Para cada vector de consulta, Milvus calcula su similitud coseno contra cada vector en doc_1:

	Introducción	guía	redes neuronales profundas	python
aprendizaje automático	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 vector de consulta, MAX_SIM selecciona la mayor similitud de su fila:

• aprendizaje automático → redes neuronales profundas (0,9)

• principiante → introducción (0,8)

• curso → guía (0,7)

La suma de las mejores coincidencias da a doc_1 una puntuación MAX_SIM de 2,4.

Paso 2: Calcular MAX_SIM para doc_2

Ahora repetimos el proceso para doc_2:

	avanzado	guía	LLM	papel	lectura
aprendizaje automático	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

Las mejores coincidencias para doc_2 son:

• "aprendizaje automático" → "LLM" (0,9)

• "beginner" → "guide" (0.6)

• "curso" → "guía" (0,8)

Al sumarlos, doc_2 obtiene una puntuación MAX_SIM de 2,3.

Paso 3: Comparar las puntuaciones

Como 2,4 > 2,3, doc_1 tiene una puntuación más alta que doc_2, lo que tiene un sentido intuitivo, ya que doc_1 está más cerca de una guía introductoria de aprendizaje automático.

De este ejemplo, podemos destacar tres características principales de MAX_SIM:

• Primero semántico, no basado en palabras clave: MAX_SIM compara incrustaciones, no literales de texto. Aunque "aprendizaje automático" y "redes neuronales profundas " comparten cero palabras que se solapan, su similitud semántica es de 0,9. Esto hace que MAX_SIM sea robusto ante sinergias. Esto hace que MAX_SIM sea robusto frente a sinónimos, paráfrasis, solapamiento conceptual y cargas de trabajo modernas ricas en incrustaciones.

• Insensible a la longitud y el orden: MAX_SIM no requiere que la consulta y el documento tengan el mismo número de vectores (por ejemplo, doc_1 tiene 4 vectores mientras que doc_2 tiene 5, y ambos funcionan bien). Tampoco tiene en cuenta el orden de los vectores: que "principiante" aparezca antes en la consulta y que "introducción" aparezca después en el documento no influye en la puntuación.

• Cada vector de consulta es importante: MAX_SIM toma la mejor coincidencia para cada vector de consulta y suma las mejores puntuaciones. Esto evita que los vectores no coincidentes distorsionen el resultado y garantiza que todos los token de consulta importantes contribuyan a la puntuación final. Por ejemplo, la coincidencia de menor calidad para "principiante" en doc_2 reduce directamente su puntuación total.

Por qué MAX_SIM + Array de estructuras son importantes en la base de datos vectorial

Milvus es una base de datos vectorial de código abierto y alto rendimiento, y ahora es totalmente compatible con MAX_SIM junto con Array of Structs, lo que permite una recuperación vectorial nativa y multivectorial a nivel de entidad:

• Almacene entidades multivectoriales de forma nativa: Array of Structs le permite almacenar grupos de vectores relacionados en un único campo sin dividirlos en filas separadas o tablas auxiliares.

• Cálculo eficaz de la mejor correspondencia: Combinado con índices vectoriales como IVF y HNSW, MAX_SIM puede calcular las mejores coincidencias sin escanear cada vector, manteniendo un alto rendimiento incluso con documentos de gran tamaño.

• Diseñado específicamente para cargas de trabajo semánticas pesadas: Este enfoque destaca en la recuperación de textos largos, la correspondencia semántica multifacética, la alineación documento-resumen, las consultas multipalabra clave y otros escenarios de IA que requieren un razonamiento semántico flexible y detallado.

Cuándo utilizar una matriz de estructuras

El valor de las matrices de estructuras se hace evidente cuando se observa lo que permiten. En esencia, esta función proporciona tres capacidades fundamentales:

• Agrupa datos heterogéneos -vectores, escalares, cadenas, metadatos- en un único objeto estructurado.

• Alineael almacenamiento con entidades del mundo real, de modo que cada fila de la base de datos se asigna limpiamente a un elemento real, como un artículo, un producto o un vídeo.

• Cuando se combina con funciones de agregación como MAX_SIM, permite una verdadera recuperación multivectorial a nivel de entidad directamente desde la base de datos, eliminando la deduplicación, agrupación o renumeración en la capa de aplicación.

Debido a estas propiedades, Array of Structs es un ajuste natural siempre que una única entidad lógica esté representada por múltiples vectores. Algunos ejemplos comunes son los artículos divididos en párrafos, los documentos descompuestos en incrustaciones de tokens o los productos representados por múltiples imágenes. Si los resultados de una búsqueda contienen resultados duplicados, fragmentos dispersos o la misma entidad aparece varias veces entre los primeros resultados, Array of Structs resuelve estos problemas en la capa de almacenamiento y recuperación, no mediante parches a posteriori en el código de la aplicación.

Este patrón es especialmente potente para los modernos sistemas de inteligencia artificial que se basan en la recuperación multivectorial. Por ejemplo:

• ColBERT representa un único documento como 100-500 tokens incrustados para realizar correspondencias semánticas precisas en ámbitos como el texto jurídico y la investigación académica.

• ColPali convierte cada página PDF en 256-1024 parches de imagen para la recuperación multimodal de estados financieros, contratos, facturas y otros documentos escaneados.

Una matriz de Structs permite a Milvus almacenar todos estos vectores en una única entidad y calcular la similitud agregada (por ejemplo, MAX_SIM) de forma eficiente y nativa. Para que esto quede más claro, he aquí dos ejemplos concretos.

Ejemplo 1: Búsqueda de productos en el comercio electrónico

Anteriormente, los productos con varias imágenes se almacenaban en un esquema plano: una imagen por fila. Un producto con imágenes frontales, laterales y en ángulo producía tres filas. A menudo, los resultados de la búsqueda devolvían varias imágenes del mismo producto, lo que obligaba a deduplicarlas y reordenarlas manualmente.

Con una matriz de estructuras, cada producto se convierte en una fila. Todas las incrustaciones de imágenes y metadatos (ángulo, is_primary, etc.) viven dentro de un campo images como una matriz de structs. Milvus entiende que pertenecen al mismo producto y devuelve el producto como un todo, no sus imágenes individuales.

Ejemplo 2: Base de conocimientos o búsqueda en Wikipedia

Anteriormente, un solo artículo de Wikipedia se dividía en N filas de párrafos. Los resultados de la búsqueda devolvían párrafos dispersos, lo que obligaba al sistema a agruparlos y adivinar a qué artículo pertenecían.

Con una matriz de estructuras, todo el artículo se convierte en una fila. Todos los párrafos y sus incrustaciones se agrupan en un campo de párrafos, y la base de datos devuelve el artículo completo, no trozos fragmentados.

Tutoriales prácticos: Recuperación a nivel de documento con la matriz de estructuras

1. Recuperación de documentos de Wikipedia

En este tutorial, veremos cómo utilizar una matriz de estructuras para convertir datos a nivel de párrafo en registros de documentos completos, permitiendo a Milvus realizar una verdadera recuperación a nivel de documento en lugar de devolver fragmentos aislados.

Muchas cadenas de bases de conocimiento almacenan los artículos de Wikipedia como fragmentos de párrafos. Esto funciona bien para la incrustación y la indexación, pero dificulta la recuperación: una consulta de usuario suele devolver párrafos dispersos, lo que obliga a agrupar y reconstruir manualmente el artículo. Con una matriz de estructuras y MAX_SIM, podemos rediseñar el esquema de almacenamiento para que cada artículo se convierta en una fila, y Milvus pueda clasificar y devolver el documento completo de forma nativa.

En los siguientes pasos, mostraremos cómo:

1. Cargar y preprocesar los datos de los párrafos de Wikipedia

2. Agrupar todos los párrafos que pertenecen al mismo artículo en una matriz de estructuras.

3. Insertar estos documentos estructurados en Milvus

4. Ejecutar consultas MAX_SIM para recuperar artículos completos, de forma limpia, sin deduplicación ni renumeración.

Al final de este tutorial, tendrá un canal de trabajo en el que Milvus gestiona directamente la recuperación a nivel de entidad, exactamente como esperan los usuarios.

Modelo de datos:

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

Paso 1: Agrupar y transformar los datos

Para esta demostración, utilizamos el conjunto de datos 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()]
})

Paso 2: Crear la colección 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)

Paso 3: Insertar datos y crear un í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”)

Paso 4: Buscar 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}")

Comparación de resultados: Recuperación tradicional frente a matriz de estructuras

El impacto de Array of Structs queda claro cuando observamos lo que devuelve realmente la base de datos:

Dimensión	Enfoque tradicional	Matriz de estructuras
Resultados de la base de datos	Devuelve los 100 párrafos principales (alta redundancia)	Devuelve los 10 mejores documentos completos - limpio y preciso
Lógica de aplicación	Requiere agrupación, deduplicación y reordenación (complejo)	No necesita post-procesamiento - los resultados a nivel de entidad provienen directamente de Milvus

En el ejemplo de Wikipedia, sólo hemos demostrado el caso más sencillo: combinar vectores de párrafos en una representación unificada del documento. Pero el verdadero punto fuerte de Array of Structs es que se generaliza a cualquier modelo de datos multivectorial, tanto a las canalizaciones de recuperación clásicas como a las arquitecturas de IA modernas.

Escenarios tradicionales de recuperación multivectorial

Muchos sistemas de búsqueda y recomendación bien establecidos operan de forma natural sobre entidades con múltiples vectores asociados. Array of Structs se adapta perfectamente a estos casos de uso:

Escenario	Modelo de datos	Vectores por entidad
🛍️ Productos de comercio electrónico	Un producto → varias imágenes	5-20
🎬 Búsqueda de vídeos	Un vídeo → múltiples clips	20-100
📖 Recuperación de papel	Un papel → múltiples secciones	5-15

Cargas de trabajo de modelos de IA (casos de uso multivectoriales clave)

Array of Structs se vuelve aún más crítico en los modelos de IA modernos que producen intencionalmente grandes conjuntos de vectores por entidad para el razonamiento semántico de grano fino.

Modelo	Modelo de datos	Vectores por entidad	Aplicación
ColBERT	Un documento → muchas incrustaciones de token	100-500	Textos jurídicos, documentos académicos, recuperación de documentos detallada
ColPali	Una página PDF → muchas incrustaciones de parches	256-1024	Informes financieros, contratos, facturas, búsqueda multimodal de documentos

Estos modelos requieren un patrón de almacenamiento multivectorial. Antes de Array of Structs, los desarrolladores tenían que dividir los vectores en filas y volver a unir manualmente los resultados. Con Milvus, estas entidades pueden ahora almacenarse y recuperarse de forma nativa, con MAX_SIM gestionando automáticamente la puntuación a nivel de documento.

2. Búsqueda de documentos basada en imágenes ColPali

ColPali es un potente modelo de recuperación multimodal de PDF. En lugar de basarse en el texto, procesa cada página PDF como una imagen y la divide en hasta 1024 parches visuales, generando una incrustación por parche. En un esquema de base de datos tradicional, esto requeriría almacenar una sola página como cientos o miles de filas separadas, lo que haría imposible que la base de datos entendiera que estas filas pertenecen a la misma página. Como resultado, la búsqueda a nivel de entidad se vuelve fragmentada y poco práctica.

Array of Structs resuelve esto limpiamente almacenando todas las incrustaciones de parches dentro de un único campo, permitiendo a Milvus tratar la página como una entidad multivectorial cohesiva.

La búsqueda tradicional en PDF depende a menudo del OCR, que convierte las imágenes de la página en texto. Esto funciona para el texto sin formato, pero se pierden los gráficos, las tablas, el diseño y otras señales visuales. ColPali evita esta limitación trabajando directamente sobre las imágenes de las páginas, conservando toda la información visual y textual. La contrapartida es la escala: cada página contiene ahora cientos de vectores, lo que requiere una base de datos que pueda agregar muchas incrustaciones en una entidad, exactamente lo que ofrece Array of Structs + MAX_SIM.

El caso de uso más común es Vision RAG, donde cada página PDF se convierte en una entidad multivectorial. Los escenarios típicos incluyen:

• Informes financieros: búsqueda en miles de PDF de páginas que contengan gráficos o tablas específicos.

• Contratos: recuperación de cláusulas de documentos legales escaneados o fotografiados.

• Facturas: búsqueda de facturas por proveedor, importe o diseño.

• Presentaciones: localización de diapositivas que contengan una figura o diagrama concreto.

Modelo de datos:

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

Paso 1: Preparar los datosPuede consultar el documento para obtener información detallada sobre cómo ColPali convierte imágenes o texto en representaciones multivectoriales.

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)

Paso 2: Crear la colección 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)

Paso 3: Insertar datos y crear un í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”)

Paso 4: Búsqueda multimodal: Consulta de texto → Resultados de imagen

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

Ejemplo de resultados:

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

Aquí, los resultados devuelven directamente páginas PDF completas. No tenemos que preocuparnos de los 1024 patch embeddings subyacentes: Milvus se encarga de toda la agregación automáticamente.

Conclusión

La mayoría de las bases de datos vectoriales almacenan cada fragmento como un registro independiente, lo que significa que las aplicaciones tienen que volver a ensamblar esos fragmentos cuando necesitan un documento, producto o página completos. Una matriz de Structs cambia esta situación. Al combinar escalares, vectores, texto y otros campos en un único objeto estructurado, permite que una fila de la base de datos represente una entidad completa de extremo a extremo.

El resultado es sencillo pero potente: el trabajo que solía requerir una compleja agrupación, deduplicación y reordenación en la capa de aplicación se convierte en una capacidad nativa de la base de datos. Y ahí es exactamente hacia donde se dirige el futuro de las bases de datos vectoriales: estructuras más ricas, recuperación más inteligente y canalizaciones más sencillas.

Para obtener más información sobre Array of Structs y MAX_SIM, consulte la documentación siguiente:

• Array of Structs | Documentación de Milvus

¿Tiene preguntas o desea una inmersión profunda en cualquier característica de la última Milvus? Únase a nuestro canal Discord o presente cuestiones en GitHub. También puede reservar una sesión individual de 20 minutos para obtener información, orientación y respuestas a sus preguntas a través de Milvus Office Hours.