LLAMACPP

llama.cpp: Inferență LLM în C++ & Formatul GGUF: comenzi, scurtături și ghid practic

91 de comenzi 9 categorii Comunitate & Q&A AI

llama.cpp este motorul nativ de inferență în limbaj C/C++ dezvoltat de Georgi Gerganov, care stă la baza întregului ecosistem modern de AI local (inclusiv Ollama, LM Studio, Jan și Faraday). Fără dependențe de medii Python greoaie, llama.cpp optimizează execuția tensorilor pe CPU-uri x86/ARM și GPU-uri NVIDIA (CUDA), Apple Silicon (Metal) sau AMD/Intel (Vulkan/SYCL), oferind suport nativ pentru formatul binar GGUF, cuantizări avansate K-quants și eșantionare strictă ghidată prin gramatici GBNF.

⚡ C/C++ Pur Fără Dependențe

Execuție nativă ultra-ușoară cu mapare directă de memorie virtuală (mmap), pornire instantanee sub o secundă și consum minim de resurse de sistem.

📦 Formatul Binar GGUF

Arhitectura binară universală care include metadatele tokenizerului, hiperparametrii și tensorii cuantizați (Q4_K_M, Q8_0, I-quants cu imatrix) într-un singur fișier.

📐 Gramatici Structurate GBNF

Constrângere matematică deterministă la decodificare: modelul este forțat să emită strict JSON valid conform schemelor cerute, valori Enum sau XML fără halucinații sintactice.

🚀 llama-server de Producție

Server HTTP asincron de mare viteză cu suport pentru continuous batching, sloturi concurente paralele și API 100% compatibil OpenAI (/v1/chat/completions).

🚀 Compilare & Instalare Rapidă llama.cpp

Clonați depozitul oficial și compilați binarile pe sistemul dumneavoastră:

# Clonare depozit oficial
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

# Pe Apple Silicon (Metal nativ):
cmake -B build -DGGML_METAL=ON && cmake --build build --config Release -j

# Pe Linux cu NVIDIA GPU (CUDA):
cmake -B build -DGGML_CUDA=ON && cmake --build build --config Release -j $(nproc)

Arhitectura Suportată & Ecosistemul Hardware

Datorită bibliotecii tensoriale de bază GGML, llama.cpp oferă suport pentru zeci de familii de modele deschise: Llama 3, Mistral, Qwen 2.5, DeepSeek-R1 Distill, Gemma 2, Command-R și Phi-3. Suportul hardware include nuclee specializate scrise în asamblor pentru instrucțiuni vectoriale AVX2, AVX-512, ARM NEON, precum și accelerare GPU pe plăci NVIDIA (cuBLAS), Apple Silicon (Metal) și AMD/Intel (Vulkan/SYCL).

Fluxul de Lucru Recomandat în 4 Pași:

Obținere Ponderi GGUF: Descărcați fișierul GGUF gata cuantizat (ex: Q4_K_M) de pe Hugging Face sau convertiți un model Hugging Face prin convert_hf_to_gguf.py.
Rulare Interactivă în Terminal: Folosiți llama-cli -m model.gguf -ngl 99 -ins pentru conversație fluidă în consolă.
Garantare Ieșiri Structurate: Aplicați gramatici formale cu --grammar-file json.gbnf pentru a obține obiecte direct parsabile în aplicații.
Servire în Rețea: Lansați llama-server --host 0.0.0.0 --port 8080 -ngl 99 pentru a conecta orice client compatibil cu API-ul OpenAI.

Indexul Complet al Comenzilor, Instrumentelor și Ghidurilor llama.cpp

Tabelul de mai jos centralizează toate noțiunile, uneltele CLI, algoritmii de eșantionare, opțiunile de cuantizare și parametrii serverului llama.cpp:

Comandă / Utilitar llama.cpp	Descriere Tehnică & Caz de Utilizare
Compilare, Build & Accelerare Hardware
Compilarea Modulară llama.cpp cu CMake `cmake -B build && cmake --build build --config Release -j $(nproc)`	Procedura standard recomandată de compilare pe sistemele Linux și Windows cu generarea binarilor optimizați.
Compilarea Rapidă prin Makefile Clasic `make -j $(nproc)`	Metoda rapidă de compilare pentru medii UNIX fără configurare suplimentară CMake.
Compilarea cu Accelerare NVIDIA CUDA & cuBLAS `cmake -B build -DGGML_CUDA=ON && cmake --build build --config Release -j`	Activarea nucleelor CUDA pentru descărcarea matricilor pe plăci video NVIDIA (GeForce, RTX, Tesla, A100/H100).
Compilarea Nativă Apple Silicon prin Metal (M1, M2, M3, M4) `cmake -B build -DGGML_METAL=ON && cmake --build build --config Release -j`	Optimizarea pentru memoria unificată Apple Silicon, permițând rularea modelelor de 70B direct pe MacBook Pro.
Accelerare Cross-Platform GPU prin Vulkan `cmake -B build -DGGML_VULKAN=ON && cmake --build build --config Release -j`	Soluția ideală pentru GPU-uri AMD Radeon, plăci integrate Intel și configurații non-CUDA.
Accelerare pe GPU-uri Diverse prin CLBlast / OpenCL `cmake -B build -DGGML_CLBLAST=ON && cmake --build build --config Release -j`	Suport pentru hardware moștenit sau acceleratoare care implementează standardul deschis OpenCL.
Compilare pentru Intel Arc & Data Center GPU prin SYCL `cmake -B build -DGGML_SYCL=ON -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx`	Optimizarea inferenței pentru GPU-urile Intel Arc A770 și acceleratoarele Data Center Flex/Max.
Optimizarea Vectorială x86: AVX, AVX2 și AVX-512 `cmake -B build -DGGML_AVX512=ON`	Maximizarea vitezei pe CPU prin utilizarea instrucțiunilor vectoriale paralele AVX-512 și FMA.
Optimizare pentru ARM64 & Raspberry Pi prin NEON `cmake -B build -DGGML_NEON=ON`	Rularea modelelor cuantizate pe plăci de dezvoltare compacte (Raspberry Pi 5, Orange Pi) și servere AWS Graviton.
Ghidul Binarilor din Suita llama.cpp `ls -l ./build/bin/llama-*`	Prezentarea uneltelor principale: llama-cli, llama-server, llama-quantize, llama-bench și llama-embedding.
llama-cli & Parametri Esențiali de Inferență
Încărcarea Fișierului Binar prin Parametrul -m / –model `./llama-cli -m cale/catre/model.gguf`	Comanda fundamentală de specificare a fișierului binar GGUF pentru rularea inferenței.
Transmiterea Instrucțiunii Inițiale prin -p / –prompt `./llama-cli -m model.gguf -p "Instrucțiunea ta aici"`	Furnizarea textului de intrare direct din linia de comandă sau din scripturi Bash automate.
Modul Conversațional Interactiv (-i / –interactive) `./llama-cli -m model.gguf -i --color`	Rularea unei sesiuni continue de dialog în consolă unde modelul așteaptă mesajele utilizatorului.
Pornirea Directă cu Inputul Utilizatorului (-ins / –interactive-first) `./llama-cli -m model.gguf -ins`	Comportamentul stil ChatGPT în consolă: așteaptă primul mesaj al utilizatorului fără a genera text spontan.
Plafonarea Numărului de Tokeni Generați (-n / –predict) `./llama-cli -m model.gguf -n 256`	Limitarea lungimii maxime a generării; valoarea -1 indică generare infinită până la tokenul EOS.
Setarea Ferestrei de Context (-c / –ctx-size) `./llama-cli -m model.gguf -c 4096`	Alocarea dimensiunii memoriei de context KV Cache (ex: 2048, 4096, 8192, 16384 tokeni).
Descărcarea Straturilor pe GPU (-ngl / –n-gpu-layers) `./llama-cli -m model.gguf -ngl 33 # sau -ngl 99 pentru toate`	Cel mai important parametru de performanță: mutarea straturilor Transformer din RAM în memoria plăcii video (VRAM).
Configurarea Firelor de Execuție CPU (-t / –threads) `./llama-cli -m model.gguf -t 8`	Numărul de fire paralele de calcul utilizate de nucleele GGML pe procesor.
Colorarea Mesajelor în Terminal (–color) `./llama-cli -m model.gguf --color`	Distincția vizuală prin culori ANSI între întrebările utilizatorului și răspunsurile generate de model.
Oprirea Generării la Secvențe Specifice (-r / –reverse-prompt) `./llama-cli -m model.gguf -r "Utilizator:" -r "<\|eot_id\|>"`	Definirea șirurilor de oprire care întrerup imediat generarea și redau controlul utilizatorului.
Injectarea Instrucțiunii Globale de Sistem `./llama-cli -m model.gguf -p "<\|start_header_id\|>system<\|end_header_id\|> Ești un expert..."`	Stabilirea personalității, rolului și regulilor de securitate ale asistentului înainte de începerea conversației.
Preluarea Instrucțiunilor pe Mai Multe Rânduri (–multiline-input) `./llama-cli -m model.gguf -i --multiline-input`	Permite inserarea de fragmente mari de cod sau paragrafe cu linii noi fără a declanșa trimiterea la simpla apăsare a tastei Enter.
Eșantionare & Controlul Distribuției (Sampling)
Reglarea Temperaturii de Generare (–temp) `./llama-cli -m model.gguf --temp 0.7`	Scalarea logit-urilor înainte de funcția Softmax pentru controlul varietății și al aleatoriului.
Filtrarea Primilor K Tokeni (–top-k) `./llama-cli -m model.gguf --top-k 40`	Restricționarea eșantionării strict la cei mai probabili K candidați din vocabular.
Eșantionarea de Nucleu Top-P (–top-p) `./llama-cli -m model.gguf --top-p 0.9`	Selectarea dinamică a numărului de tokeni a căror masă de probabilitate cumulată atinge pragul P.
Eșantionarea Adaptivă Min-P (–min-p) `./llama-cli -m model.gguf --min-p 0.05`	Alternativa modernă superioară la Top-P: elimină tokenii a căror probabilitate este sub o fracțiune din probabilitatea celui mai bun token.
Eșantionarea pe Baza Entropiei Tipice (–typical) `./llama-cli -m model.gguf --typical 0.95`	Echilibrarea conținutului informațional prin selecția tokenilor a căror surpriză corespunde entropiei medii a contextului.
Penalizarea Repetițiilor Lexicale (–repeat-penalty) `./llama-cli -m model.gguf --repeat-penalty 1.1`	Reducerea multiplicativă a logit-urilor pentru tokenii care au apărut deja în răspunsul recent.
Fereastra de Memorie pentru Repetiții (–repeat-last-n) `./llama-cli -m model.gguf --repeat-last-n 64`	Câți dintre ultimii tokeni generați sunt monitorizați pentru aplicarea penalizării de repetiție.
Controlul Perplexității cu Algoritmul Mirostat (–mirostat 2) `./llama-cli -m model.gguf --mirostat 2 --mirostat-ent 5.0 --mirostat-lr 0.1`	Controlul dinamic în buclă închisă al entropiei textului pentru eliminarea repetițiilor și a plictiselii stilistice.
Rata de Învățare a Controlerului Mirostat (–mirostat-lr) `./llama-cli -m model.gguf --mirostat 2 --mirostat-lr 0.1`	Viteza cu care controlerul Mirostat reacționează la variațiile de entropie dintre propoziții.
Determinism Matematic prin Seed Aleatoriu (-s / –seed) `./llama-cli -m model.gguf -s 42`	Fixarea generatorului pseudo-aleatoriu pentru reproducerea identică a răspunsurilor la re-rulare.
Formate GGUF, Cuantizări & Imap
Arhitectura și Specificațiile Formatului Binar GGUF `# Format binar cu antet, metadate extensibile cheie-valoare și tensori aliniați`	De ce formatul GGUF a înlocuit GGML: extensibilitate fără breaking changes, mmap rapid și metadate bogate.
Utilizarea Instrumentului de Cuantizare llama-quantize `./llama-quantize model-f16.gguf model-q4_k_m.gguf Q4_K_M`	Binarul de linie de comandă care comprimă fișierele mari f16 în formate cuantizate pe 2, 3, 4, 5, 6 sau 8 biți.
Cuantizarea Recomandată Q4_K_M (K-quants Medium) `./llama-quantize model-f16.gguf model-Q4_K_M.gguf Q4_K_M`	Standardul de aur în industrie: comprimare pe 4 biți cu menținerea straturilor critice de atenție la precizie superioară.
Cuantizarea Compactă Q4_K_S (K-quants Small) `./llama-quantize model-f16.gguf model-Q4_K_S.gguf Q4_K_S`	Varianta ușor mai compactă a formatului Q4_K pentru economie maximă de spațiu.
Cuantizarea de Înaltă Fidelitate pe 5 Biți (Q5_K_M) `./llama-quantize model-f16.gguf model-Q5_K_M.gguf Q5_K_M`	Alegerea optimă pentru sarcini care necesită un plus de precizie matematică și generare de cod fără erori.
Cuantizarea pe 8 Biți Q8_0 cu Fidelitate Identică cu f16 `./llama-quantize model-f16.gguf model-Q8_0.gguf Q8_0`	Formatul de referință pe 8 biți care păstrează comportamentul matematic identic cu modelul necuantizat.
Cuantizarea Extremă pe 2 Biți (Q2_K) `./llama-quantize model-f16.gguf model-Q2_K.gguf Q2_K`	Comprimarea extremă care permite rularea modelelor de 70B pe computere cu doar 24 GB RAM.
Nivelul Intermediar pe 3 Biți (Q3_K_M) `./llama-quantize model-f16.gguf model-Q3_K_M.gguf Q3_K_M`	Compromisul optim între dimensiune redusă și inteligibilitate lingvistică pentru dispozitive mobile.
Familia de Cuantizări I-Quants (IQ2_XXS, IQ3_M, IQ4_XS) `./llama-quantize --imatrix imatrix.dat model-f16.gguf model-IQ3_M.gguf IQ3_M`	Generația nouă de cuantizări neuniforme bazate pe matrici de importanță, superioare formatelor clasice K-quants.
Generarea Matricilor de Importanță cu llama-imatrix `./llama-imatrix -m model-f16.gguf -f date_calibrare.txt -o imatrix.dat`	Calcularea ponderii de influență a fiecărui tensor prin rularea unui set de texte reprezentative.
Alegerea Seturilor de Date de Calibrare pentru imatrix `# Text mixt cu documente tehnice, conversație, cod și articole enciclopedice`	Ghidul selectării datelor de calibrare pentru a preveni devierea modelului cuantizat pe un singur domeniu.
Conversia Ponderilor Hugging Face cu convert_hf_to_gguf.py `python3 convert_hf_to_gguf.py ./director_model_hf --outtype f16 --outfile model.gguf`	Scriptul Python oficial din repozitoriul llama.cpp care citește fișierele safetensors și scrie fișierul binar GGUF.
Fuzionarea Adaptorilor LoRA prin llama-export-lora `./llama-export-lora -m baza.gguf --lora adaptor.gguf -o fuzionat.gguf`	Combinarea directă la nivel de fișier GGUF a adaptorilor LoRA peste modelul de bază fără a reveni în PyTorch.
Inspectarea Metadatelor GGUF cu gguf-dump.py `python3 ./gguf-py/scripts/gguf-dump.py model.gguf --metadata`	Vizualizarea arhitecturii, a lungimii maxime de context, a tokenilor speciali și a listei complete de tensori.
llama-server & Servire API în Producție
Lansarea Serverului HTTP llama-server `./llama-server -m model.gguf --port 8080 --host 0.0.0.0 -ngl 99`	Pornirea serverului REST asincron de înaltă performanță pentru deservirea cererilor web concurente.
Legarea la Interfețele de Rețea (–host) `./llama-server -m model.gguf --host 127.0.0.1 # sau 0.0.0.0`	Configurarea securizată a adresei IP de ascultare (locală 127.0.0.1 vs publică 0.0.0.0).
Protejarea Accesului prin Cheie API (–api-key) `./llama-server -m model.gguf --api-key "token_secret_securizat"`	Autentificarea clienților prin antetul HTTP Authorization: Bearer .
Endpoint-ul Compatibil OpenAI (/v1/chat/completions) `curl http://localhost:8080/v1/chat/completions -d '{"messages": [...]}'`	Înlocuirea directă a API-ului OpenAI în orice bibliotecă (LangChain, LlamaIndex, SDK oficial) prin schimbarea base_url.
Endpoint-ul Clasic de Completare Directă (/completion) `curl http://localhost:8080/completion -d '{"prompt": "..."}'`	Interfața nativă de generare rapidă a textului din llama-server cu acces complet la toți parametrii interni GGML.
Servirea Concurentă prin Sloturi Paralele (-np / –parallel) `./llama-server -m model.gguf -np 4 -c 16384`	Alocarea mai multor sloturi independente pentru deservirea simultană a mai multor utilizatori fără blocaje.
Algoritmul de Continuous Batching în llama-server `./llama-server -m model.gguf --cont-batching`	Optimizarea debitului de calcul prin inserarea noilor cereri în lotul de calcul la fiecare pas de generare.
Generarea de Vectori Denși prin /v1/embeddings `curl http://localhost:8080/v1/embeddings -d '{"input": "text"}'`	Expunerea modelelor de embedding compatibile cu ecosistemul OpenAI pentru căutare semantică în Vector DB.
Monitorizarea Stării Serverului prin /health & Prometheus `curl http://localhost:8080/health`	Verificarea automată a disponibilității serviciului pentru load-balancere și Kubernetes.
Interfața Grafică Web Nativă Integrată `http://localhost:8080/ # Deschidere în browser web`	Aplicația web ușoară inclusă direct în binarul llama-server pentru testare imediată fără unelte suplimentare.
Configurarea Antetelor CORS pentru Aplicații Web Frontend `./llama-server -m model.gguf --cors-domain "https://siteultau.ro"`	Permiterea apelurilor AJAX/fetch din aplicații single-page (React, Vue, Svelte) găzduite pe alte domenii.
Crearea unui Serviciu systemd pe Linux pentru Autostart `sudo systemctl enable --now llama-server.service`	Configurarea ca daemon de fundal cu pornire automată la boot-ul serverului și restart în caz de eroare.
Gramatici Structurate GBNF (Grammar-Based Sampling)
Sintaxa Formală GBNF (Grammar-Based Normal Form) `root ::= item+ item ::= [a-z]+ ", "`	Mecanismul de ghidare deterministă care maschează logit-urile la nivel de token pentru a forța respectarea unei sintaxe stricte.
Definirea Regulii de Start root ::= în Fișiere .gbnf `root ::= regula_principala`	Punctul de intrare obligatoriu al oricărei gramatici structurate GBNF.
Aplicarea Gramaticilor în Linie de Comandă (–grammar-file) `./llama-cli -m model.gguf --grammar-file gramatica.gbnf -p "..."`	Furnizarea unui fișier extern de reguli gramaticale către comanda llama-cli.
Constrângerea Ieșirilor în Format JSON Valid `./llama-cli -m model.gguf --grammar-file ./grammars/json.gbnf`	Garantarea absolută a parsării răspunsului cu json.loads() fără nicio eroare de sintaxă.
Limitarea Răspunsurilor la Valori Enum & Booleene `root ::= "true" \| "false"`	Constrângerea modelului de clasificare să emită exclusiv opțiuni prestabilite (ex: pozitiv, negativ, neutru).
Forțarea Structurilor cu Etichete XML ( & ) `root ::= "" [^<]* "" " " [^<]* ""`	Obligarea modelului să respecte șablonul de raționament cu taguri XML delimitatoare.
Ghidarea Generării de Interogări SQL Valide Sintactic `root ::= "SELECT " coloane " FROM " tabel " WHERE " conditii ";"`	Asigurarea că modelul Text-to-SQL emite interogări executabile direct în baza de date.
Integrarea Expresiilor Regulate în Regulile GBNF `ip_address ::= [0-9]{1,3} "." [0-9]{1,3} "." [0-9]{1,3} "." [0-9]{1,3}`	Definirea tiparelor numerice, adreselor de email, numerelor de telefon și formatelor de dată.
Transmiterea Gramaticilor GBNF prin API în llama-server `curl http://localhost:8080/completion -d '{"prompt": "...", "grammar": "root ::= ..."}'`	Injectarea regulilor gramaticale direct în payload-ul cererii HTTP fără fișiere salvate pe disc.
Impactul Eșantionării pe Bază de Gramatici Asupra Latenței `# Overhead minim (< 5%) datorită calculului optimizat de mascare pe CPU`	Măsurarea costului computațional al validării stărilor gramaticale la fiecare token.
Embeddings, Căutare Semantică & Re-ranking
Generarea de Vectori cu Utilitarul llama-embedding `./llama-embedding -m bge-base.gguf -p "Textul pentru care calculăm embedding-ul"`	Extragerea vectorilor numerici denși dintr-un model lingvistic pentru sisteme de regăsire semantică (RAG).
Configurarea Tipului de Agregare (–pooling mean / cls) `./llama-embedding -m model.gguf --pooling mean # sau cls / last`	Metoda de combinare a stărilor ascunse ale tuturor tokenilor într-un singur vector final.
Normalizarea Vectorilor la Norma Unitară L2 (–embd-normalize) `./llama-embedding -m model.gguf --embd-normalize 2`	Scalarea vectorului astfel încât suma pătratelor componentelor sale să fie egală cu 1, simplificând calculul cosinus.
Generarea de Vectori prin Apel HTTP POST la /v1/embeddings `curl http://localhost:8080/v1/embeddings -d '{"input": ["text 1", "text 2"]}'`	Vectorizarea în loturi a documentelor prin serverul HTTP llama-server.
Rularea Modelelor Specializate BGE & Nomic în Format GGUF `./llama-server -m bge-m3-Q8_0.gguf --embedding`	Cele mai performante modele deschise de reprezentare semantică multilingvă (BGE-M3, Nomic-Embed).
Re-ordonarea Documentelor Relevante (Cross-Encoder Re-ranking) `curl http://localhost:8080/v1/rerank -d '{"query": "...", "documents": [...]}'`	A doua etapă a conductei RAG: scoring-ul precis al perechilor interogare-document prin modele Cross-Encoder.
Calcularea Distanței Cosinus în C++ & Python `similarity = dot_product(v1, v2) / (norm(v1) * norm(v2))`	Formula matematică de comparare a doi vectori emiși de llama.cpp.
Optimizare Memorie, FlashAttention & Cache KV
Activarea Flash Attention Nativă (-fa / –flash-attn) `./llama-cli -m model.gguf -fa # sau --flash-attn`	Calcularea atenției fără alocarea matricilor N x N, reducând consumul de VRAM cu până la 50% pe context lung.
Cuantizarea Cache-ului de Chei (–cache-type-k) `./llama-cli -m model.gguf --cache-type-k q8_0 # sau q4_0`	Comprimarea vectorilor Key din memoria de atenție de la 16 biți la 8 sau 4 biți.
Cuantizarea Cache-ului de Valori (–cache-type-v) `./llama-cli -m model.gguf --cache-type-v q8_0 # sau q4_0`	Comprimarea vectorilor Value din memoria de atenție pentru reducerea globală a amprentei VRAM.
Gestionarea Contextului Infinit prin Context Shifting (–ctx-shift) `./llama-cli -m model.gguf --ctx-shift`	Re-aranjarea automată a memoriei KV când contextul este depășit, eliminând prima jumătate a dialogului fără blocare.
Încărcarea Instantanee prin Mapare de Memorie (–mmap / –no-mmap) `./llama-cli -m model.gguf --mmap # activ implicit`	Maparea fișierului binar direct din SSD în spațiul de adrese virtuale fără a citi octet cu octet în RAM la pornire.
Blocarea Modelului în Memoria Fizică RAM (–mlock) `./llama-cli -m model.gguf --mlock`	Prevenirea trimiterii paginilor modelului în fișierul de swap pe disc pentru eliminarea pauzelor de latență.
Distribuirea Straturilor pe Mai Multe GPU-uri (-sm / –split-mode) `./llama-cli -m model.gguf -sm layer # sau -sm row`	Împărțirea unui model uriaș (Llama-70B sau DeepSeek-671B) pe mai multe plăci grafice conectate pe aceeași mașină.
Selectarea GPU-ului Principal (-mg / –main-gpu) `./llama-cli -m model.gguf -mg 1`	Desemnarea plăcii video care stochează straturile de intrare, vocabularul și generarea finală a logit-urilor.
Reglarea Dimensiunii Lotului Fizic de Calcul (-b & -ub) `./llama-cli -m model.gguf -b 512 -ub 512`	Calibrarea numărului de tokeni evaluați simultan în timpul fazei de procesare a promptului (Prompt Processing).
Benchmarking, Testare & Depanare
Rularea Testelor de Performanță cu llama-bench `./llama-bench -m model.gguf -n 128 -p 512`	Utilitarul oficial de măsurare a vitezei în tokeni pe secundă atât pe faza de prompt (PP), cât și pe generare (TG).
Măsurarea Puterii de Calcul GFLOPS & Lățimii de Bandă `./llama-bench -m model.gguf -o csv`	Exportul rezultatelor în format CSV și calcularea gradului de saturație a magistralei de memorie VRAM.
Măsurarea Degradării Calitative cu llama-perplexity `./llama-perplexity -m model.gguf -f wikitext-2-raw/wiki.test.raw`	Calcularea matematică a pierderii de inteligență între modelul necuantizat f16 și variantele comprimate (Q4, Q3, Q2).
Afișarea Detaliilor Hardware VRAM la Pornire `./llama-cli -m model.gguf -ngl 99 --verbose`	Inspectarea tabelului generat de llama.cpp la inițializare: ce tensori se află în VRAM și ce rămâne în RAM.
Activarea Jurnalizării Detaliate de Depanare (-v / –verbose) `./llama-cli -m model.gguf -v # sau --verbose`	Afișarea fiecărei etape interne de parsare a tokenilor, alocare a bufferelor și eșantionare a logit-urilor.
Depanarea Erorilor de Alocare CUDA Out of Memory `ggml_cuda_init: failed to allocate ... MiB of CUDA memory`	Soluțiile practice pentru gestionarea situațiilor în care modelul depășește capacitatea plăcii video.
Rularea Containerizată a Serverului prin Docker & GPU Passthrough `docker run --gpus all -v /modele:/models -p 8080:8080 ghcr.io/ggerganov/llama.cpp:server-cuda ...`	Găzduirea serverului llama.cpp într-un container izolat gata pentru producție și integrare Kubernetes.

Compilare, Build & Accelerare Hardware 10 comenzi

Optimizare Memorie, FlashAttention & Cache KV 9 comenzi

Benchmarking, Testare & Depanare 7 comenzi

Formate GGUF, Cuantizări & Imap 14 comenzi

llama-server & Servire API în Producție 12 comenzi

Gramatici Structurate GBNF (Grammar-Based Sampling) 10 comenzi

Embeddings, Căutare Semantică & Re-ranking 7 comenzi

llama-cli & Parametri Esențiali de Inferență 12 comenzi

Eșantionare & Controlul Distribuției (Sampling) 10 comenzi

Învață AI • Comunitate & Q&A

Discuții, Întrebări & Coduri / Prompturi llama.cpp: Inferență LLM în C++ & Formatul GGUF

Ai o nelămurire despre modulul llama.cpp: Inferență LLM în C++ & Formatul GGUF, cauți o soluție sau vrei să împărtășești un prompt sau fragment util de cod? Trimite mai jos contribuția ta.

🤖

Fii primul care pune o întrebare sau distribuie un fragment de cod / prompt!

Nu au fost adăugate încă întrebări sau resurse pentru această pagină. Dacă ai testat un prompt sau ai un snippet util, adaugă-l mai jos pentru comunitate.

Comunitate AI Adaugă o întrebare sau distribuie un cod / prompt Anulează răspunsul

Alege ce dorești să transmiți:

Titlu scurt (opțional)

Întrebarea ta *

Moderare & Siguranță:

Pentru a menține calitatea și securitatea informațiilor, fiecare întrebare sau fragment de cod/prompt este analizat (manual sau prin moderare asistată de AI) înainte de publicare.

Nume sau Pseudonim *

Adresă de Email * (nu va fi publicată)