Remove PunctCompatible with Milvus 2.5.11+

The removepunct filter removes tokens that contain punctuation or whitespace from the token stream. Use it when you want cleaner text processing that focuses on meaningful content words rather than punctuation marks.

Configuration

The removepunct filter is built into Milvus. To use it, simply specify its name in the filter section within analyzer_params.

analyzer_params = {
    "tokenizer": "jieba",
    "filter": ["removepunct"]
}

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

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

analyzerParams := map[string]any{"tokenizer": "jieba", "filter": []any{"removepunct"}}

use serde_json::json;

let analyzer_params = json!({
    "tokenizer": "jieba",
    "filter": ["removepunct"]
});

nlohmann::json analyzer_params = {
    {"tokenizer", "jieba"},
    {"filter", {"removepunct"}}
};

const analyzer_params = {
    "tokenizer": "jieba",
    "filter": ["removepunct"],
};

var analyzerParams = new Dictionary<string, object>
{
    ["tokenizer"] = "jieba",
    ["filter"] = new[] { "removepunct" }
};

# restful
analyzerParams='{
  "tokenizer": "jieba",
  "filter": [
    "removepunct"
  ]
}'

The removepunct filter operates on the terms generated by the tokenizer, so it must be used in combination with a tokenizer.

After defining analyzer_params, you can apply them to a VARCHAR field when defining a collection schema. This allows Milvus to process the text in that field using the specified analyzer for efficient tokenization and filtering. For details, refer to Example use.

Examples

Before applying the analyzer configuration to your collection schema, verify its behavior using the run_analyzer method.

Analyzer configuration

analyzer_params = {
    "tokenizer": "icu",
    "filter": ["removepunct"]
}

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

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

analyzerParams := map[string]any{"tokenizer": "icu", "filter": []string{"removepunct"}}

use serde_json::json;

let analyzer_params = json!({
    "tokenizer": "icu",
    "filter": ["removepunct"]
});

nlohmann::json analyzer_params = {
    {"tokenizer", "icu"},
    {"filter", {"removepunct"}}
};

const analyzer_params = {
    "tokenizer": "icu",
    "filter": ["removepunct"],
};

var analyzerParams = new Dictionary<string, object>
{
    ["tokenizer"] = "icu",
    ["filter"] = new[] { "removepunct" }
};

# restful
analyzerParams='{
  "tokenizer": "icu",
  "filter": [
    "removepunct"
  ]
}'

Verification using run_analyzer

from pymilvus import (
    MilvusClient,
)

client = MilvusClient(
    uri="http://localhost:19530",
    token="root:Milvus"
)

# Sample text to analyze
sample_text = "Привет! Как дела?"

# Run the analyzer with the defined configuration
result = client.run_analyzer(sample_text, analyzer_params)
print("Analyzer output:", result)

import io.milvus.v2.client.ConnectConfig;
import io.milvus.v2.client.MilvusClientV2;
import io.milvus.v2.service.vector.request.RunAnalyzerReq;
import io.milvus.v2.service.vector.response.RunAnalyzerResp;
import java.util.ArrayList;
import java.util.List;

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

List<String> texts = new ArrayList<>();
texts.add("Привет! Как дела?");

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

import (
    "context"
    "fmt"

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

ctx := context.Background()

client, err := milvusclient.New(ctx, &milvusclient.ClientConfig{
    Address: "http://localhost:19530",
    APIKey:  "root:Milvus",
})
if err != nil {
    fmt.Println(err.Error())
    // handle error
}

texts := []string{"Привет! Как дела?"}
option := milvusclient.NewRunAnalyzerOption(texts...).
    WithAnalyzerParams(analyzerParams)

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

use milvus::v2::prelude::*;
use serde_json::json;

let config = ConnectConfig::new().uri("http://localhost:19530").token("root:Milvus");
let client = ClientV2::new(&config).await?;

let text = "Привет! Как дела?";

let response = client
    .run_analyzer(
        RunAnalyzerRequest::builder()
            .texts([text])
            .analyzer_params(json!({"tokenizer": "icu", "filter": ["removepunct"]}))
            .build()?,
    )
    .await?;

for result in response.results() {
    for token in result.get_tokens() {
        println!("{}", token.get_text());
    }
}

#include "milvus/MilvusClientV2.h"
#include <iostream>

auto client = milvus::MilvusClientV2::Create();

milvus::ConnectParam connect_param{"http://localhost:19530", "root:Milvus"};
auto status = client->Connect(connect_param);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

std::string text = "Привет! Как дела?";
auto request = milvus::RunAnalyzerRequest()
                       .AddText(text)
                       .WithAnalyzerParams(analyzer_params);

milvus::RunAnalyzerResponse response;
status = client->RunAnalyzer(request, response);
if (!status.IsOk()) {
    std::cout << status.Message() << std::endl;
}

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

const sampleText = "Привет! Как дела?";

const client = new MilvusClient({
  address: "http://localhost:19530",
  token: "root:Milvus",
});

const result = await client.runAnalyzer({
  analyzer_params: analyzer_params,
  text: sampleText,
});

console.log("Analyzer output:", result);

using Milvus.Client.V2;
using Milvus.Client.V2.Types;
using Milvus.Client.V2.Requests.Utility;
using Milvus.Client.V2.Responses.Utility;

var config = new ConnectConfig
{
    Uri = "http://localhost:19530",
    ApiKey = "root:Milvus"
};
using var client = new MilvusClientV2(config);
await client.ConnectAsync();

// Sample text to analyze
string sampleText = "Привет! Как дела?";

// Run the analyzer with the defined configuration
RunAnalyzerResp result = await client.RunAnalyzerAsync(new RunAnalyzerReq
{
    Texts = [sampleText],
    AnalyzerParams = analyzerParams
});
Console.WriteLine($"Analyzer output: {result}");

# restful
curl -X POST "http://localhost:19530/v2/vectordb/common/run_analyzer" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer root:Milvus" \
  -d '{
    "analyzerParams": "{\"tokenizer\": \"icu\", \"filter\": [\"removepunct\"]}",
    "text": ["Привет! Как дела?"]
  }'

Expected output

['Привет', 'Как', 'дела']