Motori di inferenza per LLM e hardware AI locale (Edizione 2026)

You don't pick an inference engine first. You pick a hardware strategy, a workload shape, and a serving model. The engine follows.

Translate: "Non si sceglie prima un motore di inferenza. Si sceglie una strategia hardware, una forma del carico di lavoro e un modello di servizio. Il motore segue."

Then: "That is the most useful way to think about LLM inference engines." -> "Questo è il modo più utile di pensare ai motori di inferenza LLM."

Series note: "Series note: This is Part 3 in my series teaching Self-hosted LLMs / Local AI." -> "Nota della serie: questa è la Parte 3 della mia serie sull'insegnamento degli LLM auto-ospitati / AI locale."

Parts with links: keep URLs, translate link text. For Part 1: "GPU Memory Math for LLMs (2026 Edition)" -> "Matematica della memoria GPU per LLM (Edizione 2026)". Part 2: "Memory Bandwidth for Local AI Hardware (2026 Edition)" -> "Larghezza di banda della memoria per hardware AI locale (Edizione 2026)". But careful: the original link text is the same as the title? Actually the link text is the title in English. We must translate it to Italian. So:

• Part 1: Matematica della memoria GPU per LLM (Edizione 2026).
• Part 2: Larghezza di banda della memoria per hardware AI locale (Edizione 2026).

Then: "Those two pieces explain the hardware capacity and bandwidth math." -> "Quei due articoli spiegano la matematica della capacità hardware e della larghezza di banda."

"This one explains the software layer that turns that hardware into usable inference." -> "Questo spiega il livello software che trasforma quell'hardware in inferenza utilizzabile."

Engines

"These tools serve different purposes / occupy different layers" -> "Questi strumenti servono a scopi diversi / occupano diversi livelli"

List items:

• Local portability -> Portabilità locale
• Consumer CUDA -> CUDA consumer
• Apple unified-memory workflows -> Flussi di lavoro con memoria unificata Apple
• Quantized inference -> Inferenza quantizzata
• Production serving -> Servizio di produzione
• Distributed orchestration -> Orchestrazione distribuita
• Vendor-optimized datacenter execution -> Esecuzione ottimizzata per datacenter del fornitore

"A useful mental model:" -> "Un modello mentale utile:"

Then payload-block tag: <payload-block id="blk_0" type="upload" /> -> keep exactly.

"The inference engine is not "the model." It is the traffic cop, memory manager, kernel dispatcher, scheduler, cache accountant, parallelism planner, API surface, and sometimes the deployment framework." -> "Il motore di inferenza non è 'il modello'. È il vigile del traffico, il gestore della memoria, lo smistatore del kernel, lo scheduler, il contabile della cache, il pianificatore del parallelismo, la superficie API e talvolta il framework di deployment."

"The best engine matches your memory hierarchy, interconnect, quantization format, latency and throughput targets, model architecture, and operational maturity." -> "Il motore migliore corrisponde alla tua gerarchia di memoria, interconnessione, formato di quantizzazione, obiettivi di latenza e throughput, architettura del modello e maturità operativa."

The one-page decision guide

List:

• Laptop / edge / odd hardware → llama.cpp -> Laptop / edge / hardware strano → llama.cpp
• Mac-first workflows → MLX / MLX-LM -> Flussi di lavoro principalmente su Mac → MLX / MLX-LM
• Single RTX local inference → ExLlamaV2 -> Inferenza locale su singola RTX → ExLlamaV2
• 2-4+ NVIDIA / CUDA GPUs → ExLlamaV3 -> 2-4+ GPU NVIDIA / CUDA → ExLlamaV3
• General production serving → vLLM -> Servizio di produzione generale → vLLM
• Long-context / MoE / routing → SGLang -> Contesto lungo / MoE / routing → SGLang
• NVIDIA max performance → TensorRT-LLM -> Massima performance NVIDIA → TensorRT-LLM
• Cluster orchestration → NVIDIA Dynamo -> Orchestrazione cluster → NVIDIA Dynamo

"The rest of this guide explains why." -> "Il resto di questa guida spiega perché."

What an inference engine actually does

"An inference engine loads weights, tokenizes input, runs the forward pass, samples tokens, maintains the KV cache, and streams results. Serious engines also handle batching, scheduling, prefix caching, quantization, parallel execution, API serving, metrics, and distributed execution." -> "Un motore di inferenza carica i pesi, tokenizza l'input, esegue il forward pass, campiona i token, mantiene la cache KV e invia i risultati in streaming. I motori seri gestiscono anche batching, scheduling, caching dei prefissi, quantizzazione, esecuzione parallela, servizio API, metriche ed esecuzione distribuita."

"The workload has two phases:" -> "Il carico di lavoro ha due fasi:"

"Prefill reads the prompt and builds the initial KV cache. It is compute-intensive." -> "Prefill legge il prompt e costruisce la cache KV iniziale. È intensivo dal punto di vista computazionale."

"Decode generates one token at a time, repeatedly reading weights and KV cache. It is memory-bandwidth-bound. Decode speed tracks memory bandwidth more than peak compute." -> "Decode genera un token alla volta, leggendo ripetutamente pesi e cache KV. È limitato dalla larghezza di banda della memoria. La velocità di decode segue la larghezza di banda della memoria più del picco di calcolo."

"That distinction explains almost everything:" -> "Questa distinzione spiega quasi tutto:"

List:

• Short prompt, long answer: decode dominates → memory bandwidth and batching matter. -> Prompt breve, risposta lunga: decode domina → larghezza di banda della memoria e batching contano.
• Long prompt, short answer: prefill dominates → attention kernels and chunked prefill matter. -> Prompt lungo, risposta breve: prefill domina → kernel di attenzione e prefill a blocchi contano.
• Many users: scheduler quality matters → continuous batching, cache paging, fairness. -> Molti utenti: la qualità dello scheduler conta → batching continuo, paginazione della cache, equità.
• Long context: KV cache dominates → paged attention, KV quantization, offload. -> Contesto lungo: cache KV domina → attenzione paginata, quantizzazione KV, offload.
• MoE: expert routing dominates → expert parallelism, interconnect, grouped GEMMs. -> MoE: routing degli esperti domina → parallelismo degli esperti, interconnessione, GEMM raggruppati.
• Multi-node: interconnect dominates → NVLink, RDMA, pipeline parallelism, disaggregation. -> Multi-nodo: interconnessione domina → NVLink, RDMA, parallelismo pipeline, disaggregazione.

"PagedAttention tackled KV cache fragmentation. FlashAttention used IO-aware tiling to cut HBM (High Bandwidth Memory) traffic. Speculative decoding drafts cheap tokens and verifies them in parallel. The recurring theme: inference performance is memory movement plus scheduling." -> "PagedAttention ha affrontato la frammentazione della cache KV. FlashAttention ha utilizzato il tiling consapevole dell'I/O per ridurre il traffico HBM (High Bandwidth Memory). Il decoding speculativo abbozza token economici e li verifica in parallelo. Il tema ricorrente: le performance di inferenza sono movimento della memoria più scheduling."

The real bottlenecks

1. "Memory bandwidth, not just VRAM size. VRAM determines fit. Bandwidth determines decode speed. Apple's M3 Ultra offers up to 819 GB/s unified-memory bandwidth. NVIDIA's H100 SXM lists 3.35 TB/s GPU memory bandwidth. Unified memory lets you fit models that would not fit in consumer VRAM. HBM lets you serve them faster when the model fits. Fit is not speed. Capacity is not bandwidth." -> "Larghezza di banda della memoria, non solo dimensione della VRAM. La VRAM determina l'adattamento. La larghezza di banda determina la velocità di decode. L'M3 Ultra di Apple offre fino a 819 GB/s di larghezza di banda della memoria unificata. L'H100 SXM di NVIDIA elenca 3,35 TB/s di larghezza di banda della memoria GPU. La memoria unificata ti permette di far entrare modelli che non entrerebbero nella VRAM consumer. L'HBM ti permette di servirli più velocemente quando il modello ci sta. L'adattamento non è velocità. La capacità non è larghezza di banda."

1. "KV cache growth. KV cache grows with batch size and context length. Long-context workloads can run out of memory even when weights fit. PagedAttention partitions the KV cache into blocks, increasing utilization and supporting larger batches." -> "Crescita della cache KV. La cache KV cresce con la dimensione del batch e la lunghezza del contesto. I carichi di lavoro con contesto lungo possono esaurire la memoria anche quando i pesi ci stanno. PagedAttention partiziona la cache KV in blocchi, aumentando l'utilizzo e supportando batch più grandi."

1. "Interconnect. The moment a model crosses GPU boundaries (multi-GPUs), you pay communication cost. Tensor parallelism needs frequent all-reduce collectives. Pipeline parallelism communicates at stage boundaries. Expert parallelism needs all-to-all traffic for MoE. vLLM's docs note that without NVLink, pipeline parallelism can outperform tensor parallelism." -> "Interconnessione. Nel momento in cui un modello attraversa i confini della GPU (multi-GPU), si paga un costo di comunicazione. Il parallelismo tensoriale necessita di frequenti collettive all-reduce. Il parallelismo pipeline comunica ai confini degli stadi. Il parallelismo esperto necessita di traffico all-to-all per MoE. I documenti di vLLM notano che senza NVLink, il parallelismo pipeline può superare il parallelismo tensoriale."

1. "Scheduler quality. A good scheduler decides which requests enter the batch, how prefill and decode share the accelerator, whether long prompts block short decodes, and how to avoid starvation. Supporting batching is not the same as behaving like a production-ready scheduler." -> "Qualità dello scheduler. Un buon scheduler decide quali richieste entrano nel batch, come prefill e decode condividono l'acceleratore, se i prompt lunghi bloccano i decode brevi e come evitare la starvation. Supportare il batching non equivale a comportarsi come uno scheduler pronto per la produzione."

1. "Runtime overhead. CUDA graphs, kernel fusion, sampling overhead, tokenizer overhead, HTTP overhead, LoRA switching, and structured decoding all matter. At high scale, the annoying 2% overheads form a union and demand attention (no punt intended)." -> "Overhead del runtime. I grafici CUDA, la fusione dei kernel, l'overhead del campionamento, l'overhead del tokenizer, l'overhead HTTP, il passaggio LoRA e il decoding strutturato sono tutti importanti. A grande scala, i fastidiosi overhead del 2% formano un'unione e richiedono attenzione (senza gioco di parole intenzionale)."

Note: "no punt intended" is a pun? Actually the text says "no punt intended" which might be a play on "no pun intended" but with "punt" as in a football term? Or just a typo? It says "no punt intended" - I think it's a typo for "no pun intended". But we'll keep it literal? Better to translate as "senza gioco di parole intenzionale" if it's "pun". But it says "punt" - could be intentional. I'll assume it's "no pun intended" and translate accordingly.

The engine families

"There are four broad families:" -> "Ci sono quattro grandi famiglie:"

"Portable local runtimes: llama.cpp, MLC LLM, ONNX Runtime GenAI, OpenVINO, Ollama-style tools. These care about "make it run here."" -> "Runtime locali portatili: llama.cpp, MLC LLM, ONNX Runtime GenAI, OpenVINO, strumenti tipo Ollama. Questi si preoccupano di 'farlo funzionare qui'."

"Apple/unified-memory runtimes: MLX and MLX-LM. These care about "use big shared memory and Apple's stack well."" -> "Runtime Apple/memoria unificata: MLX e MLX-LM. Questi si preoccupano di 'usare bene la grande memoria condivisa e lo stack Apple'."

"Consumer CUDA quant engines: ExLlamaV2 and ExLlamaV3. These care about "make my 3090/4090/5090 box scream with low-bit weights."" -> "Motori di quantizzazione CUDA consumer: ExLlamaV2 ed ExLlamaV3. Questi si preoccupano di 'far urlare la mia scatola 3090/4090/5090 con pesi a bassi bit'."

"Production serving engines: vLLM, SGLang, TensorRT-LLM, TGI, LMDeploy. These care about concurrent users, KV cache, batching, parallelism, observability, and cost per token." -> "Motori di servizio di produzione: vLLM, SGLang, TensorRT-LLM, TGI, LMDeploy. Questi si preoccupano di utenti concorrenti, cache KV, batching, parallelismo, osservabilità e costo per token."

"Then there are orchestration layers like Dynamo that sit above engines and coordinate fleets, disaggregated prefill/decode, routing, and autoscaling." -> "Poi ci sono livelli di orchestrazione come Dynamo che si trovano sopra i motori e coordinano flotte, prefill/decode disaggregati, routing e autoscaling."

llama.cpp: the portability king

"llama.cpp is the answer when the hardware is weird, constrained, offline, CPU-heavy, edge-oriented, or not a tidy NVIDIA datacenter node." -> "llama.cpp è la risposta quando l'hardware è strano, limitato, offline, pesante sulla CPU, orientato all'edge o non è un ordinato nodo datacenter NVIDIA."

"It supports Apple Silicon via ARM NEON, Accelerate, and Metal; x86 via AVX/AVX2/AVX512/AMX; RISC-V; low-bit quantization; CUDA; AMD via HIP; MUSA; Vulkan; SYCL; and CPU+GPU hybrid offload. That is why llama.cpp owns the "just make it run" lane." -> "Supporta Apple Silicon tramite ARM NEON, Accelerate e Metal; x86 tramite AVX/AVX2/AVX512/AMX; RISC-V; quantizzazione a bassi bit; CUDA; AMD tramite HIP; MUSA; Vulkan; SYCL; e offload ibrido CPU+GPU. Ecco perché llama.cpp possiede la corsia 'fai funzionare e basta'."

"The HTTP server is more capable than a "toy local runner". llama-server provides OpenAI-compatible routes, Anthropic Messages API compatibility, reranking, continuous batching, multimodal support, JSON schema constraints, function calling, speculative decoding, and a web UI." -> "Il server HTTP è più capace di un 'giocattolo per esecuzione locale'. llama-server fornisce route compatibili con OpenAI, compatibilità con API Anthropic Messages, reranking, batching continuo, supporto multimodale, vincoli di schema JSON, chiamata di funzioni, decoding speculativo e un'interfaccia web."

"The critical limitation: llama.cpp is not for serious multi-node production serving. Its RPC backend is explicitly documented as proof-of-concept, fragile, and insecure." -> "La limitazione critica: llama.cpp non è per un serio servizio di produzione multi-nodo. Il suo backend RPC è esplicitamente documentato come proof-of-concept, fragile e insicuro."

"Verdict: Use llama.cpp when portability, offline operation, GGUF, or hybrid offload matter more than fleet-scale serving." -> "Verdetto: usa llama.cpp quando portabilità, funzionamento offline, GGUF o offload ibrido contano più del servizio su scala di flotta."

"DO NOT use with Multi-GPUs" -> "NON usare con Multi-GPU" (translated link text: "Multi-GPU" - but the original link text says "Multi-GPUs". We'll translate to "Multi-GPU" as that's the Italian form? Actually we should keep the original link text? The rule says translate link text from source language to target language. So "Multi-GPUs" becomes "Multi-GPU" (singular? but in Italian we say "Multi-GPU" as an adjective). Or keep as "Multi-GPUs"? Probably translate to "Multi-GPU" to be natural. But the URL remains same.

MLX and MLX-LM: the Apple Silicon weapon

"MLX is Apple's array framework for Apple Silicon, and MLX-LM is the LLM package built on it. It is a Mac-first ML stack." -> "MLX è il framework di array di Apple per Apple Silicon, e MLX-LM è il pacchetto LLM costruito su di esso. È uno stack ML principalmente per Mac."

"The key hardware fact is unified memory. Apple Silicon gives the CPU and GPU direct access to the same memory pool. MLX arrays live in unified memory, and you choose the device when running the operation rather than moving arrays between separate memory spaces." -> "Il dato hardware chiave è la memoria unificata. Apple Silicon dà alla CPU e alla GPU accesso diretto allo stesso pool di memoria. Gli array MLX vivono nella memoria unificata e scegli il dispositivo quando esegui l'operazione, invece di spostare array tra spazi di memoria separati."

"This changes the local inference tradeoff. On a discrete GPU system, the question is "does it fit in VRAM?" On an M-series Mac with large unified memory, the question becomes "does it fit in memory, and can the memory system feed the GPU fast enough?" Large quantized models can fit on machines where the same model would be impossible on a 24 GB consumer GPU." -> "Questo cambia il compromesso dell'inferenza locale. Su un sistema GPU discreta, la domanda è 'ci sta nella VRAM?' Su un Mac della serie M con grande memoria unificata, la domanda diventa 'ci sta in memoria e il sistema di memoria può alimentare la GPU abbastanza velocemente?' Modelli grandi quantizzati possono entrare in macchine dove lo stesso modello sarebbe impossibile su una GPU consumer da 24 GB."

"However, it is also slower." -> "Tuttavia, è anche più lento."

"MLX-LM adds Hugging Face Hub integration, quantization, LoRA and full fine-tuning, distributed inference, and a large MLX Community model ecosystem. MLX is no longer Mac-only: it offers CUDA and CPU-only packages for Linux. Distributed communication supports MPI, Ring over TCP, JACCL for RDMA over Thunderbolt, and NCCL for CUDA." -> "MLX-LM aggiunge integrazione con Hugging Face Hub, quantizzazione, LoRA e full fine-tuning, inferenza distribuita e un grande ecosistema di modelli della community MLX. MLX non è più solo per Mac: offre pacchetti CUDA e solo CPU per Linux. La comunicazione distribuita supporta MPI, Ring over TCP, JACCL per RDMA su Thunderbolt e NCCL per CUDA."

"MLX-LM's server itself warns that it is not recommended for production because it only implements basic security checks." -> "Il server di MLX-LM stesso avverte che non è raccomandato per la produzione perché implementa solo controlli di sicurezza di base."

"Verdict: Use MLX for Mac-first ML and LLM workflows. For high-concurrency public serving, start with a real serving stack." -> "Verdetto: usa MLX per flussi di lavoro ML e LLM principalmente su Mac. Per servizio pubblico ad alta concorrenza, inizia con uno stack di servizio reale."

ExLlamaV2 and V3: consumer CUDA, tuned and fast

"ExLlamaV2 is the local CUDA quantization engine for people who want a consumer NVIDIA GPU to punch above its weight. It supports paged attention, dynamic batching, prompt caching, KV cache deduplication, batched generation, streaming, and speculative decoding. The word to remember is local. It makes quantized models fast on modern CUDA GPUs, especially consumer cards." -> "ExLlamaV2 è il motore di quantizzazione CUDA locale per persone che vogliono che una GPU NVIDIA consumer dia il meglio di sé. Supporta attenzione paginata, batching dinamico, caching dei prompt, deduplicazione cache KV, generazione in batch, streaming e decoding speculativo. La parola da ricordare è locale. Rende veloci i modelli quantizzati sulle GPU CUDA moderne, specialmente le schede consumer."

"Best fits: one RTX 3090/4090/5090 box, local coding assistant, local chat, EXL2 quantized models, and prosumer workstation use." -> "Migliori adattamenti: una scatola con RTX 3090/4090/5090, assistente di codifica locale, chat locale, modelli quantizzati EXL2 e uso workstation prosumer."

"ExLlamaV3 extends the philosophy toward multi-GPU and MoE-local inference. It adds the EXL3 quantization format based on QTIP, flexible tensor-parallel and expert-parallel inference for consumer hardware, an OpenAI-compatible server through TabbyAPI, continuous dynamic batching, and multimodal support." -> "ExLlamaV3 estende la filosofia verso l'inferenza multi-GPU e MoE locale. Aggiunge il formato di quantizzazione EXL3 basato su QTIP, inferenza flessibile con parallelismo tensoriale e parallelismo esperto per hardware consumer, un server compatibile con OpenAI tramite TabbyAPI, batching dinamico continuo e supporto multimodale."

"V3 is compelling when you have 2-4+ consumer NVIDIA GPUs or want local MoE. Expect caveats: some models do not support tensor or expert parallelism in ExLlamaV3." -> "V3 è interessante quando hai 2-4+ GPU NVIDIA consumer o vuoi MoE locale. Aspettati avvertenze: alcuni modelli non supportano il parallelismo tensoriale o esperto in ExLlamaV3."

"Verdict: ExLlamaV2 is the enthusiast's local CUDA engine. ExLlamaV3 is the frontier for multi-GPU (2-4) local setups. Expect rougher edges for better capability." -> "Verdetto: ExLlamaV2 è il motore CUDA locale per appassionati. ExLlamaV3 è la frontiera per configurazioni locali multi-GPU (2-4). Aspettati spigoli più vivi per capacità migliori."

vLLM: the default open-source production server

"vLLM is the first engine most teams should evaluate for serious opensource LLM serving." -> "vLLM è il primo motore che la maggior parte dei team dovrebbe valutare per un serio servizio LLM open-source."

"It offers PagedAttention-based KV memory management, continuous batching, chunked prefill, prefix caching, CUDA/HIP graphs, extensive quantization (FP8, MXFP8/MXFP4, NVFP4, INT8, INT4, GPTQ, AWQ, GGUF), optimized attention and GEMM/MoE kernels, speculative decoding, torch.compile, and disaggregated prefill/decode/encode." -> "Offre gestione della memoria KV basata su PagedAttention, batching continuo, prefill a blocchi, caching dei prefissi, grafici CUDA/HIP, ampia quantizzazione (FP8, MXFP8/MXFP4, NVFP4, INT8, INT4, GPTQ, AWQ, GGUF), kernel ottimizzati di attenzione e GEMM/MoE, decoding speculativo, torch.compile e prefill/decode/encode disaggregati."

"It is also flexible: tensor/pipeline/data/expert/context parallelism, streaming, structured outputs, tool calling, OpenAI-compatible and Anthropic Messages APIs, gRPC, multi-LoRA, and support for NVIDIA, AMD, x86/ARM/PowerPC CPUs, plus plugins for TPUs, Gaudi, Ascend, Apple Silicon, and more." -> "È anche flessibile: parallelismo tensoriale/pipeline/dati/esperti/contesto, streaming, output strutturati, chiamata di strumenti, API compatibili con OpenAI e Anthropic Messages, gRPC, multi-LoRA e supporto per CPU NVIDIA, AMD, x86/ARM/PowerPC, più plugin per TPU, Gaudi, Ascend, Apple Silicon e altro."

"vLLM's docs note that multi-node deployments typically use Ray, and without NVLink, pipeline parallelism may beat tensor parallelism. The trap is assuming vLLM removes the need for systems thinking. You still need to tune batching, context length, GPU memory utilization, parallelism layout, and routing. vLLM gives you a very good engine; it still requires good System Design." -> "I documenti di vLLM notano che i deployment multi-nodo usano tipicamente Ray e senza NVLink, il parallelismo pipeline può battere il parallelismo tensoriale. La trappola è presumere che vLLM elimini la necessità di pensiero sistemico. Devi ancora ottimizzare batching, lunghezza del contesto, utilizzo della memoria GPU, layout del parallelismo e routing. vLLM ti dà un motore molto buono; richiede ancora un buon System Design."

"Verdict: If someone says "we need to serve open models in production," vLLM is the default starting point." -> "Verdetto: se qualcuno dice 'dobbiamo servire modelli aperti in produzione', vLLM è il punto di partenza predefinito."

SGLang: vLLM's systems-brained cousin

"SGLang is what you reach for when the serving workload is ugly: structured outputs, long context, MoE, disaggregation, and routing." -> "SGLang è ciò a cui ricorri quando il carico di lavoro di servizio è brutto: output strutturati, contesto lungo, MoE, disaggregazione e routing."

"It offers RadixAttention prefix caching, prefill-decode disaggregation, speculative decoding, continuous batching, paged attention, tensor/pipeline/expert/data parallelism, structured outputs, chunked prefill, and multi-LoRA batching. It supports NVIDIA, AMD, Intel Xeon, Google TPUs, Ascend NPUs, and more." -> "Offre caching dei prefissi RadixAttention, disaggregazione prefill-decode, decoding speculativo, batching continuo, attenzione paginata, parallelismo tensoriale/pipeline/esperti/dati, output strutturati, prefill a blocchi e batching multi-LoRA. Supporta NVIDIA, AMD, Intel Xeon, TPU Google, NPU Ascend e altro."

"SGLang's differentiator is serving architecture. Its prefill-decode disaggregation separates compute-intensive prefill from memory-intensive decode into specialized instances, transferring KV cache between them. This prevents long prefill batches from interrupting decode and spiking token latency." -> "Il fattore differenziante di SGLang è l'architettura di servizio. La sua disaggregazione prefill-decode separa il prefill intensivo dal decode intensivo in istanze specializzate, trasferendo la cache KV tra di esse. Questo impedisce ai batch di prefill lunghi di interrompere il decode e far impennare la latenza dei token."

"Verdict: SGLang is for teams whose bottleneck is no longer "can we run the model?" but "can we run it under hostile traffic without torching latency, memory, and cost?"" -> "Verdetto: SGLang è per team il cui collo di bottiglia non è più 'riusciamo a eseguire il modello?' ma 'riusciamo a eseguirlo sotto traffico ostile senza bruciare latenza, memoria e costo?'"

TensorRT-LLM: maximum NVIDIA performance

"TensorRT-LLM is the NVIDIA-max-performance stack. It is optimized, specialized, powerful, and not pretending to be portable." -> "TensorRT-LLM è lo stack di massima performance NVIDIA. È ottimizzato, specializzato, potente e non finge di essere portatile."

"It provides Python APIs to build TensorRT engines with state-of-the-art optimizations, plus Python and C++ runtimes. It includes custom kernels for attention, GEMMs, and MoE; prefill-decode disaggregation, Wide Expert Parallelism, speculative decoding; and a high-level Python API integrated with NVIDIA Dynamo and Triton Inference Server." -> "Fornisce API Python per costruire motori TensorRT con ottimizzazioni all'avanguardia, più runtime Python e C++. Include kernel personalizzati per attenzione, GEMM e MoE; disaggregazione prefill-decode, Wide Expert Parallelism, decoding speculativo; e un'API Python di alto livello integrata con NVIDIA Dynamo e Triton Inference Server."

"B200 GPUs can load FP4 weights with optimized kernels. H100 and later support FP8 quantization that can double performance and halve memory consumption versus 16-bit with minimal accuracy loss." -> "Le GPU B200 possono caricare pesi FP4 con kernel ottimizzati. H100 e successive supportano la quantizzazione FP8 che può raddoppiare le performance e dimezzare il consumo di memoria rispetto a 16 bit con minima perdita di accuratezza."

"Where it shines: H100/H200/B200/GB200/GB300-class fleets, NVIDIA-only datacenters, FP8/FP4 deployment, multi-node serving, and MoE at scale. Where it is awkward: AMD, Apple, or Intel portability; fast-changing experimental models; small local setups; and teams that need "works on everything."" -> "Dove brilla: flotte di classe H100/H200/B200/GB200/GB300, datacenter solo NVIDIA, deployment FP8/FP4, servizio multi-nodo e MoE su larga scala. Dove è scomodo: portabilità AMD, Apple o Intel; modelli sperimentali in rapido cambiamento; piccole configurazioni locali; e team che hanno bisogno di 'funziona su tutto'."

"Verdict: If you are committed to NVIDIA and care about absolute performance, TensorRT-LLM belongs in the bake-off. You trade portability for performance. Tuned specialization but less features." -> "Verdetto: se sei impegnato con NVIDIA e tieni alle performance assolute, TensorRT-LLM merita di essere nella competizione. Scambi portabilità per performance. Specializzazione ottimizzata ma meno funzionalità."

The rest of the field

"TGI is Hugging Face's production server with tracing, metrics, tensor parallelism, and continuous batching. Use it when HF integration and simplicity matter." -> "TGI è il server di produzione di Hugging Face con tracing, metriche, parallelismo tensoriale e batching continuo. Usalo quando l'integrazione con HF e la semplicità contano."

"MLC LLM is the compiler-first universal deployment engine with OpenAI-compatible APIs across REST, Python, JavaScript, iOS, and Android. Best for "ship LLMs everywhere," especially browser, mobile, and native apps." -> "MLC LLM è il motore di deployment universale incentrato sul compilatore con API compatibili con OpenAI su REST, Python, JavaScript, iOS e Android. Ideale per 'distribuire LLM ovunque', specialmente browser, app mobili e native."

"ONNX Runtime GenAI implements the full generative loop over ONNX Runtime and powers Foundry Local, Windows ML, and the VS Code AI Toolkit. It supports CPU, CUDA, DirectML, TensorRT-RTX, OpenVINO, QNN, WebGPU, and AMD GPU. Best for app deployment and ONNX workflows." -> "ONNX Runtime GenAI implementa il ciclo generativo completo su ONNX Runtime e alimenta Foundry Local, Windows ML e il VS Code AI Toolkit. Supporta CPU, CUDA, DirectML, TensorRT-RTX, OpenVINO, QNN, WebGPU e GPU AMD. Ideale per deployment di app e flussi di lavoro ONNX."

"OpenVINO GenAI is the Intel-optimized story for Xeon CPUs, Arc GPUs, Core Ultra, and NPUs. It offers OpenAI-compatible serving with continuous batching and paged attention. Best for Intel hardware." -> "OpenVINO GenAI è la storia ottimizzata Intel per CPU Xeon, GPU Arc, Core Ultra e NPU. Offre servizio compatibile con OpenAI con batching continuo e attenzione paginata. Ideale per hardware Intel."

"LMDeploy is a CUDA-focused toolkit with TurboMind for performance and PyTorch for accessibility. Most interesting for CUDA users who want an alternative to vLLM/SGLang/TensorRT-LLM." -> "LMDeploy è un toolkit focalizzato su CUDA con TurboMind per le performance e PyTorch per l'accessibilità. Più interessante per utenti CUDA che vogliono un'alternativa a vLLM/SGLang/TensorRT-LLM."

"NVIDIA Dynamo is a distributed orchestration layer above engines like vLLM, SGLang, and TensorRT-LLM, supporting disaggregation, intelligent routing, and multi-tier KV caching. Use it when single-engine serving is no longer enough." -> "NVIDIA Dynamo è un livello di orchestrazione distribuita sopra motori come vLLM, SGLang e TensorRT-LLM, che supporta disaggregazione, routing intelligente e caching KV a più livelli. Usalo quando il servizio con un singolo motore non è più sufficiente."

"Note: DO NOT USE Ollama." -> "Nota: NON USARE Ollama."

Hardware strategy recipes

"CPU-only server: llama.cpp first. OpenVINO for Intel Xeon. ONNX Runtime GenAI for app/ONNX deployment." -> "Server solo CPU: llama.cpp prima. OpenVINO per Intel Xeon. ONNX Runtime GenAI per deployment di app/ONNX."

"MacBook / Mac Studio: MLX / MLX-LM for Mac-native workflows. llama.cpp for GGUF portability." -> "MacBook / Mac Studio: MLX / MLX-LM per flussi di lavoro nativi Mac. llama.cpp per portabilità GGUF."

"Single RTX 3090 / 4090 / 5090: ExLlamaV2 for EXL2 local inference. llama.cpp for GGUF or portability. vLLM if serving multiple users." -> "Singola RTX 3090 / 4090 / 5090: ExLlamaV2 per inferenza locale EXL2. llama.cpp per GGUF o portabilità. vLLM se si servono più utenti."

"Dual or quad consumer RTX box: ExLlamaV3 for multi-GPU quantized inference or MoE. vLLM if serving behavior matters. SGLang if testing routing or long-context patterns." -> "Scatola con doppia o quadrupla RTX consumer: ExLlamaV3 per inferenza quantizzata multi-GPU o MoE. vLLM se il comportamento di servizio conta. SGLang se si testano pattern di routing o contesto lungo."

"8×H100 / H200 node: Start with vLLM or SGLang. Benchmark TensorRT-LLM if NVIDIA-only and performance justifies tuning. Use Dynamo when multi-node orchestration becomes necessary." -> "Nodo 8×H100 / H200: inizia con vLLM o SGLang. Benchmark TensorRT-LLM se solo NVIDIA e le performance giustificano l'ottimizzazione. Usa Dynamo quando l'orchestrazione multi-nodo diventa necessaria."

"B200 / GB200 / GB300-class infrastructure: Benchmark TensorRT-LLM, SGLang, and vLLM. Add Dynamo for fleet-level orchestration, KV-aware routing, and autoscaling." -> "Infrastruttura di classe B200 / GB200 / GB300: benchmark TensorRT-LLM, SGLang e vLLM. Aggiungi Dynamo per orchestrazione a livello di flotta, routing consapevole della cache KV e autoscaling."

"AMD MI300 / MI325 / MI350 / MI355: Start with vLLM or SGLang on ROCm. Avoid assuming NVIDIA benchmarks transfer cleanly." -> "AMD MI300 / MI325 / MI350 / MI355: inizia con vLLM o SGLang su ROCm. Evita di presumere che i benchmark NVIDIA si trasferiscano pulitamente."

"Intel Xeon / Core Ultra / Arc: OpenVINO GenAI or OpenVINO Model Server. ONNX Runtime GenAI if app embedding matters." -> "Intel Xeon / Core Ultra / Arc: OpenVINO GenAI o OpenVINO Model Server. ONNX Runtime GenAI se l'incorporamento nell'app conta."

"Browser, mobile, app-native: MLC LLM / WebLLM or ONNX Runtime GenAI." -> "Browser, mobile, nativo app: MLC LLM / WebLLM o ONNX Runtime GenAI."

Benchmarking: what to measure

"Bad benchmark: "I got 180 tok/s."" -> "Benchmark scadente: 'Ho ottenuto 180 tok/s.'"

"Good benchmark includes:" -> "Un buon benchmark include:"

"Model: exact model, architecture, parameter count, active MoE params." -> "Modello: modello esatto, architettura, conteggio parametri, parametri MoE attivi."

"Weights: dtype, quant format, group size, calibration." -> "Pesi: dtype, formato di quantizzazione, dimensione del gruppo, calibrazione."

"Engine: version, commit, backend, flags." -> "Motore: versione, commit, backend, flag."

"Hardware: GPU SKU, memory capacity, bandwidth, interconnect, CPU, RAM." -> "Hardware: SKU GPU, capacità di memoria, larghezza di banda, interconnessione, CPU, RAM."

"Workload: input/output length distributions, concurrency, streaming, shared prefixes, structured output." -> "Carico di lavoro: distribuzioni di lunghezza input/output, concorrenza, streaming, prefissi condivisi, output strutturato."

"Metrics: TTFT, TPOT, end-to-end latency, p50/p95/p99, tokens per second, requests per second, GPU memory usage, KV cache hit rate, prefill throughput, decode throughput, cost per 1M tokens." -> "Metriche: TTFT, TPOT, latenza end-to-end, p50/p95/p99, token al secondo, richieste al secondo, utilizzo memoria GPU, tasso di hit cache KV, throughput prefill, throughput decode, costo per 1M token."

"Benchmarking Rules:" -> "Regole di benchmarking:"

"1. Never compare engines using only single-user tokens per second." -> "1. Non confrontare mai motori usando solo token al secondo per singolo utente."

"2. Test your actual prompt and output distribution." -> "2. Testa la tua distribuzione effettiva di prompt e output."

"3. Test with realistic concurrency." -> "3. Testa con concorrenza realistica."

"4. Separate prefill from decode." -> "4. Separa prefill da decode."

"5. Track p95 and p99, not only averages." -> "5. Tieni traccia di p95 e p99, non solo medie."

"6. Measure memory headroom at target context length." -> "6. Misura il margine di memoria alla lunghezza del contesto target."

"7. Test cache reuse if your app has repeated prefixes." -> "7. Testa il riutilizzo della cache se la tua app ha prefissi ripetuti."

"8. Benchmark structured output separately; grammar adds overhead." -> "8. Fai benchmark dell'output strutturato separatamente; la grammatica aggiunge overhead."

"9. Benchmark LoRA and multi-LoRA separately." -> "9. Fai benchmark di LoRA e multi-LoRA separatamente."

"10. Re-test after driver, CUDA, ROCm, model, or engine upgrades." -> "10. Ritesta dopo aggiornamenti di driver, CUDA, ROCm, modello o motore."

Common mistakes

"Choosing by VRAM capacity alone. VRAM determines fit. Bandwidth and scheduler determine speed. A large unified-memory machine can fit huge models, but an H100 decodes faster when the model fits due to much higher HBM bandwidth." -> "Scegliere solo in base alla capacità della VRAM. La VRAM determina l'adattamento. La larghezza di banda e lo scheduler determinano la velocità. Una macchina con grande memoria unificata può contenere modelli enormi, ma un H100 decodifica più velocemente quando il modello entra a causa della larghezza di banda HBM molto più alta."

"Using tensor parallelism on weak interconnect. Without NVLink or NVSwitch, test pipeline parallelism. vLLM's docs call this out for L40S-like setups." -> "Usare il parallelismo tensoriale su interconnessione debole. Senza NVLink o NVSwitch, testa il parallelismo pipeline. I documenti di vLLM lo sottolineano per configurazioni simili a L40S."

"Ignoring KV cache. Long context and concurrency can make KV cache the limiting factor. PagedAttention, prefix caching, KV quantization, and disaggregation are not optional at scale." -> "Ignorare la cache KV. Contesto lungo e concorrenza possono rendere la cache KV il fattore limitante. PagedAttention, caching dei prefissi, quantizzazione KV e disaggregazione non sono opzionali su larga scala."

"Treating local engines as production servers. llama.cpp server is capable. MLX-LM server is convenient. Ollama is pleasant yet SHOULD NOT BE USED." -> "Trattare i motori locali come server di produzione. Il server llama.cpp è capace. Il server MLX-LM è comodo. Ollama è piacevole ma NON DOVREBBE ESSERE USATO."

"However, production means security, observability, backpressure, routing, autoscaling, and SLA behavior. MLX-LM itself warns that its server is not recommended for production." -> "Tuttavia, produzione significa sicurezza, osservabilità, backpressure, routing, autoscaling e comportamento SLA. MLX-LM stesso avverte che il suo server non è raccomandato per la produzione."

"Assuming every quantization format is portable. GGUF, EXL2, EXL3, AWQ, GPTQ, FP8, FP4, MLX formats, and ONNX are not interchangeable. The right format is the one your engine has optimized kernels for." -> "Presumere che ogni formato di quantizzazione sia portatile. GGUF, EXL2, EXL3, AWQ, GPTQ, FP8, FP4, formati MLX e ONNX non sono intercambiabili. Il formato giusto è quello per cui il tuo motore ha kernel ottimizzati."

"Ignoring model architecture. Dense models, MoE, hybrid attention, multimodal models, and long-context variants stress different parts of the engine. Broad support does not mean every optimization works equally." -> "Ignorare l'architettura del modello. Modelli densi, MoE, attenzione ibrida, modelli multimodali e varianti a contesto lungo sollecitano diverse parti del motore. Un supporto ampio non significa che ogni ottimizzazione funzioni allo stesso modo."

"Trusting benchmark charts without workload shape. A chart for Llama 3.1 8B at 1K input / 128 output says little about a coding agent with 80K context running on Qwen 3.6 27B / Gemma 4 26B-A4B, or a RAG service with 500 concurrent users." -> "Fidarsi dei grafici di benchmark senza la forma del carico di lavoro. Un grafico per Llama 3.1 8B con input 1K / output 128 dice poco su un agente di codifica con contesto 80K in esecuzione su Qwen 3.6 27B / Gemma 4 26B-A4B, o un servizio RAG con 500 utenti concorrenti."

The opinionated final map

"Local AI user: LM Studio or Harbor for convenience. llama.cpp for control. MLX on Mac. ExLlamaV2/V3 for CUDA local performance." -> "Utente AI locale: LM Studio o Harbor per comodità. llama.cpp per controllo. MLX su Mac. ExLlamaV2/V3 per performance CUDA locali."

"Building a local agent: Any should work, but given what most people use; llama.cpp for portability. MLX if users are on Apple Silicon. vLLM if simulating production serving locally." -> "Costruire un agente locale: qualsiasi dovrebbe funzionare, ma dato ciò che la maggior parte usa; llama.cpp per portabilità. MLX se gli utenti sono su Apple Silicon. vLLM se si simula il servizio di produzione localmente."

"Serving an internal team: Start with vLLM. Use SGLang if structured outputs, long context, multi-LoRA, MoE, or routing matter." -> "Servire un team interno: inizia con vLLM. Usa SGLang se output strutturati, contesto lungo, multi-LoRA, MoE o routing contano."

"Serving customers at scale: Benchmark vLLM, SGLang, and TensorRT-LLM. If routing and disaggregation matter, SGLang and Dynamo deserve attention." -> "Servire clienti su larga scala: benchmark vLLM, SGLang e TensorRT-LLM. Se routing e disaggregazione contano, SGLang e Dynamo meritano attenzione."

"NVIDIA datacenter: TensorRT-LLM for max performance. vLLM for flexibility. SGLang for complex serving. Dynamo for fleet orchestration." -> "Datacenter NVIDIA: TensorRT-LLM per massime performance. vLLM per flessibilità. SGLang per servizio complesso. Dynamo per orchestrazione flotta."

"Apple Silicon: MLX for native development. llama.cpp for GGUF. Unified memory is a capacity superpower with bandwidth tradeoffs, not HBM." -> "Apple Silicon: MLX per sviluppo nativo. llama.cpp per GGUF. La memoria unificata è un superpotere di capacità con compromessi di larghezza di banda, non HBM."

"Edge, app, browser, or Windows-native: llama.cpp, MLC LLM, ONNX Runtime GenAI, or OpenVINO, depending on stack." -> "Edge, app, browser o nativo Windows: llama.cpp, MLC LLM, ONNX Runtime GenAI o OpenVINO, a seconda dello stack."

Final principle

"Inference Engines have consequences." -> "I motori di inferenza hanno conseguenze."

"Pick the engine after answering these:" -> "Scegli il motore dopo aver risposto a queste domande:"

List of questions (translate each):

1. "What hardware do I actually have?" -> "Che hardware ho effettivamente?"
2. "Does the model fit in fast memory, or only in system/unified memory?" -> "Il modello entra nella memoria veloce o solo nella memoria di sistema/unificata?"
3. "Is decode or prefill the bottleneck?" -> "Il decode o il prefill è il collo di bottiglia?"
4. "What context length and concurrency matter?" -> "Quale lunghezza del contesto e concorrenza contano?"
5. "Are prompts shared enough for prefix caching?" -> "I prompt sono abbastanza condivisi per il caching dei prefissi?"
6. "Is the model dense, MoE, multimodal, or hybrid?" -> "Il modello è denso, MoE, multimodale o ibrido?"
7. "Do I need local convenience, production serving, or fleet orchestration?" -> "Ho bisogno di comodità locale, servizio di produzione o orchestrazione di flotta?"
8. "What quantization format has optimized kernels on my target engine?" -> "Quale formato di quantizzazione ha kernel ottimizzati sul mio motore target?"
9. "Is my interconnect PCIe, NVLink, NVSwitch, Ethernet, RDMA, or Thunderbolt?" -> "La mia interconnessione è PCIe, NVLink, NVSwitch, Ethernet, RDMA o Thunderbolt?"
10. "Am I optimizing latency, throughput, cost, privacy, portability, or developer speed?" -> "Sto ottimizzando latenza, throughput, costo, privacy, portabilità o velocità di sviluppo?"

"The engine follows the answers." -> "Il motore segue le risposte."

"Until next time." -> "Alla prossima."

"-Ahmad" -> keep as is.

Now combine all translated sections. Ensure proper spacing, blank lines between paragraphs, and preserve markdown formatting. Also ensure payload-block tags are exactly as original.

One note: In the original, there are some English terms like "attention kernels", "grouped GEMMs", etc. I kept them as is since they are technical terms. Also note "MoE" remains as MoE. "KV cache" remains. "token" remains. "LLM" remains. Also "GGUF", "EXL2", "EXL3", "AWQ", "GPTQ", "FP8", etc. remain.

Also note: In the list under "Benchmarking: what to measure", the items are not numbered in markdown but each line starts with "Model:", "Weights:", etc. I'll translate the label part but keep the colon.

Also the list of common mistakes: each item is a paragraph, but in the original they are separated by blank lines? Actually they are listed with a dash? No, it's just paragraphs. I'll keep as paragraphs.

Let me write the complete translated text.</think><blockquote>

<p>Non si sceglie prima un motore di inferenza. Si sceglie una strategia hardware, una forma del carico di lavoro e un modello di servizio. Il motore segue.</p>

</blockquote>

Questo è il modo più utile di pensare ai motori di inferenza LLM.

Nota della serie: questa è la Parte 3 della mia serie sull'insegnamento degli LLM auto-ospitati / AI locale.

• Parte 1: Matematica della memoria GPU per LLM (Edizione 2026).
• Parte 2: Larghezza di banda della memoria per hardware AI locale (Edizione 2026).

Quei due articoli spiegano la matematica della capacità hardware e della larghezza di banda.

Questo spiega il livello software che trasforma quell'hardware in inferenza utilizzabile.

Engines

Questi strumenti servono a scopi diversi / occupano diversi livelli

• Portabilità locale
• CUDA consumer
• Flussi di lavoro con memoria unificata Apple
• Inferenza quantizzata
• Servizio di produzione
• Orchestrazione distribuita
• Esecuzione ottimizzata per datacenter del fornitore

Un modello mentale utile:

Il motore di inferenza non è "il modello". È il vigile del traffico, il gestore della memoria, lo smistatore del kernel, lo scheduler, il contabile della cache, il pianificatore del parallelismo, la superficie API e talvolta il framework di deployment.

Il motore migliore corrisponde alla tua gerarchia di memoria, interconnessione, formato di quantizzazione, obiettivi di latenza e throughput, architettura del modello e maturità operativa.

La guida decisionale in una pagina

• Laptop / edge / hardware strano → llama.cpp
• Flussi di lavoro principalmente su Mac → MLX / MLX-LM
• Inferenza locale su singola RTX → ExLlamaV2
• 2-4+ GPU NVIDIA / CUDA → ExLlamaV3
• Servizio di produzione generale → vLLM
• Contesto lungo / MoE / routing → SGLang
• Massima performance NVIDIA → TensorRT-LLM
• Orchestrazione cluster → NVIDIA Dynamo

Il resto di questa guida spiega perché.

Cosa fa effettivamente un motore di inferenza

Un motore di inferenza carica i pesi, tokenizza l'input, esegue il forward pass, campiona i token, mantiene la cache KV e invia i risultati in streaming. I motori seri gestiscono anche batching, scheduling, caching dei prefissi, quantizzazione, esecuzione parallela, servizio API, metriche ed esecuzione distribuita.

Il carico di lavoro ha due fasi:

Prefill legge il prompt e costruisce la cache KV iniziale. È intensivo dal punto di vista computazionale.

Decode genera un token alla volta, leggendo ripetutamente pesi e cache KV. È limitato dalla larghezza di banda della memoria. La velocità di decode segue la larghezza di banda della memoria più del picco di calcolo.

Questa distinzione spiega quasi tutto:

• Prompt breve, risposta lunga: decode domina → larghezza di banda della memoria e batching contano.
• Prompt lungo, risposta breve: prefill domina → kernel di attenzione e prefill a blocchi contano.
• Molti utenti: la qualità dello scheduler conta → batching continuo, paginazione della cache, equità.
• Contesto lungo: cache KV domina → attenzione paginata, quantizzazione KV, offload.
• MoE: routing degli esperti domina → parallelismo degli esperti, interconnessione, GEMM raggruppati.
• Multi-nodo: interconnessione domina → NVLink, RDMA, parallelismo pipeline, disaggregazione.

PagedAttention ha affrontato la frammentazione della cache KV. FlashAttention ha utilizzato il tiling consapevole dell'I/O per ridurre il traffico HBM (High Bandwidth Memory). Il decoding speculativo abbozza token economici e li verifica in parallelo. Il tema ricorrente: le performance di inferenza sono movimento della memoria più scheduling.

I veri colli di bottiglia

1. Larghezza di banda della memoria, non solo dimensione della VRAM. La VRAM determina l'adattamento. La larghezza di banda determina la velocità di decode. L'M3 Ultra di Apple offre fino a 819 GB/s di larghezza di banda della memoria unificata. L'H100 SXM di NVIDIA elenca 3,35 TB/s di larghezza di banda della memoria GPU. La memoria unificata ti permette di far entrare modelli che non entrerebbero nella VRAM consumer. L'HBM ti permette di servirli più velocemente quando il modello ci sta. L'adattamento non è velocità. La capacità non è larghezza di banda.

1. Crescita della cache KV. La cache KV cresce con la dimensione del batch e la lunghezza del contesto. I carichi di lavoro con contesto lungo possono esaurire la memoria anche quando i pesi ci stanno. PagedAttention partiziona la cache KV in blocchi, aumentando l'utilizzo e supportando batch più grandi.

1. Interconnessione. Nel momento in cui un modello attraversa i confini della GPU (multi-GPU), si paga un costo di comunicazione. Il parallelismo tensoriale necessita di frequenti collettive all-reduce. Il parallelismo pipeline comunica ai confini degli stadi. Il parallelismo esperto necessita di traffico all-to-all per MoE. I documenti di vLLM notano che senza NVLink, il parallelismo pipeline può superare il parallelismo tensoriale.

1. Qualità dello scheduler. Un buon scheduler decide quali richieste entrano nel batch, come prefill e decode condividono l'acceleratore, se i prompt lunghi bloccano i decode brevi e come evitare la starvation. Supportare il batching non equivale a comportarsi come uno scheduler pronto per la produzione.

1. Overhead del runtime. I grafici CUDA, la fusione dei kernel, l'overhead del campionamento, l'overhead del tokenizer, l'overhead HTTP, il passaggio LoRA e il decoding strutturato sono tutti importanti. A grande scala, i fastidiosi overhead del 2% formano un'unione e richiedono attenzione (senza gioco di parole intenzionale).

Le famiglie di motori

Ci sono quattro grandi famiglie:

Runtime locali portatili: llama.cpp, MLC LLM, ONNX Runtime GenAI, OpenVINO, strumenti tipo Ollama. Questi si preoccupano di "farlo funzionare qui".

Runtime Apple/memoria unificata: MLX e MLX-LM. Questi si preoccupano di "usare bene la grande memoria condivisa e lo stack Apple".

Motori di quantizzazione CUDA consumer: ExLlamaV2 ed ExLlamaV3. Questi si preoccupano di "far urlare la mia scatola 3090/4090/5090 con pesi a bassi bit".

Motori di servizio di produzione: vLLM, SGLang, TensorRT-LLM, TGI, LMDeploy. Questi si preoccupano di utenti concorrenti, cache KV, batching, parallelismo, osservabilità e costo per token.

Poi ci sono livelli di orchestrazione come Dynamo che si trovano sopra i motori e coordinano flotte, prefill/decode disaggregati, routing e autoscaling.

llama.cpp: il re della portabilità

llama.cpp è la risposta quando l'hardware è strano, limitato, offline, pesante sulla CPU, orientato all'edge o non è un ordinato nodo datacenter NVIDIA.

Supporta Apple Silicon tramite ARM NEON, Accelerate e Metal; x86 tramite AVX/AVX2/AVX512/AMX; RISC-V; quantizzazione a bassi bit; CUDA; AMD tramite HIP; MUSA; Vulkan; SYCL; e offload ibrido CPU+GPU. Ecco perché llama.cpp possiede la corsia "fai funzionare e basta".

Il server HTTP è più capace di un "giocattolo per esecuzione locale". llama-server fornisce route compatibili con OpenAI, compatibilità con API Anthropic Messages, reranking, batching continuo, supporto multimodale, vincoli di schema JSON, chiamata di funzioni, decoding speculativo e un'interfaccia web.

La limitazione critica: llama.cpp non è per un serio servizio di produzione multi-nodo. Il suo backend RPC è esplicitamente documentato come proof-of-concept, fragile e insicuro.

Verdetto: usa llama.cpp quando portabilità, funzionamento offline, GGUF o offload ibrido contano più del servizio su scala di flotta.

NON usare con Multi-GPU

MLX e MLX-LM: l'arma Apple Silicon

MLX è il framework di array di Apple per Apple Silicon, e MLX-LM è il pacchetto LLM costruito su di esso. È uno stack ML principalmente per Mac.

Il dato hardware chiave è la memoria unificata. Apple Silicon dà alla CPU e alla GPU accesso diretto allo stesso pool di memoria. Gli array MLX vivono nella memoria unificata e scegli il dispositivo quando esegui l'operazione, invece di spostare array tra spazi di memoria separati.

Questo cambia il compromesso dell'inferenza locale. Su un sistema GPU discreta, la domanda è "ci sta nella VRAM?" Su un Mac della serie M con grande memoria unificata, la domanda diventa "ci sta in memoria e il sistema di memoria può alimentare la GPU abbastanza velocemente?" Modelli grandi quantizzati possono entrare in macchine dove lo stesso modello sarebbe impossibile su una GPU consumer da 24 GB.

Tuttavia, è anche più lento.

MLX-LM aggiunge integrazione con Hugging Face Hub, quantizzazione, LoRA e full fine-tuning, inferenza distribuita e un grande ecosistema di modelli della community MLX. MLX non è più solo per Mac: offre pacchetti CUDA e solo CPU per Linux. La comunicazione distribuita supporta MPI, Ring over TCP, JACCL per RDMA su Thunderbolt e NCCL per CUDA.

Il server di MLX-LM stesso avverte che non è raccomandato per la produzione perché implementa solo controlli di sicurezza di base.

Verdetto: usa MLX per flussi di lavoro ML e LLM principalmente su Mac. Per servizio pubblico ad alta concorrenza, inizia con uno stack di servizio reale.

ExLlamaV2 e V3: CUDA consumer, ottimizzati e veloci

ExLlamaV2 è il motore di quantizzazione CUDA locale per persone che vogliono che una GPU NVIDIA consumer dia il meglio di sé. Supporta attenzione paginata, batching dinamico, caching dei prompt, deduplicazione cache KV, generazione in batch, streaming e decoding speculativo. La parola da ricordare è locale. Rende veloci i modelli quantizzati sulle GPU CUDA moderne, specialmente le schede consumer.

Migliori adattamenti: una scatola con RTX 3090/4090/5090, assistente di codifica locale, chat locale, modelli quantizzati EXL2 e uso workstation prosumer.

ExLlamaV3 estende la filosofia verso l'inferenza multi-GPU e MoE locale. Aggiunge il formato di quantizzazione EXL3 basato su QTIP, inferenza flessibile con parallelismo tensoriale e parallelismo esperto per hardware consumer, un server compatibile con OpenAI tramite TabbyAPI, batching dinamico continuo e supporto multimodale.

V3 è interessante quando hai 2-4+ GPU NVIDIA consumer o vuoi MoE locale. Aspettati avvertenze: alcuni modelli non supportano il parallelismo tensoriale o esperto in ExLlamaV3.

Verdetto: ExLlamaV2 è il motore CUDA locale per appassionati. ExLlamaV3 è la frontiera per configurazioni locali multi-GPU (2-4). Aspettati spigoli più vivi per capacità migliori.

vLLM: il server di produzione open-source predefinito

vLLM è il primo motore che la maggior parte dei team dovrebbe valutare per un serio servizio LLM open-source.

Offre gestione della memoria KV basata su PagedAttention, batching continuo, prefill a blocchi, caching dei prefissi, grafici CUDA/HIP, ampia quantizzazione (FP8, MXFP8/MXFP4, NVFP4, INT8, INT4, GPTQ, AWQ, GGUF), kernel ottimizzati di attenzione e GEMM/MoE, decoding speculativo, torch.compile e prefill/decode/encode disaggregati.

È anche flessibile: parallelismo tensoriale/pipeline/dati/esperti/contesto, streaming, output strutturati, chiamata di strumenti, API compatibili con OpenAI e Anthropic Messages, gRPC, multi-LoRA e supporto per CPU NVIDIA, AMD, x86/ARM/PowerPC, più plugin per TPU, Gaudi, Ascend, Apple Silicon e altro.

I documenti di vLLM notano che i deployment multi-nodo usano tipicamente Ray e senza NVLink, il parallelismo pipeline può battere il parallelismo tensoriale. La trappola è presumere che vLLM elimini la necessità di pensiero sistemico. Devi ancora ottimizzare batching, lunghezza del contesto, utilizzo della memoria GPU, layout del parallelismo e routing. vLLM ti dà un motore molto buono; richiede ancora un buon System Design.

Verdetto: se qualcuno dice "dobbiamo servire modelli aperti in produzione", vLLM è il punto di partenza predefinito.

SGLang: il cugino incentrato sui sistemi di vLLM

SGLang è ciò a cui ricorri quando il carico di lavoro di servizio è brutto: output strutturati, contesto lungo, MoE, disaggregazione e routing.

Offre caching dei prefissi RadixAttention, disaggregazione prefill-decode, decoding speculativo, batching continuo, attenzione paginata, parallelismo tensoriale/pipeline/esperti/dati, output strutturati, prefill a blocchi e batching multi-LoRA. Supporta NVIDIA, AMD, Intel Xeon, TPU Google, NPU Ascend e altro.

Il fattore differenziante di SGLang è l'architettura di servizio. La sua disaggregazione prefill-decode separa il prefill intensivo dal decode intensivo in istanze specializzate, trasferendo la cache KV tra di esse. Questo impedisce ai batch di prefill lunghi di interrompere il decode e far impennare la latenza dei token.

Verdetto: SGLang è per team il cui collo di bottiglia non è più "riusciamo a eseguire il modello?" ma "riusciamo a eseguirlo sotto traffico ostile senza bruciare latenza, memoria e costo?"

TensorRT-LLM: massima performance NVIDIA

TensorRT-LLM è lo stack di massima performance NVIDIA. È ottimizzato, specializzato, potente e non finge di essere portatile.

Fornisce API Python per costruire motori TensorRT con ottimizzazioni all'avanguardia, più runtime Python e C++. Include kernel personalizzati per attenzione, GEMM e MoE; disaggregazione prefill-decode, Wide Expert Parallelism, decoding speculativo; e un'API Python di alto livello integrata con NVIDIA Dynamo e Triton Inference Server.

Le GPU B200 possono caricare pesi FP4 con kernel ottimizzati. H100 e successive supportano la quantizzazione FP8 che può raddoppiare le performance e dimezzare il consumo di memoria rispetto a 16 bit con minima perdita di accuratezza.

Dove brilla: flotte di classe H100/H200/B200/GB200/GB300, datacenter solo NVIDIA, deployment FP8/FP4, servizio multi-nodo e MoE su larga scala. Dove è scomodo: portabilità AMD, Apple o Intel; modelli sperimentali in rapido cambiamento; piccole configurazioni locali; e team che hanno bisogno di "funziona su tutto".

Verdetto: se sei impegnato con NVIDIA e tieni alle performance assolute, TensorRT-LLM merita di essere nella competizione. Scambi portabilità per performance. Specializzazione ottimizzata ma meno funzionalità.

Il resto del panorama

TGI è il server di produzione di Hugging Face con tracing, metriche, parallelismo tensoriale e batching continuo. Usalo quando l'integrazione con HF e la semplicità contano.

MLC LLM è il motore di deployment universale incentrato sul compilatore con API compatibili con OpenAI su REST, Python, JavaScript, iOS e Android. Ideale per "distribuire LLM ovunque", specialmente browser, app mobili e native.

ONNX Runtime GenAI implementa il ciclo generativo completo su ONNX Runtime e alimenta Foundry Local, Windows ML e il VS Code AI Toolkit. Supporta CPU, CUDA, DirectML, TensorRT-RTX, OpenVINO, QNN, WebGPU e GPU AMD. Ideale per deployment di app e flussi di lavoro ONNX.

OpenVINO GenAI è la storia ottimizzata Intel per CPU Xeon, GPU Arc, Core Ultra e NPU. Offre servizio compatibile con OpenAI con batching continuo e attenzione paginata. Ideale per hardware Intel.

LMDeploy è un toolkit focalizzato su CUDA con TurboMind per le performance e PyTorch per l'accessibilità. Più interessante per utenti CUDA che vogliono un'alternativa a vLLM/SGLang/TensorRT-LLM.

NVIDIA Dynamo è un livello di orchestrazione distribuita sopra motori come vLLM, SGLang e TensorRT-LLM, che supporta disaggregazione, routing intelligente e caching KV a più livelli. Usalo quando il servizio con un singolo motore non è più sufficiente.

Nota: NON USARE Ollama.

Ricette per strategie hardware

Server solo CPU: llama.cpp prima. OpenVINO per Intel Xeon. ONNX Runtime GenAI per deployment di app/ONNX.

MacBook / Mac Studio: MLX / MLX-LM per flussi di lavoro nativi Mac. llama.cpp per portabilità GGUF.

Singola RTX 3090 / 4090 / 5090: ExLlamaV2 per inferenza locale EXL2. llama.cpp per GGUF o portabilità. vLLM se si servono più utenti.

Scatola con doppia o quadrupla RTX consumer: ExLlamaV3 per inferenza quantizzata multi-GPU o MoE. vLLM se il comportamento di servizio conta. SGLang se si testano pattern di routing o contesto lungo.

Nodo 8×H100 / H200: inizia con vLLM o SGLang. Benchmark TensorRT-LLM se solo NVIDIA e le performance giustificano l'ottimizzazione. Usa Dynamo quando l'orchestrazione multi-nodo diventa necessaria.

Infrastruttura di classe B200 / GB200 / GB300: benchmark TensorRT-LLM, SGLang e vLLM. Aggiungi Dynamo per orchestrazione a livello di flotta, routing consapevole della cache KV e autoscaling.

AMD MI300 / MI325 / MI350 / MI355: inizia con vLLM o SGLang su ROCm. Evita di presumere che i benchmark NVIDIA si trasferiscano pulitamente.

Intel Xeon / Core Ultra / Arc: OpenVINO GenAI o OpenVINO Model Server. ONNX Runtime GenAI se l'incorporamento nell'app conta.

Browser, mobile, nativo app: MLC LLM / WebLLM o ONNX Runtime GenAI.

Benchmarking: cosa misurare

Benchmark scadente: "Ho ottenuto 180 tok/s."

Un buon benchmark include:

Modello: modello esatto, architettura, conteggio parametri, parametri MoE attivi.

Pesi: dtype, formato di quantizzazione, dimensione del gruppo, calibrazione.

Motore: versione, commit, backend, flag.

Hardware: SKU GPU, capacità di memoria, larghezza di banda, interconnessione, CPU, RAM.

Carico di lavoro: distribuzioni di lunghezza input/output, concorrenza, streaming, prefissi condivisi, output strutturato.

Metriche: TTFT, TPOT, latenza end-to-end, p50/p95/p99, token al secondo, richieste al secondo, utilizzo memoria GPU, tasso di hit cache KV, throughput prefill, throughput decode, costo per 1M token.

Regole di benchmarking:

1. Non confrontare mai motori usando solo token al secondo per singolo utente.
2. Testa la tua distribuzione effettiva di prompt e output.
3. Testa con concorrenza realistica.
4. Separa prefill da decode.
5. Tieni traccia di p95 e p99, non solo medie.
6. Misura il margine di memoria alla lunghezza del contesto target.
7. Testa il riutilizzo della cache se la tua app ha prefissi ripetuti.
8. Fai benchmark dell'output strutturato separatamente; la grammatica aggiunge overhead.
9. Fai benchmark di LoRA e multi-LoRA separatamente.
10. Ritesta dopo aggiornamenti di driver, CUDA, ROCm, modello o motore.

Errori comuni

Scegliere solo in base alla capacità della VRAM. La VRAM determina l'adattamento. La larghezza di banda e lo scheduler determinano la velocità. Una macchina con grande memoria unificata può contenere modelli enormi, ma un H100 decodifica più velocemente quando il modello entra a causa della larghezza di banda HBM molto più alta.

Usare il parallelismo tensoriale su interconnessione debole. Senza NVLink o NVSwitch, testa il parallelismo pipeline. I documenti di vLLM lo sottolineano per configurazioni simili a L40S.

Ignorare la cache KV. Contesto lungo e concorrenza possono rendere la cache KV il fattore limitante. PagedAttention, caching dei prefissi, quantizzazione KV e disaggregazione non sono opzionali su larga scala.

Trattare i motori locali come server di produzione. Il server llama.cpp è capace. Il server MLX-LM è comodo. Ollama è piacevole ma NON DOVREBBE ESSERE USATO.

Tuttavia, produzione significa sicurezza, osservabilità, backpressure, routing, autoscaling e comportamento SLA. MLX-LM stesso avverte che il suo server non è raccomandato per la produzione.

Presumere che ogni formato di quantizzazione sia portatile. GGUF, EXL2, EXL3, AWQ, GPTQ, FP8, FP4, formati MLX e ONNX non sono intercambiabili. Il formato giusto è quello per cui il tuo motore ha kernel ottimizzati.

Ignorare l'architettura del modello. Modelli densi, MoE, attenzione ibrida, modelli multimodali e varianti a contesto lungo sollecitano diverse parti del motore. Un supporto ampio non significa che ogni ottimizzazione funzioni allo stesso modo.

Fidarsi dei grafici di benchmark senza la forma del carico di lavoro. Un grafico per Llama 3.1 8B con input 1K / output 128 dice poco su un agente di codifica con contesto 80K in esecuzione su Qwen 3.6 27B / Gemma 4 26B-A4B, o un servizio RAG con 500 utenti concorrenti.

La mappa finale opinata

Utente AI locale: LM Studio o Harbor per comodità. llama.cpp per controllo. MLX su Mac. ExLlamaV2/V3 per performance CUDA locali.

Costruire un agente locale: qualsiasi dovrebbe funzionare, ma dato ciò che la maggior parte usa; llama.cpp per portabilità. MLX se gli utenti sono su Apple Silicon. vLLM se si simula il servizio di produzione localmente.

Servire un team interno: inizia con vLLM. Usa SGLang se output strutturati, contesto lungo, multi-LoRA, MoE o routing contano.

Servire clienti su larga scala: benchmark vLLM, SGLang e TensorRT-LLM. Se routing e disaggregazione contano, SGLang e Dynamo meritano attenzione.

Datacenter NVIDIA: TensorRT-LLM per massime performance. vLLM per flessibilità. SGLang per servizio complesso. Dynamo per orchestrazione flotta.

Apple Silicon: MLX per sviluppo nativo. llama.cpp per GGUF. La memoria unificata è un superpotere di capacità con compromessi di larghezza di banda, non HBM.

Edge, app, browser o nativo Windows: llama.cpp, MLC LLM, ONNX Runtime GenAI o OpenVINO, a seconda dello stack.

Principio finale

I motori di inferenza hanno conseguenze.

Scegli il motore dopo aver risposto a queste domande:

1. Che hardware ho effettivamente?
2. Il modello entra nella memoria veloce o solo nella memoria di sistema/unificata?
3. Il decode o il prefill è il collo di bottiglia?
4. Quale lunghezza del contesto e concorrenza contano?
5. I prompt sono abbastanza condivisi per il caching dei prefissi?
6. Il modello è denso, MoE, multimodale o ibrido?
7. Ho bisogno di comodità locale, servizio di produzione o orchestrazione di flotta?
8. Quale formato di quantizzazione ha kernel ottimizzati sul mio motore target?
9. La mia interconnessione è PCIe, NVLink, NVSwitch, Ethernet, RDMA o Thunderbolt?
10. Sto ottimizzando latenza, throughput, costo, privacy, portabilità o velocità di sviluppo?

Il motore segue le risposte.

Alla prossima.

-Ahmad