CodeLlama (7B, 13B, 34B, 70B)

Generates code from natural language prompts using Transformer-based architecture with four parameter variants (7B, 13B, 34B, 70B) allowing trade-offs between inference speed and code quality. Each variant is independently optimized for different hardware constraints and latency requirements, with the 7B model targeting edge devices and 70B targeting maximum code understanding. Inference is performed via Ollama's local execution engine or cloud API, with streaming token output for real-time code generation.

Implements bidirectional code infill using a special prompt format (<PRE>{prefix}<SUF>{suffix}<MID>) that allows the model to generate code between two existing code blocks. This capability leverages the model's ability to understand both preceding and following context simultaneously, enabling inline code completion within existing functions or methods. The FIM format is natively supported across all CodeLlama variants and works through standard API endpoints.

Builds on Llama 2's general-purpose Transformer architecture and applies code-specific pretraining to specialize the model for code understanding and generation. The exact composition of code-specific training data is undocumented, but the model learns code syntax, semantics, and common patterns from large-scale code repositories. The code-specialized weights are then fine-tuned into separate variants (base, instruct, python) for different use cases.

Provides a specialized `-instruct` variant fine-tuned on instruction-following data to enable natural language discussion about code, answering programming questions, and explaining code behavior. This variant is optimized for chat-style interactions rather than raw code generation, using instruction-tuning techniques to align model outputs with helpful, safe responses. Accessed via the `/api/chat` endpoint with multi-turn conversation support.

Provides a `codellama:python` variant fine-tuned on 100 billion tokens of Python-specific code, enabling superior Python code generation compared to the base model. This domain-adapted variant uses continued pretraining on Python code repositories to specialize the model's weights for Python syntax, idioms, and common patterns. The specialization improves both code quality and inference efficiency for Python-only use cases.

Executes CodeLlama models entirely on user hardware via Ollama's quantized GGUF format, eliminating cloud API calls and enabling offline code generation. The Ollama runtime handles model loading, quantization (format unspecified but typically 4-bit or 8-bit), memory management, and inference optimization. Models are downloaded once and cached locally, with inference latency determined by local hardware rather than network round-trips or cloud queue times.

Exposes CodeLlama inference through standardized REST API endpoints (`/api/generate` for text generation, `/api/chat` for conversation) and official SDKs (Python `ollama` library, JavaScript/TypeScript `ollama` library) with streaming token support. The API abstracts away model loading and quantization details, allowing developers to integrate code generation without understanding Ollama internals. Streaming responses enable real-time token-by-token output for UI responsiveness.

Generates code across multiple programming languages (Python, C++, Java, PHP, TypeScript/JavaScript, C#, Bash, and others) using a single unified Transformer model trained on polyglot code data. The model learns language-agnostic code patterns and syntax rules during pretraining, enabling it to switch between languages based on prompt context without separate language-specific models (except the Python variant). Language selection is implicit in the prompt — developers specify the target language in natural language instructions.

Maintains up to 16,000 token context window for the 7B, 13B, and 34B variants, enabling the model to condition code generation on substantial surrounding code, documentation, and conversation history. The context window allows developers to provide full function signatures, class definitions, imports, and multi-turn conversation history, improving code relevance and consistency. Context is managed by the client — developers must construct prompts that fit within the token limit.

Executes CodeLlama on Ollama's cloud infrastructure with usage-based pricing metered by GPU time (not token count) and configurable concurrency limits. Three pricing tiers (Free: 1 concurrent model, Pro: 3 concurrent models at $20/mo, Max: 10 concurrent models at $100/mo) control how many simultaneous inference requests are allowed. Usage is tracked per session (5-hour reset) and per week (7-day reset), with requests exceeding concurrency limits queued or rejected.

Provides command-line interface for downloading, running, and managing CodeLlama models via `ollama` command (e.g., `ollama run codellama`, `ollama pull codellama:70b`). The CLI abstracts model downloading, quantization, and inference, allowing developers to run code generation from the terminal without writing code. Models are cached locally after first download, and the CLI manages model lifecycle (loading, unloading, memory management).