Skip to main content
Below is a concise, reorganized guide to the official Cline documentation—highlighting the sections most useful when designing production systems and experimenting with models locally. This version keeps the original sequence of screenshots and examples while improving clarity and SEO by emphasizing key topics: model selection, context windows, recommended tooling, provider-specific guides, and running local models.

​
Where docs might live on your machine

Example local documentation paths:
Operating SystemExample Path
macOS/Users/[your-username]/Documents/Cline
WindowsC:\Users\[your-username]\Documents\Cline
These paths are examples only; adjust them to match your environment.

​
Model selection and understanding context windows

The official docs contain a clear, practical explanation of context windows and how they affect model choice. Use this guidance to pick models that balance cost, latency, and the context size you need for tasks like long-form summarization, document question answering, or multimodal input.
A dark-themed webpage or documentation titled "Model Selection Guide" showing a section on "Understanding Context Windows" with explanatory text and a left navigation menu of other topics. The page lists context window sizes for various AI models and includes a right-hand table of contents.
Key considerations:
  • Context size: choose a model whose context window fits your input plus expected output.
  • Cost vs. capability: larger-context models typically cost more; consider chunking/summary strategies for very long inputs.
  • Use-case fit: some models are optimized for coding, others for dialogue or vision.
The docs include a recommended stack—editors, hosting, and common frameworks—so you can bootstrap a Cline-based project quickly.
A dark-themed documentation webpage titled "Our Favorite Tech Stack" showing a recommended development stack for new Cline users (2025), listing tools like VS Code, GitHub, Next.js, Tailwind, TypeScript, and Supabase. The layout has a left navigation menu, main content in the center, and a right-side table of contents.
Typical recommendations:
  • Editor: VS Code
  • Version control / hosting: GitHub (or Git providers of your choice)
  • Front-end: Next.js + Tailwind CSS + TypeScript
  • Back-end / storage: Supabase, or any managed DB / object store

​
Hosting, production models, and operational notes

The docs explain production considerations—recommended production models, example cost guidance, and deployment patterns (e.g., model choice for inference latency and throughput). They also discuss operational best practices like checkpointing client memory and “plan and act” workflows. If you need provider-specific instructions, the docs include guides for integrating alternative providers.

​
Provider-specific example: xAI Grok (API keys and models)

Cline’s documentation contains provider-specific guides—here’s the Grok example showing steps for obtaining API keys and a list of supported Grok model names.
A dark-themed documentation webpage for xAI (Grok), showing a left navigation menu and a right-side table of contents. The main content displays "Getting an API Key" steps and a list of supported Grok models.
Example Grok model names listed in the docs: 
grok-2-vision-latest - xAI's Grok-2 Vision model - latest version with image support and 32K context window
grok-2-vision - xAI's Grok-2 Vision model with image support and 32K context window
grok-2-vision-1212 - xAI's Grok-2 Vision model (version 1212) with image support and 32K context window
grok-vision-beta - xAI's Grok Vision Beta model with image support and an 8K context window
grok-beta - xAI's Grok Beta model (legacy) with a 131K context window
Tip: match the Grok model’s context window to your task; use smaller models for cost-sensitive, short-context tasks, and larger-context models when you need to process long documents or multimodal inputs.

​
Running local models — hardware requirements and trade-offs

The docs include a detailed “Hardware Requirements” section that lists recommended GPU, RAM, SSD, and cooling. There’s also a comparison table of common model sizes (7B, 14B, 32B, 70B) and their typical capabilities.
A dark-themed documentation page titled "Hardware Requirements" listing recommended GPU, RAM, SSD and cooling, plus a table comparing model sizes (7B, 14B, 32B, 70B) and their capabilities. The screenshot also shows left and right navigation panels for the docs.
Considerations when running locally:
  • Hardware cost and availability vs. managed inference costs
  • Precision trade-offs (e.g., FP16 / quantization)
  • Memory limits and model sharding strategies
  • Cooling and long-running inference reliability
A dark-themed documentation webpage screenshot titled "Read Me First" and "Running Local Models with Cline: What You Need to Know," showing explanatory text about why local models are different with a bulleted list. Navigation menus appear in a left sidebar and a page outline on the right.
Running local models requires careful hardware planning. Ensure your GPU, RAM, and storage match the model size you intend to use, and test performance characteristics (latency, memory usage) before moving to production.

​
Example minimal project layout referenced by the docs

A minimal example layout from the docs: 
cline_docs
projectBrief.md
.clinerules
This gives you a starting scaffold—add your source code, configuration, and CI/CD files as needed.
Bookmark the official docs for ongoing updates and details: https://docs.agentic.cline.bot. The documentation is actively maintained and is the best source for model names, context window guidance, provider integrations, and hardware notes.
  • Official docs: https://docs.agentic.cline.bot
  • Provider guides and model lists: consult each provider’s section in the official docs (e.g., Grok integration)
  • Local model guidance: review “Read Me First” and “Running Local Models” before attempting large-model local deployments
This reorganized summary preserves the original screenshots and sequence while clarifying the key decision points: which model to pick, what tooling to use, how to integrate alternate providers, and what to consider when running models locally.

Watch Video