Continue in VS Code and JetBrains with Ollama: a private, free coding assistant (Linux, Windows, Mac)

What you get in one minute#

Continue is a free, open-source coding assistant for VS Code and JetBrains. With Ollama behind it, chat, agent mode and inline autocomplete all run on your own computer, so your code never leaves it.

Logo: the official Continue project (github.com/continuedev/continue, Apache 2.0, file extensions/vscode/media/icon.png at tag v2.0.0-vscode)

You get a chat panel next to your code, an agent that can read and edit files and run tools, and ghost-text suggestions as you type. You pick the models. There is no subscription and no Docker. It is just an editor extension plus Ollama.

One honest note first. The Continue team shipped a final 2.0.0 release and then made the GitHub repository read-only. The 2.0.0 release removed the anonymous telemetry and the sign-in. The docs and the extension still work and people still file issues, but do not expect new features from the maintainers. We cover what that means for you below.

At a glance#

• What you get: chat, edit, agent mode with tools (MCP), codebase search and autocomplete, all with local models.
• Time needed: about 20 minutes, plus the model download.
• Difficulty: easy. One extension, one YAML file.
• You need: VS Code (or a JetBrains IDE), Ollama, and a GPU with 8 GB of memory or more for a pleasant experience.

Why 2.0.0? The repository README says 2.0.0 is the final polished release. We looked at the open issues (read 26 Oct 2026) and found no install failures or data-loss reports for it, only a few narrow bugs, listed under Known bugs. So we use the last stable release and not the 2.1.0 pre-release.

How it fits together#

The extension reads config.yaml, then sends each kind of request to the Ollama model you gave that job.

Each model has a role. A big model chats and runs the agent. A tiny model finishes your lines, because autocomplete must be fast. An optional embeddings model helps codebase search.

Before you start#

You need an editor, Ollama and enough GPU memory for the models you pick.

Check your tools:

code --version
ollama --version

On Windows PowerShell the same two commands work. If code is not found, open VS Code and run "Shell Command: Install code command in PATH" from the command palette.

Checklist:

• [ ] Your VRAM (or Mac memory) is known. See our VRAM guide to match models to it.
• [ ] You have 10 GB or more free disk for the models below.
• [ ] Port 11434 is free, or Ollama already uses it.

Tested on 2026-10-26: not run. Commands and settings checked against the official Continue docs (config.yaml reference, Ollama page, autocomplete page, FAQ) and the project README.

Step 1: Install Ollama and pull the models#

Install Ollama, then download one chat model, one autocomplete model and one embeddings model.

Pick the chat model for your memory. Sizes are the official Ollama download sizes from our VRAM guide.

The Continue docs list Qwen3 Coder 30B for agent mode. The 8 and 12 GB rows are our picks, not an official Continue list. For autocomplete the docs recommend qwen2.5-coder:1.5b (986 MB) or qwen2.5-coder:7b (4.7 GB). For embeddings they recommend nomic-embed-text (274 MB).

Linux#

curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen3-coder:30b
ollama pull qwen2.5-coder:1.5b
ollama pull nomic-embed-text

Swap qwen3-coder:30b for the model from the table that fits you.

Windows (PowerShell)#

Download OllamaSetup.exe from ollama.com/download and run it. Then open a new PowerShell:

ollama pull qwen3-coder:30b
ollama pull qwen2.5-coder:1.5b
ollama pull nomic-embed-text

Mac (Terminal)#

Same commands as Linux, with Homebrew for the install:

brew install ollama
ollama pull qwen3-coder:30b
ollama pull qwen2.5-coder:1.5b
ollama pull nomic-embed-text

If you used Homebrew, start the server with ollama serve in another Terminal window. The app download starts it for you.

Check it worked#

ollama list

Expected: your three models are listed. Open http://localhost:11434 in a browser. It answers Ollama is running (the Continue FAQ names this check).

Step 2: Install the Continue extension#

Install it from the VS Code Marketplace, or from the plugin page in a JetBrains IDE.

Linux#

code --install-extension [email protected]

Or open the Marketplace page, click Install, and click Install again inside VS Code. The @2.0.0 part keeps you on the stable release. If you use VSCodium or another editor without the Marketplace, the same extension is on Open VSX.

Windows (PowerShell)#

code --install-extension [email protected]

Mac (Terminal)#

Same command as Linux:

code --install-extension [email protected]

JetBrains (all systems)#

Press Ctrl + Alt + S to open Settings, choose Plugins, search for "Continue" and click Install. The Continue logo appears on the right toolbar. The README says the team recommends the Continue CLI over the JetBrains plugin, so treat the plugin as the less-polished route.

Check it worked#

The Continue icon shows up in the sidebar. Drag it to the right sidebar so chat stays beside your code (the official install page suggests this).

Step 3: Write config.yaml#

One YAML file in your home folder tells Continue which Ollama model does which job.

The file lives here on every system:

(The Continue FAQ names ~/.continue, and %USERPROFILE%\.continue on Windows, as the data folder.)

Linux#

mkdir -p ~/.continue
nano ~/.continue/config.yaml

Windows (PowerShell)#

New-Item -ItemType Directory -Force "$HOME\.continue" | Out-Null
notepad "$HOME\.continue\config.yaml"

Mac (Terminal)#

Same commands as Linux.

Paste this and save the file. It follows the current config.yaml schema (name, version and schema are required; schema: v1):

name: Local Ollama
version: 1.0.0
schema: v1
models:
  - name: Qwen3 Coder 30B
    provider: ollama
    model: qwen3-coder:30b
    roles:
      - chat
      - edit
      - apply
  - name: Qwen2.5 Coder 1.5B
    provider: ollama
    model: qwen2.5-coder:1.5b
    roles:
      - autocomplete
  - name: Nomic Embed
    provider: ollama
    model: nomic-embed-text
    roles:
      - embed
rules:
  - Give short answers and explain the reason for each change.

Change model: on the first entry if you chose another chat model. Roles come from the official reference: chat, autocomplete, embed, edit, apply and more. The default roles are chat, edit, apply and summarize.

Why a separate autocomplete model? The docs explain that autocomplete models are trained for fill-in-the-middle and can be tiny, while normal chat models usually do poorly at it, even though they are larger.

Check it worked#

Continue reloads the file when you save it (VERIFY: if the model list does not change, reload the VS Code window). Open any code file and the Continue panel, pick the chat model from the drop-down and ask: "What does this file do?" An answer appears. Then type a half-written function and wait a moment: grey suggestions should appear.

Agent mode, MCP tools and rules#

Agent mode lets the model read files, edit them and call tools. It needs a model that supports tool calling.

Continue detects tool support for most Ollama models by itself. If Agent mode is greyed out, add the capability by hand (from the official Ollama page):

  - name: Qwen3 Coder 30B
    provider: ollama
    model: qwen3-coder:30b
    capabilities:
      - tool_use

To add an MCP server, use the mcpServers section. This is the official docs example for a local SQLite server:

mcpServers:
  - name: My MCP Server
    command: uvx
    args:
      - mcp-server-sqlite
      - --db-path
      - ./test.db

Each server needs name and command. args, env and cwd are optional.

Rules#

Rules are instructions added to the system message for chat, edit and agent requests (not for autocomplete). Make a folder .continue/rules in your project and add a Markdown file:

---
name: Project style
---

- Use TypeScript, never plain JavaScript.
- Add a test for every new function.

Check it worked#

Switch the mode selector to Agent and ask it to list the files in your project. If Agent is unavailable, see Troubleshooting.

Use Ollama on another machine#

Point apiBase at the other computer. The safest way is an SSH tunnel, so the Ollama port never opens to your network.

The official Ollama page uses apiBase for a remote instance:

models:
  - name: Qwen3 Coder 30B
    provider: ollama
    model: qwen3-coder:30b
    apiBase: http://localhost:11434

With the tunnel below, localhost:11434 on your laptop reaches the Ollama on the server. Run it in a terminal and leave it open (Windows 10+ and Mac have ssh built in):

ssh -N -L 11434:127.0.0.1:11434 <user>@<server-address>

The other route is the one the Continue FAQ shows: set OLLAMA_HOST=0.0.0.0:11434 on the server, restart Ollama, put the server's address in apiBase and open port 11434 in its firewall. That makes the Ollama API reachable by everyone on that network, and it has no login. Only do it on a trusted home network, and never forward the port on your router.

Turn on codebase search#

An embeddings model lets Continue search your project by meaning.

The docs say VS Code already has a built-in embeddings model (transformers.js) and JetBrains has none. Our config uses nomic-embed-text from Ollama, which is what the docs recommend for local embeddings. On x64 Linux, indexing needs the CPU features AVX2 and FMA. Without them, indexing is switched off but chat and autocomplete still work.

How Continue compares#

Continue is the free, bring-your-own-model choice. Copilot is a paid cloud service. Cline is a similar open agent with a different focus.

This table is our general summary, not an official claim from any of the three projects. Check their pages before you decide. A more terminal-style agent is in our OpenCode guide.

Security and privacy#

Keep Ollama on localhost, keep keys out of the YAML and know what Continue sends.

• Telemetry. The README says 2.0.0 removed the anonymous telemetry. There is no setting to switch off. The data section of config.yaml only sends development data if you add a destination yourself, so leave it out.
• Ollama port. By default Ollama listens on this computer only. Check from another machine that http://<your-ip>:11434 does not answer.
• Secrets. If you add a cloud model later, use ${{ secrets.NAME }} in the YAML and put the value in ~/.continue/.env (or <project>/.continue/.env). Never commit that file, and restart the editor after changes.
• Agent permissions. Read each tool request before you allow it, especially terminal commands.
• Extension source. Install only from the Marketplace or Open VSX pages linked above.

Lock the secrets file on Linux and Mac:

chmod 600 ~/.continue/.env

Tests:

ollama list
ollama ps
curl -s http://localhost:11434

Expected: your models, the loaded model (after you use chat) and Ollama is running.

Troubleshooting#

Read the logs first. In VS Code press Ctrl+Shift+P (Cmd+Shift+P on Mac), run "Developer: Toggle Developer Tools" and open the Console tab. In JetBrains read ~/.continue/logs/core.log.

Known bugs#

Open on GitHub at the time of writing (read 2026-10-26):

• #13254: the Ollama provider drops tools after the first tool call, which can break multi-step agent loops. If your agent stops after one step, this may be why.
• #12948: activation fails when the YAML extension is not present (VERIFY against your VS Code setup; installing the "YAML" extension is the natural check).
• The repository is read-only, so fixes may not ship. If 2.0.0 misbehaves, the Continue docs describe downloading an older version from the extension page.

Updates and backups#

There is nothing to update on a schedule: 2.0.0 is final. Back up one small folder.

Update Ollama the same way you installed it (rerun the Linux script, run the new Windows installer, or brew upgrade ollama). The extension stays on 2.0.0 unless you click "Switch to Pre-Release".

Everything personal is in ~/.continue (config, logs, .env, index). Back up only the config and secrets.

Linux and Mac#

mkdir -p ~/continue-backups
tar czf ~/continue-backups/continue-$(date +%F).tgz -C ~/.continue config.yaml

Add .env to the list if you created one.

Windows (PowerShell)#

New-Item -ItemType Directory -Force "$HOME\continue-backups" | Out-Null
Compress-Archive -Path "$HOME\.continue\config.yaml" -DestinationPath "$HOME\continue-backups\continue-$(Get-Date -Format yyyy-MM-dd).zip" -Force

Schedule it with cron at 03:00 (Linux/Mac) or Task Scheduler (Windows) if you edit the file often.

Restore test#

Do this once. Restore into a temporary folder and compare:

mkdir -p /tmp/restore && tar xzf ~/continue-backups/continue-*.tgz -C /tmp/restore
diff /tmp/restore/config.yaml ~/.continue/config.yaml && echo "backup matches"
rm -rf /tmp/restore

To reset the extension completely, delete ~/.continue (%USERPROFILE%\.continue on Windows), uninstall and reinstall, as the official FAQ says.

Performance and resources#

Speed depends on whether the model fits your GPU memory. We did not measure numbers ourselves. Measure on your machine:

ollama ps

• Use the large model only for chat and agent work. Keep autocomplete on a 1.5B model so suggestions come in a blink.
• Ollama keeps a model loaded for a while after the last request (Continue's keepAlive setting defaults to 1800 seconds). Two models loaded at once need memory for both.
• A longer context uses more memory. Raise it step by step and watch ollama ps. Our VRAM guide explains how.
• If autocomplete feels late, tune autocompleteOptions.debounceDelay (the docs example uses 350 ms) on the autocomplete model.

FAQ#

Is Continue still maintained? The final 2.0.0 release was published in June 2026 and the repository is now read-only. It works today, but plan for no new features.

Does my code leave my computer? Not with this setup. Continue talks to Ollama on localhost, and the README says 2.0.0 removed the telemetry. Cloud models you add yourself are a different matter.

Can I use it in JetBrains too? Yes, with the plugin, using the same ~/.continue/config.yaml. The team recommends the CLI over the plugin.

Which model should I use for autocomplete? A small fill-in-the-middle model: qwen2.5-coder:1.5b for most machines, qwen2.5-coder:7b if you have spare memory.

Do I need an embeddings model? No. VS Code has a built-in one. Add nomic-embed-text if you want Ollama to do the embedding, or if you use JetBrains.

Can I mix local and cloud models? Yes. Add another entry under models and keep the API key in ~/.continue/.env.

Sources#

• Continue README (final 2.0.0, read-only note, telemetry removal) and releases (read 2026-10-26)
• config.yaml reference, Ollama provider, Autocomplete, Embeddings role, Rules, Install, FAQ, Troubleshooting (docs from tag v2.0.0-vscode, read 2026-10-26)
• VS Code Marketplace: Continue and Open VSX
• Open issues (#13254, #12948)
• Ollama releases and model pages for the download sizes

Checked against the official docs on 2026-10-26. Not run by DIY Lab Hub. The planned Perplexity research did not complete, so this guide rests on the developer's own docs. Items marked VERIFY are not confirmed.