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 2.5, 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 2.5, 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 2.5, 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 2.5 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 2.5, 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.1 (8B/70B), Qwen 2.5 (7B/72B), ChatGLM4 9B, Mistral 7B v0.3 und Mixtral 8x7B — 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.1?

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 2.5?

Ja. Qwen 2.5 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.1 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 7B 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.1 8B Instruct (GPU, transformers backend)
xinference launch \
  --model-name llama-3.1-instruct \
  --model-engine transformers \
  --model-size-in-billions 8

# Llama 3.1 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 2.5 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 7B Instruct v0.3 (GPU)
xinference launch \
  --model-name mistral-instruct-v0.3 \
  --model-engine transformers \
  --model-size-in-billions 7

# Mixtral 8x7B 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.1 8B/70B Instruct, Qwen 2.5 7B/72B Instruct, ChatGLM4 9B, Mistral 7B Instruct v0.3 und Mixtral 8x7B 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).

A Note on Third-Party Facts

This article references third-party AI models, benchmarks, prices, and licenses. The AI landscape changes rapidly. Benchmark scores, license terms, model names, and API prices can shift between the time of writing and the time you read this. Before making deployment or compliance decisions based on this article, verify current figures on each provider's official source: Hugging Face model cards for licenses and benchmarks, provider websites for API pricing, and EUR-Lex for current GDPR and EU AI Act text. This article reflects publicly available information as of May 2026.

Vergleichen Sie Ihr lokales LLM gleichzeitig mit 25+ Cloud-Modellen in PromptQuorum.

PromptQuorum-Warteliste beitreten →

← Zurück zu Lokale LLMs

Xinference 2026: Llama 3, Qwen, ChatGLM & Mistral lokal