> 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/sprachmodelle/deepseek-v3.md).

# DeepSeek-V3

Führen Sie DeepSeek-V3 aus, das modernste Open-Source-LLM mit außergewöhnlichen Schlussfolgerungsfähigkeiten auf CLORE.AI-GPUs.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**Aktualisiert: DeepSeek-V3-0324 (März 2024)** — Die neueste Revision von DeepSeek-V3 bringt erhebliche Verbesserungen bei der Codeerzeugung, mathematischen Argumentation und allgemeinen Problemlösung. Siehe das [Changelog](#whats-new-in-deepseek-v3-0324) Abschnitt für Details.
{% endhint %}

## Warum DeepSeek-V3?

* **State-of-the-art** - Konkuriert mit GPT-4o und Claude 3.5 Sonnet
* **671B MoE** - 671B Gesamtparameter, 37B aktiv pro Token (effiziente Inferenz)
* **Verbesserte Schlussfolgerung** - DeepSeek-V3-0324 ist deutlich besser in Mathematik und Code
* **Effizient** - MoE-Architektur reduziert Rechenkosten im Vergleich zu dichten Modellen
* **Open Source** - Vollständig offene Gewichte unter MIT-Lizenz
* **Langer Kontext** - 128K Token Kontexfenster

## Was ist neu in DeepSeek-V3-0324

DeepSeek-V3-0324 (Revision März 2024) führt bedeutende Verbesserungen in Schlüsselbereichen ein:

### Codegenerierung

* **+8-12% bei HumanEval** im Vergleich zum ursprünglichen V3
* Besser bei Multi-Datei-Codebasen und komplexen Refaktorierungsaufgaben
* Verbessertes Verständnis moderner Frameworks (FastAPI, Pydantic v2, LangChain v0.3)
* Zuverlässiger bei der Erzeugung vollständigen, ausführbaren Codes ohne Auslassungen

### Mathematische Argumentation

* **+5% beim MATH-500** Benchmark
* Besserer schrittweiser Beweisaufbau
* Verbesserte numerische Genauigkeit bei mehrstufigen Problemen
* Erhöhte Fähigkeit, Fehler mitten in einer Lösung zu identifizieren und zu korrigieren

### Allgemeine Schlussfolgerungen

* Stärkere logische Deduktion und kausale Inferenz
* Besser bei mehrstufigen Planungsaufgaben
* Konsistentere Leistung bei Randfällen und mehrdeutigen Eingaben
* Verbesserte Befolgung von Anweisungen bei komplexen, mehrfachen Einschränkungen

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:**

```
vllm/vllm-openai:latest
```

**Ports:**

```
22/tcp
8000/http
```

**Befehl (Mehrere GPUs erforderlich):**

```bash
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --host 0.0.0.0 \
    --port 8000 \
    --tensor-parallel-size 8 \
    --trust-remote-code
```

## Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

1. Gehen Sie zur **Meine Bestellungen** Seite
2. Klicken Sie auf Ihre Bestellung
3. Finden Sie die `http_pub` URL (z. B., `abc123.clorecloud.net`)

Verwenden Sie `https://IHRE_HTTP_PUB_URL` anstelle von `localhost` in den Beispielen unten.

### Überprüfen, ob es funktioniert

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

# Verfügbare Modelle auflisten
curl https://your-http-pub.clorecloud.net/v1/models

# Version abrufen
curl https://your-http-pub.clorecloud.net/version
```

{% hint style="warning" %}
**Wichtig:** DeepSeek-V3 erfordert **8x A100 80GB** GPUs und erhebliche Downloadzeit. HTTP 502 kann 15–30 Minuten bestehen bleiben, während das Modell heruntergeladen wird.
{% endhint %}

## Modellvarianten

| Modell            | Parameter | Aktiv | Benötigter VRAM | HuggingFace                                                                                             |
| ----------------- | --------- | ----- | --------------- | ------------------------------------------------------------------------------------------------------- |
| DeepSeek-V3-0324  | 671B      | 37B   | 8x80GB          | [deepseek-ai/DeepSeek-V3-0324](https://huggingface.co/deepseek-ai/DeepSeek-V3-0324)                     |
| DeepSeek-V3       | 671B      | 37B   | 8x80GB          | [deepseek-ai/DeepSeek-V3](https://huggingface.co/deepseek-ai/DeepSeek-V3)                               |
| DeepSeek-V3-Base  | 671B      | 37B   | 8x80GB          | [deepseek-ai/DeepSeek-V3-Base](https://huggingface.co/deepseek-ai/DeepSeek-V3-Base)                     |
| DeepSeek-V2.5     | 236B      | 21B   | 4x80GB          | [deepseek-ai/DeepSeek-V2.5](https://huggingface.co/deepseek-ai/DeepSeek-V2.5)                           |
| DeepSeek-V2-Lite  | 16B       | 2.4B  | 16GB            | [deepseek-ai/DeepSeek-V2-Lite](https://huggingface.co/deepseek-ai/DeepSeek-V2-Lite)                     |
| DeepSeek-Coder-V2 | 236B      | 21B   | 4x80GB          | [deepseek-ai/DeepSeek-Coder-V2-Instruct](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Instruct) |

## Hardware-Anforderungen

### Volle Präzision

| Modell           | Minimum       | Empfohlen    |
| ---------------- | ------------- | ------------ |
| DeepSeek-V3-0324 | 8x A100 80GB  | 8x H100 80GB |
| DeepSeek-V2.5    | 4x A100 80GB  | 4x H100 80GB |
| DeepSeek-V2-Lite | RTX 4090 24GB | A100 40GB    |

### Quantisiert (AWQ/GPTQ)

| Modell           | Quantisierung | VRAM   |
| ---------------- | ------------- | ------ |
| DeepSeek-V3-0324 | INT4          | 4x80GB |
| DeepSeek-V2.5    | INT4          | 2x80GB |
| DeepSeek-V2-Lite | INT4          | 8GB    |

## Installation

### Verwendung von vLLM (empfohlen)

```bash
pip install vllm==0.7.3

# DeepSeek-V3-0324 (neueste, 8 GPUs)
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

# Original V3 (noch verfügbar)
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000
```

### Verwendung von Transformers

```python
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "deepseek-ai/DeepSeek-V3-0324"

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

messages = [{"role": "user", "content": "Erkläre Quantencomputing in einfachen Worten."}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)

outputs = model.generate(inputs, max_new_tokens=512, temperature=0.7)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))
```

### Verwendung von Ollama

```bash
# DeepSeek-V3 herunterladen (erfordert erhebliche Ressourcen)
ollama pull deepseek-v3

# Oder leichtere Variante
ollama pull deepseek-coder-v2:16b

# Ausführen
ollama run deepseek-v3
```

## API-Nutzung

### OpenAI-kompatible API (vLLM)

```python
from openai import OpenAI

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

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[
        {"role": "system", "content": "Du bist ein hilfreicher KI-Assistent."},
        {"role": "user", "content": "Schreibe eine Python-Funktion, um Primzahlen zu finden."}
    ],
    temperature=0.7,
    max_tokens=1000
)

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

### Streaming

```python
stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": "Erkläre maschinelles Lernen"}],
    stream=True
)

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

### cURL

```bash
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "deepseek-ai/DeepSeek-V3-0324",
        "messages": [
            {"role": "user", "content": "Was ist die Hauptstadt von Frankreich?"}
        ],
        "temperature": 0.7
    }'
```

## DeepSeek-V2-Lite (Single GPU)

Für Nutzer mit begrenzter Hardware:

```bash
# Verwendung von vLLM
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V2-Lite \
    --trust-remote-code \
    --host 0.0.0.0

# Verwendung von Ollama
ollama run deepseek-coder-v2:16b
```

```python
# Verwendung von Transformers auf einer einzelnen GPU
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model = AutoModelForCausalLM.from_pretrained(
    "deepseek-ai/DeepSeek-V2-Lite",
    torch_dtype=torch.float16,
    device_map="cuda",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V2-Lite", trust_remote_code=True)
```

## Codegenerierung

DeepSeek-V3-0324 ist erstklassig für Code:

```python
prompt = """Schreibe eine Python-Klasse für einen binären Suchbaum mit:
- einfügen
- suchen
- löschen
- Inorder-Traversal
Fügen Sie Typannotationen und Docstrings hinzu."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2  # Niedriger für Code
)

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

Erweiterte Codeaufgaben, in denen V3-0324 brilliert:

```python
# Multi-Datei-Refactoring
prompt = """Ich habe eine Flask-Anwendung mit dem gesamten Code in app.py (500 Zeilen).
Refaktoriere sie, um das Application-Factory-Muster mit Blueprints zu verwenden für:
- auth (Login, Registrierung, Logout)
- api (REST-Endpunkte)
- admin (Dashboard)
Zeige die komplette Dateistruktur und alle Dateien."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,
    max_tokens=4000
)
```

## Mathematik & Schlussfolgerung

```python
# Komplexes Mathematikproblem
prompt = """Beweise, dass für jede ganze Zahl n >= 1 die Summe 1^2 + 2^2 + ... + n^2 = n(n+1)(2n+1)/6 gilt.
Verwende vollständige Induktion und zeige alle Schritte deutlich."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1  # Sehr niedrig für Mathematik
)

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

## Multi-GPU-Konfiguration

### 8x GPU (Vollständiges Modell — V3-0324)

```bash
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9 \
    --trust-remote-code
```

### 4x GPU (V2.5)

```bash
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V2.5 \
    --tensor-parallel-size 4 \
    --max-model-len 16384 \
    --trust-remote-code
```

## Leistung

### Durchsatz (Tokens/Sek)

| Modell                | GPUs         | Kontext | Tokens/sec |
| --------------------- | ------------ | ------- | ---------- |
| DeepSeek-V3-0324      | 8x H100      | 32K     | \~85       |
| DeepSeek-V3-0324      | 8x A100 80GB | 32K     | \~52       |
| DeepSeek-V3-0324 INT4 | 4x A100 80GB | 16K     | \~38       |
| DeepSeek-V2.5         | 4x A100 80GB | 16K     | \~70       |
| DeepSeek-V2.5         | 2x A100 80GB | 8K      | \~45       |
| DeepSeek-V2-Lite      | RTX 4090     | 8K      | \~40       |
| DeepSeek-V2-Lite      | RTX 3090     | 4K      | \~25       |

### Zeit bis zum ersten Token (TTFT)

| Modell           | Konfiguration | TTFT     |
| ---------------- | ------------- | -------- |
| DeepSeek-V3-0324 | 8x H100       | \~750ms  |
| DeepSeek-V3-0324 | 8x A100       | \~1100ms |
| DeepSeek-V2.5    | 4x A100       | \~500ms  |
| DeepSeek-V2-Lite | RTX 4090      | \~150ms  |

### Speichernutzung

| Modell           | Präzision | Benötigter VRAM |
| ---------------- | --------- | --------------- |
| DeepSeek-V3-0324 | FP16      | 8x 80GB         |
| DeepSeek-V3-0324 | INT4      | 4x 80GB         |
| DeepSeek-V2.5    | FP16      | 4x 80GB         |
| DeepSeek-V2.5    | INT4      | 2x 80GB         |
| DeepSeek-V2-Lite | FP16      | 20GB            |
| DeepSeek-V2-Lite | INT4      | 10GB            |

## Benchmarks

### DeepSeek-V3-0324 vs Konkurrenz

| Benchmark         | V3-0324 | V3 (ursprünglich) | GPT-4o | Claude 3.5 Sonnet |
| ----------------- | ------- | ----------------- | ------ | ----------------- |
| MMLU              | 88.5%   | 87.1%             | 88.7%  | 88.3%             |
| HumanEval         | 90.2%   | 82.6%             | 90.2%  | 92.0%             |
| MATH-500          | 67.1%   | 61.6%             | 76.6%  | 71.1%             |
| GSM8K             | 92.1%   | 89.3%             | 95.8%  | 96.4%             |
| LiveCodeBench     | 72.4%   | 65.9%             | 71.3%  | 73.8%             |
| Codeforces-Rating | 1850    | 1720              | 1780   | 1790              |

*Hinweis: MATH-500-Verbesserung von V3 → V3-0324 beträgt +5,5 Prozentpunkte.*

## Docker Compose

```yaml
version: '3.8'

services:
  deepseek:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    command: >
      --model deepseek-ai/DeepSeek-V2-Lite
      --host 0.0.0.0
      --port 8000
      --trust-remote-code
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
```

## Zusammenfassung der GPU-Anforderungen

| Einsatzgebiet           | Empfohlene Konfiguration | Kosten/Stunde |
| ----------------------- | ------------------------ | ------------- |
| Volles DeepSeek-V3-0324 | 8x A100 80GB             | \~$2.00       |
| DeepSeek-V2.5           | 4x A100 80GB             | \~$1.00       |
| Entwicklung/Testing     | RTX 4090 (V2-Lite)       | \~$0.10       |
| Produktions-API         | 8x H100 80GB             | \~$3.00       |

## Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

| GPU-Konfiguration | Stundensatz | Tagessatz |
| ----------------- | ----------- | --------- |
| RTX 4090 24GB     | \~$0.10     | \~$2.30   |
| A100 40GB         | \~$0.17     | \~$4.00   |
| A100 80GB         | \~$0.25     | \~$6.00   |
| 4x A100 80GB      | \~$1.00     | \~$24.00  |
| 8x A100 80GB      | \~$2.00     | \~$48.00  |

*Preise variieren je nach Anbieter. Prüfe* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für Entwicklung (oft 30–50% günstiger)
* Bezahlen mit **CLORE** Token
* Verwenden Sie DeepSeek-V2-Lite zum Testen, bevor Sie hochskalieren

## Fehlerbehebung

### Kein Speicher mehr

```bash
# Kontextlänge reduzieren
--max-model-len 8192

# Oder Quantisierung verwenden
--quantization awq

# Für V2-Lite auf 12GB GPU
--gpu-memory-utilization 0.85
--max-model-len 4096
```

### Modell-Download langsam

```bash
# Vorab herunterladen
huggingface-cli download deepseek-ai/DeepSeek-V3-0324

# Oder Mirror verwenden
export HF_ENDPOINT=https://hf-mirror.com
```

### trust\_remote\_code-Fehler

```bash
# Fügen Sie diesen Flag immer für DeepSeek-Modelle hinzu
--trust-remote-code
```

### Multi-GPU funktioniert nicht

```bash
# Prüfe NCCL
nvidia-smi topo -m

# Setze NCCL-Variablen
export NCCL_DEBUG=INFO
export NCCL_P2P_DISABLE=0
```

## DeepSeek vs Andere

| Funktion   | DeepSeek-V3-0324  | Llama 3.1 405B | Mixtral 8x22B    |
| ---------- | ----------------- | -------------- | ---------------- |
| Parameter  | 671B (37B aktiv)  | 405B           | 176B (44B aktiv) |
| Kontext    | 128K              | 128K           | 64K              |
| Code       | **Ausgezeichnet** | Großartig      | Gut              |
| Mathematik | **Ausgezeichnet** | Gut            | Gut              |
| Min. VRAM  | 8x80GB            | 8x80GB         | 2x80GB           |
| Lizenz     | MIT               | Llama 3.1      | Apache 2.0       |

**Verwenden Sie DeepSeek-V3, wenn:**

* Beste Schlussfolgerungsleistung benötigt wird
* Codegenerierung die primäre Verwendung ist
* Mathematik/Logikaufgaben wichtig sind
* Eine Multi-GPU-Umgebung verfügbar ist
* Vollständig Open-Source-Gewichte (MIT-Lizenz) gewünscht sind

## Nächste Schritte

* [vLLM](/guides/guides_v2-de/sprachmodelle/vllm.md) - Bereitstellungsserver
* [DeepSeek-R1](/guides/guides_v2-de/sprachmodelle/deepseek-r1.md) - Auf Schlussfolgerungen spezialisiertes Varianten
* [DeepSeek Coder](/guides/guides_v2-de/sprachmodelle/deepseek-coder.md) - Code-spezifische Variante
* [Ollama](/guides/guides_v2-de/sprachmodelle/ollama.md) - Einfachere Bereitstellung
* [LLM feinabstimmen](/guides/guides_v2-de/training/finetune-llm.md) - Benutzerdefiniertes Training


---

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

```
GET https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/deepseek-v3.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.