Разблокирование истинного поиска на уровне сущностей: Новые возможности Array-of-Structs и MAX_SIM в Milvus

Если вы создавали приложения для искусственного интеллекта на основе векторных баз данных, то, вероятно, сталкивались с одной и той же проблемой: база данных извлекает вкрапления отдельных фрагментов, а ваше приложение заботится о сущностях. Это несоответствие усложняет весь рабочий процесс извлечения.

Скорее всего, вы видели, как это происходит снова и снова:

• Базы знаний RAG: Статьи разбиты на вкрапления абзацев, поэтому поисковая система возвращает разрозненные фрагменты вместо полного документа.

• Рекомендации по электронной коммерции: Товар имеет несколько вложений изображений, и ваша система возвращает пять ракурсов одного и того же товара, а не пять уникальных продуктов.

• Видеоплатформы: Видео разбито на вкрапления клипов, но в результатах поиска появляются фрагменты одного и того же видео, а не одна объединенная запись.

• Поиск в стиле ColBERT / ColPali: Документы разбиваются на сотни вкраплений на уровне токенов или патчей, а результаты поиска выдаются в виде крошечных кусочков, которые все еще требуют объединения.

Все эти проблемы обусловлены одним и тем же архитектурным недостатком: большинство векторных баз данных рассматривают каждое вкрапление как отдельную строку, в то время как реальные приложения оперируют сущностями более высокого уровня - документами, продуктами, видео, предметами, сценами. В результате инженерные команды вынуждены реконструировать сущности вручную, используя логику дедупликации, группировки, группировки и ранжирования. Это работает, но хрупко, медленно и раздувает слой приложения логикой, которая не должна была там находиться.

Milvus 2.6.4 устраняет этот недостаток с помощью новой функции: Массив структур с метрическим типом MAX_SIM. Вместе они позволяют хранить все вкрапления для одной сущности в одной записи и дают Milvus возможность оценивать и возвращать сущность в целостном виде. Больше никаких дублирующихся наборов результатов. Никакой сложной постобработки, такой как повторное ранжирование и объединение.

В этой статье мы расскажем, как работают Array of Structs и MAX_SIM, и продемонстрируем их на двух реальных примерах: Поиск документов в Википедии и поиск документов по изображениям в ColPali.

Что такое массив структур?

В Milvus поле Array of Structs позволяет одной записи содержать упорядоченный список элементов Struct, каждый из которых следует одной и той же предопределенной схеме. Структура может содержать несколько векторов, а также скалярные поля, строки или любые другие поддерживаемые типы. Другими словами, он позволяет объединить все части, принадлежащие одной сущности - вкрапления абзацев, представления изображений, векторы токенов, метаданные - непосредственно в одной строке.

Вот пример сущности из коллекции, содержащей поле 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
}

В приведенном примере поле chunks является полем Array of Structs, а каждый элемент Struct содержит свои собственные поля, а именно text, text_vector и chapter.

Этот подход решает давнюю проблему моделирования в векторных базах данных. Традиционно каждое вложение или атрибут должны быть отдельной строкой, что вынуждает разбивать многовекторные сущности (документы, продукты, видео) на десятки, сотни или даже тысячи записей. С помощью Array of Structs Milvus позволяет хранить всю многовекторную сущность в одном поле, что делает его естественным для списков абзацев, вкраплений токенов, последовательностей клипов, многоракурсных изображений или любого сценария, в котором один логический элемент состоит из многих векторов.

Как массив структур работает с MAX_SIM?

Поверх этой новой структуры массива структур лежит MAX_SIM, новая стратегия подсчета баллов, которая делает семантический поиск ориентированным на сущность. Когда поступает запрос, Milvus сравнивает его с каждым вектором внутри каждого массива структур и берет максимальное сходство в качестве итоговой оценки сущности. Затем сущность ранжируется и возвращается на основе этой единственной оценки. Это позволяет избежать классической проблемы базы данных векторов, связанной с поиском разрозненных фрагментов, и переложить бремя группировки, дедупирования и повторного ранжирования на прикладной уровень. С MAX_SIM поиск на уровне сущностей становится встроенным, последовательным и эффективным.

Чтобы понять, как MAX_SIM работает на практике, давайте рассмотрим конкретный пример.

Примечание: все векторы в этом примере сгенерированы одной и той же моделью встраивания, а сходство измеряется косинусным сходством в диапазоне [0,1].

Предположим, пользователь ищет "курс машинного обучения для начинающих".

Запрос разбивается на три лексемы:

• Машинное обучение

• начинающий

• курс

Каждый из этих лексем затем преобразуется в вектор встраивания с помощью той же модели встраивания, которая использовалась для документов.

Теперь представьте, что база векторов содержит два документа:

• doc_1: An Introduction Guide to Deep Neural Networks with Python.

• doc_2: Продвинутое руководство по чтению LLM-документов.

Оба документа были вложены в векторы и сохранены в массиве структур.

Шаг 1: Вычислить MAX_SIM для doc_1

Для каждого вектора запроса Milvus вычисляет его косинусное сходство с каждым вектором в doc_1:

	Введение	руководство	глубокие нейронные сети	python
машинное обучение	0.0	0.0	0.9	0.3
начинающий	0.8	0.1	0.0	0.3
курс	0.3	0.7	0.1	0.1

Для каждого вектора запроса MAX_SIM выбирает наибольшее сходство из его ряда:

• машинное обучение → глубокие нейронные сети (0,9)

• новичок → введение (0,8)

• курс → руководство (0,7)

Суммирование лучших совпадений дает doc_1 оценку MAX_SIM, равную 2,4.

Шаг 2: Вычислите MAX_SIM для doc_2

Теперь мы повторим процесс для doc_2:

	advanced	руководство	LLM	статья	чтение
машинное обучение	0.1	0.2	0.9	0.3	0.1
начинающий	0.4	0.6	0.0	0.2	0.5
курс	0.5	0.8	0.1	0.4	0.7

Лучшими совпадениями для doc_2 являются:

• "машинное обучение" → "LLM" (0.9)

• "начинающий" → "руководство" (0,6)

• "курс" → "руководство" (0,8)

Их суммирование дает документу doc_2 оценку MAX_SIM, равную 2,3.

Шаг 3: Сравните баллы

Поскольку 2,4 > 2,3, doc_1 занимает более высокое место, чем doc_2, что имеет интуитивный смысл, поскольку doc_1 ближе к вводному руководству по машинному обучению.

Из этого примера мы можем выделить три основные характеристики MAX_SIM:

• Семантический подход, а не основанный на ключевых словах: MAX_SIM сравнивает вкрапления, а не текстовые литералы. Несмотря на то, что слова "машинное обучение" и "глубокие нейронные сети" не совпадают друг с другом, их семантическое сходство составляет 0,9. Это делает MAX_SIM устойчивым к синонимам, парафразам, концептуальному дублированию и современным рабочим нагрузкам с большим количеством вкраплений.

• Нечувствительность к длине и порядку: MAX_SIM не требует, чтобы запрос и документ имели одинаковое количество векторов (например, doc_1 имеет 4 вектора, а doc_2 - 5, и оба работают нормально). Он также игнорирует порядок векторов - "новичок", появившийся раньше в запросе, и "введение", появившееся позже в документе, не влияют на оценку.

• Каждый вектор запроса имеет значение: MAX_SIM берет лучшее совпадение для каждого вектора запроса и суммирует эти лучшие оценки. Это предотвращает искажение результата за счет несовпадающих векторов и гарантирует, что каждая важная лексема запроса внесет свой вклад в итоговый результат. Например, менее качественное совпадение для слова "beginner" в doc_2 напрямую снижает его общий балл.

Почему MAX_SIM + массив структур имеют значение в векторной базе данных

Milvus - это высокопроизводительная векторная база данных с открытым исходным кодом, и теперь она полностью поддерживает MAX_SIM вместе с Array of Structs, что позволяет осуществлять многовекторный поиск на уровне сущностей:

• Храните многовекторные сущности в естественном виде: Array of Structs позволяет хранить группы связанных векторов в одном поле, не разбивая их на отдельные строки или вспомогательные таблицы.

• Эффективное вычисление наилучшего соответствия: В сочетании с векторными индексами, такими как IVF и HNSW, MAX_SIM может вычислять наилучшие соответствия без сканирования каждого вектора, поддерживая высокую производительность даже при работе с большими документами.

• Предназначен для тяжелых семантических нагрузок: Этот подход отлично подходит для поиска длинных текстов, многогранного семантического сопоставления, выравнивания документов и резюме, запросов с несколькими ключевыми словами и других сценариев ИИ, требующих гибких и тонких семантических рассуждений.

Когда использовать массив структур

Ценность Array of Structs становится очевидной, когда вы посмотрите, что она позволяет. По своей сути эта функция обеспечивает три основополагающие возможности:

• Она объединяет разнородные данные - векторы, скаляры, строки, метаданные - в единый структурированный объект.

• Она приводит хранилище в соответствие с реальными сущностями, так что каждая строка базы данных четко соответствует реальному объекту, такому как статья, продукт или видео.

• В сочетании с такими агрегатными функциями, как MAX_SIM, это позволяет осуществлять истинный многовекторный поиск на уровне сущностей непосредственно из базы данных, исключая дедупликацию, группировку или повторное ранжирование на прикладном уровне.

Благодаря этим свойствам Array of Structs является естественным решением в тех случаях, когда одна логическая сущность представлена несколькими векторами. Обычные примеры - статьи, разбитые на абзацы, документы, разложенные на вкрапления токенов, или продукты, представленные несколькими изображениями. Если результаты поиска страдают от дубликатов, разрозненных фрагментов или одного и того же объекта, появляющегося несколько раз в верхних результатах, Array of Structs решает эти проблемы на уровне хранения и поиска, а не путем внесения исправлений в код приложения "постфактум".

Этот паттерн особенно силен для современных систем искусственного интеллекта, которые полагаются на многовекторный поиск. Например:

• ColBERT представляет один документ в виде 100-500 вкраплений токенов для тонкого семантического сопоставления в таких областях, как юридические тексты и академические исследования.

• ColPali преобразует каждую страницу PDF в 256-1024 патча изображения для кросс-модального поиска по финансовым отчетам, контрактам, счетам и другим отсканированным документам.

Массив структур позволяет Milvus хранить все эти векторы под одной сущностью и эффективно и нативно вычислять суммарное сходство (например, MAX_SIM). Чтобы сделать это более понятным, приведем два конкретных примера.

Пример 1: Поиск товаров в электронной коммерции

Раньше товары с несколькими изображениями хранились в плоской схеме - по одному изображению в строке. Для товара с фронтальными, боковыми и угловыми снимками создавалось три ряда. Результаты поиска часто возвращали несколько изображений одного и того же продукта, что требовало ручной дедупликации и повторного ранжирования.

При использовании массива структур каждый продукт становится одной строкой. Все вложения изображений и метаданные (угол, is_primary и т. д.) хранятся в поле images в виде массива структур. Milvus понимает, что они принадлежат одному продукту, и возвращает продукт в целом, а не его отдельные изображения.

Пример 2: База знаний или поиск в Википедии

Раньше одна статья Википедии была разбита на N строк абзацев. Результаты поиска возвращали разрозненные абзацы, заставляя систему группировать их и угадывать, к какой статье они относятся.

С массивом структур вся статья становится одной строкой. Все абзацы и их вкрапления группируются в поле paragraphs, и база данных возвращает полную статью, а не разрозненные фрагменты.

Практические руководства: Поиск на уровне документов с помощью массива структур

1. Поиск документов в Википедии

В этом руководстве мы рассмотрим, как использовать массив структур для преобразования данных на уровне абзацев в полные записи документов, что позволит Milvus выполнять поиск на уровне документов, а не возвращать изолированные фрагменты.

Многие конвейеры баз знаний хранят статьи Википедии в виде фрагментов абзацев. Это хорошо подходит для встраивания и индексирования, но мешает поиску: пользовательский запрос обычно возвращает разрозненные абзацы, заставляя вас вручную группировать и реконструировать статью. С помощью массива структур и MAX_SIM мы можем переделать схему хранения таким образом, что каждая статья станет одной строкой, и Milvus сможет ранжировать и возвращать весь документ в естественном виде.

В следующих шагах мы покажем, как:

1. Загружать и предварительно обрабатывать данные об абзацах Википедии

2. Объединить все абзацы, принадлежащие одной статье, в массив структур

3. Вставить эти структурированные документы в Milvus

4. Выполнять запросы MAX_SIM для получения полных текстов статей - чисто, без дедупирования или реранжирования.

К концу этого руководства у вас будет рабочий конвейер, в котором Milvus будет напрямую обрабатывать поиск на уровне сущностей, именно так, как ожидают пользователи.

Модель данных:

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

Шаг 1: группировка и преобразование данных

Для этой демонстрации мы используем набор данных 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()]
})

Шаг 2: Создание коллекции 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)

Шаг 3: Вставка данных и создание индекса

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

Шаг 4: Поиск документов

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

Сравнение результатов: Традиционный поиск и массив структур

Влияние массива структур становится очевидным, когда мы смотрим на то, что на самом деле возвращает база данных:

Размерность	Традиционный подход	Массив структур
Вывод базы данных	Возвращает 100 лучших абзацев (высокая избыточность)	Возвращает 10 лучших полных документов - чистых и точных
Логика приложения	Требуется группировка, дедупликация и повторное ранжирование (сложно)	Нет необходимости в постобработке - результаты на уровне сущностей поступают непосредственно из Milvus

В примере с Википедией мы продемонстрировали лишь простейший случай: объединение векторов абзацев в единое представление документа. Но настоящая сила Array of Structs в том, что она универсальна для любой многовекторной модели данных - как для классических поисковых конвейеров, так и для современных архитектур ИИ.

Традиционные сценарии многовекторного поиска

Многие хорошо зарекомендовавшие себя поисковые и рекомендательные системы естественным образом оперируют сущностями с несколькими связанными векторами. Массив структур хорошо подходит для этих сценариев использования:

Сценарий	Модель данных	Векторы на сущность
🛍️ Продукты электронной коммерции	Один товар → несколько изображений	5-20
🎬 Поиск видео	Одно видео → несколько клипов	20-100
📖 Поиск документов	Один документ → несколько разделов	5-15

Рабочие нагрузки в моделях ИИ (ключевые многовекторные сценарии использования)

Массив структур становится еще более важным в современных моделях ИИ, которые намеренно создают большие наборы векторов на сущность для тонких семантических рассуждений.

Модель	Модель данных	Векторы на сущность	Приложение
ColBERT	Один документ → множество вкраплений токенов	100-500	Юридические тексты, научные статьи, тонкий поиск документов
ColPali	Одна страница PDF → множество вкраплений патчей	256-1024	Финансовые отчеты, контракты, счета-фактуры, мультимодальный поиск документов

Эти модели требуют многовекторного шаблона хранения. До появления Array of Structs разработчикам приходилось разбивать векторы на строки и вручную сшивать результаты вместе. С Milvus эти сущности теперь можно хранить и извлекать нативно, а MAX_SIM автоматически обрабатывает скоринг на уровне документов.

2. Поиск документов на основе изображений ColPali

ColPali - это мощная модель для кросс-модального поиска PDF-файлов. Вместо того чтобы полагаться на текст, она обрабатывает каждую PDF-страницу как изображение и разбивает ее на 1024 визуальных фрагмента, генерируя по одному вкраплению на каждый фрагмент. При традиционной схеме базы данных это потребовало бы хранения одной страницы в виде сотен или тысяч отдельных строк, что не позволило бы базе данных понять, что эти строки относятся к одной и той же странице. В результате поиск на уровне сущностей становится фрагментарным и непрактичным.

Array of Structs решает эту проблему, храня все вкрапления патчей в одном поле, что позволяет Milvus рассматривать страницу как единую целостную многовекторную сущность.

Традиционный поиск в PDF часто зависит от OCR, который преобразует изображения страниц в текст. Это работает для обычного текста, но при этом теряются графики, таблицы, макеты и другие визуальные подсказки. ColPali позволяет избежать этого ограничения, работая непосредственно с изображениями страниц, сохраняя всю визуальную и текстовую информацию. Компромисс заключается в масштабе: каждая страница теперь содержит сотни векторов, что требует базы данных, которая может объединить множество вкраплений в одну сущность - именно то, что обеспечивает Array of Structs + MAX_SIM.

Наиболее распространенным вариантом использования является Vision RAG, где каждая страница PDF становится многовекторной сущностью. Типичные сценарии включают:

• Финансовые отчеты: поиск в тысячах PDF-файлов страниц, содержащих определенные графики или таблицы.

• Контракты: поиск пунктов из отсканированных или сфотографированных юридических документов.

• Счета-фактуры: поиск счетов-фактур по поставщику, сумме или макету.

• Презентации: поиск слайдов, содержащих определенный рисунок или диаграмму.

Модель данных:

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

Шаг 1: Подготовка данныхПодробную информацию о том, как ColPali преобразует изображения или текст в многовекторные представления, вы можете найти в документе.

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)

Шаг 2: Создание коллекции 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)

Шаг 3: Вставка данных и создание индекса

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

Шаг 4: Кросс-модальный поиск: Текстовый запрос → результаты по изображениям

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

Образец вывода:

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

Здесь результаты напрямую возвращают полные страницы PDF. Нам не нужно беспокоиться о вкраплениях 1024 патчей - Milvus автоматически выполняет все операции агрегирования.

Заключение

Большинство векторных баз данных хранят каждый фрагмент как отдельную запись, что означает, что приложениям приходится собирать эти фрагменты, когда им нужен полный документ, продукт или страница. Массив структур меняет эту ситуацию. Объединяя скаляры, векторы, текст и другие поля в единый структурированный объект, он позволяет одной строке базы данных представлять одну полную сущность из конца в конец.

Результат прост, но эффективен: работа, которая раньше требовала сложной группировки, дедупирования и ранжирования на уровне приложения, становится встроенной возможностью базы данных. Именно за векторными базами данных будущее - более строгие структуры, более интеллектуальный поиск и более простые конвейеры.

Для получения дополнительной информации о Array of Structs и MAX_SIM ознакомьтесь с документацией ниже:

• Array of Structs | Milvus Documentation

У вас есть вопросы или вы хотите получить подробную информацию о любой функции последней версии Milvus? Присоединяйтесь к нашему каналу Discord или создавайте проблемы на GitHub. Вы также можете записаться на 20-минутную индивидуальную сессию, чтобы получить понимание, руководство и ответы на свои вопросы через Milvus Office Hours.