GPT4All lokales LLM

Deploye GPT4All auf Clore.ai — betreibe datenschutzorientierte lokale LLMs mit einem mit OpenAI kompatiblen API-Server per Docker, der GGUF-Modelle mit optionaler CUDA-Beschleunigung für maximale Leistung unterstützt.

Überblick

GPT4All von Nomic AI ist eines der beliebtesten Open-Source-Lokal-LLM-Projekte, mit über 72.000 GitHub-Stars. Es ermöglicht Ihnen, große Sprachmodelle vollständig offline auf Ihrer eigenen Hardware auszuführen — keine Internetverbindung erforderlich, keine Daten an Dritte gesendet.

GPT4All ist vor allem für seine ausgereifte Desktop-Anwendung bekannt, enthält aber auch ein Python-Bibliothek (gpt4all Paket) und einen integrierten OpenAI-kompatiblen API-Server laufend auf Port 4891. Auf Clore.ai können Sie GPT4All in einem Docker-Container auf einer gemieteten GPU bereitstellen, es per HTTP ausliefern und jeden OpenAI-kompatiblen Client damit verbinden.

Docker-Hinweis: GPT4All veröffentlicht kein offizielles Docker-Image für die Server-Komponente. Diese Anleitung verwendet ein benutzerdefiniertes Docker-Setup mit dem gpt4all Python-Paket. Für eine produktionsreifere Docker-Alternative, die die gleichen GGUF-Modelldateien, siehe den Abschnitt zur LocalAI-Alternative — LocalAI ist auf Docker ausgerichtet und unterstützt dasselbe Modellformat.

Wichtige Funktionen:

• 🔒 100 % offline — die gesamte Inferenz läuft lokal

• 🤖 OpenAI-kompatible REST-API (Port 4891)

• 📚 LocalDocs — RAG über Ihre eigenen Dokumente

• 🧩 Unterstützt alle gängigen GGUF-Modellformate

• 🐍 Vollständige Python-API mit pip install gpt4all

• 💬 Schöne Desktop-Oberfläche (für den Server nicht relevant, aber gut zum lokalen Testen)

---

Anforderungen

Hardware-Anforderungen

Stufe	GPU	VRAM	RAM	Speicher	Clore.ai-Preis
Nur CPU	Keine	—	16 GB	50 GB SSD	~$0,02/Stunde (CPU-Server)
Einsteiger-GPU	RTX 3060 12 GB	12 GB	16 GB	50 GB SSD	0,03–0,07 $/Std.
Empfohlen	RTX 3090	24 GB	32 GB	100 GB SSD	ca. 0,07–0,21 $/h
High-End	RTX 4090	24 GB	64 GB	200 GB SSD	ca. 0,14–0,42 $/h

Hinweis: Die GPU-Unterstützung von GPT4All verwendet intern CUDA über llama.cpp. Im Gegensatz zu vLLM benötigt sie nicht keine bestimmte CUDA-Compute-Capability — RTX 10xx und neuer funktionieren in der Regel.

VRAM-Anforderungen des Modells (GGUF Q4_K_M)

Modell	Größe auf dem Datenträger	VRAM	Min. GPU
Phi-3 Mini 3.8B	~2,4 GB	~3 GB	RTX 3060
Mistral 7B Instruct	~4,1 GB	~5 GB	RTX 3060
Llama 3.1 8B Instruct	~4,7 GB	~6 GB	RTX 3060
Llama 3 70B Instruct	~40 GB	~45 GB	A100 80GB
Mixtral 8x7B	~26 GB	~30 GB	2× RTX 3090

---

Schnellstart

Schritt 1 — Einen GPU-Server auf Clore.ai mieten

1. Melde dich an bei clore.ai

2. Filter: Docker aktiviert, GPU: RTX 3090 (für 7B–13B-Modelle)

3. Bereitstellen mit Image: nvidia/cuda:12.8.1-runtime-ubuntu22.04

4. Ports öffnen: 4891 (GPT4All-API), 22 (SSH)

5. Weisen Sie mindestens 50 GB an Festplattenspeicher zu

Schritt 2 — Per SSH verbinden

ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

# GPU überprüfen
nvidia-smi
# Sollte Ihre GPU mit Treiberversion auflisten

Schritt 3 — Das GPT4All-Docker-Image erstellen

Da es kein offizielles GPT4All-Docker-Image gibt, erstellen wir eines:

mkdir -p /workspace/gpt4all-server && cd /workspace/gpt4all-server

cat > Dockerfile << 'EOF'
FROM nvidia/cuda:12.8.1-runtime-ubuntu22.04

ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

# Python- und Systemabhängigkeiten installieren
RUN apt-get update && apt-get install -y \
    python3.11 \\
    python3.11-dev \\
    python3-pip \\
    curl \
    wget \
    git \
    libgomp1 \\
    && rm -rf /var/lib/apt/lists/*

# python3.11 als Standard festlegen
RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1 \\
    && update-alternatives --install /usr/bin/python python python3.11 1

# GPT4All mit CUDA-Unterstützung installieren
RUN pip install --upgrade pip && \\
    pip install gpt4all>=2.8.0 fastapi uvicorn aiofiles pydantic

# Verzeichnisse erstellen
RUN mkdir -p /models /workspace /app

WORKDIR /app

# Serverskript kopieren (wird gemountet oder ins Image eingebaut)
COPY server.py .

EXPOSE 4891

CMD ["python", "server.py"]
EOF

Schritt 4 — Das API-Server-Skript erstellen

cat > /workspace/gpt4all-server/server.py << 'PYEOF'
#!/usr/bin/env python3
"""
GPT4All OpenAI-kompatibler API-Server
Läuft auf Port 4891 (GPT4All-Standard)
"""

import os
import time
import json
import asyncio
from typing import Optional, List, Dict, Any
from pathlib import Path

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
import uvicorn
from gpt4all import GPT4All

# Konfiguration
MODEL_NAME = os.environ.get("MODEL_NAME", "Mistral 7B Instruct v0.1 Q4_0")
MODEL_PATH = os.environ.get("MODEL_PATH", "/models")
API_HOST = os.environ.get("API_HOST", "0.0.0.0")
API_PORT = int(os.environ.get("API_PORT", "4891"))
DEVICE = os.environ.get("DEVICE", "gpu")  # 'gpu', 'cpu', 'metal'
N_CTX = int(os.environ.get("N_CTX", "4096"))

app = FastAPI(title="GPT4All API Server", version="1.0.0")

# Globale Modellinstanz
model = None

def load_model():
    global model
    print(f"Modell wird geladen: {MODEL_NAME}")
    print(f"Modellpfad: {MODEL_PATH}")
    print(f"Gerät: {DEVICE}")
    model = GPT4All(
        model_name=MODEL_NAME,
        model_path=MODEL_PATH,
        device=DEVICE,
        n_ctx=N_CTX,
        allow_download=True,  # Lädt bei Bedarf aus dem GPT4All-Hub herunter
        verbose=True
    )
    Modell erfolgreich geladen!

# --- Pydantic-Modelle ---

class Message(BaseModel):
    role: str
    content: str

class ChatCompletionRequest(BaseModel):
    model: str
    messages: List[Message]
    temperature: float = 0.7
    max_tokens: int = 512
    top_p: float = 0.95
    top_k: int = 40
    stream: bool = False

class CompletionRequest(BaseModel):
    model: str
    prompt: str
    temperature: float = 0.7
    max_tokens: int = 512
    stream: bool = False

# --- API-Routen ---

@app.get("/health")
async def health():
    return {"status": "ok", "model": MODEL_NAME, "device": DEVICE}

@app.get("/v1/models")
async def list_models():
    return {
        "object": "list",
        "data": [{
            "id": MODEL_NAME,
            "object": "model",
            "created": int(time.time()),
            "owned_by": "gpt4all",
        }]
    }

@app.post("/v1/chat/completions")
async def chat_completions(request: ChatCompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="Modell nicht geladen")

    # Nachrichten in einen einzelnen Prompt formatieren
    prompt_parts = []
    for msg in request.messages:
        if msg.role == "system":
            prompt_parts.append(f"### System:\\n{msg.content}")
        elif msg.role == "user":
            prompt_parts.append(f"### Human:\\n{msg.content}")
        elif msg.role == "assistant":
            prompt_parts.append(f"### Assistant:\\n{msg.content}")
    prompt_parts.append("### Assistant:")
    full_prompt = "\\n\\n".join(prompt_parts)

    with model.chat_session():
        response_text = model.generate(
            full_prompt,
            max_tokens=request.max_tokens,
            temp=request.temperature,
            top_p=request.top_p,
            top_k=request.top_k,
        )

    return {
        "id": f"chatcmpl-{int(time.time())}",
        "object": "chat.completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "index": 0,
            "message": {"role": "assistant", "content": response_text},
            "finish_reason": "stop"
        }],
        "usage": {
            "prompt_tokens": len(full_prompt.split()),
            "completion_tokens": len(response_text.split()),
            "total_tokens": len(full_prompt.split()) + len(response_text.split())
        }
    }

@app.post("/v1/completions")
async def completions(request: CompletionRequest):
    if model is None:
        raise HTTPException(status_code=503, detail="Modell nicht geladen")

    response_text = model.generate(
        request.prompt,
        max_tokens=request.max_tokens,
        temp=request.temperature,
    )

    return {
        "id": f"cmpl-{int(time.time())}",
        "object": "text_completion",
        "created": int(time.time()),
        "model": request.model,
        "choices": [{
            "text": response_text,
            "index": 0,
            "finish_reason": "stop"
        }]
    }

if __name__ == "__main__":
    load_model()
    uvicorn.run(app, host=API_HOST, port=API_PORT, log_level="info")
PYEOF

Schritt 5 — Erstellen und Ausführen

cd /workspace/gpt4all-server

# Docker-Image erstellen
docker build -t gpt4all-server:latest .

# Zuerst ein Modell herunterladen (optional — der Server kann es auch automatisch herunterladen)
mkdir -p /workspace/models
wget -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \\
  https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf

# Mit GPU-Unterstützung ausführen
docker run -d \
  --name gpt4all-server \\
  --gpus all \
  --restart unless-stopped \\
  -p 4891:4891 \\
  -v /workspace/models:/models \\
  -v /workspace/gpt4all-server/server.py:/app/server.py \\
  -e MODEL_NAME="mistral-7b-instruct-v0.1.Q4_0.gguf" \\
  -e MODEL_PATH="/models" \\
  -e DEVICE="gpu" \\
  -e N_CTX="4096" \\
  gpt4all-server:latest

# Logs verfolgen
docker logs -f gpt4all-server

Schritt 6 — Die API testen

# Gesundheitsprüfung
curl http://localhost:4891/health

# Modelle auflisten
curl http://localhost:4891/v1/models

# Chat-Vervollständigung
curl http://localhost:4891/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral-7b-instruct-v0.1.Q4_0.gguf",
    "messages": [
      {"role": "user", "content": "Was ist die Hauptstadt von Frankreich?"}
    ],
    "temperature": 0.7,
    "max_tokens": 256
  }'

---

Alternative: LocalAI-Docker-Image

Für eine robustere, produktionsreife Docker-Bereitstellung, die die gleichen GGUF-Modelle wie GPT4All ausführt, ist LocalAI die empfohlene Wahl. Es hat ein offizielles Docker-Image, CUDA-Unterstützung und wird aktiv gepflegt:

# LocalAI mit CUDA-Unterstützung ziehen
docker pull localai/localai:latest-aio-gpu-nvidia-cuda-12

# Modelleverzeichnis erstellen und ein GGUF-Modell herunterladen
mkdir -p /workspace/localai-models
wget -O /workspace/localai-models/mistral-7b.gguf \\
  https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.1-GGUF/resolve/main/mistral-7b-instruct-v0.1.Q4_K_M.gguf

# Modellkonfiguration erstellen
cat > /workspace/localai-models/mistral-7b.yaml << 'EOF'
name: mistral-7b
parameters:
  model: mistral-7b.gguf
  temperature: 0.7
  top_p: 0.95
  top_k: 40
  max_tokens: 2048
context_size: 4096
f16: true
gpu_layers: 35
threads: 8
EOF

# LocalAI ausführen
docker run -d \
  --name localai \\
  --gpus all \
  --restart unless-stopped \\
  -p 8080:8080 \
  -v /workspace/localai-models:/build/models \\
  -e DEBUG=true \\
  localai/localai:latest-aio-gpu-nvidia-cuda-12

# LocalAI testen (gleiche OpenAI-kompatible API)
curl http://localhost:8080/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "mistral-7b",
    "messages": [{"role": "user", "content": "Hallo!"}]
  }'

---

Konfiguration

Umgebungsvariablen für den GPT4All-Server

Variable	Standard	Beschreibung
MODEL_NAME	mistral-7b-instruct...	Modell-Dateiname oder Name im GPT4All-Hub
MODEL_PATH	/models	Verzeichnis mit Modelldateien
DEVICE	gpu	gpu, cpu, oder metal (macOS)
N_CTX	4096	Größe des Kontextfensters (Tokens)
API_HOST	0.0.0.0	Bind-Adresse
API_PORT	4891	Port für den API-Server

Docker-Compose-Setup

# /workspace/gpt4all-server/docker-compose.yml
version: '3.8'

services:
  gpt4all-server:
    build: .
    container_name: gpt4all-server
    restart: unless-stopped
    ports:
      - "4891:4891"
    volumes:
      - /workspace/models:/models
      - ./server.py:/app/server.py
    environment:
      - MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf
      - MODEL_PATH=/models
      - DEVICE=gpu
      - N_CTX=4096
      - API_PORT=4891
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:4891/health"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 120s

docker compose up -d
docker compose logs -f

---

GPU-Beschleunigung

Überprüfung der GPU-Nutzung

Die GPT4All-Python-Bibliothek verwendet llama.cpp unter der Haube mit CUDA-Unterstützung:

# GPU-VRAM-Auslastung nach dem Laden des Modells prüfen
watch -n 2 nvidia-smi

# Im Container prüfen, ob CUDA verfügbar ist
docker exec gpt4all-server python3 -c "
from gpt4all import GPT4All
devices = GPT4All.list_gpus()
print('Verfügbare GPUs:', devices)
"

GPU-Layer auswählen

Der gpu_layers (oder n_gpu_layers) steuert, wie viel vom Modell auf der GPU gegenüber der CPU ausgeführt wird:

# In server.py — alle Layer auf die GPU zwingen
model = GPT4All(
    model_name=MODEL_NAME,
    model_path=MODEL_PATH,
    device="gpu",
    n_ctx=N_CTX,
    # Zusätzliche llama.cpp-Parameter werden durchgereicht:
    # n_gpu_layers=99  # Alle Layer auf der GPU
)

# Mit maximalen GPU-Layern neu bauen und neu starten
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d \
  --name gpt4all-server \\
  --gpus all \
  -p 4891:4891 \\
  -v /workspace/models:/models \\
  -e DEVICE=gpu \\
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \\
  gpt4all-server:latest

CPU-Fallback-Modus

Wenn keine GPU verfügbar ist (z. B. ein Clore.ai-Server nur mit CPU zum Testen):

docker run -d \
  --name gpt4all-server-cpu \
  -p 4891:4891 \\
  -v /workspace/models:/models \\
  -e DEVICE=cpu \
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \
  gpt4all-server:latest

⚠️ CPU-Inferenz ist 10–50× langsamer als auf einer GPU. Für Server nur mit CPU verwenden Sie kleine Modelle (Phi-3 Mini, TinyLlama) und erwarten Sie 2–5 Token/Sek.

---

Tipps & bewährte Praktiken

📥 Modelle vorab herunterladen

Anstatt sich auf den automatischen Download beim Start zu verlassen, laden Sie Modelle vorab herunter, um schnellere Neustarts zu ermöglichen:

# Beliebte GPT4All-Modelle herunterladen
mkdir -p /workspace/models

# Mistral 7B (am beliebtesten, gute Qualität)
wget -q -O /workspace/models/mistral-7b-instruct-v0.1.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/mistral-7b-instruct-v0.1.Q4_0.gguf"

# Phi-3 Mini (am schnellsten, am kleinsten)
wget -q -O /workspace/models/Phi-3-mini-4k-instruct.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/Phi-3-mini-4k-instruct.Q4_0.gguf"

# Llama 3 (beste Qualität im 8B-Bereich)
wget -q -O /workspace/models/Meta-Llama-3-8B-Instruct.Q4_0.gguf \
  "https://gpt4all.io/models/gguf/Meta-Llama-3-8B-Instruct.Q4_0.gguf"

ls -lh /workspace/models/

🔌 Verwendung mit Python-Anwendungen

# Direkte Python-Nutzung (ohne Docker-API)
from gpt4all import GPT4All

model = GPT4All(
    model_name="mistral-7b-instruct-v0.1.Q4_0.gguf",
    model_path="/workspace/models",
    device="gpu"
)

# Einfache Generierung
with model.chat_session():
    response = model.generate("Erkläre GPU-Computing in einfachen Worten", max_tokens=200)
    print(response)

# Den API-Server mit dem OpenAI-Client verwenden
from openai import OpenAI

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

completion = client.chat.completions.create(
    model="mistral-7b-instruct-v0.1.Q4_0.gguf",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(completion.choices[0].message.content)

💰 Kostenoptimierung auf Clore.ai

# RTX 3090 @ US$0,07–0,21/Stunde — für 7B-Modelle verwenden (bestes Preis-Leistungs-Verhältnis)
# Erwarteter Durchsatz: ~40 Token/Sek. für Mistral 7B Q4
# Kosten pro 1 Mio. generierte Token: ~0,005 $ (extrem günstig im Vergleich zu OpenAI)

# RTX 4090 @ US$0,14–0,42/Stunde — für 13B-Modelle verwenden oder wenn Geschwindigkeit wichtig ist
# Erwarteter Durchsatz: ~60 Token/Sek. für Mistral 7B Q4

# Für Stapelverarbeitung: Modell vorladen, alle Prompts verarbeiten, herunterfahren
docker run --rm \\
  --gpus all \
  -v /workspace/models:/models \\
  -v /workspace/prompts:/prompts \
  gpt4all-server:latest \
  python3 -c "
from gpt4all import GPT4All
import json

model = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/models', device='gpu')
prompts = open('/prompts/batch.txt').readlines()
results = []
for p in prompts:
    with model.chat_session():
        results.append(model.generate(p.strip(), max_tokens=256))
json.dump(results, open('/prompts/results.json', 'w'))
print(f'{len(results)} Prompts verarbeitet')
"

---

Fehlerbehebung

Modell kann nicht geladen werden — Datei nicht gefunden

# Prüfen, ob die Modelldatei existiert und den richtigen Namen hat
ls -lh /workspace/models/
docker exec gpt4all-server ls /models/

# GPT4All unterscheidet bei Modellnamen zwischen Groß- und Kleinschreibung
# Verwenden Sie den exakten Dateinamen aus der ls-Ausgabe als MODEL_NAME
docker stop gpt4all-server && docker rm gpt4all-server
docker run -d --gpus all -p 4891:4891 \
  -v /workspace/models:/models \\
  -e MODEL_NAME=mistral-7b-instruct-v0.1.Q4_0.gguf \\
  gpt4all-server:latest

CUDA-Fehler: kein Kernel-Image für diese Architektur

# Ihre GPU ist möglicherweise nicht mit der CUDA-Version kompatibel
# GPU-Compute-Fähigkeit prüfen
nvidia-smi --query-gpu=compute_cap --format=csv,noheader

# Wenn < 6.0, CPU-Modus verwenden
docker run -d --gpus all -p 4891:4891 \
  -v /workspace/models:/models \\
  -e DEVICE=cpu \
  -e MODEL_NAME=Phi-3-mini-4k-instruct.Q4_0.gguf \
  gpt4all-server:latest

API gibt 503 zurück — Modell nicht geladen

# Startprotokolle prüfen
docker logs gpt4all-server | head -50

# Das Laden des Modells kann 30–120 Sekunden dauern
# Warten und erneut versuchen:
sleep 60 && curl http://localhost:4891/health

# Prüfen, ob die Modelldatei beschädigt ist
python3 -c "
from gpt4all import GPT4All
m = GPT4All('mistral-7b-instruct-v0.1.Q4_0.gguf', '/workspace/models')
print('Modell OK:', m)
"

Port 4891 ist von außen nicht erreichbar

# Port-Bindung überprüfen
docker ps | grep 4891
# Sollte anzeigen: 0.0.0.0:4891->4891/tcp

# Prüfen, ob Clore.ai Firewall-Regeln hat
# Stellen Sie in den Clore.ai-Servereinstellungen sicher, dass Port 4891 als offen aufgeführt ist

# Intern testen:
curl http://127.0.0.1:4891/health

# Hinweis: Clore.ai ordnet Ports zufällig zu — verwenden Sie den Port, der in Ihrem Server-Dashboard angezeigt wird

---

Weiterführende Lektüre

• GPT4All auf GitHub — Haupt-Repository

• GPT4All Python-Dokumentation — Python-API-Referenz

• GPT4All-Modell-Explorer — Verfügbare Modelle durchsuchen

• LocalAI-Dokumentation — Docker-freundliche Alternative

• Ollama auf Clore.ai — Einfachere Docker-LLM-Bereitstellung

• vLLM auf Clore.ai — Inferenzserver für die Produktion

• GPU-Vergleichsleitfaden — Wählen Sie die richtige Clore.ai-GPU

• TheBloke auf HuggingFace — Tausende von GGUF-Quantisierungen

• GGUF-Format erklärt — Dokumentation zum Modellformat

💡 Empfehlung: Wenn Sie die einfachste Docker-Bereitstellung für lokale LLMs wünschen, ziehen Sie Ollama stattdessen in Betracht — es hat ein offizielles Docker-Image, integrierte GPU-Unterstützung und ist speziell für die serverseitige Bereitstellung entwickelt. Die Stärke von GPT4All ist seine schöne Desktop-Oberfläche und die LocalDocs-(RAG)-Funktionen, die im Servermodus nicht verfügbar sind.