Vector Retrieval Service for Milvus:Gunakan Milvus BM25 untuk Pencarian Teks Penuh dan Pencarian Hibrida dalam Sistem RAG

Langkah 1: Instal pustaka dependensi

pip3 install pymilvus langchain dashscope

Langkah 2: Persiapkan data

Topik ini menggunakan dokumentasi resmi Milvus sebagai contoh untuk menunjukkan cara membagi teks dengan SDK LangChain, menghasilkan penyematan dengan model penyematan text-embedding-v2, dan menyisipkan penyematan yang dihasilkan serta teks asli ke dalam Milvus.

from langchain_community.document_loaders import WebBaseLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.embeddings import DashScopeEmbeddings
from pymilvus import MilvusClient, DataType, Function, FunctionType

dashscope_api_key = "<YOUR_DASHSCOPE_API_KEY>"
milvus_url = "<YOUR_MILVUS_URL>"
user_name = "root"
password = "<YOUR_PASSWORD>"
collection_name = "milvus_overview"
dense_dim = 1536

loader = WebBaseLoader([
    'https://raw.githubusercontent.com/milvus-io/milvus-docs/refs/heads/v2.5.x/site/en/about/overview.md'
])

docs = loader.load()

text_splitter = RecursiveCharacterTextSplitter(chunk_size=1024, chunk_overlap=256)

# Bagi dokumen input berdasarkan ukuran chunk menggunakan LangChain
all_splits = text_splitter.split_documents(docs)

embeddings = DashScopeEmbeddings(
    model="text-embedding-v2", dashscope_api_key=dashscope_api_key
)

text_contents = [doc.page_content for doc in all_splits]

vectors = embeddings.embed_documents(text_contents)


client = MilvusClient(
    uri=f"http://{milvus_url}:19530",
    token=f"{user_name}:{password}",
)

schema = MilvusClient.create_schema(
    enable_dynamic_field=True,
)

analyzer_params = {
    "type": "english"
}

# Tambahkan bidang ke skema
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True, auto_id=True)
schema.add_field(field_name="text", datatype=DataType.VARCHAR, max_length=65535, enable_analyzer=True, analyzer_params=analyzer_params, enable_match=True)
schema.add_field(field_name="sparse_bm25", datatype=DataType.SPARSE_FLOAT_VECTOR)
schema.add_field(field_name="dense", datatype=DataType.FLOAT_VECTOR, dim=dense_dim)

bm25_function = Function(
   name="bm25",
   function_type=FunctionType.BM25,
   input_field_names=["text"],
   output_field_names="sparse_bm25",
)
schema.add_function(bm25_function)

index_params = client.prepare_index_params()

# Tambahkan indeks
index_params.add_index(
    field_name="dense",
    index_name="dense_index",
    index_type="IVF_FLAT",
    metric_type="IP",
    params={"nlist": 128},
)

index_params.add_index(
    field_name="sparse_bm25",
    index_name="sparse_bm25_index",
    index_type="SPARSE_WAND",
    metric_type="BM25"
)

# Buat koleksi
client.create_collection(
    collection_name=collection_name,
    schema=schema,
    index_params=index_params
)

data = [
    {"dense": vectors[idx], "text": doc}
    for idx, doc in enumerate(text_contents)
]

# Sisipkan data
res = client.insert(
    collection_name=collection_name,
    data=data
)

print(f"Menghasilkan {len(vectors)} vektor, dimensi: {len(vectors[0])}")

Contoh ini melibatkan parameter berikut. Ganti mereka dengan nilai sebenarnya Anda.

Contoh ini menggunakan fitur terbaru dari Milvus 2.5. Saat Anda membuat objek bm25_function, Milvus secara otomatis mentransformasi kolom teks menjadi vektor jarang.

Demikian pula, saat Anda memproses dokumen berbahasa Cina, Milvus 2.5 memungkinkan Anda menentukan analis bahasa Cina yang sesuai.

# Tentukan parameter analis
analyzer_params = {
    "type": "chinese"  # Tentukan tipe analis sebagai Cina
}

# Tambahkan bidang teks ke skema dan aktifkan analis
schema.add_field(
    field_name="text",                      # Nama bidang
    datatype=DataType.VARCHAR,              # Tipe data: string (VARCHAR)
    max_length=65535,                       # Panjang maksimum: 65535 karakter
    enable_analyzer=True,                   # Aktifkan analis
    analyzer_params=analyzer_params         # Parameter analis
)

Langkah 3: Lakukan pencarian teks penuh

Milvus 2.5 menyediakan API yang memungkinkan Anda dengan mudah menggunakan fitur pencarian teks penuh terbaru. Kode berikut menunjukkan sebuah contoh.

from pymilvus import MilvusClient

# Buat klien Milvus.
client = MilvusClient(
    uri="http://c-xxxx.milvus.aliyuncs.com:19530",  # Titik akhir publik dari instans Milvus.
    token="<yourUsername>:<yourPassword>",  # Nama pengguna dan kata sandi untuk masuk ke instans Milvus.
    db_name="default"  # Nama database untuk terhubung. Contoh ini menggunakan database default.
)

search_params = {
    'params': {'drop_ratio_search': 0.2},
}

full_text_search_res = client.search(
    collection_name='milvus_overview',
    data=['apa yang membuat milvus begitu cepat?'],
    anns_field='sparse_bm25',
    limit=3,
    search_params=search_params,
    output_fields=["text"],
)

for hits in full_text_search_res:
    for hit in hits:
        print(hit)
        print("\n")

"""
{'id': 456165042536597485, 'distance': 6.128782272338867, 'entity': {'text': '## Apa yang Membuat Milvus Begitu Cepat?\n\nMilvus dirancang sejak awal untuk menjadi sistem database vektor yang sangat efisien. Dalam banyak kasus, Milvus mengungguli database vektor lainnya sebesar 2-5x (lihat hasil VectorDBBench). Kinerja tinggi ini merupakan hasil dari beberapa keputusan desain utama:\n\n**Optimasi Berbasis Perangkat Keras**: Untuk mengakomodasi Milvus di berbagai lingkungan perangkat keras, kami telah mengoptimalkan kinerjanya secara khusus untuk banyak arsitektur perangkat keras dan platform, termasuk AVX512, SIMD, GPU, dan NVMe SSD.\n\n**Algoritma Pencarian Lanjutan**: Milvus mendukung berbagai algoritma pengindeksan/pencarian dalam memori dan pada disk, termasuk IVF, HNSW, DiskANN, dan lainnya, yang semuanya telah dioptimalkan secara mendalam. Dibandingkan dengan implementasi populer seperti FAISS dan HNSWLib, Milvus memberikan performa 30%-70% lebih baik.'}}

{'id': 456165042536597487, 'distance': 4.760214805603027, 'entity': {'text': "## Apa yang Membuat Milvus Begitu Skalabel\n\nPada tahun 2022, Milvus mendukung vektor berskala miliaran, dan pada tahun 2023, ia berkembang hingga puluhan miliar dengan stabilitas yang konsisten, memberdayakan skenario skala besar untuk lebih dari 300 perusahaan besar, termasuk Salesforce, PayPal, Shopee, Airbnb, eBay, NVIDIA, IBM, AT&T, LINE, ROBLOX, Inflection, dll.\n\nArsitektur sistem cloud-native dan sangat terpisah dari Milvus memastikan bahwa sistem dapat terus berkembang seiring dengan pertumbuhan data:\n\n![Arsitektur sistem sangat terpisah dari Milvus](../../../assets/highly-decoupled-architecture.png)"}}
"""

Langkah 4: Lakukan pencocokan kata kunci

Pencocokan kata kunci adalah fitur baru di Milvus 2.5. Anda dapat menggabungkannya dengan pencarian kesamaan vektor untuk mempersempit ruang lingkup pencarian dan meningkatkan kinerja pencarian. Untuk menggunakan fitur pencocokan kata kunci, Anda harus menyetel enable_analyzer dan enable_match ke `True` saat mendefinisikan skema.

filter = "TEXT_MATCH(text, 'query') and TEXT_MATCH(text, 'node')"

text_match_res = client.search(
    collection_name="milvus_overview",
    anns_field="dense",
    data=query_embeddings,
    filter=filter,
    search_params={"params": {"nprobe": 10}},
    limit=2,
    output_fields=["text"]
)

filter = "TEXT_MATCH(text, 'scalable fast')"

text_match_res = client.query(
    collection_name="milvus_overview",
    filter=filter,
    output_fields=["text"]
)

Langkah 5: Gunakan pencarian hibrida dan RAG

Pencarian hibrida menggabungkan pencarian vektor dan pencarian teks penuh. Ini menggunakan algoritma Reciprocal Rank Fusion (RRF) untuk menggabungkan hasil dari kedua pencarian. Proses ini mengoptimalkan ulang pengurutan dan alokasi bobot untuk meningkatkan laju recall data dan akurasi.

Kode berikut menunjukkan sebuah contoh.

from pymilvus import MilvusClient
from pymilvus import AnnSearchRequest, RRFRanker
from langchain_community.embeddings import DashScopeEmbeddings
from dashscope import Generation

# Buat klien Milvus.
client = MilvusClient(
    uri="http://c-xxxx.milvus.aliyuncs.com:19530",  # Titik akhir publik dari instans Milvus.
    token="<yourUsername>:<yourPassword>",  # Nama pengguna dan kata sandi untuk masuk ke instans Milvus.
    db_name="default"  # Nama database untuk terhubung. Contoh ini menggunakan database default.
)

collection_name = "milvus_overview"

# Ganti dengan Kunci API DashScope Anda
dashscope_api_key = "<YOUR_DASHSCOPE_API_KEY>"

# Inisialisasi model penyematan
embeddings = DashScopeEmbeddings(
    model="text-embedding-v2",  # Gunakan model text-embedding-v2.
    dashscope_api_key=dashscope_api_key
)

# Tentukan kueri
query = "Mengapa Milvus berjalan begitu skalabel?"

# Sematkan kueri dan hasilkan representasi vektor yang sesuai
query_embeddings = embeddings.embed_documents([query])

# Tetapkan jumlah hasil top K
top_k = 5  # Dapatkan 5 dokumen teratas terkait kueri

# Tentukan parameter untuk pencarian vektor padat
search_params_dense = {
    "metric_type": "IP",
    "params": {"nprobe": 2}
}

# Buat permintaan pencarian vektor padat
request_dense = AnnSearchRequest([query_embeddings[0]], "dense", search_params_dense, limit=top_k)

# Tentukan parameter untuk pencarian teks BM25
search_params_bm25 = {
    "metric_type": "BM25"
}

# Buat permintaan pencarian teks BM25
request_bm25 = AnnSearchRequest([query], "sparse_bm25", search_params_bm25, limit=top_k)

# Gabungkan dua permintaan
reqs = [request_dense, request_bm25]

# Inisialisasi algoritma peringkat RRF
ranker = RRFRanker(100)

# Lakukan pencarian hibrida
hybrid_search_res = client.hybrid_search(
    collection_name=collection_name,
    reqs=reqs,
    ranker=ranker,
    limit=top_k,
    output_fields=["text"]
)

# Ekstrak konteks dari hasil pencarian hibrida
context = []
print("Hasil Top K:")
for hits in hybrid_search_res:  # Gunakan variabel yang benar di sini
    for hit in hits:
        context.append(hit['entity']['text'])  # Ekstrak konten teks ke daftar konteks
        print(hit['entity']['text'])  # Keluarkan setiap dokumen yang diambil


# Tentukan fungsi untuk mendapatkan jawaban berdasarkan kueri dan konteks
def getAnswer(query, context):
    prompt = f'''Silakan jawab pertanyaan saya berdasarkan konten di dalam:
    ```
    {context}
    ```
    Pertanyaan saya adalah: {query}.
    '''
    # Panggil modul generasi untuk mendapatkan jawaban
    rsp = Generation.call(model='qwen-turbo', prompt=prompt)
    return rsp.output.text

# Dapatkan jawaban
answer = getAnswer(query, context)

print(answer)


# Output yang diharapkan
"""
Milvus sangat skalabel karena arsitektur sistem cloud-native dan sangat terpisahnya. Arsitektur ini memungkinkan sistem untuk terus berkembang seiring dengan pertumbuhan data. Selain itu, Milvus mendukung tiga mode penyebaran yang mencakup...
"""