Serveur Llama.cpp

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

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

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	-

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

Location sur CLORE.AI

1. Visitez 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 :

# 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

# 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

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.

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

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": {...}
}

Construire depuis la source

# 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

# 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

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

Déchargement GPU complet

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

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

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

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

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

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

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

Complétion

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é

curl http://localhost:8080/health

Métriques

curl http://localhost:8080/metrics

Multi-GPU

# 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

# 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 de template spécifiques

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 (Plusieurs 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("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

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

# 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 la flash attention
--flash-attn

# Activer le regroupement 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 (à 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 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 - Inférence plus rapide

• Text Generation WebUI - Interface web