Praktik langsung dengan Qwen 3 dan Milvus: Membangun RAG dengan Model Inferensi Hibrida Terbaru

Sebagai pengembang yang selalu mencari alat bantu AI praktis, saya tidak dapat mengabaikan desas-desus seputar rilis terbaru Alibaba Cloud: rangkaian model Qwen 3, sebuah rangkaian delapan model inferensi hibrida yang kuat yang dirancang untuk mengubah keseimbangan antara kecerdasan dan efisiensi. Hanya dalam waktu 12 jam, proyek ini berhasil mengumpulkan lebih dari 17.000 bintang GitHub dan mencapai puncaknya dengan 23.000 unduhan per jam di Hugging Face.

Jadi apa yang berbeda kali ini? Singkatnya, model Qwen 3 menggabungkan penalaran (respons yang lambat dan penuh pertimbangan) dan non-nalar (jawaban yang cepat dan efisien) dalam satu arsitektur tunggal, termasuk pilihan model yang beragam, pelatihan dan kinerja yang ditingkatkan, dan memberikan lebih banyak fitur yang siap untuk perusahaan.

Dalam tulisan ini, saya akan merangkum kemampuan utama model Qwen 3 yang harus Anda perhatikan dan memandu Anda melalui proses memasangkan Qwen 3 dengan Milvus untuk membangun sistem retrieval-augmented generation (RAG) yang hemat biaya-lengkap dengan kode praktis dan tips untuk mengoptimalkan kinerja versus latensi.

Mari kita selami.

Apa yang Menarik dari Qwen 3?

Setelah menguji dan mempelajari Qwen 3, jelaslah bahwa ini bukan hanya tentang angka-angka yang lebih besar pada lembar spesifikasi. Ini tentang bagaimana pilihan desain model ini benar-benar membantu pengembang membangun aplikasi GenAI yang lebih baik - lebih cepat, lebih cerdas, dan dengan kontrol yang lebih besar. Inilah yang menonjol.

1. Mode Berpikir Hibrida: Cerdas Saat Anda Membutuhkannya, Cepat Saat Anda Tidak Membutuhkannya

Salah satu fitur paling inovatif di Qwen 3 adalah arsitektur inferensi hibridanya. Ini memberi Anda kontrol yang sangat baik atas seberapa banyak "pemikiran" yang dilakukan model berdasarkan tugas per tugas. Tidak semua tugas membutuhkan penalaran yang rumit.

• Untuk masalah kompleks yang membutuhkan analisis mendalam, Anda dapat memanfaatkan kekuatan penalaran penuh - meskipun lebih lambat.

• Untuk pertanyaan sederhana sehari-hari, Anda dapat beralih ke mode yang lebih cepat dan lebih ringan.

• Anda bahkan dapat mengatur "anggaran berpikir " - membatasi berapa banyak komputasi atau token yang dibakar dalam satu sesi.

Ini juga bukan hanya fitur lab. Fitur ini secara langsung menangani trade-off yang dihadapi para pengembang setiap hari: memberikan respons berkualitas tinggi tanpa membebani biaya infrastruktur atau latensi pengguna.

2. Jajaran Produk Serbaguna: Model MoE dan Model Padat untuk Kebutuhan yang Berbeda

Qwen 3 menyediakan berbagai macam model yang dirancang untuk menyesuaikan dengan kebutuhan operasional yang berbeda:

• Dua model MoE (Campuran Ahli):

  • Qwen3-235B-A22B: 235 miliar total parameter, 22 miliar aktif per kueri

  • Qwen3-30B-A3B: 30 miliar total, 3 miliar aktif

• Enam model Padat: mulai dari 0,6B yang lincah hingga parameter 32B yang besar

Latar belakang teknologi yang cepat: Model padat (seperti GPT-3 atau BERT) selalu mengaktifkan semua parameter, membuatnya lebih berat tetapi terkadang lebih mudah diprediksi. Model MoE hanya mengaktifkan sebagian kecil jaringan pada satu waktu, membuatnya jauh lebih efisien dalam skala besar.

Dalam praktiknya, jajaran model serbaguna ini berarti Anda bisa:

• Menggunakan model padat untuk beban kerja yang ketat dan dapat diprediksi (seperti perangkat yang disematkan)

• Menggunakan model MoE ketika Anda membutuhkan kemampuan kelas berat tanpa melelehkan tagihan cloud Anda

Dengan rentang ini, Anda dapat menyesuaikan penerapan Anda - mulai dari pengaturan yang ringan dan siap pakai hingga penerapan skala cloud yang kuat - tanpa terkunci pada satu jenis model.

3. Berfokus pada Efisiensi dan Penerapan di Dunia Nyata

Alih-alih hanya berfokus pada ukuran model penskalaan, Qwen 3 berfokus pada efisiensi pelatihan dan kepraktisan penerapan:

• Dilatih dengan 36 triliun token - dua kali lipat dari yang digunakan Qwen 2.5

• Diperluas hingga 235B parameter - tetapi dikelola dengan cerdas melalui teknik MoE, menyeimbangkan kemampuan dengan permintaan sumber daya.

• Dioptimalkan untuk penerapan - kuantisasi dinamis (turun dari FP4 ke INT8) memungkinkan Anda menjalankan model Qwen 3 terbesar sekalipun pada infrastruktur sederhana - misalnya, penerapan pada empat GPU H20.

Tujuannya jelas: memberikan performa yang lebih kuat tanpa memerlukan investasi infrastruktur yang tidak proporsional.

4. Dibangun untuk Integrasi Nyata: Dukungan MCP dan Kemampuan Multibahasa

Qwen 3 dirancang dengan mempertimbangkan integrasi, bukan hanya performa model yang terisolasi:

• Kompatibilitas MCP (Model Context Protocol) memungkinkan integrasi tanpa batas dengan database eksternal, API, dan alat, sehingga mengurangi biaya teknik untuk aplikasi yang kompleks.

• Qwen-Agent meningkatkan pemanggilan alat dan orkestrasi alur kerja, mendukung pembangunan sistem AI yang lebih dinamis dan dapat ditindaklanjuti.

• Dukungan multibahasa dalam 119 bahasa dan dialek menjadikan Qwen 3 pilihan yang kuat untuk aplikasi yang menargetkan pasar global dan multibahasa.

Fitur-fitur ini secara kolektif memudahkan pengembang untuk membangun sistem tingkat produksi tanpa memerlukan rekayasa khusus yang ekstensif di sekitar model.

Qwen 3 Sekarang Didukung di DeepSearcher

DeepSearcher adalah proyek sumber terbuka untuk pengambilan data mendalam dan pembuatan laporan, yang dirancang sebagai alternatif lokal pertama untuk OpenAI's Deep Research. Proyek ini membantu pengembang membangun sistem yang menampilkan informasi berkualitas tinggi dan sesuai konteks dari sumber data pribadi atau domain tertentu.

DeepSearcher kini mendukung arsitektur inferensi hibrida Qwen 3, yang memungkinkan pengembang untuk mengubah penalaran secara dinamis - menerapkan inferensi yang lebih dalam hanya jika itu menambah nilai, dan melewatkannya ketika kecepatan lebih penting.

Di baliknya, DeepSearcher terintegrasi dengan Milvus, database vektor berkinerja tinggi yang dikembangkan oleh para insinyur Zilliz, untuk menyediakan pencarian semantik yang cepat dan akurat melalui data lokal. Dikombinasikan dengan fleksibilitas model, hal ini memberikan kontrol yang lebih besar kepada pengembang atas perilaku sistem, biaya, dan pengalaman pengguna.

Tutorial Praktis: Membangun Sistem RAG dengan Qwen 3 dan Milvus

Mari kita terapkan model Qwen 3 ini dengan membangun sistem RAG menggunakan database vektor Milvus.

Siapkan lingkungan.

# Install required packages
pip install --upgrade pymilvus openai requests tqdm
# Set up API key
import os
os.environ["DASHSCOPE_API_KEY"] = "YOUR_DASHSCOPE_API_KEY" # Get this from Alibaba Cloud DashScope

Catatan: Anda perlu mendapatkan API Key dari Alibaba Cloud.

Persiapan Data

Kita akan menggunakan halaman dokumentasi Milvus sebagai basis pengetahuan utama kita.

# Download and extract Milvus documentation
!wget https://github.com/milvus-io/milvus-docs/releases/download/v2.4.6-preview/milvus_docs_2.4.x_en.zip
!unzip -q milvus_docs_2.4.x_en.zip -d milvus_docs
# Load and parse the markdown files
from glob import glob
text_lines = []
for file_path in glob(“milvus_docs/en/faq/*.md”, recursive=True):
with open(file_path, “r”) as file:
file_text = file.read()
text_lines += file_text.split("# ")

Menyiapkan Model

Kita akan menggunakan API yang kompatibel dengan OpenAI dari DashScope untuk mengakses Qwen 3:

# Set up OpenAI client to access Qwen 3
from openai import OpenAI
openai_client = OpenAI(
base_url=“https://dashscope.aliyuncs.com/compatible-mode/v1”,
api_key=os.getenv(“DASHSCOPE_API_KEY”)
)
# Set up embedding model
from pymilvus import model as milvus_model
embedding_model = milvus_model.DefaultEmbeddingFunction()

Mari kita buat embedding uji coba dan cetak dimensi dan beberapa elemen pertamanya:

test_embedding = embedding_model.encode_queries(["This is a test"])[0]
embedding_dim = len(test_embedding)
print(embedding_dim)
print(test_embedding[:10])

Keluaran:

768
[-0.04836066 0.07163023 -0.01130064 -0.03789345 -0.03320649 -0.01318448
 -0.03041712 -0.02269499 -0.02317863 -0.00426028]

Membuat Koleksi Milvus

Mari kita siapkan basis data vektor Milvus kita:

from pymilvus import MilvusClient
# Initialize Milvus client (using local storage for simplicity)
milvus_client = MilvusClient(uri=“./milvus_demo.db”)
collection_name = “my_rag_collection”
# Create a fresh collection
if milvus_client.has_collection(collection_name):
milvus_client.drop_collection(collection_name)
# Create a new collection
test_embedding = embedding_model.encode_queries([“This is a test”])[0]
embedding_dim = len(test_embedding)
milvus_client.create_collection(
collection_name=collection_name,
dimension=embedding_dim,
metric_type=“IP”, # Inner product distance
consistency_level=“Strong”, # Strong consistency level
)

Tentang pengaturan parameter MilvusClient:

• Mengatur URI ke berkas lokal (misalnya, ./milvus.db) adalah metode yang paling mudah karena secara otomatis menggunakan Milvus Lite untuk menyimpan semua data dalam berkas tersebut.

• Untuk data berskala besar, Anda dapat menyiapkan server Milvus yang lebih kuat pada Docker atau Kubernetes. Dalam hal ini, gunakan URI server (misalnya, http://localhost:19530) sebagai URI Anda.

• Jika Anda ingin menggunakan Zilliz Cloud (layanan terkelola Milvus), sesuaikan URI dan token, yang sesuai dengan Public Endpoint dan kunci API di Zilliz Cloud.

Menambahkan Dokumen ke Koleksi

Sekarang kita akan membuat penyematan untuk potongan teks kita dan menambahkannya ke Milvus:

from tqdm import tqdm
data = []
doc_embeddings = embedding_model.encode_documents(text_lines)
for i, line in enumerate(tqdm(text_lines, desc=“Creating embeddings”)):
data.append({“id”: i, “vector”: doc_embeddings[i], “text”: line})
milvus_client.insert(collection_name=collection_name, data=data)

Output:

Creating embeddings: 100%|██████████████████████████████████████████████████| 72/72 [00:00<00:00, 381300.36it/s]
{'insert_count': 72, 'ids': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71], 'cost': 0}

Membangun Sistem Kueri RAG

Sekarang untuk bagian yang menarik - mari kita siapkan sistem RAG kita untuk menjawab pertanyaan.

Mari kita tentukan sebuah pertanyaan umum tentang Milvus:

question = "How is data stored in milvus?"

Cari pertanyaan ini dalam koleksi dan ambil 3 hasil teratas yang cocok secara semantik:

search_res = milvus_client.search(
    collection_name=collection_name,
    data=embedding_model.encode_queries([question]), # Convert the question to an embedding vector
    limit=3, # Return top 3 results
    search_params={"metric_type": "IP", "params": {}}, # Inner product distance
    output_fields=["text"], # Return the text field
)

Mari kita lihat hasil pencarian untuk pertanyaan ini:

import json
retrieved_lines_with_distances = [
    (res["entity"]["text"], res["distance"]) for res in search_res[0]
]
print(json.dumps(retrieved_lines_with_distances, indent=4))

Keluaran:

[
    [
        " Where does Milvus store data?\n\nMilvus deals with two types of data, inserted data and metadata. \n\nInserted data, including vector data, scalar data, and collection-specific schema, are stored in persistent storage as incremental log. Milvus supports multiple object storage backends, including [MinIO](https://min.io/), [AWS S3](https://aws.amazon.com/s3/?nc1=h_ls), [Google Cloud Storage](https://cloud.google.com/storage?hl=en#object-storage-for-companies-of-all-sizes) (GCS), [Azure Blob Storage](https://azure.microsoft.com/en-us/products/storage/blobs), [Alibaba Cloud OSS](https://www.alibabacloud.com/product/object-storage-service), and [Tencent Cloud Object Storage](https://www.tencentcloud.com/products/cos) (COS).\n\nMetadata are generated within Milvus. Each Milvus module has its own metadata that are stored in etcd.\n\n###",
        0.6572665572166443
    ],
    [
        "How does Milvus flush data?\n\nMilvus returns success when inserted data are loaded to the message queue. However, the data are not yet flushed to the disk. Then Milvus' data node writes the data in the message queue to persistent storage as incremental logs. If `flush()` is called, the data node is forced to write all data in the message queue to persistent storage immediately.\n\n###",
        0.6312146186828613
    ],
    [
        "How does Milvus handle vector data types and precision?\n\nMilvus supports Binary, Float32, Float16, and BFloat16 vector types.\n\n- Binary vectors: Store binary data as sequences of 0s and 1s, used in image processing and information retrieval.\n- Float32 vectors: Default storage with a precision of about 7 decimal digits. Even Float64 values are stored with Float32 precision, leading to potential precision loss upon retrieval.\n- Float16 and BFloat16 vectors: Offer reduced precision and memory usage. Float16 is suitable for applications with limited bandwidth and storage, while BFloat16 balances range and efficiency, commonly used in deep learning to reduce computational requirements without significantly impacting accuracy.\n\n###",
        0.6115777492523193
    ]
]

Menggunakan LLM untuk Membangun Tanggapan RAG

Ubah dokumen yang diambil ke format string:

context = "\n".join(
    [line_with_distance[0] for line_with_distance in retrieved_lines_with_distances]
)

Sediakan perintah sistem dan perintah pengguna untuk model bahasa yang besar:

SYSTEM_PROMPT = """
You are an AI assistant. You are able to find answers to the questions from the contextual passage snippets provided.
"""
USER_PROMPT = f"""
Use the following pieces of information enclosed in  tags to provide an answer to the question enclosed in  tags.

{context}


{question}

“"”

Gunakan model Qwen terbaru untuk menghasilkan respons berdasarkan prompt:

completion = openai_client.chat.completions.create(
    # Model list: https://help.aliyun.com/zh/model-studio/getting-started/models
    model="qwen-plus-2025-04-28",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": USER_PROMPT},
    ],
    # Control thinking process with enable_thinking parameter (default True for open-source, False for commercial)
    extra_body={"enable_thinking": False},
)
print(completion.choices[0].message.content)

Keluaran:

In Milvus, data is stored in two main categories: **inserted data** and **metadata**.

Inserted Data: This includes vector data (like Binary, Float32, Float16, and BFloat16 types), scalar data, and collection-specific schema. These are stored in persistent storage as incremental logs. Milvus supports various object storage backends for this purpose, including:

[MinIO](https://min.io/)
[AWS S3](https://aws.amazon.com/s3/?nc1=h_ls)
[Google Cloud Storage (GCS)](https://cloud.google.com/storage?hl=en#object-storage-for-companies-of-all-sizes)
[Azure Blob Storage](https://azure.microsoft.com/en-us/products/storage/blobs)
[Alibaba Cloud OSS](https://www.alibabacloud.com/product/object-storage-service)
[Tencent Cloud Object Storage (COS)](https://www.tencentcloud.com/products/cos)

Metadata: Metadata generated within Milvus is stored separately. Each Milvus module maintains its own metadata, which is stored in [etcd](https://etcd.io/), a distributed key-value store.
When data is inserted into Milvus, it is first loaded into a message queue. It is not immediately written to disk. A <span class="hljs-title">flush</span>() operation ensures that all data in the queue is written to persistent storage immediately.

Membandingkan Mode Penalaran vs Mode Non-Penalaran: Tes Praktis

Saya menjalankan tes yang membandingkan dua mode inferensi pada soal matematika:

Soal: Orang A dan Orang B mulai berlari dari lokasi yang sama. A berangkat lebih dulu dan berlari selama 2 jam dengan kecepatan 5 km/jam. B menyusul dengan kecepatan 15 km/jam. Berapa lama waktu yang dibutuhkan B untuk menyusul?

import os
import time
from openai import OpenAI
os.environ[“DASHSCOPE_API_KEY”] = “sk-****************”
client = OpenAI(
api_key=os.getenv(“DASHSCOPE_API_KEY”),
base_url=“https://dashscope.aliyuncs.com/compatible-mode/v1”,
)
############################################
# Think
# Record the start time
start_time = time.time()
stream = client.chat.completions.create(
# model lists：https://help.aliyun.com/zh/model-studio/getting-started/models
model=“qwen3-235b-a22b”,
# model="qwen-plus-2025-04-28",
messages=[
{“role”: “system”, “content”: “You are a helpful assistant.”},
{“role”: “user”, “content”: “A and B depart from the same location. A leaves 2 hours earlier at 5 km/h. B follows at 15 km/h. When will B catch up?”},
],
# You can control the thinking mode through the enable_thinking parameter
extra_body={“enable_thinking”: True},
stream=True,
)
answer_content = “”
for chunk in stream:
delta = chunk.choices[0].delta
if delta.content is not None:
answer_content += delta.content
print(answer_content)
# Record the end time and calculate the total runtime
end_time = time.time()
print(f"\n\nTotal runtime：{end_time - start_time:.2f}seconds")

Dengan mode penalaran diaktifkan:

• Waktu pemrosesan: ~74,83 detik

• Analisis mendalam, penguraian masalah, beberapa jalur solusi

• Output penurunan harga berkualitas tinggi dengan rumus

(Gambar di bawah ini adalah tangkapan layar dari visualisasi respons penurunan nilai model, untuk kenyamanan pembaca)

Mode Non-Penalaran:

Di dalam kode, Anda hanya perlu mengatur "enable_thinking": False

Hasil dari mode non-reasoning pada masalah ini:

• Waktu pemrosesan: ~74,83 detik
• Analisis mendalam, penguraian masalah, beberapa jalur solusi
• Output penurunan harga berkualitas tinggi dengan rumus

(Gambar di bawah ini adalah tangkapan layar dari visualisasi respons penurunan nilai model, untuk kenyamanan pembaca)

Kesimpulan

Qwen 3 memperkenalkan arsitektur model yang fleksibel yang selaras dengan kebutuhan dunia nyata pengembangan GenAI. Dengan berbagai ukuran model (termasuk varian padat dan MoE), mode inferensi hibrida, integrasi MCP, dan dukungan multibahasa, ini memberi pengembang lebih banyak pilihan untuk menyesuaikan kinerja, latensi, dan biaya, tergantung pada kasus penggunaan.

Daripada menekankan pada skala saja, Qwen 3 berfokus pada kemampuan beradaptasi. Hal ini menjadikannya pilihan praktis untuk membangun pipeline RAG, agen AI, dan aplikasi produksi yang membutuhkan kemampuan penalaran dan operasi yang hemat biaya.

Ketika dipasangkan dengan infrastruktur seperti Milvus - basis data vektor sumber terbuka berkinerja tinggi - kemampuan Qwen 3 menjadi semakin berguna, memungkinkan pencarian semantik yang cepat dan integrasi yang lancar dengan sistem data lokal. Bersama-sama, keduanya menawarkan fondasi yang kuat untuk aplikasi GenAI yang cerdas dan responsif dalam skala besar.