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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

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	-

Llama.cpp est économe en mémoire grâce à la quantification GGUF. Les modèles 7B peuvent fonctionner avec 6 à 8 Go de VRAM.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

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 :

# 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

# 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

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.

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

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

Réponse :

{"tokens": [15496, 1917]}

Propriétés du serveur

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

Réponse :

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

Compiler à partir des sources

# 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

# 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

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

Déchargement complet sur GPU

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

./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)

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

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

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

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

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

Exemples cURL

Chat

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

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

curl http://localhost:8080/health

Métriques

curl http://localhost:8080/metrics

Multi-GPU

# 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

# 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

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

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

Mistral Instruct

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

ChatML (de nombreux modèles)

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

Wrapper serveur 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

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

# Recompiler avec CUDA
make clean
make LLAMA_CUDA=1

# Vérifier CUDA
nvidia-smi

Mémoire insuffisante

# 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

# Augmenter la taille du lot
-b 1024

# Activer Flash Attention
--flash-attn

# Activer le batching continu
--cont-batching

Configuration de production

Service systemd

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

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 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 - Inférence plus rapide

• Text Generation WebUI - Interface Web