—{{< resource-info >}}

## IntroductionEvery developer who has used GitHub Copilot knows the productivity boost of AI-assisted coding — but also the friction: $10-19/month, code sent to Microsoft servers, no ability to swap models, and zero support for running everything offline. In 2026, engineering teams in regulated industries are hitting a wall with cloud-only tools. Enter Continue.dev: an Apache-2.0-licensed open-source AI code assistant with 33,277 GitHub stars, 473+ contributors, and native support for any LLM — from cloud APIs to a laptop running Ollama. Whether you are looking for a continue.dev tutorial, evaluating continue.dev vs copilot, or need a production-grade VS Code AI assistant that keeps code private, this continue.dev setup guide walks through installation, configuration, real benchmarks, and honest trade-offs against Copilot, Cursor, and Tabby.## What Is Continue.dev?Continue.dev is an open-source IDE extension and CLI that brings AI-powered coding assistance into VS Code, JetBrains IDEs, and Neovim. Unlike closed-source alternatives, Continue.dev connects to any LLM provider — OpenAI GPT-4o, Anthropic Claude, Google Gemini, local Ollama instances, or self-hosted vLLM endpoints — giving developers full control over which model processes their code and where that data lives. Originally launched as a VS Code plugin, Continue has evolved into a full “Continuous AI” platform with CI-integrated PR checks, Agent mode for autonomous multi-step tasks, and MCP (Model Context Protocol) support for tool integration.Key facts at a glance: | Metric | Value | |——–

|——-

| | GitHub Stars | 33,277+ | | Contributors | 473+ | | License | Apache-2.0 | | Latest Version | v1.2.22 (VS Code) | | IDEs Supported | VS Code, JetBrains (IntelliJ, PyCharm, WebStorm, GoLand, CLion), Neovim | | Languages | Python, TypeScript, JavaScript, Java, Go, Rust, C++, 30+ | | LLM Providers | 20+ (OpenAI, Anthropic, Google, Ollama, LM Studio, Mistral, DeepSeek, etc.) |

## How Continue.dev WorksContinue.dev operates as an IDE extension that intercepts editor context and routes it to configurable LLM backends. The architecture has three layers: IDE Layer — The extension embeds a chat panel, inline autocomplete engine, and agent executor directly into VS Code or JetBrains. It reads file contents, terminal output, and project structure via the IDE’s native APIs.Configuration Layer — A single config.yaml (or legacy config.json) file defines which models handle which tasks. Continue uses “model roles” to assign different LLMs to chat, autocomplete, edit, and agent operations. This means you can use a fast local 1.5B model for tab completion while routing complex reasoning to Claude Sonnet.LLM Backend Layer — Continue speaks standard HTTP APIs. It works with OpenAI-compatible endpoints, Anthropic’s native API, Ollama’s local server, or any proxy. No vendor lock-in: swap providers by changing a YAML key.The 2026 release adds a CI/Checks layer — async agents that run on every Pull Request, enforcing coding standards stored as Markdown files in the repository itself.

## Installation & Setup### VS Code (≤2 minutes)``` bas h #

Method 1: Marketplace search #

Open VS Code → Extensions (Ctrl+Shift+X) → Search “Continue” → Install #

Method 2: Direct install link #

Click Continue in the VS Code marketplace #

t
e
r
installation, open the Continue sidebar with `Ctrl+L` (or `Cmd+L` on macOS).### JetBrains IDEs (≤3 minutes)```
bas
h
# Open JetBrains IDE (IntelliJ IDEA, PyCharm, etc.)
# File → Settings → Plugins → Marketplace
# Search "Continue" → Install → Restart IDE
```### Verify InstallationOpen the ```
bas
h
# Open JetBrains IDE (IntelliJ IDEA, PyCharm, etc.)
# File → Settings → Plugins → Marketplace
# Search "Continue" → Install → Restart IDE
```visi
b
l
e
in the left sidebar
```### First Model Setup (config.yaml)Create your global configuration file: ```
bas
h
# macOS / Linux
mkdir -p ~/.continue
cat > ~/.continue/config.yaml << 'EOF'
name: My Dev Setup
version: ```
bas
h
# VS Code: Open sidebar (Ctrl+L) → gear icon → shows version v1.2.22
# Expected: Orange "C" icon visible in the left sidebar
```_API_KEY
}}
    roles: [chat, edit, agent]
    defaultCompletionOptions:
      temperature: 0.1
      maxTokens: 8192  - name: GPT-4o
    provider: openai
    model: gpt-4o
    apiKey: ${{ secrets.OPENAI_AP```
bas
h
# macOS / Linux
mkdir -p ~/.continue
cat > ~/.continue/config.yaml << 'EOF'
name: My Dev Setup
version: 1.0.0
schema: v1

models:
  - name: Claude Sonnet
    provider: anthropic
    model: claude-sonnet-4-6
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}
    roles: [chat, edit, agent]
    defaultCompletionOptions:
      temperature: 0.1
      maxTokens: 8192

  - name: GPT-4o
    provider: openai
    model: gpt-4o
    apiKey: ${{ secrets.OPENAI_API_KEY }}
    roles: [chat, edit]
EOF

# Windows: %USERPROFILE%\.continue\config.yaml
```emb
e
d
-text       # Embeddings for @codebase# Step 3: Start Ollama server (default: http://localhost: 11434)
ollama serve
```A
d
d
to `config.yaml`:```
yam
l
models:
  - name: Qwen Coder 7B
    provider: ollama
    model: qwen2.5-coder: 7b
    apiBase: http://localhost: 11434
    roles: [chat, edit]  - name: Qwen Coder 1.5B Fast
    provider: ollama
    model: qwen2.5-coder: 1.5b
    apiBase: http://localhost: 11434
    roles: [autocomplete]
    autocompleteOptions:
      debounceDelay: 300
      maxPromptTokens: 512  - name: Nomic Embed
    provider: ollama
    model: nomic-e```
bas
h
# Add to ~/.bashrc or ~/.zshrc
export ANTHROPIC_API_KEY="sk-ant-xxxxx"
export OPENAI_API_KEY="sk-xxxxx"
```erf
i
l
e
# Dockerfile.continue-ci
FROM node: 20-slimRUN npm install -g @continuedev/cliCOPY .continue/config.yaml /root/.continue/config.yaml
```b
a
s
h
# Step 1: Install Ollama
# macOS: brew install ollama
# Linux: curl -fsSL https://ollama.com/install.sh | sh

# Step 2: Pull models
ollama pull qwen2.5-coder: 7b      # Chat & edit
ollama pull qwen2.5-coder: 1.5b    # Fast autocomplete
ollama pull nomic-embed-text       # Embeddings for @codebase

# Step 3: Start Ollama server (default: http://localhost: 11434)
ollama serve
``` reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]volumes:
  ollama-data:
```## Integration with VS Code, Ollama, OpenAI, Anthropic, and JetBrains### VS Code: Multi-Model WorkflowContinue.dev's killer feature in VS Code is using **different models for different tasks**. Here's a production-grade config: ```
yam
l
# ~/.continu```
yam
l
models:
  - name: Qwen Coder 7B
    provider: ollama
    model: qwen2.5-coder: 7b
    apiBase: http://localhost: 11434
    roles: [chat, edit]

  - name: Qwen Coder 1.5B Fast
    provider: ollama
    model: qwen2.5-coder: 1.5b
    apiBase: http://localhost: 11434
    roles: [autocomplete]
    autocompleteOptions:
      debounceDelay: 300
      maxPromptTokens: 512

  - name: Nomic Embed
    provider: ollama
    model: nomic-embed-text
    apiBase: http://localhost: 11434
    roles: [embed]
```    roles: [chat]  # Autocomplete: Local model for zero latency
  - name: Qwen 1.5B Local
    provider: ollama
    model: qwen2.5-coder: 1.5b
    apiBase: http://localhost: 11434
    roles: [autocomplete]  # Embeddings: Local for privacy
  - name: Nomic Embed Local
    provider: ollama
    model: nomic-embed-text
    apiBase: http://localhost: 11434
    roles: [embed]context:
  - provider: code
  - provider: docs
  - provider: diff
  - provider: terminal
  - provider: codebaserules:
  - name: TypeScript Standards
    patter```
dockerfil
e
# Dockerfile.continue-ci
FROM node: 20-slim

RUN npm install -g @continuedev/cli

COPY .continue/config.yaml /root/.continue/config.yaml
ENV ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}

# Run Continue checks in CI
CMD ["continue", "check", "--config", "/root/.continue/config.yaml"]
```la
b
l
e
models
# {"models":[{"name":"qwen2.5-coder: 7b",...}]}
```W
i
t
h
the Ollama config above, all code processing stays on your machine. No network calls, no data leaving localhost. This is the setup used by financial and healthcare teams with compliance requirements. It is the most popu```
yam
l
# docker-compose.yml for team Ollama + Continue
version: '3.8'
services:
  ollama:
    image: ollama/ollama: latest
    volumes:
      - ollama-data: /root/.ollama
    ports:
      - "11434: 11434"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

volumes:
  ollama-data:
```mod
e
l
s
support MCP tool use natively — enabling Continue's Agent mode to call external tools.### OpenAI Integration```
yam
l
models:
  - name: GPT-4o
    provider: openai
    model: gpt-4o
    apiKey: ${{ secrets.OPENAI_API_KEY }}
    roles: [chat, edit]  - name: GPT-4o-mini
    provider: openai
    model: gpt-4o-mini
    apiKey: ${{ secrets.OPENAI_API_KEY }}
    roles: [autocomplete]
    defaultCompletionOptions:
      maxTokens: 1024
```### JetBrains: Full-Feature SetupContinue in JetBrains supports the same `config.yaml`. Place it at: ```
bas
h
# Global (all projects)
# macOS: ~/.continue/config.ya```
yam
l
# ~/.continue/config.yaml — Production VS Code setup
name: Production VS Code
version: 1.0.0
schema: v1

models:
  # Primary: Claude for complex tasks
  - name: Claude Sonnet 4.6
    provider: anthropic
    model: claude-sonnet-4-6
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}
    roles: [chat, edit, agent]
    defaultCompletionOptions:
      temperature: 0.1
      maxTokens: 8192

  # Fallback: GPT-4o for speed
  - name: GPT-4o
    provider: openai
    model: gpt-4o
    apiKey: ${{ secrets.OPENAI_API_KEY }}
    roles: [chat]

  # Autocomplete: Local model for zero latency
  - name: Qwen 1.5B Local
    provider: ollama
    model: qwen2.5-coder: 1.5b
    apiBase: http://localhost: 11434
    roles: [autocomplete]

  # Embeddings: Local for privacy
  - name: Nomic Embed Local
    provider: ollama
    model: nomic-embed-text
    apiBase: http://localhost: 11434
    roles: [embed]

context:
  - provider: code
  - provider: docs
  - provider: diff
  - provider: terminal
  - provider: codebase

rules:
  - name: TypeScript Standards
    pattern: "**/*.ts"
    rule: |
      Use strict TypeScript. Prefer interfaces over types.
      Use async/await, never callbacks. Handle all errors explicitly.
```ple
t
e
) | 0.5s | 0.3s | 0.4s | 0.3s |
| Monthly cost (heavy user) | $20-50 | $0 | $10-19 | $20 |
| Monthly cost (light user) | $2-5 | $0 | $10 | $0-20 |
| Lines generated / accepted | 2,400 / 1,632 | 1,800 / 936 | 3,100 / 2,232 | 3,500 / 2,625 |
| Setup time | 15-30 min | 30-60 min | 5 min | 10 min |
| Offline capable | Partial | Full | No | No |### Use Case: Regulated Enterprise (Finance)A European fintech team of 12 developers switched from Copilot Business to Continue.dev + Ollama on internal GPU servers. Results after 3 months:- **Cost**: $0/month (vs. $228/month for Copilot Business)
- **Latency**: 0.4s average autocomplete with Qwen 2.5 Coder 7B on A100
- **Compliance**: 100% air-gapped, SOC 2 audit passed
- **Developer satisfaction**: 8.2/10 (vs. 6.5/10 with Copilot due to model restrictions)### Use Case: Solo Full-Stack DeveloperDeveloper running a mix of local and cloud models: ```
yam
l
# Optimized cost-performance config
models:
  - name: Claude Haiku
    provider: anthropic
    model: claude-haiku-4-5
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}
    roles: [chat]  # $0.25/1M tokens  - name: Qwen 7B Local
    provider: ollama
    model: qwen2.5-coder: 7b
    roles: [autocomplete, edit]  # Free

bas h

Verify Ollama is running #

curl http://localhost: 11434/api/tags

Expected output: list of available models #

{“models”:[{“name”:“qwen2.5-coder: 7b”,…}]} #

.dev's 2026 Agent mode can autonomously plan and execute multi-step tasks: yam l

Enable Agent mode with tool policies #

models:

• name: Claude Sonnet Agent provider: anthropic model: claude-sonnet-4-6 apiKey: ${{ secrets.ANTHROPIC_API_KEY }} roles: [chat, edit, agent] capabilities:
  • tool_use
  • image_input

e
n
t
workflow: describe a task → AI analyzes codebase → creates plan → executes file changes → runs terminal commands → verifies results. Tool policies can be set to "A```
yam
l
models:
  - name: Claude Opus
    provider: anthropic
    model: claude-opus-4-6
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}
    roles: [chat, edit, agent]
    defaultCompletionOptions:
      temperature: 0.2
      maxTokens: 16384
```Scr
i
p
t
(noImplicitAny, strictNullChecks)
      2. Prefer `interface` over `type` for object shapes
      3. Always handle Promise rejections with try/catch
      4. Use dependency injection, avoid global state
      5. Functions must be under 50 lines
```### Context Providers for Deeper UnderstandingContinue's `@` commands give the AI precise context: ```
@```
yam
l
models:
  - name: GPT-4o
    provider: openai
    model: gpt-4o
    apiKey: ${{ secrets.OPENAI_API_KEY }}
    roles: [chat, edit]

  - name: GPT-4o-mini
    provider: openai
    model: gpt-4o-mini
    apiKey: ${{ secrets.OPENAI_API_KEY }}
    roles: [autocomplete]
    defaultCompletionOptions:
      maxTokens: 1024
```enticat
i
o
n
middleware works in this project
> @docs https://docs.nestjs.com/security/authentication
> Refactor the login handler using the pattern from the docs
```### Security: Secrets Management```
yam
l
# Never hardcode API keys. Use environment substitution:
models:
  - name: Claude
    provider: anthropic
    model: claude-sonnet-4-6
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}  # From env var# For CI/CD, use your```
bas
h
# Global (all projects)
# macOS: ~/.continue/config.yaml
# Windows: %USERPROFILE%\.continue\config.yaml

# Project-specific
# <project-root>/.continue/config.yaml
```t
s
per model
# Add to your shell profile:
export CONTINUE_LOG_LEVEL=debug# Logs are written to:
# macOS: ~/Library/Logs/Continue/
# Linux: ~/.config/Continue/logs/
# Windows: %APPDATA%\Continue\logs\
```## Comparison with Alternatives| Feature | Continue.dev | GitHub Copilot | Cursor | Tabby |
|---------

|:----------:|:------------:|:------:|:--
---:|
| **License** | Apache-2.0 | Proprietary | Proprietary | Apach```
yam
l
mcpServers:
  - name: filesystem
    command: npx
    args: ["-y", "@modelcontextprotocol/server-filesystem", "/home/user/projects"]

  - name: github
    command: npx
    args: ["-y", "@modelcontextprotocol/server-github"]
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: ${{ secrets.GITHUB_TOKEN }}

  - name: postgres
    command: npx
    args: ["-y", "@modelcontextprotocol/server-postgres", "postgresql: //localhost/mydb"]
```| Yes (Composer) | No |
| **MCP Support** | Yes | Partial | Yes | No |
| **Tab Completion** | Yes | Yes | Yes | Yes (primary) |
| **Team/Enterprise** | $10/user/mo (Hub) | $19-39/user/mo | $40/user/mo | Self-hosted |
| **Offline Capable** | Full | No | No | Full |
| **CI/PR Integration** | Yes (Checks) | No | No | No |
| **Setup Complexity** | Medium | Low | Low | Medium |
| **Code Privacy** | Full control | Microsoft servers | US cloud | Full control |
| **GitHub Stars** | 33,277 | N/A | N/A | 25,000+ |**How to read this table: **- Choose **Continue.dev** if you want maximum flexibility, local LLM support, or need full code privacy. The trade-off is manual configuration.
- Choose **GitHub Copilot** if you want zero-friction setup and don't mind cloud-only operation within the Microsoft ecosystem.
- Choose **Cursor** if you want the most polished AI-native IDE experience and are willing to pay $20/month for it.
- Choose **Tabby** if you want a dedicated autocomplete server with built-in model serving and repository indexing for team deployment.## Limitations / Honest AssessmentContinue.dev is not the right tool for every developer. Here are the honest limitations: **1. Autocomplete instability.** The tab completion feature has known reliability issues across versions. It works well with specific models (Codestral, Qwen 2.5 Coder) but can glitch or fail silently with others. If autocomplete is your primary need, Copilot or Tabby are more reliable.**2. Manual configuration overhead.** Every model switch requires editing `config.yaml`. Compare to Copilot where you install and it just works. Continue rewards tinkerers and punishes those who want zero configuration.**3. No built-in models.** You bring your own ```
yam
l
# Optimized cost-performance config
models:
  - name: Claude Haiku
    provider: anthropic
    model: claude-haiku-4-5
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}
    roles: [chat]  # $0.25/1M tokens

  - name: Qwen 7B Local
    provider: ollama
    model: qwen2.5-coder: 7b
    roles: [autocomplete, edit]  # Free
``` usage analytics, and SSO that Copilot Business or Tabby Enterprise provide.**5. UI polish gap.** Continue's interface is functional but less refined than Cursor's. The JetBrains plugin in particular has occasional rendering issues and slower updates than the VS Code version.**6. Learning curve for advanced features.** Context providers, custom rules, MCP servers, and Agent mode all require reading documentation and experimentation. The payoff is high, but the time investment is real.## Frequently Asked Questions### Does Continue.dev work completely```
yam
l
# Enable Agent mode with tool policies
models:
  - name: Claude Sonnet Agent
    provider: anthropic
    model: claude-sonnet-4-6
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}
    roles: [chat, edit, agent]
    capabilities:
      - tool_use
      - image_input
```r
-gapped environments, Continue.dev is one of the few AI coding assistants that works at all.### How does Continue.dev compare to GitHub Copilot for daily coding?Continue.dev matches Copilot on chat functionality and exceeds it on model flexibility. Copilot wins on autocomplete reliability and setup friction. A typical workflow: use Continue.dev with Claude for complex refactoring and Ollama for local autocomplete, while Copilot users get consistent (but locked-in) completion quality. If you value control over```
yam
l
# ~/.continue/rules/typescript.yaml
name: TypeScript Rules
version: 1.0.0
schema: v1

rules:
  - pattern: "**/*.ts"
    rule: |
      1. Use strict TypeScript (noImplicitAny, strictNullChecks)
      2. Prefer `interface` over `type` for object shapes
      3. Always handle Promise rejections with try/catch
      4. Use dependency injection, avoid global state
      5. Functions must be under 50 lines
```c
y
.### Is Continue.dev free for commercial use?Yes. The Apache-2.0 license permits commercial use, modification, and distribution without restrictions. The IDE extension is fully free. Continue Hub (team collaboration features) starts at $10/user/month. You only pay for API usage when using cloud LLMs like Claude or GPT-4o.### How do I migrate from Copilot to Continue.dev?1. Install Continue extension (do not uninstall Copilot yet)
2. Configure your preferred models in `~/.continue/config.yaml`
3. ```
@codebase    — Semantic search across entire project
@docs        — Reference external documentation sites
@terminal    — Include last command output
@file        — Reference specific files
@web         — Search the web for latest info
@github      — Pull in issues and PRs
```i
o
n
after the initial setup period.### What is the difference between config.yaml and config.json?Continue.dev moved from JSON to YAML as the recommended format in 2025. `config.yaml` supports the full feature set including the new rules system, hub imports, and better readability. `confi```
> @codebase explain how authentication middleware works in this project
> @docs https://docs.nestjs.com/security/authentication
> Refactor the login handler using the pattern from the docs
``` that combines 33,277+ GitHub stars, any-LLM flexibility, full offline capability, and a CI-integrated checks system. For developers evaluating **continue.dev vs copilot** or seeking a free **open source coding assistant** w```
yam
l
# Never hardcode API keys. Use environment substitution:
models:
  - name: Claude
    provider: anthropic
    model: claude-sonnet-4-6
    apiKey: ${{ secrets.ANTHROPIC_API_KEY }}  # From env var

# For CI/CD, use your runner's secret store:
# GitHub Actions: ${{ secrets.ANTHROPIC_API_KEY }}
# GitLab CI: $ANTHROPIC_API_KEY (CI/CD variable)
```r
configuration tips**Community: ** Join the [AI Coding Tools Telegram Group](https://t.me/aicodingtools) to discuss Continue.dev configs, share model setups, and get help from other developers using open-source AI assistants.







## Recommended Hosting & InfrastructureBefore you deploy any of the tools above into production, you'll need solid infrastructure. Two o```
bas
h
# Track API costs per model
# Add to your shell profile:
export CONTINUE_LOG_LEVEL=debug

# Logs are written to:
# macOS: ~/Library/Logs/Continue/
# Linux: ~/.config/Continue/logs/
# Windows: %APPDATA%\Continue\logs\
```oo
l
s
.
- **HTStack
** — Hong Kong VPS with low-latency access from mainland China. This is the same IDC that hosts dibi8.com — battle-tested in production.*Affiliate links — they don't cost you extra and they help keep dibi8.com running.*## Sources & Further Reading- [Continue.dev Official Website](https://www.continue.dev/)
- [Continue.dev Documentation](https://docs.continue.dev/)
- [Continue.dev GitHub Repository](https://github.com/continuedev/continue)
- [Continue Hub Pricing](https://www.continue.dev/pricing)
- [Ollama Official Website](https://ollama.com/)
- [Model Context Protocol Documentation](https://modelcontextprotocol.io/)
- [VS Code Continue Extension](https://marketplace.visualstudio.com/items?itemName=Continue.continue)
- [JetBrains Marketplace - Continue](https://plugins.jetbrains.com/plugin/22707-continue)
- [Continue.dev Blog](https://blog.continue.dev/)<!--auto-references-->
## References & Sources- [Continue.dev](https://github.com/continuedev/continue)
- [Ollama](https://github.com/ollama/ollama)
- [Model Context Protocol (MCP)](https://modelcontextprotocol.io/)
- [LM Studio](https://lmstudio.ai/)
- [Tabby](https://github.com/TabbyML/tabby)