LocalAI: vollständige OpenAI-API, 100 % selbst gehostet

#Warum LocalAI?

LocalAI (das GitHub-Projekt mudler/LocalAI unter MIT-Lizenz, erstellt und gepflegt von Ettore Di Giacinto und dem LocalAI-Team) bezeichnet sich als „drop-in replacement“ für die OpenAI-API. Konkret gehen Ihre Anfragen an /v1/chat/completions, /v1/embeddings, /v1/audio/transcriptions, /v1/audio/speech oder /v1/images/generations an einen Server, den Sie selbst hosten, statt an die Server von OpenAI. Kein Token verlässt Ihr Netzwerk, keine nutzungsabhängige Abrechnung, keine Kontingente.

Der eigentliche Vorteil von LocalAI besteht nicht darin, einen weiteren Chat zu betreiben, sondern darin, mehrere Modalitäten hinter einem einzigen kompatiblen Endpunkt zu bündeln. Dieselbe Instanz stellt ein LLM für Text, ein Embedding-Modell für Ihr RAG, Whisper für die Transkription, Stable Diffusion für Bilder und inzwischen auch Videomodelle bereit. Für eine Anwendung, die mehrere Komponenten benötigt, entfällt damit die Notwendigkeit, drei oder vier separate Server einzurichten und zu warten und sich in deren jeweils eigene API einzuarbeiten.

OpenAI-kompatible API

Dieselben Pfade, dieselben JSON-Payloads. Ihre offiziellen SDKs (openai-python, openai-node) funktionieren, wenn Sie lediglich die Basis-URL ändern.

Multi-backend

LocalAI basiert auf llama.cpp (GGUF), whisper.cpp, diffusers, piper und anderen je nach Modell. Sie müssen diese nicht einzeln installieren.

Multimodal

Text, Embeddings, Audio (STT + TTS) und Bilder auf derselben Instanz, jeweils über einen eigenen OpenAI-Endpunkt.

100 % lokal

Funktioniert offline nach dem Download der Modelle. Keine Inferenz-Telemetrie, keine Cloud-Abhängigkeit.

Das Projekt hat sich seit seiner ursprünglichen Beschreibung als einfacher Klon der OpenAI-API über die Versionen hinweg deutlich erweitert. Seine „Drop-in“-Kompatibilität umfasst inzwischen auch die APIs von Anthropic und ElevenLabs, und zwar auf jedem seiner Backends. Mehr als 60 Backends werden unterstützt — darunter llama.cpp, vLLM, SGLang, transformers, whisper.cpp, diffusers sowie MLX und MLX-VLM für Apple Silicon — und lassen sich bei Bedarf aus einer Backend-Galerie installieren, ohne dass alle vorab in einem einzigen Image enthalten sein müssen.

LocalAI integriert auch autonome KI-Agenten mit Werkzeugnutzung, RAG und Unterstützung des MCP-Protokolls sowie einen Mehrbenutzermodus mit Authentifizierung per API-Schlüssel, Kontingenten und rollenbasierter Zugriffskontrolle. Version 4.1.0 (April 2026) ergänzte einen verteilten Cluster-Modus mit intelligentem Routing abhängig vom verfügbaren VRAM und automatischer Skalierung; Version 4.2.0 (Mai 2026) ergänzte Sprach- und Gesichtserkennung, Sprecherdiarisierung, eine Ollama-kompatible API und Videogenerierung.

#LocalAI oder Ollama, je nach Bedarf

Beide führen GGUF über llama.cpp aus und stellen eine OpenAI-kompatible API für Text bereit. Der Unterschied liegt im Funktionsumfang und in der Philosophie. Ollama setzt bei Text (und in gewissem Umfang bei Bildverarbeitung) auf Einfachheit mit einer schlanken CLI; LocalAI strebt eine breite Abdeckung an – mehrere Modalitäten, mehr Backends, mehr Einstellungen, integrierte Agenten –, erfordert dafür aber beim Einrichten eine deutlich umfangreichere Konfiguration.

Nichts hindert Sie daran, beide auf derselben Maschine zu betreiben: Ollama für den interaktiven Chat im Alltag, LocalAI als multimodales Gateway für Ihre Anwendungen, die Embeddings, Audio oder Bilder über dieselbe API benötigen.

#Voraussetzungen

LocalAI lässt sich am saubersten über Docker bereitstellen, mit einem für Ihre Hardware passenden Image. Planen Sie den Speicherbedarf anhand der vorgesehenen Modelle: Letztlich bestimmt der VRAM (oder bei reinem CPU-Betrieb der RAM), welche Modelle Sie tatsächlich bereitstellen können.

Docker

Eine aktuelle Version von Docker Engine oder Docker Desktop. Docker Compose wird für eine reproduzierbare Bereitstellung empfohlen.

GPU (optional)

NVIDIA mit dem NVIDIA Container Toolkit für die Beschleunigung über CUDA 12 oder 13. LocalAI unterstützt auch die Beschleunigung auf AMD (ROCm), Intel (oneAPI/SYCL) und Apple Silicon (Metal), mit Vulkan als allgemeiner Ausweichlösung, wenn keiner dieser Wege infrage kommt. Ohne GPU läuft alles auf der CPU, allerdings langsamer.

VRAM je nach Größe (Q4)

3B ≈ 2 GB · 7B ≈ 5 GB · 14B ≈ 9 GB · 32B ≈ 19 GB · 70B ≈ 40 GB. Planen Sie zusätzlichen Speicher für ein Embedding-Modell und/oder Whisper ein, wenn Sie diese parallel bereitstellen.

GPU-Hinweise

Eine RTX 3060 mit 12 GB (Einstieg) oder eine RTX 4070 mit 12 GB bietet ausreichend Platz für ein 7–14B-Modell; für größere Modelle eignen sich eine RTX 4090 mit 24 GB oder ein Mac M4 Pro mit 24–48 GB gemeinsamem Speicher.

Festplattenspeicher

Jedes Modell benötigt mehrere GB, bei Bild- oder Videomodellen manchmal noch mehr. Planen Sie ein dediziertes Volume ein, damit Sie nicht bei jedem Neustart des Containers alles erneut herunterladen müssen.

#LocalAI in Docker bereitstellen

1. 01
   Test-Container starten

   Der schnellste Befehl startet LocalAI und stellt die API auf Port 8080 bereit. Verwenden Sie das Image „-gpu-nvidia-cuda-12“ (oder „-cuda-13“ bei den neuesten Treibern), wenn Sie eine NVIDIA-Karte haben, andernfalls das standardmäßige CPU-Image.
2. 02
   Prüfen, ob die API antwortet

   Sobald der Container bereit ist, sollte die Route /v1/models die Liste (initial leer) im OpenAI-Format zurückgeben. Dies ist der Hinweis darauf, dass der Server korrekt auf dem Port 8080 läuft.
3. 03
   Modelle dauerhaft speichern

   Binden Sie ein Volume unter /models ein (oder unter /build/models, je nach Image), damit die heruntergeladenen Modelle nach einem Neustart erhalten bleiben. Ohne Volume wird bei jedem „docker run“ alles erneut heruntergeladen.
4. 04
   Zu Docker Compose wechseln

   Für einen dauerhaften Einsatz beschreiben Sie den Dienst in einer docker-compose.yml-Datei: Image, Ports, Volume und GPU-Reservierung. Mit „docker compose up -d“ starten Sie alles erneut.

# Lance LocalAI, API OpenAI-compatible sur le port 8080
docker run -p 8080:8080 --name localai \
  -v $PWD/models:/models \
  localai/localai:latest

# Version GPU NVIDIA (CUDA 12) :
# docker run -p 8080:8080 --gpus all \
#   -v $PWD/models:/models \
#   localai/localai:latest-gpu-nvidia-cuda-12

# Version GPU NVIDIA (CUDA 13, plus récente) :
# docker run -p 8080:8080 --gpus all \
#   -v $PWD/models:/models \
#   localai/localai:latest-gpu-nvidia-cuda-13

services:
  localai:
    image: localai/localai:latest-gpu-nvidia-cuda-12
    container_name: localai
    ports:
      - "8080:8080"
    volumes:
      - ./models:/models
    environment:
      - DEBUG=true
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped

# La route est identique à celle d'OpenAI
curl http://localhost:8080/v1/models

#Ein Modell aus der Galerie installieren

LocalAI bietet eine Galerie vorkonfigurierter Modelle, die auch über „local-ai models list“ in der Kommandozeile oder auf models.localai.io eingesehen werden kann: Jeder Eintrag enthält das passende Backend, die Prompt-Vorlage und die Standardparameter. Sie können ein Modell anhand seines Namens über die API installieren, ohne eine YAML-Datei von Hand zu schreiben.

# Installe un modèle de la galerie (nom d'exemple)
curl http://localhost:8080/models/apply -H "Content-Type: application/json" -d '{
  "id": "localai@qwen2.5-7b-instruct"
}'

# Suivre l'avancement du téléchargement
curl http://localhost:8080/models/jobs

Für vollständige Kontrolle können Sie ein Modell auch manuell in einer YAML-Datei im Ordner /models definieren. Diese Datei beschreibt den Namen, unter dem das Modell über die API verfügbar ist, das Backend und die zu ladende Gewichtsdatei.

name: qwen2.5-7b
backend: llama-cpp
parameters:
  model: qwen2.5-7b-instruct-q4_k_m.gguf
context_size: 8192
template:
  chat: |
    <|im_start|>system
    {{.SystemPrompt}}<|im_end|>
    {{.Input}}

#Eine einzige API für Text, Embeddings, Audio und Bilder

Hier hebt sich LocalAI ab. Jede Modalität nutzt den jeweiligen Standard-API-Endpunkt von OpenAI; dafür muss lediglich für jede Modalität das passende Modell installiert sein. Hier sind die vier nützlichsten Bausteine.

curl http://localhost:8080/v1/chat/completions -H "Content-Type: application/json" -d '{
  "model": "qwen2.5-7b",
  "messages": [{"role": "user", "content": "Explique le RAG en une phrase."}]
}'

curl http://localhost:8080/v1/embeddings -H "Content-Type: application/json" -d '{
  "model": "bert-embeddings",
  "input": "Texte à vectoriser pour ma base vectorielle"
}'

curl http://localhost:8080/v1/audio/transcriptions \
  -H "Content-Type: multipart/form-data" \
  -F file="@reunion.wav" \
  -F model="whisper-1"

curl http://localhost:8080/v1/images/generations -H "Content-Type: application/json" -d '{
  "model": "stablediffusion",
  "prompt": "un phare breton sous la pluie, aquarelle",
  "size": "512x512"
}'

#Eine OpenAI-App ohne Änderung des Codes migrieren

Da die Routen und Payloads identisch sind, genügt es bei der Migration einer Anwendung, die Basis-URL anzupassen und die Modellnamen zu ersetzen. Die offiziellen SDKs akzeptieren eine benutzerdefinierte base_url: Das ist der einzige Parameter, der geändert werden muss, unabhängig davon, ob die Anwendung die API von OpenAI, Anthropic oder ElevenLabs anspricht.

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8080/v1",  # au lieu de l'endpoint OpenAI
    api_key="sk-localai",                 # ignorée si l'auth n'est pas activée
)

resp = client.chat.completions.create(
    model="qwen2.5-7b",                    # au lieu de "gpt-4o-mini"
    messages=[{"role": "user", "content": "Bonjour !"}],
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "http://localhost:8080/v1",
  apiKey: "sk-localai",
});

const resp = await client.chat.completions.create({
  model: "qwen2.5-7b",
  messages: [{ role: "user", content: "Bonjour !" }],
});
console.log(resp.choices[0].message.content);

Basis-URL

Ersetzen Sie den OpenAI-Endpunkt durch http://votre-hote:8080/v1. Oft genügt eine einfache Umgebungsvariable OPENAI_BASE_URL.

Modellnamen

„gpt-4o“ → der Name Ihres lokalen Modells. Das ist die wichtigste Anpassung, die Sie im Code oder in der Konfiguration vornehmen müssen.

API-Schlüssel

Im lokalen Betrieb optional; geben Sie einen beliebigen Wert ein, falls das SDK ihn verlangt, oder konfigurieren Sie einen echten Schlüssel in LocalAI.

Verhaltensabweichungen

Ein lokales 7B-Modell schlussfolgert nicht wie GPT-4. Passen Sie Ihre Prompts und Erwartungen an, statt von gleicher Qualität auszugehen.

#Fehlerbehebung

Der Container startet beim ersten Start langsam

Die LocalAI-Container-Images und der erste Modell-Download sind groß. Das ist normal; spätere Starts sind schnell, wenn das Volume /models persistent ist.

„model not found“

Der Parameter „model“ in der Anfrage muss exakt dem „name“ in der Galerie oder im YAML entsprechen. Prüfen Sie mit „curl /v1/models“.

Keine GPU-Beschleunigung

Verwenden Sie unbedingt ein Image „-gpu-nvidia-cuda-12“ (oder „-cuda-13“), installieren Sie das NVIDIA Container Toolkit und übergeben Sie „--gpus all“. Aktivieren Sie DEBUG=true, um das tatsächlich ausgewählte Backend zu sehen.

Langsame Antworten oder OOM

Das Modell benötigt mehr VRAM, als Ihnen zur Verfügung steht, und wird teilweise auf CPU und System-RAM ausgelagert. Eine Stufe heruntergehen (Q4_K_M statt Q8_0 oder ein kleineres Modell) oder context_size reduzieren.

Eine Modalität antwortet nicht

Jede Route benötigt das passende Modell: keine Embeddings ohne installiertes Embedding-Modell, kein /audio ohne Whisper-Modell. Installieren Sie den fehlenden Baustein aus der Galerie.

#Weiterführende Informationen

LocalAI ist nur einer der verfügbaren Inferenzserver für Open-Weight-Modelle. Um eine fundierte Entscheidung zu treffen, vergleichen Sie LocalAI mit llama-server (dem HTTP-Server von llama.cpp) und dem Ansatz von Ollama. Optimieren Sie außerdem den Kompromiss zwischen Speicherbedarf und Qualität Ihrer Modelle mithilfe des Leitfadens zur Quantisierung. Schließen Sie anschließend eine Benutzeroberfläche oder eine App über den OpenAI-Endpunkt von LocalAI an.

• llama-server: eine lokale OpenAI-API mit llama.cpp
• Ollama vs llama.cpp: Welches wählen?
• Quantisierung wählen (Q4, Q5, Q8, FP16)
• Lokales RAG ohne Programmieren: Open WebUI, AnythingLLM
• Quelle: GitHub-Repository von LocalAI
• Quelle : offizielle LocalAI-Dokumentation
• Quelle: LocalAI-Backend-Galerie

#FAQ