# Serveur Llama.cpp

Exécutez des LLM efficacement avec le serveur llama.cpp sur GPU.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Exigences du serveur

| Paramètre          | Minimum       | Recommandé |
| ------------------ | ------------- | ---------- |
| RAM                | 8 Go          | 16 Go+     |
| VRAM               | 6 Go          | 8 Go+      |
| Réseau             | 200 Mbps      | 500 Mbps+  |
| Temps de démarrage | \~2-5 minutes | -          |

{% hint style="info" %}
Llama.cpp est économe en mémoire grâce à la quantification GGUF. Les modèles 7B peuvent fonctionner avec 6-8 Go de VRAM.
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Qu'est-ce que Llama.cpp ?

Llama.cpp est le moteur d'inférence CPU/GPU le plus rapide pour les LLM :

* Prend en charge les modèles quantifiés GGUF
* Faible utilisation de la mémoire
* API compatible OpenAI
* Prise en charge multi-utilisateurs

## Niveaux de quantification

| Format   | Taille (7B) | Vitesse        | Qualité   |
| -------- | ----------- | -------------- | --------- |
| Q2\_K    | 2,8 Go      | Le plus rapide | Faible    |
| Q4\_K\_M | 4,1 Go      | Rapide         | Bon       |
| Q5\_K\_M | 4,8 Go      | Moyen          | Excellent |
| Q6\_K    | 5,5 Go      | Plus lent      | Excellent |
| Q8\_0    | 7,2 Go      | Le plus lent   | Meilleur  |

## Déploiement rapide

**Image Docker :**

```
ghcr.io/ggerganov/llama.cpp:server-cuda
```

**Ports :**

```
22/tcp
8080/http
```

**Commande :**

```bash

# Télécharger le modèle
wget https://huggingface.co/bartowski/Meta-Llama-3.1-8B-Instruct-GGUF/resolve/main/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf

# Démarrer le serveur
./llama-server \
    -m Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf \
    --host 0.0.0.0 \
    --port 8080 \
    -ngl 35 \
    -c 4096
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

### Vérifiez que cela fonctionne

```bash
# Vérifier la santé
curl https://your-http-pub.clorecloud.net/health

# Obtenir les informations du serveur
curl https://your-http-pub.clorecloud.net/props
```

{% hint style="warning" %}
Si vous obtenez HTTP 502, le service peut être en cours de démarrage ou en train de télécharger le modèle. Attendez 2-5 minutes et réessayez.
{% endhint %}

## Référence complète de l'API

### Points de terminaison standard

| Point de terminaison   | Méthode | Description                              |
| ---------------------- | ------- | ---------------------------------------- |
| `/health`              | GET     | Vérification de l'état                   |
| `/v1/models`           | GET     | Lister les modèles                       |
| `/v1/chat/completions` | POST    | Chat (compatible OpenAI)                 |
| `/v1/completions`      | POST    | Complétion de texte (compatible OpenAI)  |
| `/v1/embeddings`       | POST    | Générer des embeddings                   |
| `/completion`          | POST    | Point de terminaison de complétion natif |
| `/tokenize`            | POST    | Tokenizer le texte                       |
| `/detokenize`          | POST    | Détokenizer les tokens                   |
| `/props`               | GET     | Propriétés du serveur                    |
| `/metrics`             | GET     | Métriques Prometheus                     |

#### Tokenizer du texte

```bash
curl https://your-http-pub.clorecloud.net/tokenize \
    -H "Content-Type: application/json" \
    -d '{"content": "Hello world"}'
```

Réponse :

```json
{"tokens": [15496, 1917]}
```

#### Propriétés du serveur

```bash
curl https://your-http-pub.clorecloud.net/props
```

Réponse :

```json
{
  "total_slots": 1,
  "chat_template": "...",
  "default_generation_settings": {...}
}
```

## Construire depuis la source

```bash

# Cloner le repo
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Construire avec CUDA
make LLAMA_CUDA=1

# Ou avec CMake
mkdir build && cd build
cmake .. -DLLAMA_CUDA=ON
cmake --build . --config Release
```

## Télécharger des modèles

```bash

# Llama 3.1 8B
wget https://huggingface.co/bartowski/Meta-Llama-3.1-8B-Instruct-GGUF/resolve/main/Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf

# Mistral 7B
wget https://huggingface.co/bartowski/Mistral-7B-Instruct-v0.3-GGUF/resolve/main/Mistral-7B-Instruct-v0.3-Q4_K_M.gguf

# Mixtral 8x7B
wget https://huggingface.co/bartowski/Mixtral-8x7B-Instruct-v0.1-GGUF/resolve/main/Mixtral-8x7B-Instruct-v0.1-Q4_K_M.gguf

# Phi-2
wget https://huggingface.co/bartowski/Phi-4-GGUF/resolve/main/Phi-4-Q4_K_M.gguf

# CodeLlama 7B
wget https://huggingface.co/bartowski/CodeLlama-7B-Instruct-GGUF/resolve/main/CodeLlama-7B-Instruct-Q4_K_M.gguf
```

## Options du serveur

### Serveur basique

```bash
./llama-server \
    -m model.gguf \
    --host 0.0.0.0 \
    --port 8080
```

### Déchargement GPU complet

```bash
./llama-server \
    -m model.gguf \
    --host 0.0.0.0 \
    --port 8080 \
    -ngl 99 \           # Couches GPU (99 = toutes)
    -c 4096 \           # Taille du contexte
    -t 8 \              # Threads CPU
    --parallel 4        # Requêtes simultanées
```

### Toutes les options

```bash
./llama-server \
    -m model.gguf \           # Fichier modèle
    --host 0.0.0.0 \          # Adresse de liaison
    --port 8080 \             # Port
    -ngl 35 \                 # Couches GPU
    -c 4096 \                 # Taille du contexte
    -t 8 \                    # Threads
    -b 512 \                  # Taille de lot
    --parallel 4 \            # Requêtes parallèles
    --mlock \                 # Verrouiller la mémoire
    --no-mmap \               # Désactiver mmap
    --cont-batching \         # Regroupement continu
    --flash-attn \            # Flash attention
    --metrics                 # Activer le point de terminaison des métriques
```

## Utilisation de l'API

### Chat Completions (compatible OpenAI)

```python
import openai

client = openai.OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="non-nécessaire"
)

response = client.chat.completions.create(
    model="llama-3.1-8b",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant serviable."},
        {"role": "user", "content": "What is machine learning?"}
    ],
    temperature=0.7,
    max_tokens=500
)

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

### Streaming

```python
stream = client.chat.completions.create(
    model="llama-3.1-8b",
    messages=[{"role": "user", "content": "Write a story"}],
    stream=True
)

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

### Complétion de texte

```python
response = client.completions.create(
    model="llama-3.1-8b",
    prompt="The future of AI is",
    max_tokens=100,
    temperature=0.8
)

print(response.choices[0].text)
```

### Embeddings

```python
response = client.embeddings.create(
    model="llama-3.1-8b",
    input="Hello, world!"
)

print(f"Embedding: {response.data[0].embedding[:5]}...")
```

## Exemples cURL

### Chat

```bash
curl http://localhost:8080/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "llama-3.1-8b",
        "messages": [
            {"role": "user", "content": "Hello!"}
        ]
    }'
```

### Complétion

```bash
curl http://localhost:8080/completion \
    -H "Content-Type: application/json" \
    -d '{
        "prompt": "Building a website requires",
        "n_predict": 128,
        "temperature": 0.7
    }'
```

### Vérification de l'état de santé

```bash
curl http://localhost:8080/health
```

### Métriques

```bash
curl http://localhost:8080/metrics
```

## Multi-GPU

```bash

# Répartir entre les GPUs
./llama-server \
    -m model.gguf \
    -ngl 99 \
    --tensor-split 0.5,0.5 \  # Répartition entre 2 GPUs
    --main-gpu 0              # GPU principal
```

## Optimisation de la mémoire

### Pour VRAM limitée

```bash

# Déchargement partiel
./llama-server -m model.gguf -ngl 20 -c 2048

# Utiliser une quantification plus petite

# Télécharger Q2_K ou Q3_K au lieu de Q4_K
```

### Pour une vitesse maximale

```bash
./llama-server \
    -m model.gguf \
    -ngl 99 \
    --flash-attn \
    --cont-batching \
    --parallel 8 \
    -b 1024
```

## Modèles de template spécifiques

### Llama 2 Chat

```bash
./llama-server -m Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf \
    --chat-template llama2
```

### Mistral Instruct

```bash
./llama-server -m mistral-7b-instruct.gguf \
    --chat-template mistral
```

### ChatML (Plusieurs modèles)

```bash
./llama-server -m model.gguf \
    --chat-template chatml
```

## Wrapper serveur Python

```python
import subprocess
import requests
import time

class LlamaCppServer:
    def __init__(self, model_path, port=8080, gpu_layers=35):
        self.port = port
        self.process = subprocess.Popen([
            "./llama-server",
            "-m", model_path,
            "--host", "0.0.0.0",
            "--port", str(port),
            "-ngl", str(gpu_layers),
            "-c", "4096"
        ])
        self._wait_for_ready()

    def _wait_for_ready(self, timeout=60):
        start = time.time()
        while time.time() - start < timeout:
            try:
                r = requests.get(f"http://localhost:{self.port}/health")
                if r.status_code == 200:
                    return
            except:
                pass
            time.sleep(1)
        raise TimeoutError("Server didn't start")

    def chat(self, messages, **kwargs):
        response = requests.post(
            f"http://localhost:{self.port}/v1/chat/completions",
            json={"messages": messages, **kwargs}
        )
        return response.json()

    def stop(self):
        self.process.terminate()

# Utilisation
server = LlamaCppServer("llama-3.1-8b.gguf")
result = server.chat([{"role": "user", "content": "Hello!"}])
print(result["choices"][0]["message"]["content"])
server.stop()
```

## Benchmarking

```bash

# Benchmark intégré
./llama-bench -m model.gguf -ngl 99

# La sortie inclut :

# - Tokens par seconde

# - Utilisation de la mémoire

# - Temps de chargement
```

## Comparaison des performances

| Modèle       | GPU      | Quantification | Tokens/sec |
| ------------ | -------- | -------------- | ---------- |
| Llama 3.1 8B | RTX 3090 | Q4\_K\_M       | \~100      |
| Llama 3.1 8B | RTX 4090 | Q4\_K\_M       | \~150      |
| Llama 3.1 8B | RTX 3090 | Q4\_K\_M       | \~60       |
| Mistral 7B   | RTX 3090 | Q4\_K\_M       | \~110      |
| Mixtral 8x7B | A100     | Q4\_K\_M       | \~50       |

## Dépannage

### CUDA non détecté

```bash

# Recompiler avec CUDA
make clean
make LLAMA_CUDA=1

# Vérifier CUDA
nvidia-smi
```

### Mémoire insuffisante

```bash

# Réduire les couches GPU
-ngl 20  # Au lieu de 99

# Réduire le contexte
-c 2048  # Au lieu de 4096

# Utiliser une quantification plus petite

# Q4_K_S au lieu de Q4_K_M
```

### Génération lente

```bash

# Augmenter la taille du lot
-b 1024

# Activer la flash attention
--flash-attn

# Activer le regroupement continu
--cont-batching
```

## Configuration de production

### Service systemd

```ini

# /etc/systemd/system/llama.service
[Unit]
Description=Serveur Llama.cpp
After=network.target

[Service]
Type=simple
ExecStart=/opt/llama.cpp/llama-server -m /models/model.gguf -ngl 99 --host 0.0.0.0 --port 8080
Restart=always

[Install]
WantedBy=multi-user.target
```

### Avec nginx

```nginx
upstream llama {
    server localhost:8080;
}

server {
    listen 80;

    location / {
        proxy_pass http://llama;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
    }
}
```

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

| GPU       | Tarif horaire | Tarif journalier | Session de 4 heures |
| --------- | ------------- | ---------------- | ------------------- |
| RTX 3060  | \~$0.03       | \~$0.70          | \~$0.12             |
| RTX 3090  | \~$0.06       | \~$1.50          | \~$0.25             |
| RTX 4090  | \~$0.10       | \~$2.30          | \~$0.40             |
| A100 40GB | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80GB | \~$0.25       | \~$6.00          | \~$1.00             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* vLLM Inference - Débit plus élevé
* [ExLlamaV2](/guides/guides_v2-fr/modeles-de-langage/exllamav2-fast.md) - Inférence plus rapide
* [Text Generation WebUI](/guides/guides_v2-fr/modeles-de-langage/text-generation-webui.md) - Interface web


---

# Agent Instructions: 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-fr/modeles-de-langage/llamacpp-server.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.