Ollama

Führe LLMs lokal mit Ollama auf Clore.ai-GPUs aus

Der einfachste Weg, LLMs lokal auf CLORE.AI-GPUs auszuführen.

Aktuelle Version: v0.6+ — Dieser Leitfaden behandelt Ollama v0.6 und neuer. Zu den wichtigsten neuen Funktionen gehören strukturierte Ausgaben (JSON-Schema-Durchsetzung), ein OpenAI-kompatibler Embeddings-Endpunkt (/api/embed), sowie paralleles Laden von Modellen (mehrere Modelle gleichzeitig ohne Auslagerung ausführen). Siehe Neu in v0.6+ für Details.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die über CLORE.AI Marketplace.

Serveranforderungen

Parameter	Minimum	Empfohlen
RAM	8 GB	16 GB+
VRAM	6 GB	8 GB+
Netzwerk	100 Mbit/s	500 Mbit/s+
Startzeit	~30 Sekunden	-

Ollama ist leichtgewichtig und funktioniert auf den meisten GPU-Servern. Für größere Modelle (13B+) wählen Sie Server mit 16 GB+ RAM und 12 GB+ VRAM.

Warum Ollama?

• Einrichtung mit einem Befehl - Kein Python, keine Abhängigkeiten

• Modellbibliothek - Modelle herunterladen mit ollama pull

• OpenAI-kompatible API - Direkter Ersatz

• GPU-Beschleunigung - Automatische CUDA-Erkennung

• Mehrere Modelle - Mehrere Modelle gleichzeitig ausführen (v0.6+)

Schnellbereitstellung auf CLORE.AI

Docker-Image:

ollama/ollama

Ports:

22/tcp
11434/http

Befehl:

ollama serve

Funktion überprüfen

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen und testen Sie:

# Ersetzen Sie dies durch Ihre tatsächliche http_pub-URL
curl https://your-http-pub.clorecloud.net/

# Erwartete Antwort: "Ollama is running"

Wenn Sie HTTP 502 erhalten, warten Sie 30–60 Sekunden – der Dienst startet noch.

Auf Ihren Dienst zugreifen

Wenn auf CLORE.AI bereitgestellt, greifen Sie auf Ihre Ollama-Instanz über die http_pub URL zu:

# Finden Sie Ihr http_pub unter Meine Bestellungen, dann:
curl https://your-http-pub.clorecloud.net/api/tags

# Für API-Aufrufe verwenden Sie Ihre http_pub-URL:
curl https://your-http-pub.clorecloud.net/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Hello!"}],
  "stream": false
}'

Alle localhost:11434 Beispiele unten funktionieren bei Verbindung per SSH. Für externen Zugriff ersetzen Sie dies durch Ihre https://your-http-pub.clorecloud.net/ URL.

Installation

Mit Docker (empfohlen)

docker run -d --gpus all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Manuelle Installation

curl -fsSL https://ollama.com/install.sh | sh

Dieser einzelne Befehl installiert die neueste Version von Ollama, richtet den systemd-Dienst ein und konfiguriert die GPU-Erkennung automatisch. Funktioniert auf Ubuntu, Debian, Fedora und den meisten modernen Linux-Distributionen.

Modelle ausführen

Herunterladen und ausführen

# Modell herunterladen
ollama pull llama3.2

# Interaktiven Chat starten
ollama run llama3.2

# Mit Prompt ausführen
ollama run llama3.2 "Explain quantum computing"

Beliebte Modelle

Modell	Größe	Anwendungsfall
llama3.2	3B	Schnell, universell einsetzbar
llama3.1	8B	Bessere Qualität
llama3.1:70b	70B	Beste Qualität
mistral	7B	Schnell, gute Qualität
mixtral	47B	MoE, hohe Qualität
codellama	7-34B	Code-Generierung
deepseek-coder-v2	16B	Am besten für Code
deepseek-r1	7B-671B	Reasoning-Modell
deepseek-r1:32b	32B	Ausgewogenes Reasoning
qwen2.5	7B	Mehrsprachig
qwen2.5:72b	72B	Beste Qwen-Qualität
phi4	14B	Microsofts neueste Version
gemma2	9B	Googles Modell

Modellvarianten

# Quantisierungsvarianten
ollama pull llama3.1:8b-instruct-q4_K_M   # 4-Bit (kleiner, schneller)
ollama pull llama3.1:8b-instruct-q8_0     # 8-Bit (bessere Qualität)
ollama pull llama3.1:8b-instruct-fp16     # Volle Präzision

# Größenvarianten
ollama pull llama3.1:8b    # 8 Milliarden Parameter
ollama pull llama3.1:70b   # 70 Milliarden Parameter

# Neue Modelle (v0.6+ Ära)
ollama pull deepseek-r1:7b      # Reasoning, preiswert
ollama pull deepseek-r1:14b     # Reasoning, effizient
ollama pull deepseek-r1:32b     # Reasoning, ausgewogen
ollama pull deepseek-r1:70b     # Reasoning, hohe Qualität
ollama pull qwen2.5:72b         # Größtes Qwen, höchste Qualität
ollama pull phi4                # Microsoft Phi-4 14B

Neu in v0.6+

Ollama v0.6 führte mehrere wichtige Funktionen für produktive Workloads ein:

Strukturierte Ausgaben (JSON-Schema)

Erzwingen Sie, dass Modellantworten einem bestimmten JSON-Schema entsprechen. Nützlich für Anwendungen, die zuverlässige, parsebare Ausgaben benötigen:

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Tell me about Canada."}],
  "format": {
    "type": "object",
    "properties": {
      "name": {"type": "string"},
      "capital": {"type": "string"},
      "population": {"type": "integer"},
      "languages": {
        "type": "array",
        "items": {"type": "string"}
      }
    },
    "required": ["name", "capital", "population", "languages"]
  },
  "stream": false
}'

Python-Beispiel mit strukturierten Ausgaben:

from openai import OpenAI
import json

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "List 3 programming languages with their main use cases"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "languages",
            "schema": {
                "type": "object",
                "properties": {
                    "languages": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "use_case": {"type": "string"},
                                "popularity_rank": {"type": "integer"}
                            }
                        }
                    }
                }
            }
        }
    }
)

data = json.loads(response.choices[0].message.content)
print(data)

OpenAI-kompatibler Embeddings-Endpunkt (/api/embed)

Neu in v0.6+: der /api/embed Endpunkt ist vollständig OpenAI-kompatibel und unterstützt Batch-Eingaben:

# Einzelnes Text-Embedding
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "Hello world"
}'

# Batch-Embeddings (neu in v0.6)
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["First document", "Second document", "Third document"]
}'

Der OpenAI-Client funktioniert direkt mit /v1/embeddings:

from openai import OpenAI
import numpy as np

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

# Erst das Embedding-Modell herunterladen: ollama pull nomic-embed-text
response = client.embeddings.create(
    model="nomic-embed-text",
    input=["Hello world", "Goodbye world"]
)

emb1 = np.array(response.data[0].embedding)
emb2 = np.array(response.data[1].embedding)

# Kosinusähnlichkeit
similarity = np.dot(emb1, emb2) / (np.linalg.norm(emb1) * np.linalg.norm(emb2))
print(f"Similarity: {similarity:.4f}")

Beliebte Embedding-Modelle:

ollama pull nomic-embed-text      # 137M, schnell, gute Qualität
ollama pull mxbai-embed-large     # 335M, höhere Qualität
ollama pull all-minilm            # 23M, am schnellsten

Paralleles Laden von Modellen

Vor v0.6 entlud Ollama ein Modell, um ein anderes zu laden. V0.6+ unterstützt das gleichzeitige Ausführen mehrerer Modelle, begrenzt nur durch den verfügbaren VRAM:

# Zwei Modelle gleichzeitig laden
ollama run llama3.2 &
ollama run deepseek-r1:7b &

# Prüfen, was läuft
curl http://localhost:11434/api/ps

Parallelität konfigurieren:

# Bis zu 4 gleichzeitig geladene Modelle erlauben
OLLAMA_MAX_LOADED_MODELS=4 ollama serve

# Jeder Runner in einem separaten Prozess (bessere Isolierung)
OLLAMA_NUM_PARALLEL=2 ollama serve

Das ist besonders nützlich für:

• A/B-Tests verschiedener Modelle

• Spezialisierte Modelle für unterschiedliche Aufgaben (Coding + Chat)

• Häufig verwendete Modelle im VRAM warm halten

API-Nutzung

Chat-Vervollständigung

# Über http_pub (externer Zugriff):
curl https://your-http-pub.clorecloud.net/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Hello!"}],
  "stream": false
}'

# Über SSH-Tunnel (localhost):
curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Hello!"}],
  "stream": false
}'

Fügen Sie "stream": false hinzu, um die vollständige Antwort auf einmal statt als Streaming zu erhalten.

OpenAI-kompatibler Endpunkt

from openai import OpenAI

# Für externen Zugriff verwenden Sie Ihre http_pub-URL:
client = OpenAI(
    base_url="https://your-http-pub.clorecloud.net/v1",
    api_key="ollama"  # beliebiger String funktioniert
)

# Oder über SSH-Tunnel:
# client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "user", "content": "What is machine learning?"}
    ]
)

print(response.choices[0].message.content)

Streaming

stream = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Write a poem"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Embeddings

# Legacy-Endpunkt (funktioniert weiterhin)
curl http://localhost:11434/api/embeddings -d '{
  "model": "nomic-embed-text",
  "prompt": "Hello world"
}'

# Neuer v0.6+-Endpunkt (Batch-Unterstützung, OpenAI-kompatibel)
curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": ["Hello world", "Another text"]
}'

Textgenerierung (Nicht-Chat)

curl https://your-http-pub.clorecloud.net/api/generate -d '{
  "model": "llama3.2",
  "prompt": "The meaning of life is",
  "stream": false
}'

Vollständige API-Referenz

Alle Endpunkte funktionieren sowohl mit http://localhost:11434 (via SSH) als auch mit https://your-http-pub.clorecloud.net (extern).

Modellverwaltung

Endpunkt	Methode	Beschreibung
/api/tags	GET	Alle heruntergeladenen Modelle auflisten
/api/show	POST	Modelldetails abrufen
/api/pull	POST	Ein Modell herunterladen
/api/delete	DELETE	Ein Modell entfernen
/api/ps	GET	Aktuell laufende Modelle auflisten
/api/version	GET	Ollama-Version abrufen

Modelle auflisten

curl https://your-http-pub.clorecloud.net/api/tags

Antwort:

{
  "models": [
    {"name": "llama3.2:latest", "size": 2019393189, "digest": "...", "modified_at": "..."}
  ]
}

Modelldetails anzeigen

curl https://your-http-pub.clorecloud.net/api/show -d '{"name": "llama3.2"}'

Modell per API herunterladen

curl https://your-http-pub.clorecloud.net/api/pull -d '{
  "name": "mistral:7b",
  "stream": false
}'

Antwort:

{"status": "success"}

Große Modelle können mehrere Minuten zum Herunterladen brauchen. Bei sehr großen Modellen (30 GB+) sollten Sie SSH und die CLI verwenden: ollama pull model-name

Modell löschen

curl -X DELETE https://your-http-pub.clorecloud.net/api/delete -d '{"name": "mistral:7b"}'

Laufende Modelle auflisten

curl https://your-http-pub.clorecloud.net/api/ps

Antwort:

{
  "models": [
    {"name": "llama3.2:latest", "size": 2019393189, "expires_at": "2025-01-25T12:00:00Z"}
  ]
}

Version abrufen

curl https://your-http-pub.clorecloud.net/api/version

Antwort:

{"version": "0.6.8"}

Inferenz-Endpunkte

Endpunkt	Methode	Beschreibung
/api/generate	POST	Textvervollständigung
/api/chat	POST	Chat-Vervollständigung
/api/embeddings	POST	Embeddings generieren (legacy)
/api/embed	POST	Embeddings v0.6+ generieren (Batch, OpenAI-kompatibel)
/v1/chat/completions	POST	OpenAI-kompatibler Chat
/v1/embeddings	POST	OpenAI-kompatible Embeddings

Benutzerdefinierte Modell-Erstellung

Erstellen Sie benutzerdefinierte Modelle mit spezifischen System-Prompts über die API:

curl https://your-http-pub.clorecloud.net/api/create -d '{
  "name": "my-assistant",
  "modelfile": "FROM llama3.2\nSYSTEM You are a helpful coding assistant."
}'

GPU-Konfiguration

GPU-Nutzung prüfen

# Im Container oder Server
nvidia-smi

# Ollama zeigt die GPU in den Logs
ollama run llama3.2 --verbose

Mehrere GPUs

Ollama verwendet automatisch verfügbare GPUs. Für eine bestimmte GPU:

CUDA_VISIBLE_DEVICES=0 ollama serve

Speicherverwaltung

# GPU-Speicherlimit festlegen
OLLAMA_GPU_MEMORY=8GiB ollama serve

# Modell geladen halten
OLLAMA_KEEP_ALIVE=24h ollama serve

# Gleichzeitige Modelle zulassen (v0.6+)
OLLAMA_MAX_LOADED_MODELS=3 ollama serve

Benutzerdefinierte Modelle (Modelfile)

Erstellen Sie benutzerdefinierte Modelle mit System-Prompts:

# Modelfile
FROM llama3.2

SYSTEM You are a helpful coding assistant. Always provide code examples.

PARAMETER temperature 0.7
PARAMETER top_p 0.9

ollama create coding-assistant -f Modelfile
ollama run coding-assistant

Als Dienst ausführen

Systemd

# /etc/systemd/system/ollama.service
[Unit]
Description=Ollama-Dienst
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/ollama serve
Restart=always
Environment="OLLAMA_HOST=0.0.0.0"

[Install]
WantedBy=multi-user.target

systemctl enable ollama
systemctl start ollama

Leistungstipps

1. Geeignete Quantisierung verwenden

   • Q4_K_M für Geschwindigkeit

   • Q8_0 für Qualität

   • fp16 für maximale Qualität

2. Modell an VRAM anpassen

   • 8 GB: 7B-Modelle (Q4)

   • 16 GB: 13B-Modelle oder 7B (Q8)

   • 24 GB: 34B-Modelle (Q4)

   • 48 GB+: 70B-Modelle

3. Modell geladen halten

   OLLAMA_KEEP_ALIVE=1h ollama serve

4. Schnelle SSD verbessert die Leistung

   • Modellladen und KV-Cache profitieren von schnellem Speicher

   • Server mit NVMe-SSD können 2-3x bessere Leistung erreichen

Benchmarks

Generierungsgeschwindigkeit (Tokens/Sek.)

Modell	RTX 3060	RTX 3090	RTX 4090	A100 40GB
Llama 3.2 3B (Q4)	120	160	200	220
Llama 3.1 8B (Q4)	60	100	130	150
Llama 3.1 8B (Q8)	45	80	110	130
Mistral 7B (Q4)	70	110	140	160
Mixtral 8x7B (Q4)	-	35	55	75
Llama 3.1 70B (Q4)	-	-	18	35
DeepSeek-R1 7B (Q4)	65	105	135	155
DeepSeek-R1 32B (Q4)	-	-	22	42
Qwen2.5 72B (Q4)	-	-	15	30
Phi-4 14B (Q4)	-	50	75	90

Benchmarks aktualisiert im Januar 2026. Die tatsächlichen Geschwindigkeiten können je nach Serverkonfiguration variieren.

Zeit bis zum ersten Token (ms)

Modell	RTX 3090	RTX 4090	A100
3B	50	35	25
7-8B	120	80	60
13B	250	150	100
34B	600	350	200
70B	-	1200	500

Kontextlänge vs. VRAM (Q4)

Modell	2K Kontext	4K Kontext	8K Kontext	16K Kontext
7B	5 GB	6 GB	8 GB	12 GB
13B	8 GB	10 GB	14 GB	22 GB
34B	20 GB	24 GB	32 GB	48 GB
70B	40 GB	48 GB	64 GB	96 GB

GPU-Anforderungen

Modell	Q4 VRAM	Q8 VRAM
3B	3 GB	5 GB
7-8B	5 GB	9 GB
13B	8 GB	15 GB
34B	20 GB	38 GB
70B	40 GB	75 GB

Kostenschätzung

Typische CLORE.AI-Marktplatzpreise:

GPU	VRAM	Preis/Tag	Gut geeignet für
RTX 3090	24 GB	$0.30–1.00	13B-34B-Modelle
RTX 4090	24 GB	$0.50–2.00	34B-Modelle, schnell
RTX 4070	12 GB	$0.20–0.50	7B-Modelle
A100 80GB	80 GB	$1.50–3.00	70B-Modelle

Preise in USD/Tag. Die Tarife variieren je nach Anbieter — prüfen Sie CLORE.AI Marketplace für aktuelle Preise.

Fehlerbehebung

Modell wird nicht geladen

# Verfügbaren Speicher prüfen
nvidia-smi

# Kleinere Quantisierung ausprobieren
ollama pull llama3.1:8b-q4_0

Langsame Generierung

# Prüfen, ob die GPU verwendet wird
ollama run llama3.2 --verbose

# Sicherstellen, dass CUDA verfügbar ist
nvidia-smi

Verbindung abgelehnt

# Sicherstellen, dass der Server läuft
ollama serve

# Prüfen, ob an alle Schnittstellen gebunden wird
OLLAMA_HOST=0.0.0.0 ollama serve

HTTP 502 bei http_pub-URL

Das bedeutet, dass der Dienst noch startet. 30–60 Sekunden warten und erneut versuchen:

# Prüfen, ob der Dienst bereit ist
curl https://your-http-pub.clorecloud.net/

# Erwartet: "Ollama is running"
# Bei 502: warten und erneut versuchen

Nächste Schritte

• WebUI öffnen - Schöne Chat-Oberfläche für Ollama

• vLLM - Produktionsbereitstellung mit hohem Durchsatz

• DeepSeek-R1 - Reasoning-Modell

• DeepSeek-V3 - Bestes allgemeines Modell

• Qwen2.5 - Mehrsprachige Alternative

• Text Generation WebUI - Erweiterte Funktionen