Skip to main content
PromptQuorumPromptQuorum
Startseite/Lokale LLMs/Xinference: Llama 3, Qwen, ChatGLM & Mistral lokal ausführen 2026
Tools & Interfaces

Xinference: Llama 3, Qwen, ChatGLM & Mistral lokal ausführen 2026

·10 Min. Lesezeit·Von Hans Kuepper · Gründer von PromptQuorum, Multi-Model-AI-Dispatch-Tool · PromptQuorum

**Installieren Sie Xinference mit `pip install "xinference[all]"`, starten Sie es mit `xinference-local`, und führen Sie dann `xinference launch --model-name llama-3.1-instruct --model-engine transformers --model-size-in-billions 8` aus.** Xinference unterstützt nativ Llama 3, Qwen 3, ChatGLM4, Mistral und über 30 weitere Familien — alle über eine OpenAI-kompatible API auf localhost:9997.

Xinference (Xorbits Inference) ist ein Open-Source-Framework, mit dem Sie Llama 3, Qwen 3, ChatGLM4, Mistral und über 30 weitere Modellfamilien über eine einzige OpenAI-kompatible API bereitstellen können — installiert mit einem pip-Befehl, gestartet mit einem CLI-Aufruf. Im Gegensatz zu Ollama, das auf Benutzerfreundlichkeit ausgelegt ist, wurde Xinference für Teams entwickelt, die Multi-Modell-Serving, GPU-Cluster-Unterstützung und Embedding/Reranking neben der LLM-Inferenz benötigen. Diese Anleitung behandelt unterstützte Modellfamilien, Installation, Startbefehle und einen Vergleich mit Ollama und vLLM.

Wichtigste Erkenntnisse

  • Xinference bedient über 30 Modellfamilien über eine einzige API — Llama 3, Qwen 3, ChatGLM4, Mistral, Embedding-Modelle und Reranker teilen denselben Endpunkt auf localhost:9997/v1.
  • Ein pip install, ein CLI-Befehl — `pip install "xinference[all]"` dann `xinference-local` startet den Server mit Web-Oberfläche; `xinference launch --model-name <Name>` deployt jedes Modell.
  • Drei wählbare Backends — `transformers` (GPU, volle Präzision), `llama.cpp` (CPU + quantisiertes GGUF, kein GPU erforderlich), `vllm` (hoher Durchsatz, mehrere GPUs). Pro Modell konfigurierbar.
  • Qwen 3 und ChatGLM4 sind die besten Xinference-Optionen für CJK-Aufgaben — beide laufen in ~6–7 GB VRAM und übertreffen vergleichbare englischsprachige Modelle auf chinesischen und japanischen Benchmarks.
  • Bevorzuge Xinference gegenüber Ollama, wenn du Multi-Modell-Serving, Embedding + Reranking oder GPU-Cluster-Unterstützung benötigst — Ollama ist besser für einfache Desktop-Nutzung.

Was Xinference ist und wie es funktioniert

Xinference (github.com/xorbitsai/inference) ist ein Open-Source-Framework für LLM- und multimodale Modellbereitstellung von Xorbits. Es wurde als Enterprise-Inferenzplattform für verteilte Cluster entwickelt und 2023 als Open Source veröffentlicht. Kernidee: Du registrierst ein Modell nach Name, Xinference lädt die Gewichte herunter, wählt das richtige Backend und stellt eine REST-API bereit.

📍 In einem Satz

Xinference ist ein Open-Source-Inferenz-Server, der Llama 3, Qwen 3, ChatGLM4, Mistral und über 30 weitere Modellfamilien nativ über eine einzige OpenAI-kompatible API unterstützt.

💬 In einfachen Worten

Stell dir Xinference als eine Vermittlungsstelle für lokale KI-Modelle vor. Du sagst ihr, welches Modell geladen werden soll, sie lädt es herunter und startet es — deine App kommuniziert damit wie mit der OpenAI-API, ohne Code-Änderungen.

  • Modell-Registrierung: Über 200 vorregistrierte Modelle. Referenzierung nach Name (`llama-3.1-instruct`, `qwen2.5-instruct`, `chatglm4`) statt manueller Gewichtspfad-Verwaltung.
  • Backend-Abstraktion: Ein Befehl wechselt zwischen transformers-, llama.cpp- und vLLM-Backends — dieselbe API unabhängig vom Backend.
  • Multi-Modell-Parallelität: Llama 3 für Textgenerierung und ein BGE-Embedding-Modell für RAG gleichzeitig auf derselben GPU.
  • Web-Oberfläche: Ein React-Dashboard auf localhost:9997 zum Starten, Inspizieren und Beenden von Modellen ohne Code.
  • Cluster-Modus: Supervisor-Worker-Architektur skaliert über mehrere GPU-Knoten via `xinference start --host 0.0.0.0` auf Workers.

Unterstützte Modellfamilien: Llama 3, Qwen, ChatGLM, Mistral

Die folgende Tabelle zeigt die sieben meistgefragten Modellkonfigurationen in Xinference mit dem minimal erforderlichen VRAM. Alle sieben teilen dasselbe Befehlsmuster — nur `--model-name`, `--model-size-in-billions` und optional `--quantization` ändern sich.

📍 In einem Satz

Xinference unterstützt nativ Llama 3.3 (8B/70B), Qwen 3 (7B/72B), ChatGLM4 9B, Mistral Small v0.3 und Mixtral 8x22B — jedes mit einem einzigen CLI-Befehl startbar.

💬 In einfachen Worten

VRAM ist der Speicher auf Ihrer GPU. Ein Modell, das 6 GB VRAM benötigt, braucht eine GPU mit mindestens diesem Speicher. Bei kleineren GPUs nutzen Sie das llama.cpp-Backend mit Q4-Quantisierung, was den Speicherbedarf etwa halbiert.

ModellFamilieVRAM (Q4)BackendAm besten für
llama-3.1-instruct 8BMeta~6 GBtransformers / llama.cppAllgemeiner Englisch-Einsatz
llama-3.1-instruct 70BMeta~40 GBvLLMHochwertige englische Ausgabe
qwen2.5-instruct 7BAlibaba~6 GBtransformers / llama.cppMehrsprachig, CJK, Programmierung
qwen2.5-instruct 72BAlibaba~40 GBvLLMGroßmaßstäbliche CJK-Aufgaben
chatglm4 9BZhipu AI~7 GBtransformersChinesische Unternehmensaufgaben
mistral-instruct-v0.3 7BMistral AI~5 GBtransformers / llama.cppEuropäische Sprachen, Funktionsaufruf
mixtral-instruct-v0.1 8x7BMistral AI~26 GBvLLMHochwertige Mehrsprachigkeit

Unterstützt Xinference Llama 3.3?

Ja. Verwenden Sie `--model-name llama-3.1-instruct` mit `--model-size-in-billions 8` für die 8B-Variante oder `70` für 70B. Wechseln Sie zu llama.cpp mit `--model-engine llama.cpp` und `--quantization q4_k_m` für CPU- oder Low-VRAM-Nutzung.

Unterstützt Xinference Qwen 3?

Ja. Qwen 3 Instruct ist als `qwen2.5-instruct` registriert. Größen 0,5B bis 72B sind verfügbar. Die 7B-Variante läuft in ~6 GB VRAM und verarbeitet Chinesisch, Japanisch, Koreanisch und Englisch mit vergleichbarer Qualität zu Llama 3.3 8B.

Unterstützt Xinference ChatGLM?

Ja. ChatGLM3 (`chatglm3`), ChatGLM4 (`chatglm4`) und ChatGLM4-Vision (`chatglm4v`) sind alle registriert. ChatGLM4 9B ist 2026 die empfohlene Wahl für chinesischsprachige Aufgaben.

Unterstützt Xinference Mistral?

Ja. `mistral-instruct-v0.3` (7B) und `mixtral-instruct-v0.1` (8x7B MoE) sind beide registriert. Für Funktionsaufruf und JSON-Ausgabe ist Mistral Small v0.3 die beste Kleinmodell-Option in Xinference.

Xinference installieren: pip und Server starten

Xinference erfordert Python 3.9+ und pip. Das `[all]`-Extra installiert CUDA-Unterstützung, das llama.cpp-Backend und das transformers-Backend in einem Schritt. Auf reinen CPU-Maschinen verwenden Sie `pip install xinference` (ohne `[all]`) und fügen `--model-engine llama.cpp` beim Modellstart hinzu.

📍 In einem Satz

Installiere Xinference mit `pip install "xinference[all]"` und starte den Server mit `xinference-local` — die Web-Oberfläche öffnet sich auf http://localhost:9997.

bash
# Vollständige Installation — CUDA + transformers + llama.cpp Backends
pip install "xinference[all]"

# Nur-CPU-Installation (kein GPU erforderlich)
pip install xinference

# Lokalen Server starten (Web-Oberfläche auf http://localhost:9997)
xinference-local

# Oder an bestimmten Host für LAN-Zugriff binden
xinference-local --host 0.0.0.0 --port 9997

Benötigt Xinference eine GPU?

Nein. Verwenden Sie das llama.cpp-Backend (`--model-engine llama.cpp`), um quantisierte GGUF-Modelle vollständig auf der CPU auszuführen. Die Performance ist langsamer als GPU-Inferenz, funktioniert aber auf jeder Maschine mit Python 3.9+.

Wie aktualisiere ich Xinference?

Führen Sie `pip install --upgrade xinference` aus. Prüfen Sie vor dem Upgrade die GitHub-Releases auf Breaking Changes, besonders im Cluster-Modus.

Llama 3, Qwen, ChatGLM und Mistral starten

Verwenden Sie `xinference launch`, um jedes registrierte Modell zu deployen. Das Muster ist immer dasselbe: `--model-name` setzt die Modellfamilie, `--model-size-in-billions` die Parameteranzahl, und `--model-engine` wählt das Backend. Nach dem Start gibt Xinference eine Modell-UID zurück, die Sie in API-Aufrufen verwenden.

📍 In einem Satz

Starte jedes Xinference-Modell mit `xinference launch --model-name <Name> --model-engine transformers --model-size-in-billions <Größe>` — das Modell ist kurz nach dem Download auf localhost:9997/v1 verfügbar.

bash
# Llama 3.3 8B Instruct (GPU, transformers backend)
xinference launch \
  --model-name llama-3.1-instruct \
  --model-engine transformers \
  --model-size-in-billions 8

# Llama 3.3 8B Instruct (CPU, Q4_K_M quantization)
xinference launch \
  --model-name llama-3.1-instruct \
  --model-engine llama.cpp \
  --model-size-in-billions 8 \
  --quantization q4_k_m

# Qwen 3 7B Instruct (GPU)
xinference launch \
  --model-name qwen2.5-instruct \
  --model-engine transformers \
  --model-size-in-billions 7

# ChatGLM4 9B (GPU)
xinference launch \
  --model-name chatglm4 \
  --model-engine transformers \
  --model-size-in-billions 9

# Mistral Small Instruct v0.3 (GPU)
xinference launch \
  --model-name mistral-instruct-v0.3 \
  --model-engine transformers \
  --model-size-in-billions 7

# Mixtral 8x22B Instruct (vLLM backend, requires 26+ GB VRAM)
xinference launch \
  --model-name mixtral-instruct-v0.1 \
  --model-engine vllm \
  --model-size-in-billions 46

Wie liste ich alle von Xinference unterstützten Modelle auf?

Führe `xinference registrations --model-type LLM` aus, oder öffne die Web-Oberfläche auf http://localhost:9997 und durchsuche die Modellbibliothek.

Kann ich in Xinference gleichzeitig zwei Modelle ausführen?

Ja — führe `xinference launch` zweimal mit verschiedenen Modellnamen aus. Jedes Modell erhält eine eigene UID und einen eigenen Endpunkt. Das gesamte VRAM-Budget muss beide Modelle gleichzeitig abdecken.

Die OpenAI-kompatible API verwenden

Xinferences API ist ein Drop-in-Ersatz für die OpenAI-API. Zeige jeden OpenAI-Client auf `http://localhost:9997/v1`, setze `api_key` auf einen beliebigen nicht leeren String, und verwende die Modell-UID als `model`-Parameter. Bestehender LangChain-, LlamaIndex- oder benutzerdefinierter OpenAI-Client-Code funktioniert unverändert.

📍 In einem Satz

Verbinde jeden OpenAI-kompatiblen Client mit Xinference, indem du base_url auf http://localhost:9997/v1 setzt und den Modellnamen als Modell-ID verwendest.

💬 In einfachen Worten

Eine OpenAI-kompatible API bedeutet, dass sich dein Code nicht ändern muss. Derselbe Python-Code, der GPT-4 aufruft, kann über Xinference Llama 3 aufrufen — du tauschst nur die Basis-URL und den Modellnamen aus.

python
from openai import OpenAI

client = OpenAI(
    api_key="not-required",   # Xinference accepts any non-empty string
    base_url="http://localhost:9997/v1"
)

# Chat completion — works for Llama 3, Qwen, ChatGLM, Mistral
response = client.chat.completions.create(
    model="llama-3.1-instruct",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Summarise the GDPR in 3 bullet points."}
    ]
)
print(response.choices[0].message.content)

# Embedding model (run a separate xinference launch for bge-base-en-v1.5 first)
embedding = client.embeddings.create(
    model="bge-base-en-v1.5",
    input="Local LLMs preserve data privacy."
)
print(embedding.data[0].embedding[:5])

Unterstützt Xinference Streaming-Antworten?

Ja. Setze `stream=True` im `chat.completions.create`-Aufruf. Xinference streamt Tokens in Echtzeit für alle unterstützten Backends.

Kann ich LangChain mit Xinference verwenden?

Ja. Verwende `ChatOpenAI(base_url="http://localhost:9997/v1", api_key="x", model="llama-3.1-instruct")` aus `langchain_openai`. Es ist keine zusätzliche Xinference-spezifische Bibliothek erforderlich.

Xinference vs. Ollama vs. vLLM: Wann welches Framework wählen

Die drei häufigsten lokalen Inferenz-Frameworks richten sich jeweils an unterschiedliche Nutzergruppen. Wähle anhand deiner primären Anforderung.

📍 In einem Satz

Wähle Xinference, wenn du mehrere Modelltypen gleichzeitig bereitstellen musst (LLM + Embeddings + Reranker) oder nativen ChatGLM-Support benötigst — wähle Ollama für einfache Desktop-Nutzung.

KriteriumXinferenceOllamavLLM
Am besten fürTeams, Multi-Modell, Embeddings + LLMEinzelnutzer-Desktop, Modelfile-WorkflowsHoher GPU-Durchsatz
GPU erforderlich?Nein (llama.cpp-Backend)Nein (CPU-Modus verfügbar)Ja (CUDA/ROCm)
ModellwechselMehrere Modelle gleichzeitigEin Modell gleichzeitig (Swap)Ein Modell pro Server-Instanz
Embedding-UnterstützungJa (BGE, E5 usw.)Ja (eingeschränkt)Nein (separater Embedding-Server)
Web-OberflächeEingebaut auf localhost:9997Keine (Open WebUI verwenden)Keine
ChatGLM-UnterstützungNativ (chatglm4)EingeschränktEingeschränkt

Ist Xinference schwieriger einzurichten als Ollama?

Etwas schwieriger. Ollama ist ein einzelner Binary-Download; Xinference erfordert Python und pip. Aber beide sind in unter 5 Minuten einsatzbereit. Xinference bietet eine reichhaltigere Multi-Modell-Umgebung nach dem Start.

Kann Xinference vLLM ersetzen?

Für Single-Machine-Serving ja — Xinference kann vLLM als Backend verwenden (`--model-engine vllm`) und fügt Web-Oberfläche und Modell-Registrierung hinzu. Für maximalen Rohdurchsatz über mehrere GPU-Knoten sind dedizierte vLLM-Deployments noch schneller.

Häufig gestellte Fragen

Was ist Xinference?

Xinference (Xorbits Inference) ist ein Open-Source-Framework für Modellbereitstellung, das Llama 3, Qwen, ChatGLM, Mistral und über 30 weitere Familien lokal über eine OpenAI-kompatible API ausführt. Es unterstützt GPU-, CPU- (via llama.cpp) und Multi-GPU-Cluster-Deployments.

Welche Modelle unterstützt Xinference 2026?

Xinference registriert über 200 Modellkonfigurationen. Die beliebtesten 2026 sind Llama 3.3 8B/70B Instruct, Qwen 3 7B/72B Instruct, ChatGLM4 9B, Mistral Small Instruct v0.3 und Mixtral 8x22B Instruct. Führe `xinference registrations --model-type LLM` aus, um die vollständige Liste zu sehen.

Wie lädt Xinference Modellgewichte herunter?

Beim ersten `xinference launch` für jedes Modell lädt Xinference Gewichte von Hugging Face oder ModelScope (konfigurierbar) herunter. Gewichte werden lokal gecacht, sodass nachfolgende Starts sofort erfolgen. Setze `XINFERENCE_HOME` zur Steuerung des Cache-Verzeichnisses.

Funktioniert Xinference auf Windows?

Ja, über pip auf Python 3.9+. Das llama.cpp-Backend funktioniert auf Windows CPU ohne zusätzliche Abhängigkeiten. Für GPU-Unterstützung installiere CUDA 12.x und das entsprechende PyTorch-Wheel vor der Xinference-Installation.

Kann ich Xinference für RAG verwenden?

Ja. Starte ein BGE- oder E5-Embedding-Modell (`xinference launch --model-name bge-base-en-v1.5 --model-type embedding`) neben deinem LLM. Beide teilen denselben API-Endpunkt — deine RAG-Pipeline ruft den Embedding-Endpunkt für die Indizierung und den Chat-Endpunkt für die Generierung auf.

Muss ich bei der Verwendung von Xinference die DSGVO beachten?

Xinference verarbeitet alle Anfragen lokal — keine Daten werden an externe Dienste übertragen. Das erfüllt DSGVO Art. 32 (technische Sicherheitsmaßnahmen) und Art. 25 (Datenschutz durch Technikgestaltung). Für den Unternehmenseinsatz: Verarbeitungsverzeichnis (Art. 30) führen und bei besonders sensiblen Daten eine Datenschutz-Folgenabschätzung (Art. 35) durchführen.

Ist Xinference für den deutschen Mittelstand geeignet?

Ja, besonders gut. Mittelständische Unternehmen profitieren von vollständiger Datensouveränität, einfacher Python-Integration und Multi-Modell-Serving für verschiedene Fachabteilungen. Das BSI empfiehlt lokale KI-Systeme für kritische Verarbeitungsprozesse statt Cloud-APIs. Xinference läuft auf handelsüblicher Hardware (RTX 4070 oder besser).

Hinweis zu Drittanbieter-Fakten

Dieser Artikel referenziert KI-Modelle, Benchmarks, Preise und Lizenzen von Drittanbietern. Die KI-Landschaft verändert sich schnell. Benchmark-Werte, Lizenzbedingungen, Modellnamen und API-Preise können sich zwischen dem Zeitpunkt der Erstellung und dem Zeitpunkt ändern, zu dem Sie dies lesen. Bevor Sie Bereitstellungs- oder Compliance-Entscheidungen auf Basis dieses Artikels treffen, überprüfen Sie aktuelle Zahlen bei der offiziellen Quelle jedes Anbieters: Hugging-Face-Modellkarten für Lizenzen und Benchmarks, Anbieter-Websites für API-Preise und EUR-Lex für den aktuellen DSGVO- und EU-KI-Gesetz-Text. Dieser Artikel spiegelt öffentlich verfügbare Informationen vom Mai 2026 wider.

Nutzen Sie PromptQuorum mit einem lokalen LLM, eigenen API-Schlüsseln oder beidem — Sie wählen das Backend.

PromptQuorum-Warteliste beitreten →

← Zurück zu Lokale LLMs