Zum Hauptinhalt springen
Zurück zur Kategorie

LocalAI Einrichtung: OpenAI-kompatible Self-Hosted AI-API

LocalAI Docker-Installation, OpenAI-API-kompatible Self-Hosted AI-Service, Texterzeugung, Bilderzeugung, Sprachsynthese, Embedding und Modellverwaltung Anleitung.

Lesezeit: 14 Min. KI & ML Self-Hosting
localaiopenaiapikünstliche intelligenzself-hostingdockerembedding
Autor
REXE Teknoloji Network & Security Team
Redaktion
REXE Teknoloji Technical Editorial
Erstveröffentlichung
Letzte Aktualisierung

LocalAI Einrichtung: OpenAI-kompatible Self-Hosted AI-API

LocalAI ist ein Open-Source, Self-Hosted AI-API-Server, der vollständig mit der OpenAI-API kompatibel ist. Er vereint alle KI-Fähigkeiten einschließlich Texterzeugung, Bilderzeugung, Sprachsynthese, Spracherkennung und Embedding in einem einzigen Dienst. Seine Fähigkeit, im CPU-Modus ohne GPU zu laufen, ist einer seiner größten Vorteile.

Was ist LocalAI?

LocalAI ist ein Drop-in-Replacement, das das OpenAI-API-Format exakt repliziert. Sie können Ihre bestehenden Anwendungen, die das OpenAI SDK verwenden, einfach durch Ändern der Base-URL auf LocalAI umleiten. Hauptmerkmale:

  • OpenAI-API-Kompatibilität: /v1/chat/completions, /v1/images/generations, /v1/audio/transcriptions
  • Multi-Modell-Unterstützung: LLaMA, Mistral, Phi, Gemma, Whisper, Stable Diffusion
  • CPU und GPU: Funktioniert ohne GPU, NVIDIA/AMD GPU-Unterstützung
  • Embedding: Text-Embedding-Erzeugung (für RAG-Anwendungen)
  • TTS/STT: Text-zu-Sprache und Sprache-zu-Text Konvertierung
  • Bilderzeugung: Stable Diffusion Integration
  • Function Calling: OpenAI Function Calling Unterstützung

Systemanforderungen

KomponenteCPU-ModusGPU-Modus
RAM8 GB+16 GB+
Festplatte20 GB50 GB+
GPUNicht erforderlichNVIDIA 8 GB+ VRAM
OSLinux/macOSLinux (CUDA)
Docker24.0+24.0+ + nvidia-container-toolkit

Docker-Installation

CPU-Modus

hljs bash
docker run -d \
  --name localai \
  -p 8080:8080 \
  -v localai_models:/build/models \
  localai/localai:latest-cpu

GPU-Modus (NVIDIA CUDA)

hljs bash
docker run -d \
  --name localai \
  --gpus all \
  -p 8080:8080 \
  -v localai_models:/build/models \
  localai/localai:latest-gpu-nvidia-cuda-12

Docker Compose

hljs yaml
version: '3.8'
services:
  localai:
    image: localai/localai:latest-gpu-nvidia-cuda-12
    container_name: localai
    ports:
      - "8080:8080"
    volumes:
      - localai_models:/build/models
      - ./config:/build/config
    environment:
      - THREADS=4
      - CONTEXT_SIZE=4096
      - GALLERIES=[{"name":"model-gallery","url":"github:mudler/LocalAI/gallery/index.yaml@master"}]
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/readyz"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  localai_models:

Modellinstallation

Modelle aus der Galerie laden

hljs bash
# Verfügbare Modelle auflisten
curl http://localhost:8080/models/available

# Modell laden (Llama 3)
curl http://localhost:8080/models/apply -d '{
  "id": "huggingface://TheBloke/Llama-2-7B-Chat-GGUF/llama-2-7b-chat.Q4_K_M.gguf",
  "name": "llama-3"
}'

# Geladene Modelle auflisten
curl http://localhost:8080/v1/models

Manuelle Modellhinzufügung

hljs bash
wget -O models/mistral-7b-instruct.gguf \
  "https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.2-GGUF/resolve/main/mistral-7b-instruct-v0.2.Q4_K_M.gguf"

Modellkonfigurationsdatei erstellen:

hljs yaml
# config/mistral.yaml
name: mistral
backend: llama-cpp
parameters:
  model: mistral-7b-instruct.gguf
  temperature: 0.7
  top_p: 0.9
  top_k: 40
  context_size: 4096
  threads: 4
  gpu_layers: 35

API-Nutzung

Chat Completion

hljs bash
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3",
    "messages": [
      {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
      {"role": "user", "content": "Was ist Docker Compose?"}
    ],
    "temperature": 0.7,
    "max_tokens": 512
  }'

Embedding-Erzeugung

hljs bash
curl http://localhost:8080/v1/embeddings \
  -H "Content-Type: application/json" \
  -d '{
    "model": "text-embedding-ada-002",
    "input": "Server-Sicherheit Best Practices"
  }'

Bilderzeugung

hljs bash
curl http://localhost:8080/v1/images/generations \
  -H "Content-Type: application/json" \
  -d '{
    "model": "stablediffusion",
    "prompt": "a futuristic server room, neon lights",
    "size": "512x512"
  }'

Python-Nutzung

Direkt verwendbar mit dem OpenAI Python SDK:

hljs python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="llama-3",
    messages=[
        {"role": "system", "content": "Du bist ein Linux-Experte."},
        {"role": "user", "content": "Wie installiert man Nginx?"}
    ],
    max_tokens=1024
)
print(response.choices[0].message.content)

Multi-Modell-Konfiguration

hljs yaml
# config/models.yaml
- name: llama-3
  backend: llama-cpp
  parameters:
    model: llama-3-8b.gguf
    context_size: 4096
    gpu_layers: 35

- name: mistral
  backend: llama-cpp
  parameters:
    model: mistral-7b-instruct.gguf
    context_size: 4096
    gpu_layers: 35

- name: embedding
  backend: llama-cpp
  embeddings: true
  parameters:
    model: all-MiniLM-L6-v2.gguf

Leistungsoptimierung

hljs bash
export THREADS=8
export CONTEXT_SIZE=4096
export GPU_LAYERS=35
export PARALLEL_REQUESTS=true

docker run -d \
  --name localai \
  --gpus all \
  -p 8080:8080 \
  -e THREADS=8 \
  -e CONTEXT_SIZE=4096 \
  -v localai_models:/build/models \
  localai/localai:latest-gpu-nvidia-cuda-12

Betreiben Sie Ihre eigene OpenAI-kompatible AI-API mit LocalAI auf REXE-Servern. Erhalten Sie hochleistungsfähige Inferenz mit unseren GPU-Servern.

Häufig gestellte Fragen

Was ist der Unterschied zwischen LocalAI und der OpenAI-API?

LocalAI repliziert das OpenAI-API-Format exakt. Die gleichen Endpunkte und Anfrageformate werden verwendet. Der Unterschied ist, dass Modelle auf Ihrem eigenen Server laufen und Ihre Daten nie nach außen gelangen.

Funktioniert LocalAI ohne GPU?

Ja, einer der größten Vorteile von LocalAI ist die Fähigkeit, im CPU-Modus zu laufen. Quantisierte Modelle im GGUF-Format laufen mit akzeptabler Geschwindigkeit auf der CPU. GPU bietet jedoch viel schnellere Antwortzeiten.

Welche Modellformate werden unterstützt?

LocalAI unterstützt GGUF (llama.cpp), GGML, PyTorch, Safetensors und ONNX-Formate. Das am häufigsten verwendete Format ist GGUF, das einen geringen Speicherverbrauch bietet.

Kann ich mit LocalAI Embeddings erstellen?

Ja, LocalAI bietet einen OpenAI-kompatiblen /v1/embeddings-Endpunkt. Sie können Textvektoren mit Embedding-Modellen wie all-MiniLM-L6-v2 erstellen und in RAG-Anwendungen verwenden.

Können mehrere Modelle gleichzeitig laufen?

Ja, Sie können mehrere Modellkonfigurationen im config-Verzeichnis definieren. Jedes Modell ist über die API mit einem anderen Namen erreichbar. Modelle dienen parallel, solange genügend RAM/VRAM vorhanden ist.

Kann LocalAI Bilder erzeugen?

Ja, LocalAI unterstützt Bilderzeugung über den /v1/images/generations-Endpunkt mit Stable Diffusion Integration. Es unterstützt auch Spracherkennung mit Whisper und Sprachsynthese mit TTS.

Verwandte Artikel

NetzwerkverkehrEingehend— GbpsAusgehend— Gbps