> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/gpt4all.md).

# 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](https://github.com/nomic-ai/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](#alternative-localai-docker-image) — 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](https://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

```bash
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:

```bash
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

```bash
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

```bash
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

```bash
# 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:

```bash
# 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

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

```bash
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:

```bash
# 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:

```python
# 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
)
```

```bash
# 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):

```bash
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:

```bash
# 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

```python
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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

```bash
# 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](https://github.com/nomic-ai/gpt4all) — Haupt-Repository
* [GPT4All Python-Dokumentation](https://docs.gpt4all.io/) — Python-API-Referenz
* [GPT4All-Modell-Explorer](https://gpt4all.io/models/gguf/) — Verfügbare Modelle durchsuchen
* [LocalAI-Dokumentation](https://localai.io/) — Docker-freundliche Alternative
* [Ollama auf Clore.ai](/guides/guides_v2-de/sprachmodelle/ollama.md) — Einfachere Docker-LLM-Bereitstellung
* [vLLM auf Clore.ai](/guides/guides_v2-de/sprachmodelle/vllm.md) — Inferenzserver für die Produktion
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — Wählen Sie die richtige Clore.ai-GPU
* [TheBloke auf HuggingFace](https://huggingface.co/TheBloke) — Tausende von GGUF-Quantisierungen
* [GGUF-Format erklärt](https://github.com/ggerganov/ggml/blob/master/docs/gguf.md) — Dokumentation zum Modellformat

> 💡 **Empfehlung:** Wenn Sie die einfachste Docker-Bereitstellung für lokale LLMs wünschen, ziehen Sie [Ollama](/guides/guides_v2-de/sprachmodelle/ollama.md) 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.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/gpt4all.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.