Campo di testoCompatible with Milvus 3.0.x

Nelle applicazioni di ricerca basate sull'intelligenza artificiale, la ricerca vettoriale consente di individuare entità semanticamente simili, ma spesso l'applicazione necessita anche del testo originale alla base di ciascuna corrispondenza. Un modello di linguaggio di grandi dimensioni (LLM) o un agente può utilizzare tale testo come contesto per leggere, citare, riassumere o includere il risultato in un prompt.

Milvus fornisce il tipo di campo scalare ` TEXT ` per memorizzare testi di origine di grandi dimensioni direttamente insieme alle entità. I valori tipici includono brani, documenti lunghi, corpi di articoli, ticket e log. A differenza di ` VARCHAR`, che richiede una lunghezza massima in byte ( max_length) fissa, ` TEXT ` non richiede di impostare una lunghezza massima in byte nello schema della collezione.

Per definire un campo « TEXT », impostare « datatype » su « DataType.TEXT ».

common.storage.useLoonFFI Il valore predefinito è ` false`, il che significa che Storage V3 è disabilitato per impostazione predefinita. Prima di creare una collezione che contenga un campo ` TEXT `, impostare questo parametro su ` true`; in caso contrario, Milvus rifiuterà lo schema della collezione.

schema.add_field(
    field_name="content",
    datatype=DataType.TEXT,
)

Una volta definito il campo, ogni entità può includere un valore stringa in quel campo. I valori di tipo ` TEXT ` si inseriscono come gli altri campi scalari e vengono restituiti dai risultati delle query o delle ricerche elencando il campo in ` output_fields`.

Limiti

• Un campo TEXT non può essere un campo primario, una chiave di partizione o una chiave di clustering.
• TEXT non può essere utilizzato come tipo di elemento di un campo " ARRAY ", incluso un sottocampo scalare in un " StructArray".
• In Milvus 3.0.0, i campi " TEXT " non supportano i valori predefiniti.
• In Milvus 3.0.0, i campi TEXT non sono supportati nelle collezioni esterne.
• Gli utenti non possono creare un indice scalare su un campo " TEXT ". Quando si utilizza " enable_match=True", Milvus crea un indice di testo gestito dal sistema per la corrispondenza del testo. Questo indice interno non è un indice scalare creato dall'utente.
• Gli operatori di filtro scalare generici non possono essere applicati direttamente a un campo TEXT. Tra questi figurano operatori di confronto quali == e !=, operatori di intervallo quali >, >=, < e <=, nonché IN, LIKE, operatori regex (=~ e !~) e IS NULL o IS NOT NULL. Per filtrare in base ai termini analizzati, definire il campo con enable_analyzer=True e enable_match=True, quindi utilizzare TEXT_MATCH o TEXT_MATCH_FUZZY. Per il recupero full-text ordinato per rilevanza, utilizzare BM25.
• In Milvus 3.0.0, una funzione BM25 o MinHash che utilizza un campo TEXT come input deve essere definita al momento della creazione della collezione. Non può essere aggiunta in un secondo momento tramite add_function_field o AlterCollectionSchema, anche se la collezione esistente è vuota, poiché Milvus non è in grado di reintegrare l’output della funzione a partire dai valori TEXT memorizzati. Per aggiungere una funzione di questo tipo a una raccolta esistente, utilizzare un campo di input VARCHAR oppure ricreare la raccolta includendo la funzione nel suo schema. Per ulteriori dettagli sull’aggiunta di una funzione e del campo vettoriale da essa generato, consultare la sezione Modifica dello schema della raccolta.
• Anche le funzioni di embedding testuale devono essere definite al momento della creazione della collezione. Milvus 3.0.0 non supporta l’aggiunta di tali funzioni in fase di esecuzione.

Scegliere TEXT o VARCHAR

TEXT e " VARCHAR " memorizzano entrambi valori di stringa, ma soddisfano esigenze applicative diverse. Utilizzare " VARCHAR " per metadati brevi e circoscritti che identificano, categorizzano o filtrano le entità. Utilizzare " TEXT " per contenuti sorgente più lunghi che forniscono a un LLM o a un agente un contesto sufficiente per leggere, citare, riassumere o costruire un prompt.

Aspetto	VARCHAR	TEXT
Ideale per	Metadati brevi utilizzati per identificare, classificare o filtrare entità, come title, tag, category o external_id.	Contenuti di origine più lunghi utilizzati dai flussi di lavoro LLM o dagli agenti, come content, passage, article_body o log_message.
Impostazione della lunghezza	Richiede max_length, che definisce il numero massimo di byte che il campo può memorizzare. Il valore massimo è 65,535 byte. Se un valore potrebbe superare questo limite, utilizzare TEXT.	Non richiede max_length, pertanto lo schema non necessita di un limite fisso in byte per il valore del testo.
Comportamento di archiviazione	Ogni valore viene memorizzato entro il limite di byte configurato per il campo ( max_length).	Utilizza la selezione automatica dello spazio di archiviazione per i valori di testo più grandi. Per i dettagli, consultare Come Milvus archivia i valori TEXT di grandi dimensioni.
Supporto come campo primario	Può essere utilizzato come campo primario.	Non può essere utilizzato come campo primario.
Filtraggio	Da utilizzare per metadati costituiti da stringhe brevi che devono comparire nelle espressioni di filtro, come category == "news" o tag in ["ai", "database"].	Non supporta gli operatori di filtro scalari generici. Utilizzare operatori di testo con funzione di corrispondenza per il filtraggio dei termini analizzati oppure BM25 per il recupero full-text con ordinamento per rilevanza.

Per i dettagli sui campi di tipo VARCHAR, consultare il campo VarChar.

Come Milvus memorizza i valori TEXT di grandi dimensioni

Espandi per vedere come funziona

Quando si inserisce un'entità, la stringa fornita per un campo " TEXT " costituisce il valore " TEXT ". Milvus confronta la dimensione di tale valore con "dataNode.text.inlineThreshold", che per impostazione predefinita è pari a 65,536 byte, quindi sceglie uno dei due percorsi di archiviazione interni.

Archiviazione di testi di grandi dimensioni

• Archiviazione in linea: se il valore di ` TEXT ` è inferiore a ` dataNode.text.inlineThreshold`, Milvus memorizza il valore di testo originale direttamente nei dati del campo ` TEXT `.
• Archiviazione LOB: se un valore di ` TEXT ` è maggiore o uguale a ` dataNode.text.inlineThreshold`, Milvus tratta il valore come un oggetto di grandi dimensioni e archivia il testo originale separatamente in un sistema di archiviazione oggetti, come MinIO. Il campo ` TEXT ` memorizza un riferimento interno al testo archiviato separatamente. Quando il campo ` TEXT ` viene richiesto nei risultati di una query o di una ricerca, Milvus utilizza il riferimento per recuperare e restituire il testo originale.

Questa scelta di archiviazione è interna. L’inserimento, l’interrogazione e la ricerca nel campo ` TEXT ` avvengono allo stesso modo, indipendentemente dal percorso di archiviazione utilizzato da Milvus. Per ottimizzare la soglia o il comportamento relativo all’archiviazione, alla compattazione e alla garbage collection, consultare le configurazioni relative a `dataNode` e quelle relative a `dataCoord`.

Se la propria distribuzione utilizza l’archiviazione a oggetti, valori elevati di ` TEXT ` potrebbero apparire come oggetti gestiti da Milvus in percorsi quali lobs/.... Questi oggetti sono dettagli di implementazione e non devono essere spostati, copiati o eliminati manualmente. Dopo aver eliminato entità, rimosso partizioni o compattato i dati, l’utilizzo dello storage a oggetti potrebbe diminuire solo dopo che la garbage collection di Milvus avrà rimosso i dati di oggetti di grandi dimensioni non più referenziati, al termine della relativa finestra di sicurezza.

Un uso comune di TEXT è la ricerca full-text con BM25. In questo modello, il campo TEXT memorizza il contenuto originale della fonte, mentre BM25 analizza il testo e genera vettori sparsi per classificare le corrispondenze basate sulle parole chiave. I risultati della ricerca possono quindi restituire il valore TEXT corrispondente come contesto per i flussi di lavoro LLM o degli agenti. L’esempio seguente illustra come utilizzare un campo TEXT come campo di input per BM25. Per ulteriori informazioni sui concetti e sulle opzioni di query della ricerca full-text, consultare Ricerca full-text.

Passaggio 1: Creare una raccolta con un campo TEXT

L'esempio seguente crea una raccolta con un campo TEXT per il contenuto di origine e un campo vettore sparso per i vettori sparsi generati da BM25. La funzione BM25 converte il testo tokenizzato da content in vettori sparsi memorizzati in sparse.

Per la ricerca full-text con BM25, il campo di input « TEXT » deve essere impostato su enable_analyzer=True.

from pymilvus import DataType, Function, FunctionType, MilvusClient

client = MilvusClient(uri="http://localhost:19530")
COLLECTION_NAME = "text_bm25_collection"

if client.has_collection(COLLECTION_NAME):
    client.drop_collection(COLLECTION_NAME)

schema = client.create_schema(auto_id=False, enable_dynamic_field=False)
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True)
schema.add_field(
    field_name="content",
    datatype=DataType.TEXT,
    enable_analyzer=True,
)
schema.add_field(field_name="sparse", datatype=DataType.SPARSE_FLOAT_VECTOR)

bm25_function = Function(
    name="content_bm25",
    input_field_names=["content"],
    output_field_names=["sparse"],
    function_type=FunctionType.BM25,
)
schema.add_function(bm25_function)

Passaggio 2: Creare un indice di vettori sparsi

Creare un indice sul campo vettoriale sparso generato dalla funzione BM25. Il tipo di metrica deve essere impostato su BM25.

index_params = client.prepare_index_params()
index_params.add_index(
    field_name="sparse",
    index_type="SPARSE_INVERTED_INDEX",
    metric_type="BM25",
    params={
        "inverted_index_algo": "DAAT_MAXSCORE",
        "bm25_k1": 1.2,
        "bm25_b": 0.75,
    },
)

client.create_collection(
    collection_name=COLLECTION_NAME,
    schema=schema,
    index_params=index_params,
)

Passaggio 3: Inserire i dati TEXT

Inserire il testo direttamente nel campo ` TEXT `. Non specificare valori per il campo ` sparse `. Milvus genera internamente i vettori sparsi applicando la funzione BM25 a ` content`.

data = [
    {
        "id": 1,
        "content": "Milvus stores vector embeddings and scalar fields in collections. It supports vector search, full text search, and metadata filtering for retrieval applications.",
    },
    {
        "id": 2,
        "content": "Long documents are often split into passages before embedding. Store each passage in a TEXT field so search results can return the source text.",
    },
    {
        "id": 3,
        "content": "Operational logs and support tickets often contain long natural-language text. TEXT fields can store these values without a fixed max_length setting.",
    },
]

client.insert(collection_name=COLLECTION_NAME, data=data)
client.load_collection(collection_name=COLLECTION_NAME)

Passaggio 4: Eseguire la ricerca full-text con BM25

Utilizzare il testo grezzo della query come dati di ricerca ed eseguire la ricerca nel campo del vettore sparso. Milvus converte il testo della query in un vettore sparso, ordina i risultati con BM25 e restituisce il campo TEXT richiesto in output_fields.

results = client.search(
    collection_name=COLLECTION_NAME,
    data=["how does Milvus store source text for retrieval"],
    anns_field="sparse",
    limit=2,
    output_fields=["content"],
)

Passaggio 5: Leggere i valori TEXT restituiti

Ogni risultato della ricerca include il punteggio BM25 e il valore originale di TEXT.

for hit in results[0]:
    print(f"id: {hit['id']}, score: {hit['distance']}")
    print(hit["entity"]["content"])

Per ulteriori informazioni sulle funzioni BM25, sugli indici a vettori sparsi e sulla sintassi delle query per la ricerca full-text, consultare Ricerca full-text.