Ollama

Führen Sie 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. Wichtige neue Funktionen umfassen strukturierte Ausgaben (JSON-Schema-Erzwingung), OpenAI-kompatiblen Embeddings-Endpunkt (/api/embed), und gleichzeitiges Laden von Modellen (mehrere Modelle gleichzeitig ausführen, ohne zu tauschen). 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	8GB	16GB+
VRAM	6GB	8GB+
Netzwerk	100Mbps	500Mbps+
Startzeit	~30 Sekunden	-

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

Warum Ollama?

• Ein-Kommando-Setup - Kein Python, keine Abhängigkeiten

• Modellbibliothek - Modelle herunterladen mit ollama pull

• OpenAI-kompatible API - Drop-in-Ersatz

• GPU-Beschleunigung - Automatische CUDA-Erkennung

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

Schnelle Bereitstellung auf CLORE.AI

Docker-Image:

ollama/ollama

Ports:

22/tcp
11434/http

Befehl:

ollama serve

Überprüfen, ob es funktioniert

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

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

Zugriff auf Ihren Dienst

Bei Bereitstellung auf CLORE.AI greifen Sie über das http_pub URL:

# Finden Sie Ihr http_pub in My Orders, 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 Die untenstehenden Beispiele funktionieren, wenn über SSH verbunden. Für externen Zugriff ersetzen Sie durch Ihre https://your-http-pub.clorecloud.net/ URL.

Installation

Verwendung von 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 ausführen
ollama run llama3.2

# Mit Prompt ausführen
ollama run llama3.2 "Erkläre Quantencomputing"

Beliebte Modelle

Modell	Größe	Einsatzgebiet
llama3.2	3B	Schnell, für allgemeine Zwecke
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 neuestes
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 Genauigkeit

# 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, budgetfreundlich
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ößter Qwen, beste Qualität
ollama pull phi4                # Microsoft Phi-4 14B

Neu in v0.6+

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

Strukturierte Ausgaben (JSON-Schema)

Erzwingen, dass Modellantworten einem bestimmten JSON-Schema entsprechen. Nützlich zum Erstellen von Anwendungen, die zuverlässige, parsbare Ausgaben benötigen:

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Erzähl mir etwas über Kanada."}],
  "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": "Liste 3 Programmiersprachen mit ihren Hauptanwendungsfällen"}],
    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")

# Zuerst Embedding-Modell ziehen: 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

Gleichzeitiges Laden von Modellen

Vor v0.6 würde Ollama ein Modell entladen, um ein anderes zu laden. V0.6+ unterstützt das gleichzeitige Ausführen mehrerer Modelle, beschränkt nur durch 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

Konfigurieren Sie die Parallelität:

# Erlaube bis zu 4 gleichzeitig geladene Modelle
OLLAMA_MAX_LOADED_MODELS=4 ollama serve

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

Dies ist besonders nützlich für:

• A/B-Tests mit verschiedenen Modellen

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

• Häufig genutzte Modelle im VRAM warm halten

API-Nutzung

Chat Completion

# Ü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
}'

Hinzufügen "stream": false um die vollständige Antwort auf einmal zu erhalten statt gestreamt.

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": "Schreibe ein Gedicht"}],
    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 (über SSH) als auch 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	Derzeit 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 ziehen

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 benötigen. Für sehr große Modelle (30GB+) ziehen Sie in Betracht, SSH und die CLI zu 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"}

Inference-Endpunkte

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

Erstellung benutzerdefinierter Modelle

Erstellen Sie benutzerdefinierte Modelle mit spezifischen System-Prompts via 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-Auslastung prüfen

# Im Container oder auf dem Server
nvidia-smi

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

Multi-GPU

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

CUDA_VISIBLE_DEVICES=0 ollama serve

Speicherverwaltung

# GPU-Speicherlimit setzen
OLLAMA_GPU_MEMORY=8GiB ollama serve

# Modell geladen halten
OLLAMA_KEEP_ALIVE=24h ollama serve

# Gleichzeitige Modelle erlauben (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 Service
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

Performance-Tipps

1. Verwenden Sie geeignete Quantisierung

   • Q4_K_M für Geschwindigkeit

   • Q8_0 für Qualität

   • fp16 für maximale Qualität

2. Modell an VRAM anpassen

   • 8GB: 7B-Modelle (Q4)

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

   • 24GB: 34B-Modelle (Q4)

   • 48GB+: 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 (Token/Sekunde)

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 Januar 2026. Tatsächliche 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 ctx	4K ctx	8K ctx	16K ctx
7B	5GB	6GB	8GB	12GB
13B	8GB	10GB	14GB	22GB
34B	20GB	24GB	32GB	48GB
70B	40GB	48GB	64GB	96GB

GPU-Anforderungen

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

Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

GPU	VRAM	Preis/Tag	Geeignet für
RTX 3060	12GB	$0.15–0.30	7B-Modelle
RTX 3090	24GB	$0.30–1.00	13B-34B-Modelle
RTX 4090	24GB	$0.50–2.00	34B-Modelle, schnell
A100	40GB	$1.50–3.00	70B-Modelle

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

Fehlerbehebung

Modell lädt nicht

# Verfügbaren Speicher prüfen
nvidia-smi

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

Langsame Generierung

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

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

Verbindung verweigert

# 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 auf http_pub-URL

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

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

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

Nächste Schritte

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

• vLLM - Hochdurchsatz-Produktions-Serving

• DeepSeek-R1 - Reasoning-Modell

• DeepSeek-V3 - Bestes allgemeines Modell

• Qwen2.5 - Mehrsprachige Alternative

• Text Generation WebUI - Erweiterte Funktionen