Hands-on mit Qwen 3 und Milvus: Aufbau von RAG mit den neuesten hybriden Inferenzmodellen

Als Entwickler, der ständig auf der Suche nach praktischen KI-Tools ist, konnte ich den Rummel um die neueste Veröffentlichung von Alibaba Cloud nicht ignorieren: die Qwen 3-Modellfamilie, eine robuste Reihe von acht hybriden Inferenzmodellen, die das Gleichgewicht zwischen Intelligenz und Effizienz neu definieren sollen. In nur 12 Stunden erhielt das Projekt über 17.000 GitHub-Sterne und erreichte einen Spitzenwert von 23.000 Downloads pro Stunde auf Hugging Face.

Was ist also dieses Mal anders? Kurz gesagt, die Qwen 3-Modelle vereinen sowohl das Reasoning (langsame, durchdachte Antworten) als auch das Non-Reasoning (schnelle, effiziente Antworten) in einer einzigen Architektur, umfassen verschiedene Modelloptionen, verbessertes Training und Leistung und bieten mehr unternehmenstaugliche Funktionen.

In diesem Beitrag fasse ich die wichtigsten Funktionen der Qwen 3-Modelle zusammen, auf die Sie achten sollten, und führe Sie durch den Prozess der Kopplung von Qwen 3 mit Milvus, um ein lokales, kostenbewusstes Retrieval-Augmented-Generation-System (RAG) zu erstellen - komplett mit praktischem Code und Tipps zur Optimierung von Leistung und Latenz.

Lassen Sie uns eintauchen.

Was ist das Aufregende an Qwen 3?

Nachdem ich Qwen 3 getestet und genauer unter die Lupe genommen habe, ist klar, dass es nicht nur um größere Zahlen auf einem Datenblatt geht. Vielmehr geht es darum, wie die Designentscheidungen des Modells Entwicklern helfen, bessere GenAI-Anwendungen zu entwickeln - schneller, intelligenter und mit mehr Kontrolle. Hier ist, was heraussticht.

1. Hybride Denkmodi: Intelligent, wenn Sie sie brauchen, schnell, wenn Sie sie nicht brauchen

Eine der innovativsten Funktionen von Qwen 3 ist seine hybride Inferenzarchitektur. Sie gibt Ihnen die Möglichkeit, genau zu bestimmen, wie viel "Denken" das Modell bei jeder einzelnen Aufgabe an den Tag legt. Schließlich sind nicht alle Aufgaben mit komplizierten Schlussfolgerungen verbunden.

• Bei komplexen Problemen, die eine tiefgehende Analyse erfordern, können Sie die volle Denkleistung nutzen - auch wenn sie langsamer ist.

• Für alltägliche, einfache Abfragen können Sie in einen schnelleren, leichteren Modus wechseln.

• Sie können sogar ein "Denkbudget " festlegen, d. h. wie viel Rechenleistung oder Token eine Sitzung verbraucht.

Auch dies ist nicht nur eine Laborfunktion. Sie befasst sich direkt mit dem täglichen Kompromiss, mit dem Entwickler jonglieren: Hochwertige Antworten zu liefern, ohne die Infrastrukturkosten oder die Latenzzeiten für die Benutzer in die Höhe zu treiben.

2. Ein vielseitiges Lineup: MoE- und Dense-Modelle für unterschiedliche Anforderungen

Qwen 3 bietet eine breite Palette von Modellen, die auf unterschiedliche betriebliche Anforderungen abgestimmt sind:

• Zwei MoE-Modelle (Mixture of Experts):

  • Qwen3-235B-A22B: 235 Milliarden Gesamtparameter, 22 Milliarden aktive Parameter pro Abfrage

  • Qwen3-30B-A3B: 30 Milliarden insgesamt, 3 Milliarden aktiv

• Sechs Dense-Modelle: von flinken 0,6B bis zu satten 32B Parametern

Kurzer technischer Hintergrund: Dense-Modelle (wie GPT-3 oder BERT) aktivieren immer alle Parameter, was sie schwerer, aber manchmal auch berechenbarer macht. MoE-Modelle aktivieren jeweils nur einen Bruchteil des Netzes, was sie im großen Maßstab viel effizienter macht.

In der Praxis bedeutet diese vielseitige Auswahl an Modellen, dass Sie Folgendes tun können:

• Dense-Modelle für enge, vorhersehbare Arbeitslasten (wie eingebettete Geräte) verwenden

• MoE-Modelle verwenden, wenn Sie leistungsstarke Funktionen benötigen, ohne Ihre Cloud-Rechnung zum Schmelzen zu bringen

Mit dieser Palette können Sie Ihre Bereitstellung individuell anpassen - von leichtgewichtigen, Edge-fähigen Setups bis hin zu leistungsstarken Cloud-Bereitstellungen - ohne auf einen einzigen Modelltyp festgelegt zu sein.

3. Fokus auf Effizienz und Real-World Deployment

Anstatt sich ausschließlich auf die Skalierung der Modellgröße zu konzentrieren, legt Qwen 3 den Schwerpunkt auf Trainingseffizienz und praktische Einsatzmöglichkeiten:

• Trainiert auf 36 Billionen Token - doppelt so viel wie bei Qwen 2.5

• Erweitert auf 235B Parameter - aber intelligent verwaltet durch MoE-Techniken, die einen Ausgleich zwischen Kapazität und Ressourcenbedarf schaffen.

• Optimiert für den Einsatz - dynamische Quantisierung (von FP4 auf INT8) ermöglicht es, selbst das größte Qwen 3-Modell auf einer bescheidenen Infrastruktur laufen zu lassen - zum Beispiel auf vier H20 GPUs.

Das Ziel ist klar: mehr Leistung ohne unverhältnismäßig hohe Investitionen in die Infrastruktur.

4. Gebaut für echte Integration: MCP-Unterstützung und mehrsprachige Funktionen

Bei der Entwicklung von Qwen 3 stand die Integration im Vordergrund, nicht nur die isolierte Modellleistung:

• Die Kompatibilität mit dem MCP (Model Context Protocol) ermöglicht die nahtlose Integration mit externen Datenbanken, APIs und Werkzeugen und reduziert den technischen Aufwand für komplexe Anwendungen.

• Qwen-Agent verbessert den Aufruf von Werkzeugen und die Orchestrierung von Arbeitsabläufen und unterstützt so den Aufbau dynamischerer, handlungsfähiger KI-Systeme.

• Diemehrsprachige Unterstützung von 119 Sprachen und Dialekten macht Qwen 3 zu einer guten Wahl für Anwendungen, die auf globale und mehrsprachige Märkte abzielen.

Diese Funktionen machen es für Entwickler einfacher, produktionsreife Systeme zu erstellen, ohne dass sie umfangreiche kundenspezifische Anpassungen am Modell vornehmen müssen.

Qwen 3 wird jetzt in DeepSearcher unterstützt

DeepSearcher ist ein Open-Source-Projekt für Deep Retrieval und die Erstellung von Berichten, das als Local-First-Alternative zu Deep Research von OpenAI entwickelt wurde. Es hilft Entwicklern, Systeme zu erstellen, die qualitativ hochwertige, kontextbezogene Informationen aus privaten oder domänenspezifischen Datenquellen anzeigen.

DeepSearcher unterstützt jetzt die hybride Inferenzarchitektur von Qwen 3, die es Entwicklern ermöglicht, die Schlussfolgerungen dynamisch umzuschalten - tiefere Inferenzen nur dann anzuwenden, wenn sie einen Mehrwert bieten, und sie zu überspringen, wenn die Geschwindigkeit wichtiger ist.

Unter der Haube integriert sich DeepSearcher mit Milvus, einer hochleistungsfähigen Vektordatenbank, die von Zilliz-Ingenieuren entwickelt wurde, um eine schnelle und genaue semantische Suche über lokale Daten zu ermöglichen. In Kombination mit der Flexibilität des Modells erhalten Entwickler eine größere Kontrolle über das Systemverhalten, die Kosten und die Benutzerfreundlichkeit.

Praktisches Tutorial: Aufbau eines RAG-Systems mit Qwen 3 und Milvus

Lassen Sie uns diese Qwen 3-Modelle in die Praxis umsetzen, indem wir ein RAG-System mit der Milvus-Vektordatenbank erstellen.

Richten Sie die Umgebung ein.

# 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

Hinweis: Sie müssen den API-Schlüssel von Alibaba Cloud erhalten.

Vorbereitung der Daten

Wir werden die Milvus-Dokumentationsseiten als primäre Wissensbasis verwenden.

# 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("# ")

Einrichten von Modellen

Wir werden die OpenAI-kompatible API von DashScope verwenden, um auf Qwen 3 zuzugreifen:

# 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()

Wir generieren eine Testeinbettung und drucken ihre Abmessungen und die ersten Elemente aus:

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

Ausgabe:

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

Erstellen einer Milvus-Sammlung

Richten wir nun unsere Milvus-Vektor-Datenbank ein:

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
)

Über die MilvusClient-Parametereinstellungen:

• Die Einstellung der URI auf eine lokale Datei (z.B. ./milvus.db) ist die bequemste Methode, da sie automatisch Milvus Lite verwendet, um alle Daten in dieser Datei zu speichern.

• Für große Datenmengen können Sie einen leistungsfähigeren Milvus-Server auf Docker oder Kubernetes einrichten. In diesem Fall verwenden Sie die URI des Servers (z. B. http://localhost:19530) als Ihre URI.

• Wenn Sie Zilliz Cloud (den verwalteten Dienst von Milvus) verwenden möchten, passen Sie die URI und das Token an, die dem öffentlichen Endpunkt und dem API-Schlüssel in Zilliz Cloud entsprechen.

Hinzufügen von Dokumenten zur Sammlung

Jetzt erstellen wir Einbettungen für unsere Textbausteine und fügen sie zu Milvus hinzu:

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)

Ausgabe:

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}

Aufbau des RAG-Abfragesystems

Jetzt kommt der spannende Teil - wir richten unser RAG-System ein, um Fragen zu beantworten.

Lassen Sie uns eine allgemeine Frage über Milvus spezifizieren:

question = "How is data stored in milvus?"

Suchen Sie nach dieser Frage in der Sammlung und holen Sie sich die ersten 3 semantisch passenden Ergebnisse:

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
)

Schauen wir uns die Suchergebnisse für diese Frage an:

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))

Ausgabe:

[
    [
        " 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
    ]
]

Verwendung des LLM zur Erstellung einer RAG-Antwort

Konvertieren Sie die abgerufenen Dokumente in das String-Format:

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

Geben Sie eine System- und eine Benutzereingabeaufforderung für das große Sprachmodell ein:

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}

“"”

Verwenden Sie das neueste Qwen-Modell, um eine Antwort auf der Grundlage der Eingabeaufforderung zu erstellen:

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)

Ausgabe:

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.

Vergleich von Reasoning vs. Non-Reasoning Modi: Ein praktischer Test

Ich habe einen Test durchgeführt, in dem ich die beiden Inferenzmodi anhand eines mathematischen Problems verglichen habe:

Problem: Person A und Person B laufen vom selben Ort aus los. A geht als erster los und läuft 2 Stunden lang mit 5km/h. B folgt mit 15km/h. Wie lange wird B brauchen, um aufzuholen?

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")

Mit aktiviertem Argumentationsmodus:

• Verarbeitungszeit: ~74,83 Sekunden

• Tiefgreifende Analyse, Problem-Parsing, mehrere Lösungswege

• Hochwertige Markdown-Ausgabe mit Formeln

(Das Bild unten ist ein Screenshot der Visualisierung der Markdown-Antwort des Modells, um es dem Leser zu erleichtern)

Non-Reasoning-Modus:

Im Code müssen Sie nur die Option "enable_thinking": False

Ergebnisse des Non-Reasoning-Modus für dieses Problem:

• Verarbeitungszeit: ~74,83 Sekunden
• Tiefgreifende Analyse, Problem-Parsing, mehrere Lösungswege
• Hochwertige Markdown-Ausgabe mit Formeln

(Das Bild unten ist ein Screenshot der Visualisierung der Markdown-Antwort des Modells, zur Bequemlichkeit des Lesers)

Fazit

Qwen 3 führt eine flexible Modellarchitektur ein, die sich gut an die realen Bedürfnisse der GenAI-Entwicklung anpasst. Mit einer Reihe von Modellgrößen (darunter sowohl dichte als auch MoE-Varianten), hybriden Inferenzmodi, MCP-Integration und mehrsprachiger Unterstützung bietet es Entwicklern mehr Optionen, um Leistung, Latenz und Kosten je nach Anwendungsfall zu optimieren.

Qwen 3 legt den Schwerpunkt nicht nur auf die Skalierbarkeit, sondern auch auf die Anpassungsfähigkeit. Das macht es zu einer praktischen Wahl für den Aufbau von RAG-Pipelines, KI-Agenten und Produktionsanwendungen, die sowohl logische Fähigkeiten als auch einen kosteneffizienten Betrieb erfordern.

In Verbindung mit einer Infrastruktur wie Milvus - einer leistungsstarken Open-Source-Vektordatenbank - werden die Fähigkeiten von Qwen 3 noch nützlicher, da sie eine schnelle, semantische Suche und eine reibungslose Integration mit lokalen Datensystemen ermöglichen. Zusammen bieten sie eine starke Grundlage für intelligente, reaktionsschnelle GenAI-Anwendungen im großen Maßstab.