Descripción general del analizador

En el procesamiento de texto, un analizador es un componente fundamental que convierte el texto sin procesar en un formato estructurado y en el que se pueden realizar búsquedas. Cada analizador suele constar de dos elementos principales: un tokenizador y un filtro. Juntos, transforman el texto de entrada en tokens, refinan dichos tokens y los preparan para una indexación y recuperación eficientes.

En Milvus, los analizadores se configuran durante la creación de la colección, al añadir campos de « VARCHAR » al esquema de la colección. Los tokens generados por un analizador pueden utilizarse para crear un índice destinado a la coincidencia de palabras clave o convertirse en representaciones dispersas para la búsqueda de texto completo. Para obtener más información, consulta Búsqueda de texto completo, Coincidencia de frases o Coincidencia de texto.

Anatomía de un analizador

Un analizador en Milvus consta exactamente de un tokenizador y cero o más filtros.

• Tokenizador: El tokenizador divide el texto de entrada en unidades discretas denominadas tokens. Estos tokens pueden ser palabras o frases, dependiendo del tipo de tokenizador.

• Filtros: Se pueden aplicar filtros a los tokens para refinarlos aún más, por ejemplo, convirtiéndolos a minúsculas o eliminando palabras comunes.

El flujo de trabajo que se muestra a continuación ilustra cómo un analizador procesa el texto.

Flujo de trabajo del proceso del analizador

Tipos de analizadores

Milvus ofrece dos tipos de analizadores para satisfacer diferentes necesidades de procesamiento de texto:

• Analizador integrado: se trata de configuraciones predefinidas que cubren tareas comunes de procesamiento de texto con una configuración mínima. Los analizadores integrados son ideales para búsquedas de uso general, ya que no requieren una configuración compleja.

• Analizador personalizado: para requisitos más avanzados, los analizadores personalizados te permiten definir tu propia configuración especificando tanto el tokenizador como cero o más filtros. Este nivel de personalización resulta especialmente útil para casos de uso especializados en los que se necesita un control preciso sobre el procesamiento de texto.

Analizador integrado

Los analizadores integrados en Milvus vienen preconfigurados con tokenizadores y filtros específicos, lo que te permite utilizarlos de inmediato sin necesidad de definir tú mismo estos componentes. Cada analizador integrado sirve como plantilla que incluye un tokenizador y filtros preestablecidos, con parámetros opcionales para su personalización.

Por ejemplo, para utilizar el analizador integrado « standard », basta con especificar su nombre « standard » como « type » e incluir, de forma opcional, configuraciones adicionales específicas para este tipo de analizador, como « stop_words »:

analyzer_params = {
    "type": "standard", # Uses the standard built-in analyzer
    "stop_words": ["a", "an", "for"] # Defines a list of common words (stop words) to exclude from tokenization
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("type", "standard");
analyzerParams.put("stop_words", Arrays.asList("a", "an", "for"));

const analyzer_params = {
    "type": "standard", // Uses the standard built-in analyzer
    "stop_words": ["a", "an", "for"] // Defines a list of common words (stop words) to exclude from tokenization
};

analyzerParams := map[string]any{"type": "standard", "stop_words": []string{"a", "an", "for"}}

export analyzerParams='{
       "type": "standard",
       "stop_words": ["a", "an", "for"]
    }'

Para comprobar el resultado de la ejecución de un analizador, utiliza el método run_analyzer:

# Sample text to analyze
text = "An efficient system relies on a robust analyzer to correctly process text for various applications."

# Run analyzer
result = client.run_analyzer(
    text,
    analyzer_params
)

import io.milvus.v2.service.vector.request.RunAnalyzerReq;
import io.milvus.v2.service.vector.response.RunAnalyzerResp;

List<String> texts = new ArrayList<>();
texts.add("An efficient system relies on a robust analyzer to correctly process text for various applications.");

RunAnalyzerResp resp = client.runAnalyzer(RunAnalyzerReq.builder()
        .texts(texts)
        .analyzerParams(analyzerParams)
        .build());
List<RunAnalyzerResp.AnalyzerResult> results = resp.getResults();

// javascrip# Sample text to analyze
const text = "An efficient system relies on a robust analyzer to correctly process text for various applications."

// Run analyzer
const result = await client.run_analyzer({
    text,
    analyzer_params
});

import (
    "context"
    "encoding/json"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/milvusclient"
)

bs, _ := json.Marshal(analyzerParams)
texts := []string{"An efficient system relies on a robust analyzer to correctly process text for various applications."}
option := milvusclient.NewRunAnalyzerOption(texts).
    WithAnalyzerParams(string(bs))

result, err := client.RunAnalyzer(ctx, option)
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

# restful

El resultado será:

['efficient', 'system', 'relies', 'on', 'robust', 'analyzer', 'to', 'correctly', 'process', 'text', 'various', 'applications']

Esto demuestra que el analizador tokeniza correctamente el texto de entrada filtrando las palabras vacías « "a" », « "an" » y « "for" », al tiempo que devuelve los tokens significativos restantes.

La configuración del analizador integrado « standard » anterior equivale a configurar un analizador personalizado con los siguientes parámetros, en los que las opciones « tokenizer » y « filter » se definen explícitamente para lograr una funcionalidad similar:

analyzer_params = {
    "tokenizer": "standard",
    "filter": [
        "lowercase",
        {
            "type": "stop",
            "stop_words": ["a", "an", "for"]
        }
    ]
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "standard");
analyzerParams.put("filter",
        Arrays.asList("lowercase",
                new HashMap<String, Object>() {{
                    put("type", "stop");
                    put("stop_words", Arrays.asList("a", "an", "for"));
                }}));

const analyzer_params = {
    "tokenizer": "standard",
    "filter": [
        "lowercase",
        {
            "type": "stop",
            "stop_words": ["a", "an", "for"]
        }
    ]
};

analyzerParams = map[string]any{"tokenizer": "standard",
    "filter": []any{"lowercase", map[string]any{
        "type":       "stop",
        "stop_words": []string{"a", "an", "for"},
    }}}

export analyzerParams='{
       "type": "standard",
       "filter":  [
       "lowercase",
       {
            "type": "stop",
            "stop_words": ["a", "an", "for"]
       }
   ]
}'

Milvus ofrece los siguientes analizadores integrados, cada uno de ellos diseñado para necesidades específicas de procesamiento de texto:

• standard: Adecuado para el procesamiento de texto de uso general, aplicando tokenización estándar y filtrado de minúsculas.

• english: Optimizado para texto en inglés, con soporte para palabras vacías en inglés.

• chinese: Especializado en el procesamiento de texto en chino, incluyendo una tokenización adaptada a las estructuras del idioma chino.

• arabic: Especializado en texto árabe, con normalización árabe, normalización de dígitos decimales, derivación de raíces árabes y eliminación de palabras vacías árabes.

• thai: Especializado en texto tailandés, con segmentación de palabras tailandesas, normalización de dígitos decimales y eliminación de palabras vacías tailandesas.

Analizador personalizado

Para un procesamiento de texto más avanzado, los analizadores personalizados de Milvus te permiten crear un flujo de trabajo de gestión de texto a medida especificando tanto un tokenizador como filtros. Esta configuración es ideal para casos de uso especializados en los que se requiere un control preciso.

Tokenizador

El tokenizador es un componente obligatorio para un analizador personalizado, que inicia el flujo de trabajo del analizador dividiendo el texto de entrada en unidades discretas o tokens. La tokenización sigue reglas específicas, como la división por espacios en blanco o signos de puntuación, dependiendo del tipo de tokenizador. Este proceso permite un manejo más preciso e independiente de cada palabra o frase.

Por ejemplo, un tokenizador convertiría el texto « "Vector Database Built for Scale" » en tokens separados:

["Vector", "Database", "Built", "for", "Scale"]

Ejemplo de cómo especificar un tokenizador:

analyzer_params = {
    "tokenizer": "whitespace",
}

Map<String, Object> analyzerParams = new HashMap<>();
analyzerParams.put("tokenizer", "whitespace");

const analyzer_params = {
    "tokenizer": "whitespace",
};

analyzerParams = map[string]any{"tokenizer": "whitespace"}

export analyzerParams='{
       "type": "whitespace"
    }'

Filtro

Los filtros son componentes opcionales que actúan sobre los tokens generados por el tokenizador, transformándolos o refinándolos según sea necesario. Por ejemplo, tras aplicar un filtro « lowercase » a los términos tokenizados « ["Vector", "Database", "Built", "for", "Scale"] », el resultado podría ser:

["vector", "database", "built", "for", "scale"]

Los filtros de un analizador personalizado pueden ser integrados o personalizados, en función de las necesidades de configuración.

• Filtros integrados: preconfigurados por Milvus, que requieren una configuración mínima. Puedes utilizar estos filtros tal cual, especificando sus nombres. Los siguientes filtros están integrados para su uso directo:

  • lowercase: Convierte el texto a minúsculas, lo que garantiza una coincidencia que no distingue entre mayúsculas y minúsculas. Para más detalles, consulta «Minúsculas».

  • asciifolding: Convierte los caracteres no ASCII en sus equivalentes ASCII, lo que simplifica el manejo de texto multilingüe. Para más detalles, consulta «ASCII folding».

  • alphanumonly: Conserva únicamente los caracteres alfanuméricos eliminando el resto. Para más detalles, consulta «Alphanumonly».

  • cnalphanumonly: Elimina los tokens que contengan cualquier carácter que no sea un carácter chino, una letra inglesa o un dígito. Para más detalles, consulta «Cnalphanumonly».

  • cncharonly: Elimina los tokens que contengan cualquier carácter que no sea chino. Para más detalles, consulta «Cncharonly».

  • pinyin: Añade formas de token en pinyin a los tokens chinos, lo que permite la coincidencia basada en pinyin para el texto chino. Para más detalles, consulta «Pinyin».

  Ejemplo de uso de un filtro integrado:

  Python Java NodeJS Go cURL

  analyzer_params = {
      "tokenizer": "standard", # Mandatory: Specifies tokenizer
      "filter": ["lowercase"], # Optional: Built-in filter that converts text to lowercase
  }
  

  Map<String, Object> analyzerParams = new HashMap<>();
  analyzerParams.put("tokenizer", "standard");
  analyzerParams.put("filter", Collections.singletonList("lowercase"));
  

  const analyzer_params = {
      "tokenizer": "standard", // Mandatory: Specifies tokenizer
      "filter": ["lowercase"], // Optional: Built-in filter that converts text to lowercase
  }
  

  analyzerParams = map[string]any{"tokenizer": "standard",
          "filter": []any{"lowercase"}}
  

  export analyzerParams='{
         "type": "standard",
         "filter":  ["lowercase"]
      }'
  

• Filtros personalizados: Los filtros personalizados permiten configuraciones especializadas. Puedes definir un filtro personalizado eligiendo un tipo de filtro válido (filter.type) y añadiendo ajustes específicos para cada tipo de filtro. Ejemplos de tipos de filtro que admiten personalización:

  • stop: Elimina palabras comunes especificadas mediante una lista de palabras de exclusión (p. ej., "stop_words": ["of", "to"]). Para más detalles, consulta «Stop».

  • length: Excluye tokens en función de criterios de longitud, como establecer una longitud máxima para los tokens. Para más detalles, consulta «Longitud».

  • stemmer: Reduce las palabras a sus formas raíz para una coincidencia más flexible. Para más detalles, consulta «Stemmer».

  Ejemplo de configuración de un filtro personalizado:

  Python Java NodeJS Go cURL

  analyzer_params = {
      "tokenizer": "standard", # Mandatory: Specifies tokenizer
      "filter": [
          {
              "type": "stop", # Specifies 'stop' as the filter type
              "stop_words": ["of", "to"], # Customizes stop words for this filter type
          }
      ]
  }
  

  Map<String, Object> analyzerParams = new HashMap<>();
  analyzerParams.put("tokenizer", "standard");
  analyzerParams.put("filter",
          Collections.singletonList(new HashMap<String, Object>() {{
              put("type", "stop");
              put("stop_words", Arrays.asList("a", "an", "for"));
          }}));
  

  const analyzer_params = {
      "tokenizer": "standard", // Mandatory: Specifies tokenizer
      "filter": [
          {
              "type": "stop", // Specifies 'stop' as the filter type
              "stop_words": ["of", "to"], // Customizes stop words for this filter type
          }
      ]
  };
  

  analyzerParams = map[string]any{"tokenizer": "standard",
      "filter": []any{map[string]any{
          "type":       "stop",
          "stop_words": []string{"of", "to"},
      }}}
  

  export analyzerParams='{
         "type": "standard",
         "filter":  [
         {
              "type": "stop",
              "stop_words": ["a", "an", "for"]
         }
      ]
  }'
  

Ejemplo de uso

En este ejemplo, crearás un esquema de colección que incluya:

• Un campo vectorial para las representaciones.

• Dos campos « VARCHAR » para el procesamiento de texto:

  • Un campo utiliza un analizador integrado.

  • El otro utiliza un analizador personalizado.

Antes de incorporar estas configuraciones a tu colección, verificarás cada analizador utilizando el método ` run_analyzer `.

Paso 1: Inicializar MilvusClient y crear un esquema

Empieza por configurar el cliente Milvus y crear un nuevo esquema.

from pymilvus import MilvusClient, DataType

# Set up a Milvus client
client = MilvusClient(uri="http://localhost:19530")

# Create a new schema
schema = client.create_schema(auto_id=True, enable_dynamic_field=False)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.common.DataType;
import io.milvus.v2.common.IndexParam;
import io.milvus.v2.service.collection.request.AddFieldReq;
import io.milvus.v2.service.collection.request.CreateCollectionReq;

// Set up a Milvus client
ConnectConfig config = ConnectConfig.builder()
        .uri("http://localhost:19530")
        .build();
MilvusClientV2 client = new MilvusClientV2(config);

// Create schema
CreateCollectionReq.CollectionSchema schema = CreateCollectionReq.CollectionSchema.builder()
        .enableDynamicField(false)
        .build();

import { MilvusClient, DataType } from "@zilliz/milvus2-sdk-node";

// Set up a Milvus client
const client = new MilvusClient("http://localhost:19530");

import (
    "context"
    "fmt"

    "github.com/milvus-io/milvus/client/v2/column"
    "github.com/milvus-io/milvus/client/v2/entity"
    "github.com/milvus-io/milvus/client/v2/index"
    "github.com/milvus-io/milvus/client/v2/milvusclient"
)  

ctx, cancel := context.WithCancel(context.Background())
defer cancel()

cli, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "localhost:19530",
})
if err != nil {
    fmt.Println(err.Error())
    // handle err
}
defer client.Close(ctx)

schema := entity.NewSchema().WithAutoID(true).WithDynamicFieldEnabled(false)

# restful

Paso 2: Definir y verificar las configuraciones de los analizadores

1. Configura y verifica un analizador integrado (english):

   • Configuración: Define los parámetros del analizador para el analizador de inglés integrado.

   • Verificación: Utiliza run_analyzer para comprobar que la configuración produce la tokenización esperada.

   Python Java NodeJS Go cURL

   # Built-in analyzer configuration for English text processing
   analyzer_params_built_in = {
       "type": "english"
   }
   
   # Verify built-in analyzer configuration
   sample_text = "Milvus simplifies text analysis for search."
   result = client.run_analyzer(sample_text, analyzer_params_built_in)
   print("Built-in analyzer output:", result)
   
   # Expected output:
   # Built-in analyzer output: ['milvus', 'simplifi', 'text', 'analysi', 'search']
   
   

   Map<String, Object> analyzerParamsBuiltin = new HashMap<>();
   analyzerParamsBuiltin.put("type", "english");
   
   List<String> texts = new ArrayList<>();
   texts.add("Milvus simplifies text ana
   
   lysis for search.");
   
   RunAnalyzerResp resp = client.runAnalyzer(RunAnalyzerReq.builder()
           .texts(texts)
           .analyzerParams(analyzerParams)
           .build());
   List<RunAnalyzerResp.AnalyzerResult> results = resp.getResults();
   
   

   // Use a built-in analyzer for VARCHAR field `title_en`
   const analyzerParamsBuiltIn = {
     type: "english",
   };
   
   const sample_text = "Milvus simplifies text analysis for search.";
   const result = await client.run_analyzer({
       text: sample_text, 
       analyzer_params: analyzer_params_built_in
   });
   
   

   analyzerParams := map[string]any{"type": "english"}
   
   bs, _ := json.Marshal(analyzerParams)
   texts := []string{"Milvus simplifies text analysis for search."}
   option := milvusclient.NewRunAnalyzerOption(texts).
       WithAnalyzerParams(string(bs))
   
   result, err := client.RunAnalyzer(ctx, option)
   if err != nil {
       fmt.Println(err.Error())
       // handle error
   }
   
   

   # restful
   

2. Configurar y verificar un analizador personalizado:

   • Configuración: Define un analizador personalizado que utilice un tokenizador estándar junto con un filtro integrado para convertir a minúsculas y filtros personalizados para la longitud de los tokens y las palabras vacías.

   • Verificación: Utiliza run_analyzer para asegurarte de que la configuración personalizada procesa el texto según lo previsto.

   Python Java NodeJS Go cURL

   # Custom analyzer configuration with a standard tokenizer and custom filters
   analyzer_params_custom = {
       "tokenizer": "standard",
       "filter": [
           "lowercase",  # Built-in filter: convert tokens to lowercase
           {
               "type": "length",  # Custom filter: restrict token length
               "max": 40
           },
           {
               "type": "stop",  # Custom filter: remove specified stop words
               "stop_words": ["of", "for"]
           }
       ]
   }
   
   # Verify custom analyzer configuration
   sample_text = "Milvus provides flexible, customizable analyzers for robust text processing."
   result = client.run_analyzer(sample_text, analyzer_params_custom)
   print("Custom analyzer output:", result)
   
   # Expected output:
   # Custom analyzer output: ['milvus', 'provides', 'flexible', 'customizable', 'analyzers', 'robust', 'text', 'processing']
   
   

   // Configure a custom analyzer
   Map<String, Object> analyzerParams = new HashMap<>();
   analyzerParams.put("tokenizer", "standard");
   analyzerParams.put("filter",
           Arrays.asList("lowercase",
                   new HashMap<String, Object>() {{
                       put("type", "length");
                       put("max", 40);
                   }},
                   new HashMap<String, Object>() {{
                       put("type", "stop");
                       put("stop_words", Arrays.asList("of", "for"));
                   }}
           )
   );
   
   List<String> texts = new ArrayList<>();
   texts.add("Milvus provides flexible, customizable analyzers for robust text processing.");
   
   RunAnalyzerResp resp = client.runAnalyzer(RunAnalyzerReq.builder()
           .texts(texts)
           .analyzerParams(analyzerParams)
           .build());
   List<RunAnalyzerResp.AnalyzerResult> results = resp.getResults();
   

   // Configure a custom analyzer for VARCHAR field `title`
   const analyzerParamsCustom = {
     tokenizer: "standard",
     filter: [
       "lowercase",
       {
         type: "length",
         max: 40,
       },
       {
         type: "stop",
         stop_words: ["of", "to"],
       },
     ],
   };
   const sample_text = "Milvus provides flexible, customizable analyzers for robust text processing.";
   const result = await client.run_analyzer({
       text: sample_text, 
       analyzer_params: analyzer_params_built_in
   });
   

   analyzerParams = map[string]any{"tokenizer": "standard",
       "filter": []any{"lowercase", 
       map[string]any{
           "type": "length",
           "max":  40,
       map[string]any{
           "type": "stop",
           "stop_words": []string{"of", "to"},
       }}}
       
   bs, _ := json.Marshal(analyzerParams)
   texts := []string{"Milvus provides flexible, customizable analyzers for robust text processing."}
   option := milvusclient.NewRunAnalyzerOption(texts).
       WithAnalyzerParams(string(bs))
   
   result, err := client.RunAnalyzer(ctx, option)
   if err != nil {
       fmt.Println(err.Error())
       // handle error
   }
   

   # curl
   

Paso 3: Añadir campos al esquema

Ahora que ha verificado las configuraciones de su analizador, añádalas a los campos de su esquema:

# Add VARCHAR field 'title_en' using the built-in analyzer configuration
schema.add_field(
    field_name='title_en',
    datatype=DataType.VARCHAR,
    max_length=1000,
    enable_analyzer=True,
    analyzer_params=analyzer_params_built_in,
    enable_match=True,
)

# Add VARCHAR field 'title' using the custom analyzer configuration
schema.add_field(
    field_name='title',
    datatype=DataType.VARCHAR,
    max_length=1000,
    enable_analyzer=True,
    analyzer_params=analyzer_params_custom,
    enable_match=True,
)

# Add a vector field for embeddings
schema.add_field(field_name="embedding", datatype=DataType.FLOAT_VECTOR, dim=3)

# Add a primary key field
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True)

schema.addField(AddFieldReq.builder()
        .fieldName("title")
        .dataType(DataType.VarChar)
        .maxLength(1000)
        .enableAnalyzer(true)
        .analyzerParams(analyzerParams)
        .enableMatch(true) // must enable this if you use TextMatch
        .build());

// Add vector field
schema.addField(AddFieldReq.builder()
        .fieldName("embedding")
        .dataType(DataType.FloatVector)
        .dimension(3)
        .build());
// Add primary field
schema.addField(AddFieldReq.builder()
        .fieldName("id")
        .dataType(DataType.Int64)
        .isPrimaryKey(true)
        .autoID(true)
        .build());

// Create schema
const schema = {
  auto_id: true,
  fields: [
    {
      name: "id",
      type: DataType.INT64,
      is_primary: true,
    },
    {
      name: "title_en",
      data_type: DataType.VARCHAR,
      max_length: 1000,
      enable_analyzer: true,
      analyzer_params: analyzerParamsBuiltIn,
      enable_match: true,
    },
    {
      name: "title",
      data_type: DataType.VARCHAR,
      max_length: 1000,
      enable_analyzer: true,
      analyzer_params: analyzerParamsCustom,
      enable_match: true,
    },
    {
      name: "embedding",
      data_type: DataType.FLOAT_VECTOR,
      dim: 4,
    },
  ],
};

schema.WithField(entity.NewField().
    WithName("id").
    WithDataType(entity.FieldTypeInt64).
    WithIsPrimaryKey(true).
    WithIsAutoID(true),
).WithField(entity.NewField().
    WithName("embedding").
    WithDataType(entity.FieldTypeFloatVector).
    WithDim(3),
).WithField(entity.NewField().
    WithName("title").
    WithDataType(entity.FieldTypeVarChar).
    WithMaxLength(1000).
    WithEnableAnalyzer(true).
    WithAnalyzerParams(analyzerParams).
    WithEnableMatch(true),
)

# restful

Paso 4: Preparar los parámetros de indexación y crear la colección

# Set up index parameters for the vector field
index_params = client.prepare_index_params()
index_params.add_index(field_name="embedding", metric_type="COSINE", index_type="AUTOINDEX")

# Create the collection with the defined schema and index parameters
client.create_collection(
    collection_name="my_collection",
    schema=schema,
    index_params=index_params
)

// Set up index params for vector field
List<IndexParam> indexes = new ArrayList<>();
indexes.add(IndexParam.builder()
        .fieldName("embedding")
        .indexType(IndexParam.IndexType.AUTOINDEX)
        .metricType(IndexParam.MetricType.COSINE)
        .build());

// Create collection with defined schema
CreateCollectionReq requestCreate = CreateCollectionReq.builder()
        .collectionName("my_collection")
        .collectionSchema(schema)
        .indexParams(indexes)
        .build();
client.createCollection(requestCreate);

// Set up index params for vector field
const indexParams = [
  {
    name: "embedding",
    metric_type: "COSINE",
    index_type: "AUTOINDEX",
  },
];

// Create collection with defined schema
await client.createCollection({
  collection_name: "my_collection",
  schema: schema,
  index_params: indexParams,
});

console.log("Collection created successfully!");

idx := index.NewAutoIndex(index.MetricType(entity.COSINE))
indexOption := milvusclient.NewCreateIndexOption("my_collection", "embedding", idx)

err = client.CreateCollection(ctx,
    milvusclient.NewCreateCollectionOption("my_collection", schema).
        WithIndexOptions(indexOption))
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

# restful

Próximos pasos

Una vez configurado un analizador, puedes integrarlo con las funciones de recuperación de texto que ofrece Milvus. Para más detalles:

• Búsqueda de texto completo

• Coincidencia de texto

• Coincidencia de frases