Qwen3 Embedding und Reranker Modelle lokal mit Ollama ausführen

Die Welt der großen Sprachmodelle (LLMs) expandiert in einem explosionsartigen Tempo, doch lange Zeit bedeutete der Zugriff auf hochmoderne Funktionen, sich auf cloudbasierte APIs zu verlassen. Diese Abhängigkeit bringt oft Bedenken hinsichtlich Datenschutz, Kosten und Anpassung mit sich. Das Blatt wendet sich jedoch dank leistungsstarker Open-Source-Modelle und Tools wie Ollama, die das Ausführen auf dem lokalen Rechner einfacher denn je machen.

Zu den aufregendsten jüngsten Entwicklungen gehört die Veröffentlichung der Qwen3-Modellfamilie durch Alibaba Cloud. Diese Modelle, insbesondere die spezialisierten Embedding- und Reranker-Versionen, setzen neue Maßstäbe in der Leistung. In Kombination mit Ollama bieten sie ein leistungsstarkes Toolkit für Entwickler und Forscher, die anspruchsvolle KI-Anwendungen wie erweiterte Suchmaschinen und Retrieval-Augmented Generation (RAG)-Systeme entwickeln möchten – und das alles bequem von ihrer eigenen Hardware aus.

Dieser Artikel ist Ihr umfassender Schritt-für-Schritt-Leitfaden zur Nutzung dieser Leistung. Wir werden entmystifizieren, was Embedding- und Reranker-Modelle sind, die Einrichtung von Ollama durchgehen und praktischen Python-Code bereitstellen, um die Qwen3 Embedding- und Reranker-Modelle für einen vollständigen, End-to-End-RAG-Workflow auszuführen.

💡

Sie suchen ein großartiges API-Testtool, das schöne API-Dokumentation generiert?

Sie wünschen sich eine integrierte All-in-One-Plattform, damit Ihr Entwicklerteam mit maximaler Produktivität zusammenarbeiten kann?

Apidog erfüllt all Ihre Anforderungen und ersetzt Postman zu einem viel günstigeren Preis!

Schaltfläche

Das Power-Duo: Embedding- und Reranker-Modelle verstehen

Bevor wir uns dem „Wie“ widmen, wollen wir das „Was“ verstehen. Im Kontext eines RAG-Systems spielen Embedding- und Reranker-Modelle unterschiedliche, aber komplementäre Rollen.

1. Der Bibliothekar: Das Embedding-Modell

Stellen Sie sich eine riesige Bibliothek mit Millionen von Büchern vor, aber ohne Katalogsystem. Informationen zu finden wäre ein Albtraum. Ein Embedding-Modell ist wie ein hyperintelligenter Bibliothekar, der jedes einzelne Dokument liest und ihm einen bestimmten Ort in einem riesigen, mehrdimensionalen „Konzeptraum“ zuweist.

Technisch gesehen ist ein Texteinbettung (Text Embedding) ein Prozess, der einen Textabschnitt (ein Wort, einen Satz oder ein ganzes Dokument) in einen dichten Zahlenvektor umwandelt. Dieser Vektor erfasst die semantische Bedeutung des Textes. Dokumente mit ähnlichen Bedeutungen haben Vektoren, die in diesem Raum „nah“ beieinander liegen.

Wenn Sie eine Abfrage haben, wandelt das Embedding-Modell Ihre Frage in einen Vektor um und durchsucht dann die Bibliothek nach Dokumentvektoren, die diesem am nächsten sind. Diese erste Suche ist unglaublich effizient und ruft eine breite Palette potenziell relevanter Dokumente ab.

2. Der Expertenberater: Das Reranker-Modell

Die anfängliche Abfrage vom Embedding-Modell ist schnell, aber nicht immer perfekt. Es könnten Dokumente abgerufen werden, die thematisch verwandt sind, aber die Benutzeranfrage nicht präzise beantworten. Hier kommt der Reranker ins Spiel.

Wenn das Embedding-Modell ein Generalist unter den Bibliothekaren ist, ist der Reranker ein Fachexperte. Er nimmt die besten Ergebnisse der ersten Suche und führt eine nuanciertere, rechenintensivere Analyse durch. Anstatt einen Abfragevektor unabhängig mit Dokumentvektoren zu vergleichen, betrachtet ein Reranker-Modell (typischerweise ein Cross-Encoder) die Abfrage und jedes Dokument *als Paar*.

Dieser direkte Vergleich ermöglicht es dem Reranker, eine viel genauere Relevanzbewertung zu berechnen. Er ordnet die Dokumente dann basierend auf dieser Bewertung neu an und schiebt die relevantesten Ergebnisse an die Spitze. Dieser zweistufige Prozess – eine schnelle anfängliche Abfrage, gefolgt von einer präzisen Neuanordnung – ist das Geheimnis der hochmodernen RAG-Leistung.

Die Qwen3-Modelle: Ein neuer Standard in der Open-Source-KI

Die Qwen3-Serie von Alibaba Cloud ist nicht nur ein weiteres Modellset; sie stellt einen bedeutenden Fortschritt in der Open-Source-NLP dar. Hier sind die Merkmale, die die Embedding- und Reranker-Modelle auszeichnen:

Spitzenleistung: Das Qwen3-Embedding-8B-Modell schoss zum Zeitpunkt seiner Veröffentlichung auf Platz 1 der hart umkämpften mehrsprachigen MTEB (Massive Text Embedding Benchmark)-Bestenliste und übertraf viele etablierte Modelle.
Außergewöhnliche Mehrsprachigkeit: Die Modelle wurden auf einem riesigen Korpus trainiert und unterstützen über 100 Sprachen, was sie ideal für den Aufbau globaler Anwendungen macht.
Flexibel und effizient: Die Modelle sind in verschiedenen Größen erhältlich (z. B. 0,6B, 4B und 8B Parameter), sodass Entwickler die beste Balance zwischen Leistung, Geschwindigkeit und Hardwareanforderungen wählen können. Sie unterstützen auch verschiedene Quantisierungsstufen, was ihren Speicherbedarf bei minimalen Auswirkungen auf die Genauigkeit weiter reduziert.
Instruktionsbewusst: Sie können den Modellen benutzerdefinierte Anweisungen geben, um ihre Leistung für bestimmte Aufgaben oder Domänen anzupassen, eine Funktion, die erhebliche Leistungssteigerungen erzielen kann.

Ihre lokale KI-Umgebung einrichten

Nun wollen wir uns die Hände schmutzig machen. Der erste Schritt ist die Einrichtung von Ollama und das Herunterladen der Qwen3-Modelle.

Schritt 1: Ollama installieren

Ollama bietet einen einfachen, einzeiligen Installationsbefehl für macOS und Linux. Öffnen Sie Ihr Terminal und führen Sie aus:

curl -fsSL https://ollama.com/install.sh | sh

Für Windows laden Sie das offizielle Installationsprogramm von der Ollama-Website herunter.

Nach der Installation können Sie überprüfen, ob es funktioniert, indem Sie ausführen:

ollama --version

Schritt 2: Die Qwen3-Modelle herunterladen

Wenn Ollama läuft, können Sie Modelle aus der Ollama-Bibliothek ziehen. Die Qwen3-Modelle werden unter dem `dengcao`-Namespace gehostet. Wir werden eine empfohlene Version der Embedding- und Reranker-Modelle herunterladen. Das Tag `:Q5_K_M` kennzeichnet eine bestimmte Quantisierungsstufe, die ein hervorragendes Gleichgewicht zwischen Leistung und Ressourcennutzung bietet.

Führen Sie in Ihrem Terminal die folgenden Befehle aus:

# Download the 8B parameter embedding model
ollama pull dengcao/Qwen3-Embedding-8B:Q5_K_M

# Download the 4B parameter reranker model
ollama pull dengcao/Qwen3-Reranker-4B:Q5_K_M

Diese Downloads können je nach Internetverbindung einige Zeit in Anspruch nehmen. Sobald sie abgeschlossen sind, können Sie Ihre lokal verfügbaren Modelle durch Ausführen von `ollama list` sehen.

Teil 1: Embeddings mit Qwen3 generieren

Nachdem das Embedding-Modell heruntergeladen wurde, generieren wir nun einige Vektoren. Wir verwenden die offizielle `ollama` Python-Bibliothek. Falls Sie diese nicht installiert haben, führen Sie `pip install ollama` aus.

Hier ist ein einfaches Python-Skript, um ein Embedding für einen Textabschnitt zu generieren:

import ollama

# Define the model name as downloaded
EMBEDDING_MODEL = 'dengcao/Qwen3-Embedding-8B:Q5_K_M'

def get_embedding(text: str):
    """Generates an embedding for a given text."""
    try:
        response = ollama.embeddings(
            model=EMBEDDING_MODEL,
            prompt=text
        )
        return response['embedding']
    except Exception as e:
        print(f"An error occurred: {e}")
        return None

# --- Example Usage ---
sentence = "Ollama makes it easy to run LLMs locally."
embedding = get_embedding(sentence)

if embedding:
    print(f"Embedding for: '{sentence}'")
    # Print the first few dimensions for brevity
    print(f"First 5 dimensions: {embedding[:5]}")
    print(f"Total dimensions: {len(embedding)}")

Dieses Skript gibt die ersten fünf Werte des generierten Vektors und seine Gesamtgröße (die 4096 für das 8B-Modell beträgt) aus. Dieser Vektor ist die numerische Darstellung unseres Satzes, bereit zur Speicherung und zum Vergleich.

Teil 2: Ergebnisse mit dem Qwen3 Reranker verfeinern

Die Verwendung des Rerankers ist etwas anders. Anstelle eines dedizierten `rerank`-Endpunkts verwenden wir den Standard-`chat`-Endpunkt. Wir erstellen eine spezifische Eingabeaufforderung, die das Modell anweist, als Reranker zu agieren, indem es eine Abfrage und ein Dokument als Eingabe nimmt und einen Relevanzwert ausgibt.

Lassen Sie uns eine Python-Funktion erstellen, um dies zu handhaben. Wir werden das Modell bitten, ein einfaches "Ja" oder "Nein" zurückzugeben, um die Relevanz anzuzeigen, was wir leicht in einen Wert umwandeln können.

import ollama

# Define the model name as downloaded
RERANKER_MODEL = 'dengcao/Qwen3-Reranker-4B:Q5_K_M'

def rerank_document(query: str, document: str) -> float:
    """
    Uses the Qwen3 Reranker to score the relevance of a document to a query.
    Returns a score of 1.0 for 'Yes' and 0.0 for 'No'.
    """
    prompt = f"""
    You are an expert relevance grader. Your task is to evaluate if the
    following document is relevant to the user's query.
    Please answer with a simple 'Yes' or 'No'.

    Query: {query}
    Document: {document}
    """
    try:
        response = ollama.chat(
            model=RERANKER_MODEL,
            messages=[{'role': 'user', 'content': prompt}],
            options={'temperature': 0.0} # For deterministic output
        )
        answer = response['message']['content'].strip().lower()
        if 'yes' in answer:
            return 1.0
        return 0.0
    except Exception as e:
        print(f"An error occurred during reranking: {e}")
        return 0.0

# --- Example Usage ---
user_query = "How do I run models locally?"
doc1 = "Ollama is a tool for running large language models on your own computer."
doc2 = "The capital of France is Paris."

score1 = rerank_document(user_query, doc1)
score2 = rerank_document(user_query, doc2)

print(f"Relevance of Doc 1: {'Relevant' if score1 > 0.5 else 'Not Relevant'} (Score: {score1})")
print(f"Relevance of Doc 2: {'Relevant' if score2 > 0.5 else 'Not Relevant'} (Score: {score2})")

Diese Funktion demonstriert, wie man mit dem Reranker interagiert. Sie erkennt korrekt, dass `doc1` für die Abfrage hochrelevant ist, während `doc2` es nicht ist.

Alles zusammenfügen: Eine einfache RAG-Implementierung

Nun zum Hauptereignis. Lassen Sie uns eine Mini-RAG-Pipeline erstellen, die beide unserer Modelle verwendet, um eine Abfrage aus einer kleinen Wissensbasis zu beantworten. Für die Ähnlichkeitssuche verwenden wir `numpy`. Installieren Sie es mit `pip install numpy`.

import ollama
import numpy as np

# --- Model Definitions ---
EMBEDDING_MODEL = 'dengcao/Qwen3-Embedding-8B:Q5_K_M'
RERANKER_MODEL = 'dengcao/Qwen3-Reranker-4B:Q5_K_M'

# --- 1. Corpus and Offline Embedding Generation ---
documents = [
    "The Qwen3 series of models was developed by Alibaba Cloud.",
    "Ollama provides a simple command-line interface for running LLMs.",
    "A reranker model refines search results by calculating a precise relevance score.",
    "To install Ollama on Linux, you can use a curl command.",
    "Embedding models convert text into numerical vectors for semantic search.",
]

# In a real application, you would store these embeddings in a vector database
corpus_embeddings = []
print("Generating embeddings for the document corpus...")
for doc in documents:
    response = ollama.embeddings(model=EMBEDDING_MODEL, prompt=doc)
    corpus_embeddings.append(response['embedding'])
print("Embeddings generated.")

def cosine_similarity(v1, v2):
    """Calculates cosine similarity between two vectors."""
    return np.dot(v1, v2) / (np.linalg.norm(v1) * np.linalg.norm(v2))

# --- 2. Online Retrieval and Reranking ---
user_query = "How do I install Ollama?"

# Embed the user's query
query_embedding = ollama.embeddings(model=EMBEDDING_MODEL, prompt=user_query)['embedding']

# Perform initial retrieval (semantic search)
retrieval_scores = [cosine_similarity(query_embedding, emb) for emb in corpus_embeddings]
top_k_indices = np.argsort(retrieval_scores)[::-1][:3] # Get top 3 results

print("\n--- Initial Retrieval Results (before reranking) ---")
for i in top_k_indices:
    print(f"Score: {retrieval_scores[i]:.4f} - Document: {documents[i]}")

# --- 3. Rerank the top results ---
retrieved_docs = [documents[i] for i in top_k_indices]

print("\n--- Reranking the top results ---")
reranked_scores = [rerank_document(user_query, doc) for doc in retrieved_docs]

# Combine documents with their new scores and sort
reranked_results = sorted(zip(retrieved_docs, reranked_scores), key=lambda x: x[1], reverse=True)

print("\n--- Final Results (after reranking) ---")
for doc, score in reranked_results:
    print(f"Relevance Score: {score:.2f} - Document: {doc}")

Wenn Sie dieses Skript ausführen, werden Sie die Leistungsfähigkeit des zweistufigen Prozesses sehen. Die anfängliche Abfrage findet korrekt Dokumente, die sich auf „Ollama“ und „Installation“ beziehen. Der Reranker identifiziert jedoch dann präzise das Dokument über die Verwendung von `curl` als das relevanteste und schiebt es mit einer perfekten Punktzahl an die Spitze.

Fazit

Sie haben nun erfolgreich eines der leistungsstärksten Open-Source-KI-Tandems, das heute verfügbar ist, direkt auf Ihrem lokalen Rechner eingerichtet und verwendet. Durch die Kombination der breiten Reichweite des Qwen3-Embedding-Modells mit der scharfen Präzision des Qwen3-Rerankers können Sie Anwendungen entwickeln, die Sprache mit einem Nuancenreichtum verstehen und verarbeiten, der zuvor ausschließlich großen, proprietären Systemen vorbehalten war.

Die Reise endet hier nicht. Sie können mit verschiedenen Modellgrößen experimentieren, verschiedene Quantisierungsstufen ausprobieren und diese Pipeline in komplexere Anwendungen integrieren. Die Möglichkeit, diese Tools lokal auszuführen, eröffnet eine Welt voller Möglichkeiten und befähigt Sie, zu kreieren, zu innovieren und zu forschen, ohne Kompromisse bei Datenschutz oder Leistung einzugehen. Willkommen in der neuen Ära der lokalen, quelloffenen KI.

💡

Schaltfläche