llama.cpp

Executes large language models entirely on CPU using GGML (Ggerganov's Machine Learning library), a tensor computation framework optimized for inference. Implements multiple quantization schemes (Q4_0, Q4_1, Q5_0, Q8_0, etc.) that reduce model size by 75-90% while maintaining inference quality through mixed-precision arithmetic and custom SIMD kernels for x86/ARM architectures. Supports batch processing and streaming token generation without GPU dependencies.

Converts models from HuggingFace, SafeTensors, and other formats into GGUF (Ggerganov Universal Format) with configurable quantization schemes. The pipeline uses a modular converter architecture that parses model architectures (LLaMA, Mistral, Phi, etc.), maps tensor names to quantization strategies, and applies per-layer or per-tensor quantization with optional calibration data. Supports both symmetric and asymmetric quantization with configurable bit-widths and mixed-precision strategies (e.g., keeping attention layers at higher precision).

Provides tools to measure and compare quantization impact on model performance, including perplexity evaluation on benchmark datasets, inference speed benchmarking across quantization levels, and memory usage profiling. Generates detailed reports showing trade-offs between model size, inference speed, and output quality for different quantization schemes (Q4, Q5, Q8, etc.), enabling data-driven selection of quantization parameters.

Enables parameter-efficient fine-tuning using Low-Rank Adaptation (LoRA) and Quantized LoRA (QLoRA), which add small trainable adapter layers instead of updating all model weights. Supports training on consumer hardware by keeping base model weights frozen and quantized while only updating low-rank adapter matrices. Integrates with standard training frameworks (PyTorch, HuggingFace Transformers) and supports saving/loading adapters independently of base model.

Exposes token probabilities and raw logits at each generation step, enabling analysis of model confidence, alternative token predictions, and attention patterns. Provides APIs to inspect top-k alternative tokens with their probabilities, allowing developers to understand why the model made specific choices and detect low-confidence generations. Supports exporting attention weights and hidden states for deeper model analysis.

Provides a command-line REPL for multi-turn conversations with streaming token generation, supporting both single-shot inference and interactive chat modes. Implements line-buffered input handling, real-time token streaming to stdout, and conversation history management in memory. Supports prompt templates (Alpaca, ChatML, etc.) for automatic formatting of user/assistant roles, and allows custom system prompts and sampling parameters (temperature, top-p, top-k) to be configured via CLI flags or interactive commands.

Enforces structured output by constraining token generation to match user-defined EBNF grammars, preventing invalid JSON, code, or domain-specific formats. The implementation compiles EBNF rules into a finite-state automaton that filters the logit distribution at each generation step, allowing only tokens that keep the output on a valid path. Supports common grammars (JSON, SQL, regex) with pre-built templates and allows custom grammar definition for domain-specific languages.

Extracts dense vector embeddings from text by running the model in embedding mode, extracting the final hidden state or pooled representation and normalizing to unit vectors. Supports batch embedding of multiple texts with configurable pooling strategies (mean, max, CLS token). Outputs embeddings in raw float32 format compatible with vector databases (Pinecone, Weaviate, Milvus) and similarity search libraries.

Distributes model inference across multiple GPUs (CUDA, Metal, ROCm) or CPU cores using layer-wise model splitting and tensor parallelism. Automatically partitions model layers across available devices, manages inter-device communication, and coordinates token generation across distributed workers. Supports both data parallelism (batch splitting) and model parallelism (layer splitting) with configurable strategies based on available hardware.

Runs llama.cpp as a background server exposing a REST API compatible with OpenAI's Chat Completions and Embeddings endpoints, allowing drop-in replacement of cloud APIs in existing applications. Implements request queuing, concurrent request handling with configurable worker threads, and streaming responses via Server-Sent Events (SSE). Supports authentication via API keys and request rate limiting.

Implements multiple sampling algorithms (greedy, temperature-scaled softmax, nucleus/top-p, top-k, min-p) that modify the probability distribution over next tokens before sampling. Allows fine-grained control over generation diversity vs determinism through configurable parameters, and supports dynamic sampling (changing parameters mid-generation). Includes advanced strategies like repetition penalty, frequency penalty, and presence penalty to reduce hallucinations and repetitive output.

Manages model context efficiently using sliding window attention, which limits attention computation to a fixed window of recent tokens rather than all previous tokens. This reduces memory usage from O(n²) to O(n*w) where w is window size, enabling longer context windows on limited hardware. Implements KV cache management with automatic eviction policies and supports context compression techniques (e.g., summarization of old context).

Processes multiple inference requests concurrently by batching them together, reducing per-request overhead and improving GPU/CPU utilization. Implements dynamic batching where requests are grouped based on arrival time and context length, with configurable batch size and scheduling policies (FCFS, priority-based). Supports variable-length sequences within batches through padding and masking, and automatically schedules new requests into running batches when possible.