> 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-fr/modeles-de-langage/llamacpp-server.md).

# Llama.cpp Server

Inférence LLM efficace avec le serveur llama.cpp sur les GPU Clore.ai

Exécutez efficacement des LLM 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 [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

## Exigences du serveur

| Paramètre          | Minimum       | Recommandé |
| ------------------ | ------------- | ---------- |
| RAM                | 8 Go          | 16 Go+     |
| VRAM               | 6 Go          | 8GB+       |
| 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 %}

## Louer sur CLORE.AI

1. Visitez [la place de marché CLORE.AI](https://clore.ai/marketplace)
2. Filtrez par type de GPU, VRAM et prix
3. Choisissez **À 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@<proxy-address>`

## 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 avec OpenAI
* Prise en charge multi-utilisateur

## Niveaux de quantification

| Format   | Taille (7B) | Vitesse        | Qualité    |
| -------- | ----------- | -------------- | ---------- |
| Q2\_K    | 2.8GB       | Le plus rapide | Faible     |
| Q4\_K\_M | 4.1GB       | Rapide         | Bon        |
| Q5\_K\_M | 4.8GB       | Moyen          | Excellent  |
| Q6\_K    | 5.5GB       | Plus lent      | Excellente |
| Q8\_0    | 7.2GB       | 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

# Lancer 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. Accédez à **Mes commandes** la page
2. Cliquez sur votre commande
3. Trouvez le `http_pub` URL (par ex., `abc123.clorecloud.net`)

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

### Vérifier que cela fonctionne

```bash
# Vérifier l'état
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 une erreur HTTP 502, le service est peut-être encore en cours de démarrage ou de téléchargement du modèle. Attendez 2 à 5 minutes et réessayez.
{% endhint %}

## Référence API complète

### 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    | Tokeniser le texte                       |
| `/detokenize`          | POST    | Détokeniser les jetons                   |
| `/props`               | GET     | Propriétés du serveur                    |
| `/metrics`             | GET     | Métriques Prometheus                     |

#### Tokeniser le 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": {...}
}
```

## Compiler à partir des sources

```bash

# Cloner le dépôt
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Compiler avec CUDA
make LLAMA_CUDA=1

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

## Télécharger les 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 de base

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

### Déchargement complet sur GPU

```bash
./llama-server \
    -m model.gguf \
    --host 0.0.0.0 \
    --port 8080 \
    -ngl 99 \           # Couches GPU (99 = tout)
    -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 du 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 du lot
    --parallel 4 \            # Requêtes parallèles
    --mlock \                 # Verrouiller la mémoire
    --no-mmap \               # Désactiver mmap
    --cont-batching \         # Batching continu
    --flash-attn \            # Flash attention
    --metrics                 # Activer le point de terminaison des métriques
```

## Utilisation de l’API

### Complétions de chat (compatible OpenAI)

```python
import openai

client = openai.OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="llama-3.1-8b",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant utile."},
        {"role": "user", "content": "Qu'est-ce que l'apprentissage automatique ?"}
    ],
    temperature=0.7,
    max_tokens=500
)

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

### Flux continu

```python
stream = client.chat.completions.create(
    model="llama-3.1-8b",
    messages=[{"role": "user", "content": "Écris une histoire"}],
    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="Le futur de l'IA est",
    max_tokens=100,
    temperature=0.8
)

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

### Embeddings

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

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": "Bonjour !"}
        ]
    }'
```

### Complétion

```bash
curl http://localhost:8080/completion \
    -H "Content-Type: application/json" \
    -d '{
        "prompt": "Construire un site web nécessite",
        "n_predict": 128,
        "temperature": 0.7
    }'
```

### Vérification de l'état

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

### Métriques

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

## Multi-GPU

```bash

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

## Optimisation de la mémoire

### Pour une 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 spécifiques au modèle

### 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 (de nombreux 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("Le serveur n'a pas démarré")

    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": "Bonjour !"}])
print(result["choices"][0]["message"]["content"])
server.stop()
```

## Benchmark

```bash

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

# La sortie inclut :

# - Jetons par seconde

# - Utilisation de la mémoire

# - Temps de chargement
```

## Comparaison des performances

| Modèle       | GPU      | Quantification | Jetons/s |
| ------------ | -------- | -------------- | -------- |
| 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 Flash Attention
--flash-attn

# Activer le batching 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 (en 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 40 Go | \~$0.17       | \~$4.00          | \~$0.70             |
| A100 80 Go | \~$0.25       | \~$6.00          | \~$1.00             |

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

**Économisez de l'argent :**

* Utilisez le **Spot** marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane \~13 % de remise), les autres s'alignent dessus
* Payez avec **CLORE** jetons
* Comparez les prix entre différents fournisseurs

## Étapes suivantes

* Inférence vLLM - 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
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-fr/modeles-de-langage/llamacpp-server.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.