Wie man Qwen 3 lokal mit Ollama einrichtet und betreibt

Qwen3 ist die neueste Generation von Alibabas großen Sprachmodellen mit offenem Gewicht. Mit der Unterstützung von mehr als 100 Sprachen und einer starken Leistung bei Argumentations-, Kodierungs- und Übersetzungsaufgaben konkurriert Qwen3 mit vielen heute verfügbaren Spitzenmodellen, darunter DeepSeek-R1, o3-mini und Gemini 2.5.

In diesem Tutorial erkläre ich Schritt für Schritt wie man Qwen3 lokal ausführt mit Ollama ausführt.

Wir werden auch eine lokale, leichtgewichtige Anwendung mit Qwen 3 erstellen. Mit der App kannst du zwischen den Argumentationsmodi von Qwen3 wechseln und zwischen verschiedenen Sprachen übersetzen.

Wir halten unsere Leserinnen und Leser mit The Median auf dem Laufenden, unserem kostenlosen Freitags-Newsletter, der die wichtigsten Meldungen der Woche aufschlüsselt. Melde dich an und bleibe in nur ein paar Minuten pro Woche auf dem Laufenden:

Warum Qwen3 vor Ort betreiben?

Der lokale Betrieb von Qwen3 bietet mehrere wichtige Vorteile:

• Datenschutz: Deine Daten verlassen nie deinen Rechner.
• Latenz: Lokale Inferenzen sind ohne API-Roundtrips schneller.
• Kosteneffizienz: Keine Token-Gebühren oder Cloud-Rechnungen.
• Kontrolle: Du kannst deine Prompts anpassen, Modelle auswählen und Denkmodi konfigurieren.
• Offline-Zugang: Nach dem Herunterladen des Modells kannst du auch ohne Internetverbindung arbeiten.

Qwen3 ist sowohl für tiefes Denken (Denkmodus) als auch für schnelle Antworten (Nicht-Denkmodus) optimiert und unterstützt über 100 Sprachen. Lass uns das lokal einrichten.

Qwen3 lokal mit Ollama einrichten

Ollama ist ein Tool, mit dem du Sprachmodelle wie Llama oder Qwen lokal auf deinem Computer über eine einfache Befehlszeilenschnittstelle ausführen kannst.

Schritt 1: Ollama installieren

Lade Ollama für macOS, Windows oder Linux herunter unter: https://ollama.com/download.

Befolge die Anweisungen des Installationsprogramms und überprüfe nach der Installation, indem du dies im Terminal ausführst:

ollama --version

Schritt 2: Qwen3 herunterladen und ausführen

Ollama bietet eine wachsende Auswahl an Qwen3-Modellen an, die für eine Vielzahl von Hardwarekonfigurationen geeignet sind, von leichten Laptops bis hin zu High-End-Servern.

ollama run qwen3

Wenn du den obigen Befehl ausführst, wird das Standardmodell von Qwen3 in Ollama gestartet, das derzeit auf qwen3:8b voreingestellt ist. Wenn du mit begrenzten Ressourcen arbeitest oder schnellere Startzeiten haben willst, kannst du explizit kleinere Varianten wie das 4B-Modell einsetzen:

ollama run qwen3:4b

Qwen3 ist derzeit in mehreren Varianten erhältlich, angefangen von der kleinsten 0,6b(523MB) bis hin zur größten 235b(142GB) Parametervariante. Diese kleineren Varianten bieten eine beeindruckende Leistung beim Reasoning, der Übersetzung und der Codegenerierung, vor allem wenn sie im Denkmodus verwendet werden.

Die MoE-Modelle (30b-a3b, 235b-a22b) sind besonders interessant, da sie nur eine Teilmenge von Experten pro Inferenzschritt aktivieren, was eine große Anzahl von Parametern ermöglicht und gleichzeitig die Laufzeitkosten niedrig hält.

Generell solltest du das größte Modell verwenden, das deine Hardware verarbeiten kann, und für reaktionsschnelle lokale Experimente auf Consumer-Rechnern auf das 8B- oder 4B-Modell zurückgreifen.

Hier ist eine kurze Übersicht über alle Qwen3-Modelle, die du einsetzen kannst :

Schritt 3: Qwen3 im Hintergrund ausführen (optional)

Um das Modell über die API zu bedienen, führe diesen Befehl im Terminal aus:

ollama serve

Dadurch wird das Modell für die Integration in andere Anwendungen verfügbar unter http://localhost:11434.

Qwen3 lokal verwenden

In diesem Abschnitt zeige ich dir verschiedene Möglichkeiten, wie du Qwen3 lokal nutzen kannst, von der einfachen CLI-Interaktion bis zur Integration des Modells in Python.

Option 1: Inferenz über CLI ausführen

Sobald das Modell heruntergeladen ist, kannst du direkt im Terminal mit Qwen3 interagieren. Führe den folgenden Befehl in deinem Terminal aus:

echo "What is the capital of Brazil? /think" | ollama run qwen3:8b

Dies ist nützlich für schnelle Tests oder leichte Interaktionen, ohne dass du Code schreiben musst. Der /think Tag am Ende der Aufforderung weist das Modell an, Schritt für Schritt tiefer zu argumentieren. Du kannst dies durch /no_think ersetzen, um eine schnellere, flachere Reaktion zu erhalten, oder es ganz weglassen, um den Standard-Denkmodus des Modells zu verwenden.

Option 2: Zugriff auf Qwen3 über die API

Sobald ollama serve im Hintergrund läuft, kannst du über eine HTTP-API programmatisch mit Qwen3 interagieren, was sich perfekt für Backend-Integration, Automatisierung oder das Testen von REST-Clients eignet.

curl http://localhost:11434/api/chat -d '{
  "model": "qwen3:8b",
  "messages": [{ "role": "user", "content": "Define entropy in physics. /think" }],
  "stream": false
}'

So funktioniert es:

• curl stellt eine POST Anfrage (wie wir die API aufrufen) an den lokalen Ollama-Server, der unter localhost:11434 läuft.
• Die Nutzlast ist ein JSON-Objekt mit:
• "model": Gibt das zu verwendende Modell an (hier ist es: qwen3:8b).
• "messages": Eine Liste von Chat-Nachrichten, die role und content enthält.
• "stream": false: Stellt sicher, dass die Antwort auf einmal zurückgegeben wird, nicht Token für Token.

Option 3: Zugriff auf Qwen3 über Python

Wenn du in einer Python-Umgebung (wie Jupyter, VSCode oder einem Skript) arbeitest, ist der einfachste Weg, mit Qwen3 zu interagieren, über das Ollama Python SDK. Beginne mit der Installation von ollama:

pip install ollama

Dann führst du dein Qwen3-Modell mit diesem Skript aus (wir verwenden qwen3:8b ):

import ollama
response = ollama.chat(
    model="qwen3:8b",
    messages=[
        {"role": "user", "content": "Summarize the theory of evolution. /think"}
    ]
)
print(response["message"]["content"])

Im obigen Code: 

• ollama.chat(...) sendet eine Anfrage im Chat-Stil an den lokalen Ollama-Server.
• Du gibst das Modell (qwen3:8b) und eine Liste von Nachrichten in einem Format an, das der API von OpenAI ähnelt.
• Der /think Tag sagt dem Modell, dass es Schritt für Schritt denken soll.
• Schließlich wird die Antwort als Wörterbuch zurückgegeben, und du kannst mit ["message"]["content"] auf die Antwort des Modells zugreifen.

Dieser Ansatz ist ideal für lokale Experimente, Prototyping oder den Aufbau von LLM-gestützten Apps, ohne auf Cloud-APIs angewiesen zu sein.

Eine App für lokales Reasoning mit Qwen3

Qwen3 unterstützt hybrides Inferenzverhalten mit /think (Deep Reasoning) und /no_think (Fast Response) Tags. In diesem Abschnitt werden wir Gradio verwenden, um eine interaktive lokale Web-App mit zwei separaten Registerkarten zu erstellen:

1. Eine Denkschnittstelle, um zwischen den Denkmodi zu wechseln.
2. Eine mehrsprachige Schnittstelle, um Text in verschiedenen Sprachen zu übersetzen oder zu bearbeiten.

Schritt 1: Demo zum hybriden Denken 

In diesem Schritt bauen wir unsere hybride Argumentationskarte mit den Tags /think und /no_think auf.

import gradio as gr
import subprocess
def reasoning_qwen3(prompt, mode):
    prompt_with_mode = f"{prompt} /{mode}"
    result = subprocess.run(
        ["ollama", "run", "qwen3:8b"],
        input=prompt_with_mode.encode(),
        stdout=subprocess.PIPE
    )
    return result.stdout.decode()
reasoning_ui = gr.Interface(
    fn=reasoning_qwen3,
    inputs=[
        gr.Textbox(label="Enter your prompt"),
        gr.Radio(["think", "no_think"], label="Reasoning Mode", value="think")
    ],
    outputs="text",
    title="Qwen3 Reasoning Mode Demo",
    description="Switch between /think and /no_think to control response depth."
)

Im obigen Code:

• Die Funktion reasoning_qwen3() benötigt eine Eingabeaufforderung und einen Argumentationsmodus ("think" oder "no_think").
• Sie hängt den ausgewählten Modus als Suffix an die Eingabeaufforderung an.
• Dann führt die Methode subprocess.run() den Befehl ollama run qwen3:8b aus und gibt die Eingabeaufforderung als Standardeingabe ein.
• Schließlich wird die Ausgabe (die Antwort von Qwen3) erfasst und als dekodierter String zurückgegeben.

Sobald die ausgabeerzeugende Funktion definiert ist, wird sie mit der Funktion gr.Interface() in eine interaktive Web-UI verpackt, indem Eingabekomponenten festgelegt werden - Textbox für die Eingabeaufforderung und eine Schaltfläche Radio für die Auswahl des Argumentationsmodus - und diese den Eingaben der Funktion zugeordnet werden.

Schritt 2: Demo einer mehrsprachigen Anwendung

Richten wir nun die Registerkarte für unsere mehrsprachige Anwendung ein.

import gradio as gr
import subprocess
def multilingual_qwen3(prompt, lang):
    if lang != "English":
        prompt = f"Translate to {lang}: {prompt}"
    result = subprocess.run(
        ["ollama", "run", "qwen3:8b"],
        input=prompt.encode(),
        stdout=subprocess.PIPE
    )
    return result.stdout.decode()
multilingual_ui = gr.Interface(
    fn=multilingual_qwen3,
    inputs=[
        gr.Textbox(label="Enter your prompt"),
        gr.Dropdown(["English", "French", "Hindi", "Chinese"], label="Target Language", value="English")
    ],
    outputs="text",
    title="Qwen3 Multilingual Translator",
    description="Use Qwen3 locally to translate prompts to different languages."
)

Ähnlich wie im vorherigen Schritt funktioniert dieser Code wie folgt:

• Die Funktion multilingual_qwen3() benötigt eine Eingabeaufforderung und eine Zielsprache.
• Wenn das Ziel nicht Englisch ist, wird die Anweisung "Translate to {lang}:" vorangestellt, um das Modell anzuleiten.
• Auch hier läuft das Modell lokal über einen Unterprozess mit Ollama.
• Das Ergebnis wird als reiner Text zurückgegeben.

Schritt 3: Starte beide Tabs in Gradio

Lass uns die beiden Tabs in einer Gradio-Anwendung zusammenführen.

demo = gr.TabbedInterface(
    [reasoning_ui, multilingual_ui],
    tab_names=["Reasoning Mode", "Multilingual"]
)
demo.launch(debug = True)

Das machen wir im obigen Code:

• Die Funktion gr.TabbedInterface() erstellt eine Benutzeroberfläche mit zwei Registerkarten:
• Eine für die Kontrolle der Argumentationstiefe.
• Eine für mehrsprachige Promptübersetzung.
• Die Funktion demo.launch(debug=True) führt die App lokal aus und öffnet sie im Browser mit aktiviertem Debugging.

Fazit

Qwen3 bringt mit Ollama fortschrittliches Reasoning, schnelle Dekodierung und mehrsprachige Unterstützung auf deinen lokalen Rechner.

Mit minimaler Einrichtung kannst du:

• Lokale LLM-Inferenz ohne Cloud-Abhängigkeit ausführen
• Wechsel zwischen schnellen und durchdachten Antworten
• Verwende APIs oder Python, um intelligente Anwendungen zu entwickeln

Wenn du dir einen Überblick über die Möglichkeiten von Qwen3 verschaffen willst, empfehle ich dir, diesen Einführungsblog zu lesen Qwen3.