Tesi
Per una PMI che vuole integrare LLM locali nel proprio stack (Python, Node.js, .NET) è più utile focalizzarsi su: dimensionamento hardware preciso, pipeline di quantizzazione GGUF e modalità di esposizione del modello come servizio REST/GRPC. Questi passaggi rendono l’adozione di llama.cpp praticamente plug‑and‑play.
1. Dimensionamento hardware per i modelli più comuni
| Modello (parametri) | Quantizzazione | RAM minima* | VRAM (GPU) | CPU consigliata |
|---|
| LLaMA‑2‑7B‑Chat | 4‑bit GGUF | 8 GB | 4 GB (RTX 3060) | 8‑core moderni (i7‑10700K o superiore) |
| LLaMA‑2‑13B‑Chat | 5‑bit GGUF | 12 GB | 8 GB (RTX 3070) | 12‑core (i9‑11900K) |
| Mistral‑7B‑Instruct | 4‑bit GGUF | 6 GB | 4 GB (RTX 3060) | 6‑core (Ryzen 5 5600X) |
*RAM minima include spazio per il modello, lo stato della generazione e il buffer di prompt. Per carichi concorrenti aggiungere ~2 GB per thread.
Consigli pratici
- Se la workstation ha solo CPU, scegli modelli ≤ 7B con 4‑bit; la velocità tipica è 8‑12 t/s su i7‑12700K.
- Per un piccolo server dedicato, una GPU Vulkan con 6‑8 GB VRAM (RTX 3060/3070) raddoppia il throughput (≈15‑20 t/s).
- Usa SSD NVMe per il file GGUF: il caricamento del modello è I/O‑bound; un drive da 500 GB riduce il tempo di avvio a < 2 s.
2. Pipeline di quantizzazione (da checkpoint HF a GGUF)
git clone https://github.com/ggerganov/llama.cpp.git && cd llama.cpp
python -m pip install -U torch transformers sentencepiece
python ./convert_hf_to_gguf.py \
--model_dir /path/to/hf/llama2-7b-chat \
--outfile llama2-7b-chat-q4.gguf \
--quant_type q4_0
ls -lh llama2-7b-chat-q4.gguf
Il tool convert_hf_to_gguf.py è documentato nella README di llama.cpp (v0.2.0). Dopo la conversione il modello è pronto per l’inferenza sia su CPU che su Vulkan.
3. Esecuzione locale come servizio HTTP
3.1. Modalità server integrata (v0.2.0+)
./server -m ./models/llama2-7b-chat-q4.gguf \
-c 2048 -ngl 32 -t 4 -ngl 32 -ngl 0 \
-p "You are a helpful assistant." \
-port 8080 -host 0.0.0.0 -gpu vulkan
Il server espone due endpoint JSON:
POST /completion (compatibile con OpenAI API schema)
POST /chat/completions
3.2. Wrapper Python (FastAPI) per chi non vuole usare il server nativo
from fastapi import FastAPI, Request
from pydantic import BaseModel
import subprocess, json, os
app = FastAPI()
MODEL_PATH = os.getenv("MODEL_PATH", "./models/llama2-7b-chat-q4.gguf")
class Prompt(BaseModel):
prompt: str
max_tokens: int = 128
@app.post("/v1/completions")
async def completions(body: Prompt):
cmd = ["./llama.cpp/main", "-m", MODEL_PATH,
"-p", body.prompt,
"-n", str(body.max_tokens),
"-t", "4", "-ngl", "32"]
result = subprocess.run(cmd, capture_output=True, text=True)
return {"choices": [{"text": result.stdout.strip()}], "model": "llama2-7b-chat"}
Esegui con Docker (vedi sezione 4) o direttamente con uvicorn app:app --host 0.0.0.0 --port 8000.
4. Integrazione con stack esistenti (Docker, Node.js, .NET)
- Docker (immagine ufficiale community):
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y ca-certificates && rm -rf /var/lib/apt/lists/*
COPY --from=builder /app/llama.cpp/server /usr/local/bin/server
COPY ./models/*.gguf /models/
EXPOSE 8080
CMD ["server", "-m", "/models/llama2-7b-chat-q4.gguf", "-port", "8080", "-host", "0.0.0.0", "-gpu", "vulkan"]
Costruisci con docker build -t llama-server . e avvia docker run -p 8080:8080 llama-server.
- Node.js (client OpenAI‑compatible):
const { Configuration, OpenAIApi } = require('openai');
const config = new Configuration({ basePath: 'http://localhost:8080/v1' });
const openai = new OpenAIApi(config);
const resp = await openai.createCompletion({ model: 'local-llama', prompt: 'Ciao', max_tokens: 64 });
console.log(resp.data.choices[0].text);
- .NET (C#) usando
HttpClient:
var client = new HttpClient { BaseAddress = new Uri("http://localhost:8080/v1/") };
var payload = new { model = "local-llama", prompt = "Ciao", max_tokens = 64 };
response = client.PostAsJsonAsync(, payload);
json = response.Content.ReadFromJsonAsync<JsonElement>();
Console.WriteLine(json.GetProperty()[].GetProperty().GetString());
Queste tre integrazioni sfruttano lo stesso schema JSON, quindi il passaggio da cloud a on‑premise è una modifica di configurazione (URL e chiave API opzionale).
5. Checklist rapida per la messa in produzione
- Verifica RAM/VRAM rispetto al modello quantizzato.
- Converti il checkpoint in GGUF con il tool ufficiale.
- Scegli tra server nativo (meno overhead) o wrapper (più flessibilità).
- Containerizza con Docker per isolamento e versioning.
- Aggiorna periodicamente
llama.cpp (v0.2.x → v0.2.y) e rigenera il GGUF.
- Monitora
cpu_percent, gpu_util e token/sec con Prometheus + Grafana (esportatore node_exporter).
Domanda per il gruppo: quale linguaggio di integrazione (Python/FastAPI, Node.js, .NET) avete già in produzione e quali problemi avete incontrato nella gestione della concorrenza delle richieste verso il server llama.cpp?