GPT4All Lokaler LLM

Setzen Sie GPT4All auf Clore.ai ein — betreiben Sie datenschutzorientierte lokale LLMs mit einem OpenAI-kompatiblen API-Server per Docker, unterstützen GGUF-Modelle mit optionaler CUDA-Beschleunigung für maximale Leistung.

Überblick

GPT4All von Nomic AI ist eines der beliebtesten Open-Source-Local-LLM-Projekte, mit über 72.000 GitHub-Sternen. Damit können Sie große Sprachmodelle vollständig offline auf Ihrer eigenen Hardware ausführen — keine Internetverbindung erforderlich, keine Daten an Dritte gesendet.

GPT4All ist am besten für seine ausgefeilte Desktop-Anwendung bekannt, enthält aber auch eine Python-Bibliothek (gpt4all Paket) und einen integrierten OpenAI-kompatiblen API-Server läuft auf Port 4891. Auf Clore.ai können Sie GPT4All in einem Docker-Container auf einer gemieteten GPU bereitstellen, über HTTP bedienen und jeden OpenAI-kompatiblen Client anschließen.

Docker-Hinweis: GPT4All veröffentlicht kein offizielles Docker-Image für die Serverkomponente. Diese Anleitung verwendet ein benutzerdefiniertes Docker-Setup mit dem gpt4all Python-Paket. Für eine produktionsreifere Docker-Alternative, die die gleichen GGUF-Modell-Dateienausführt, siehe die LocalAI-Alternativ-Sektion — LocalAI ist Docker-first und unterstützt dasselbe Modellformat.

Hauptfunktionen:

• 🔒 100% offline — alle Inferenzläufe laufen lokal

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

• 📚 LocalDocs — RAG über Ihre eigenen Dokumente

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

• 🐍 Volle Python-API mit pip install gpt4all

• 💬 Schöne Desktop-Benutzeroberfläche (für den Server nicht relevant, aber gut für lokale Tests)

---

Anforderungen

Hardware-Anforderungen

Tier	GPU	VRAM	RAM	Speicher	Clore.ai-Preis
Nur CPU	Keine	—	16 GB	50 GB SSD	~0,02 $/Std. (CPU-Server)
Einsteiger-GPU	RTX 3060 12GB	12 GB	16 GB	50 GB SSD	~0,10 $/Std.
Empfohlen	RTX 3090	24 GB	32 GB	100 GB SSD	~$0.20/Stunde
High-End	RTX 4090	24 GB	64 GB	200 GB SSD	~$0.35/Stunde

Hinweis: Die GPU-Unterstützung von GPT4All verwendet unter der Haube CUDA über llama.cpp. Im Gegensatz zu vLLM unterstützen erfordert sie keine spezifische CUDA-Compute-Fähigkeit — RTX 10xx und neuer funktionieren im Allgemeinen.

Modell-VRAM-Anforderungen (GGUF Q4_K_M)

Modell	Größe auf der Festplatte	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 — Mieten Sie einen GPU-Server auf Clore.ai

1. Melde dich an bei clore.ai

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

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

4. Offene Ports: 4891 (GPT4All API), 22 (SSH)

5. Reservieren Sie mindestens 50 GB an Festplattenspeicher

Schritt 2 — Verbindung per SSH herstellen

ssh -p <CLORE_SSH_PORT> root@<CLORE_SERVER_IP>

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

Schritt 3 — Erstellen Sie das GPT4All Docker-Image

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

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

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

ENV DEBIAN_FRONTEND=noninteractive
ENV PYTHONUNBUFFERED=1

# Installieren Sie Python und Systemabhängigkeiten
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/*

# Machen Sie python3.11 zum Standard
RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1 \
    && update-alternatives --install /usr/bin/python python python3.11 1

# Installieren Sie GPT4All mit CUDA-Unterstützung
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

# Server-Skript kopieren (wird gemountet oder eingebacken)
COPY server.py .

EXPOSE 4891

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

Schritt 4 — Erstellen Sie das API-Server-Skript

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"Lade Modell: {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 vom GPT4All-Hub herunter, falls nicht vorhanden
        verbose=True
    )
    print("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")

    # Formatiere Nachrichten zu einem einzelnen Prompt
    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"### Mensch:\n{msg.content}")
        elif msg.role == "assistant":
            prompt_parts.append(f"### Assistent:\n{msg.content}")
    prompt_parts.append("### Assistent:")
    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 — Bauen und Ausführen

cd /workspace/gpt4all-server

# Bauen Sie das Docker-Image
docker build -t gpt4all-server:latest .

# Laden Sie zuerst ein Modell herunter (optional — der Server kann 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 — Testen Sie die API

# 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, produktionsreifere 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

# Erstellen Sie das Modelle-Verzeichnis und laden Sie ein GGUF-Modell herunter
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

# Erstellen Sie die Modellkonfiguration
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": "Hello!"}]
  }'

---

Konfiguration

Umgebungsvariablen für den GPT4All-Server

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

Docker Compose Einrichtung

# /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

GPU-Nutzungsüberprüfung

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

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

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

Auswahl von GPU-Schichten

Der gpu_layers (oder n_gpu_layers) Parameter steuert, wie viel des Modells auf GPU vs. CPU läuft:

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

# Neu bauen und mit maximalen GPU-Schichten 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. CPU-only Clore.ai-Server 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 GPU. Für CPU-only Server verwenden Sie kleine Modelle (Phi-3 Mini, TinyLlama) und erwarten 2–5 Tokens/Sekunde.

---

Tipps & bewährte Methoden

📥 Vorab-Download von Modellen

Statt sich auf automatischen Download beim Start zu verlassen, laden Sie Modelle vor für schnellere Neustarts:

# 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 (schnellstes, kleinstes)
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)

# Nutzung des API-Servers mit einem OpenAI-Client
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:4891/v1",
    api_key="nicht benötigt"
)

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 @ $0.20/Std. — verwenden Sie sie für 7B-Modelle (bestes Preis-Leistungs-Verhältnis)
# Erwarteter Durchsatz: ~40 Tokens/Sekunde für Mistral 7B Q4
# Kosten pro 1M generierten Tokens: ~0,005 $ (extrem günstig im Vergleich zu OpenAI)

# RTX 4090 @ $0.35/Std. — verwenden Sie sie für 13B-Modelle oder wenn Geschwindigkeit wichtig ist
# Erwarteter Durchsatz: ~60 Tokens/Sekunde für Mistral 7B Q4

# Für Batch-Verarbeitung: 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'Verarbeitet {len(results)} Prompts')
"

---

Fehlerbehebung

Modell lädt nicht — Datei nicht gefunden

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

# GPT4All ist bei Modellnamen case-sensitiv
# 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
# Überprüfen Sie die Compute-Fähigkeit der GPU
nvidia-smi --query-gpu=compute_cap --format=csv,noheader

# Wenn < 6.0, verwenden Sie den CPU-Modus
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

# Überprüfen Sie die Startprotokolle
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

# Überprüfen Sie, 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 von außen nicht erreichbar

# Überprüfen Sie die Portbindung
docker ps | grep 4891
# Sollte anzeigen: 0.0.0.0:4891->4891/tcp

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

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

# Hinweis: Clore.ai mappt Ports zufällig — verwenden Sie den in Ihrem Server-Dashboard angezeigten Port

---

Weiterführende Lektüre

• GPT4All 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 — Produktions-Inferenzserver

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

• TheBloke auf HuggingFace — Tausende von GGUF-Quantisierungen

• GGUF-Format erklärt — Modellformat-Dokumentation

💡 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 konzipiert. GPT4Alls Stärke liegt in seiner schönen Desktop-Benutzeroberfläche und LocalDocs (RAG)-Funktionen, die im Server-Modus nicht verfügbar sind.