Local Autocomplete

Inline code completions in VS Code from a model that runs on your own machine — Ollama, LM Studio, llama-server (llama.cpp), vLLM, LocalAI. Nothing leaves your computer, and there is no subscription.

The model is chosen by you, and can be switched per file, per language, or everywhere, from the status bar.

Requirements

1. A local server that can run a completion model: Ollama, LM Studio, llama.cpp's llama-server, vLLM, LocalAI, …
2. A code model trained for fill-in-the-middle (FIM), preferably a base (non-instruct) variant. Chat models are trained to talk, not to continue your code, and give poor completions.

With Ollama:

ollama pull qwen2.5-coder:1.5b-base

Anything from ~1.5B up works; bigger models are better but slower. The default setting is qwen2.5-coder:1.5b-base.

Quick start

Install the extension, start your server, then open the status bar item (bottom right, ✨ Autocomplete) and pick Select model…. That's it — completions appear as ghost text as you type; press Tab to accept.

If the server is not on the default port, set localAutocomplete.provider and localAutocomplete.endpoint:

Leave endpoint empty to use the provider's default. A bare origin such as http://127.0.0.1:1234 gets /v1 added for you.

Chat-only servers

Some proxies and gateways implement /v1/chat/completions and answer /v1/completions with 404: not found. Pick openai-chat for those: the prompt is sent as a single user message, a markdown fence around the reply is removed, and chain-of-thought in reasoning_content is ignored.

This is a compatibility mode, not a quality one — a chat model talks about code instead of continuing it, so set fimTemplate to custom and give it an instruction instead of fill-in-the-middle markers:

Complete the code. Return ONLY the missing code, no explanation and no markdown fence.

Code before the cursor:
{prefix}
Code after the cursor:
{suffix}
Missing code:

A reasoning model thinks before it answers, so raise maxTokens until the reply contains any code at all; if it spends the whole budget thinking, the extension says so instead of staying quiet.

Turning it on and off

Three switches, most specific wins:

1. Everywhere — localAutocomplete.enable. Off means off: no request is made, whatever the other settings say.
2. Per language — localAutocomplete.disabledLanguages, e.g. ["markdown", "plaintext"].
3. Per file — remembered in extension storage, keyed by the file's URI. A notebook cell belongs to its notebook. Overrides for files that are deleted or renamed are dropped automatically, and only the 200 most recent files are kept.

The status bar shows which switch decided the current file, and clicking it opens a menu with the three toggles, model selection, the API key, settings and the log. If you would rather not see it, set localAutocomplete.showStatusBar to iconOnly or hidden. The same actions are commands:

Per-language and everywhere state are settings, so they sync across machines and can be set per workspace. Per-file choices are not.

Settings

multiline, maxTokens, temperature, debounceMs, maxPrefixChars and maxSuffixChars are language-overridable, so a [python] block in settings.json can ask for longer completions in Python than in JSON:

{ "localAutocomplete.maxTokens": 64, "[python]": { "localAutocomplete.maxTokens": 256 } }

fimTemplate: auto recognises the format from the model name. Each family is trained on its own special tokens, and a mismatch gives poor or empty completions — if the log says the format was guessed, set it explicitly.

How it behaves

• Works alongside IntelliSense. While the suggestion list is open, the completion is written as if the selected item had been accepted, so the ghost text fits the code you are about to have.
• No completion in the middle of a word — if characters follow the cursor that look like part of an identifier, you are editing a name, not writing code.
• Multi-line completions stop when the model's output drops back to a lower indent or repeats the first non-empty line below the cursor.
• Single-line completions may overwrite the rest of the line when it appears in order inside the completion, which avoids duplicated auto-closed brackets and quotes.
• Recent completions are cached (64 entries) keyed by the text around the cursor: typing the start of a suggestion, or deleting back to where it was made, is answered without asking the model again.
• The prompt is cut at whole lines so its start stays put while you type, which lets the server reuse its prompt cache.
• Completions stream (localAutocomplete.stream). The first characters appear as soon as the server sends them, and the request is closed the moment the completion cannot change any more — a stop sequence landed, or the block clearly ended. Turn it off to get one response back, which is what a server that does not support streaming needs.
• The context window is requested, not assumed. Ollama defaults to 4096 tokens and silently drops the start of a longer prompt, which cuts off the <|fim_prefix|> marker and produces nonsense. When the prompt needs more, the extension asks for a bigger num_ctx (up to maxContextTokens) and logs what it did. If a server still refuses, the notification tells you to shrink maxPrefixChars.
• Requests are cancelled as soon as you keep typing, and give up after timeoutMs. The first failure of each kind raises one notification (with Copy Command for a missing Ollama model, Open Settings, Show Log); later ones only mark the status bar and the log, so a stopped server does not pop up on every keystroke.
• Completions are offered in normal editors, notebook cells, remote and virtual workspaces — not in output panes, diff views or the commit message box. Untrusted workspaces are supported; nothing is sent anywhere but to the server you configured.

Development

npm install
npm run compile          # tsc -> out/
npm run watch
npm test                 # unit tests (node --test)
npm run test:integration # real VS Code via vscode-test
npm run format           # prettier --write
npm run format:check     # prettier --check, run by CI
npm run package          # -> local-autocomplete-<version>.vsix

The integration test starts a stub Ollama server in-process (/api/generate and /api/tags), so it needs no local model. To run it against your installed VS Code instead of downloading one:

VSCODE_EXECUTABLE="/Applications/Visual Studio Code.app/Contents/Code" npm run test:integration

.vscode/ is committed with a launch config: press F5 to start an Extension Development Host that runs the extension from out/.

GitHub Actions runs the format check, the compile and the unit tests on Linux, macOS and Windows, and the integration tests under Xvfb (.github/workflows/ci.yml). Pushing a v* tag builds the .vsix and attaches it to the release.

License

MIT.