llama-cookbook

Provides optimized fine-tuning workflows for Llama models on single GPU hardware using Parameter-Efficient Fine-Tuning (PEFT) techniques like LoRA and QLoRA. The implementation leverages HuggingFace's PEFT library integrated with PyTorch to reduce trainable parameters from millions to thousands while maintaining model quality, enabling developers to fine-tune on consumer-grade GPUs (8GB-24GB VRAM) without full model replication in memory.

Orchestrates fine-tuning across multiple GPUs using Fully Sharded Data Parallel (FSDP) training, a PyTorch native distributed training strategy that shards model parameters, gradients, and optimizer states across GPUs to enable training of large Llama models (70B+) that exceed single-GPU memory. The cookbook provides FSDP configuration templates, launch scripts, and gradient accumulation patterns that abstract away distributed training complexity while maintaining training stability and convergence.

Provides integration patterns for deploying Llama models on managed inference platforms (vLLM, TGI, Replicate, Together AI) and frameworks (LangChain, LlamaIndex). The cookbook includes configuration templates for each provider, API client examples, and guidance on selecting providers based on cost, latency, and feature requirements. This enables developers to run Llama inference without managing infrastructure while maintaining code portability across providers.

Integrates Llama Guard, a specialized safety classifier, to filter unsafe inputs and outputs in Llama-powered applications. The cookbook provides patterns for input validation (detecting harmful requests before processing), output filtering (removing unsafe generated content), and safety policy configuration. Llama Guard uses a taxonomy of unsafe categories (violence, illegal activity, etc.) to classify content and enable developers to enforce safety policies without external moderation APIs.

Demonstrates using Llama models for multilingual tasks including translation, cross-lingual question answering, and language-specific fine-tuning. The cookbook provides examples for prompting Llama in multiple languages, handling language detection, and evaluating multilingual performance. Llama models trained on diverse language corpora enable reasonable performance across 100+ languages without language-specific fine-tuning, though quality varies by language.

Enables running Llama models locally on consumer hardware (CPU, single GPU, or multi-GPU) with automatic hardware detection and quantization strategy selection. The implementation uses transformers library's device_map='auto' for memory-efficient loading, integrates bitsandbytes for 8-bit and 4-bit quantization, and provides fallback strategies (CPU offloading, Flash Attention) when VRAM is insufficient. Developers specify target hardware constraints and the system automatically selects optimal loading strategy without manual memory calculations.

Extends text inference to support image inputs using Llama 3.2 Vision models, which embed vision encoders (CLIP-like architecture) alongside language models to process images and text jointly. The cookbook provides image loading utilities, prompt formatting for vision tasks (image captioning, visual question answering, document OCR), and integration patterns with common image sources (URLs, local files, base64 encoding). Inference handles variable image resolutions through dynamic patching and produces text outputs grounded in visual content.

Implements RAG pipelines that augment Llama model generation with external knowledge by retrieving relevant documents from vector databases before generation. The cookbook provides patterns for document chunking, embedding generation (using Llama embeddings or third-party models), vector store integration (Chroma, Pinecone, Weaviate), and prompt augmentation that injects retrieved context into the LLM input. This enables Llama models to answer questions grounded in custom knowledge bases without fine-tuning.

Provides utilities and patterns for preparing training datasets and evaluating fine-tuned models, including data loading from multiple formats (JSON, CSV, HuggingFace Datasets), instruction-response pair formatting, train/validation splitting, and evaluation metrics (BLEU, ROUGE, perplexity). The cookbook includes dataset validation checks (duplicate detection, length distribution analysis) and integration with evaluation frameworks (lm-eval-harness) to benchmark fine-tuned models against standard benchmarks and baselines.

Demonstrates multiple quantization approaches (4-bit, 8-bit, GPTQ, AWQ) to reduce model size and inference latency while maintaining quality. The cookbook provides quantization configuration templates, post-training quantization workflows, and guidance on selecting quantization strategies based on hardware constraints and quality requirements. Quantized models are 4-8x smaller and enable inference on consumer GPUs or edge devices that cannot fit full-precision models.

Provides complete working examples of chatbot and agentic systems built with Llama, including multi-turn conversation management, tool calling for function execution, and integration with external services (email, messaging platforms, APIs). The cookbook includes prompt engineering patterns for agent reasoning, memory management for conversation history, and deployment templates for platforms like WhatsApp, Messenger, and Slack. These examples demonstrate how to compose Llama inference with orchestration logic to build autonomous agents.

Demonstrates using Llama models to generate SQL queries from natural language questions and code from specifications. The cookbook provides prompt engineering patterns for SQL generation (schema context, query validation), code generation (language-specific formatting, syntax checking), and integration with execution environments for validation. These examples show how to use Llama as a code/SQL generator with feedback loops that validate generated code before execution.

Provides an end-to-end example of using Llama agents to automatically triage GitHub issues by analyzing issue descriptions, assigning labels, suggesting assignees, and generating responses. The implementation uses GitHub API integration, issue text analysis with Llama, and tool calling to perform actions (label assignment, comment posting). This demonstrates how to build autonomous agents that interact with external platforms and make decisions based on LLM reasoning.