Continue: AI Assistant for Your IDE
What This Article Covers
- What Continue is and how it works
- How to connect Continue with Ollama
- Which editors support Continue
- How to use code suggestions and chat while keeping data on your own network
Introduction: Continue as an AI Assistant
Continue is an open-source plugin that brings language models directly into your development environment. It works with Visual Studio Code and JetBrains. Developers can explain code, receive completions, fix errors, and generate code without leaving the IDE. Continue integrates with local models via Ollama, ensuring your source code stays within your network.
For anyone who values privacy and wants full control over their data, Continue with a local model is a strong alternative to cloud-based code assistants.
Why Do You Need Continue?
Coding with AI is now standard practice. Most tools, however, send code and context to external providers. This poses no problem for many use cases, but it can be problematic when dealing with proprietary code, sensitive projects, or strict compliance requirements.
Continue delivers the same workflow locally. You get chat, autocomplete, and code explanations without leaving your editor and without sending source code to external servers.
Continue at a Glance
Continue is a plugin that integrates into your IDE. It offers:
- Chat: Conversations about selected code or open files.
- Autocomplete: Suggestions based on the current context.
- Refactoring: Rewrite, explain, or fix code.
- Multiple Providers: Ollama, OpenAI, Anthropic, and more.
- Local Models: Connect to Ollama or other local endpoints.
Who Is Continue For?
- Developers who want to use AI directly in the IDE
- Teams that cannot send source code to external providers
- Beginners who want to use Ollama in their daily workflow
- Anyone looking for an open alternative to GitHub Copilot
Key Concepts Around Continue
- IDE: Integrated development environment like VS Code or JetBrains.
- Ollama: Local platform for running language models.
- Autocomplete: Suggestions for the next lines of code.
- Inline Edit: Direct editing of selected code through AI commands.
- Context: The code and project background visible to the model.
- Tab Autocomplete: Suggestions when you press the Tab key.
Real-World Examples with Continue
Explaining Code
Select a complex function and ask Continue what it does. The model provides an explanation without leaving the editor.
Fixing Errors
An error message appears. Continue analyzes the code and error text, then suggests a corrected version.
Refactoring
You want to make a function shorter or more readable. Continue rewrites it, and you review the result.
Local Tab Autocomplete
With a small local model, Continue can show code suggestions as you type. For proprietary or sensitive projects, this is a major privacy advantage.
Common Pitfalls with Continue
- Model Too Large: Larger models are slower in the IDE. For autocomplete, smaller models often work better.
- Poor Context: Continue can only use the visible context. Unstructured projects yield weaker results.
- Insufficient VRAM or RAM: Autocomplete and chat run simultaneously and require adequate memory.
- Misconfigured Provider: Connecting to Ollama requires the correct URL and model.
- Unrealistic Expectations of Local Models: Local models are not always as precise as cloud-based ones.
Further Resources and Information on Continue
FAQ: Continue
Which editors does Continue support? Continue is available for Visual Studio Code and JetBrains. VS Code has the best support.
Do I need Ollama for Continue? No. Continue also works with OpenAI, Anthropic, or other APIs. For local operation, Ollama is the simplest choice.
How do I connect Continue with Ollama?
In the settings, enter the Ollama URL, for example http://localhost:11434. Then select the desired model.
Is Continue free? Continue itself is open source and free. Costs only occur when using external AI APIs.
How large should the model be for autocomplete? Models with 1 to 3 billion parameters are often fast enough for autocomplete. For chat and explanations, larger models with 7 billion parameters or more are suitable.
Sources and Further Reading
- Continue: https://www.continue.dev/
- Continue Docs: https://docs.continue.dev/
- Ollama: https://ollama.com/
Summary: Continue
Continue brings AI into your IDE and can run using local models via Ollama. Developers get chat, autocomplete, code explanations, and refactoring without sending source code to the cloud. For local workflows, a small model suffices for autocomplete and a medium-sized model for chat. When you properly connect Ollama and Continue, you get a privacy-friendly code assistant directly in your editor.