What is Continue?
Continue (github.com/continuedev/continue) is an open-source, dual-IDE (VS Code and JetBrains) AI code assistant designed to give developers total control over their LLM architecture. Unlike proprietary, cloud-tethered alternatives that quietly ingest your proprietary codebase while serving closed-source telemetry, Continue acts as an open protocol wrapper inside your existing development environment. It supports local models (via Ollama, LM Studio, or vLLM), cloud providers (Anthropic, OpenAI, DeepSeek), and native execution of Anthropic’s Model Context Protocol (MCP).
┌─────────────────────────────────────────────────────────┐
│ YOUR IDE (VS Code / JetBrains) │
│ ┌───────────────────────────────────────────────────┐ │
│ │ Continue Assistant Extension │ │
│ └────────┬──────────────────┬───────────────────┬───┘ │
└───────────┼──────────────────┼───────────────────┼──────┘
│ │ │
▼ ▼ ▼
┌──────────────────┐ ┌─────────────────┐ ┌──────────────────┐
│ Local Inference │ │ Cloud Providers │ │ MCP Extensions │
│ (Ollama / vLLM) │ │(Claude / DeepSeek)││(Postgres/GitHub) │
└──────────────────┘ └─────────────────┘ └──────────────────┘
The Problem: Closed Ecosystems and Telemetry Anxiety
Let us be brutally honest for a moment: developers are suffering from severe subscriptions fatigue and context-blindness.
Over the past two years, the AI coding space has coalesced around two extremes. On one side, you have cloud-only extensions that treat your codebase as training fodder, charge a monthly toll, and break down the instant you pass through an airplane tunnel. On the other side, you have standalone, custom-forked IDEs that demand you abandon your carefully tuned VS Code extensions or JetBrains hotkeys just to get fast inline edits.
Furthermore, context remains the perennial bottleneck. Standard coding assistants know what is inside your immediate tab, but they have zero clue what is lurking inside your staging PostgreSQL database, your local Jira tickets, or your internal documentation site.
This is precisely where Continue enters the room—wearing an open-source badge and brandishing native support for Anthropic's Model Context Protocol.
Key Architectural Highlights
Continue’s core philosophy is non-invasive modularity. It runs inside your native editor without requiring you to switch to a proprietary IDE fork.
1. Dual-Engine Architecture: Continue bridges the gap between fast, sub-50ms tab completion and deep, multi-file chat edits. It handles inline autocompletions using small, lightning-fast local models (like qwen2.5-coder:1.5b) while routing heavy refactoring prompts to beefier local weights or frontier cloud endpoints.
2. First-Class MCP (Model Context Protocol) Integration: Rather than relying on static indexing hacks, Continue allows you to connect any standard MCP server directly to your chat interface. Want your editor to query your local Postgres schema, search Notion, or parse your company's vector database before generating TypeScript interfaces? You simply add the MCP server definition to your config.json.
3. Absolute Data Sovereignty: Zero code leaves your workstation if you choose an offline provider. For security-conscious enterprise teams and developers working under strict NDA constraints, this eliminates compliance headaches entirely.
Feature Comparison Matrix
| Feature | Continue | GitHub Copilot | Cursor |
|---|---|---|---|
| Open Source | Yes (Apache 2.0) | No (Proprietary) | No (Proprietary) |
| Model Choice | Unlimited (Ollama, Claude, DeepSeek, Local) | Fixed (OpenAI / Claude subset) | Fixed (Claude / OpenAI) |
| Offline / Local Execution | Supported | Not Supported | Not Supported |
| MCP Integration | Native First-Class | No | Closed / Proprietary Extensions |
| Supported IDEs | VS Code & JetBrains | VS Code, JetBrains, Visual Studio | Custom VS Code Fork Only |
| Configuration | Code/JSON (config.json) | GUI Toggle | GUI Toggle |
Setting Up Continue with Local LLMs & Custom MCP
Setting up a completely private, air-gapped coding suite takes less than five minutes.
Step 1: Install the Extension
Search for Continue inside the VS Code Marketplace or JetBrains Plugin Marketplace and install it.
Step 2: Configure config.json
Continue controls its brain via a simple, declarative ~/.continue/config.json (or .continue/config.json in your project root for repository-specific team settings).
Here is a practical configuration using Ollama for local completions and Anthropic's Claude 3.5 Sonnet combined with a custom PostgreSQL MCP server for context:
{
"models": [
{
"title": "Claude 3.5 Sonnet",
"provider": "anthropic",
"model": "claude-3-5-sonnet-latest",
"apiKey": "YOUR_ANTHROPIC_API_KEY"
},
{
"title": "DeepSeek R1 (Local)",
"provider": "ollama",
"model": "deepseek-r1:14b"
}
],
"tabAutocompleteModel": {
"title": "Qwen 2.5 Coder 1.5B",
"provider": "ollama",
"model": "qwen2.5-coder:1.5b"
},
"experimental": {
"modelContextProtocolServers": [
{
"transport": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://postgres:secret@localhost:5432/dev_db"
]
}
}
]
}
}
Practical Workflow: Prompting with Deep Context
Once configured, Continue provides a unified interface triggered via simple keyboard shortcuts (Cmd+I or Ctrl+I for inline edit; Cmd+L or Ctrl+L for chat).
Example 1: In-Line Code Generation
Highlight a function stub and press Cmd+I:
// Prompt: Refactor this to use exponential backoff and typed errors
async function fetchUserData(userId: string) {
const res = await fetch(`/api/users/${userId}`);
return res.json();
}
Continue streams the diff straight into your editor buffer, allowing you to accept (Cmd+Shift+Y) or reject (Cmd+Shift+N) individual chunks—just like a standard Git merge tool.
Example 2: Prompting with Context Symbols
Inside the chat side-panel, you can pull in ambient workspace context using @ operators:
@Files: References specific files in your tree.@Code: Attaches highlighted symbols or functions.@Docs: Searches indexed documentation sites locally.@Git: Pulls recent commits or git diff status into the prompt context.
Prompt: @Files src/schema.ts @dev_db Explain why the user query in userController.ts fails to match the DB schema.
Because the PostgreSQL MCP server is connected, Continue executes a read-only query against your local database schema, compares it with src/schema.ts, and points out missing columns before you even run your test suite.
Why Continue Stand Out in the Developer Community
If you monitor developer forums on Reddit, X, and YouTube tech channels, a distinct pattern emerges: developers are tiring of "walled-garden IDEs."
While dedicated editor forks offer slick demos, senior engineers routinely report frustration at losing their custom keybindings, specialized debugging setups, and legacy plugin ecosystems. Continue sidesteps this trade-off completely. It brings state-of-the-art context window orchestration and MCP extensions straight into the editor you already spent five years customising.
By decoupling the user interface from the inference engine, Continue ensures that whether local open-weight models surpass closed APIs tomorrow, or a new cloud provider emerges next week, your core editor workflow remains entirely unchanged. You simply update a line in your config.json.
Key Takeaways
- Total Data Privacy: Route completion requests through Ollama or local vLLM instances for 100% offline development.
- Model Agnostic: Mix and match models at will—use small, lightweight models for inline autocomplete and high-reasoning LLMs for architecture planning.
- Native MCP Ecosystem: Instantly wire up databases, terminal environments, and custom API tools directly to your assistant without writing glue code.
- Zero Vendor Lock-In: Works seamlessly within both VS Code and JetBrains without forcing an IDE migration.