llama-vscode
ExtensionFreeLocal LLM-assisted text completion using llama.cpp
Capabilities14 decomposed
fill-in-middle (fim) code completion with configurable generation time limits
Medium confidenceProvides real-time inline code suggestions using the Fill-In-Middle pattern, where the LLM predicts code between cursor position and surrounding context. The extension sends the current file content with cursor position to a local llama.cpp server, which generates completions constrained by a configurable max generation time (preventing UI blocking). Suggestions appear as inline overlays in the editor and can be accepted via Tab, Shift+Tab for first line only, or Ctrl+Right for next word.
Uses Fill-In-Middle pattern with configurable generation time limits and smart context reuse mechanism (--cache-reuse 256) to support low-end hardware; predefined hardware-specific model presets (30B for >64GB VRAM down to 0.5B for CPU-only) eliminate manual tuning
Faster than cloud-based completers (Copilot, Codeium) for latency-sensitive workflows because inference runs locally; more resource-efficient than Ollama-based setups due to llama.cpp's optimized server implementation and context caching
configurable context window with multi-file awareness
Medium confidenceDynamically constructs context for completions by combining the current file content with configurable window size around cursor position, plus optional chunks from other open/edited files. The extension maintains a smart context reuse cache to avoid redundant re-computation on low-end hardware. Context scope and cache reuse parameters are user-configurable via settings, allowing developers to trade off suggestion quality vs inference latency.
Implements smart context reuse caching (--cache-reuse 256) to avoid redundant re-computation on low-end hardware; combines current file + open files + clipboard in single context vector, with user-configurable window size and cache parameters for hardware-specific tuning
More efficient than Copilot's cloud-based context management because caching happens locally and can be tuned per-machine; more flexible than Tabnine's fixed context window because scope is fully configurable
hardware-specific model presets with automatic parameter tuning
Medium confidenceProvides predefined llama.cpp command configurations optimized for five hardware tiers: >64GB VRAM (Qwen2.5-Coder 30B), >16GB VRAM (7B), <16GB VRAM (3B), <8GB VRAM (1.5B), and CPU-only (0.5B or 1.5B). Each preset includes optimized batch size (-b, -ub), context size (--ctx-size), and cache reuse (--cache-reuse 256) parameters. Users select hardware tier via environment selection, and extension applies preset parameters automatically without manual tuning.
Five-tier hardware presets with Qwen2.5-Coder model variants (30B-0.5B) provide granular hardware-specific optimization; automatic parameter application eliminates manual llama.cpp CLI tuning; cache-reuse mechanism (--cache-reuse 256) specifically optimizes for low-end hardware
More user-friendly than raw llama.cpp which requires manual parameter research; more granular than Ollama's single-model approach because presets support multiple model sizes per-task
model storage and caching with os-specific cache directories
Medium confidenceManages model file storage in OS-specific cache directories: ~/Library/Caches/llama.cpp/ (Mac OS), ~/.cache/llama.cpp (Linux), LOCALAPPDATA (Windows). Models are downloaded from Huggingface or user-provided paths and cached locally to avoid re-downloading. The extension maintains a model registry tracking available models and their locations. Cache directory location is OS-specific and not user-configurable.
OS-specific cache directories (~/Library/Caches on Mac, ~/.cache on Linux, LOCALAPPDATA on Windows) provide system integration; automatic model caching eliminates manual file management; model registry tracks available models and locations
More integrated than manual model management; OS-standard cache directories vs Ollama's single models directory
plaintext and code file support with language-agnostic completion
Medium confidenceSupports code completion and chat for multiple file types including JavaScript, TypeScript, Python, and plaintext. The extension sends file content to llama.cpp without language-specific preprocessing, allowing FIM models to handle language detection and completion. No explicit language detection or syntax-aware parsing documented; completion works uniformly across supported file types.
Language-agnostic completion using single FIM model across JavaScript, TypeScript, Python, and plaintext — no language-specific model selection required; Qwen2.5-Coder series trained on diverse languages enabling polyglot support
Simpler than language-specific completion engines (e.g., Copilot's per-language models); more flexible than Tabnine which requires language selection
clipboard/yanked text context inclusion in completions
Medium confidenceIncludes clipboard or yanked text as part of the context sent to the LLM for completions and chat. This allows users to reference code snippets, documentation, or other text without manually copying into the file. Clipboard content is automatically detected and included in the context window alongside current file and open files.
Automatic clipboard inclusion in context without explicit user action; allows implicit reference to external code/documentation without copy-paste workflow
More implicit than Copilot which requires explicit context selection; reduces friction vs manual copy-paste workflows
chat interface with local llm models
Medium confidenceProvides a conversational chat UI accessible via the Explorer sidebar, allowing users to interact with selected chat models running on the local llama.cpp server. Chat context includes access to current file, open files, and clipboard content. The extension manages model selection per-task (completion vs chat vs embeddings) and supports both predefined models (Qwen2.5-Coder, gpt-oss 20B) and custom models via add/remove/export/import functionality.
Chat runs entirely locally on llama.cpp server with no cloud dependency; supports per-task model selection (completion vs chat vs embeddings) via environment concept, allowing users to run lightweight completion models alongside heavier chat models
Maintains full data privacy compared to ChatGPT/Claude integrations; allows model switching per-task unlike Copilot Chat which uses single backend model
agentic coding workflows with autonomous task execution
Medium confidenceEnables Llama Agent functionality for autonomous coding tasks, where the AI can decompose user requests into sub-tasks and execute them with access to MCP (Model Context Protocol) tools. The agent runs locally on the llama.cpp server and can invoke selected MCP tools from VS Code-installed MCP Servers. Documentation indicates support for local models (gpt-oss 20B recommended) but details are incomplete.
Integrates MCP (Model Context Protocol) tools directly into local agent execution; agent runs on llama.cpp server without cloud dependency; supports tool-calling models with schema-based function invocation
Full local execution vs GitHub Copilot Workspace (cloud-based); MCP integration provides standardized tool protocol vs custom API integrations in other agents
model and environment management with predefined hardware presets
Medium confidenceProvides a model registry system where users can add/remove/export/import models for different tasks (completion, chat, embeddings, tools). The extension groups models into 'environments' — predefined configurations optimized for specific hardware tiers (>64GB VRAM, >16GB VRAM, <16GB VRAM, <8GB VRAM, CPU-only). Each environment selects appropriate model sizes and llama.cpp parameters (batch size, context size, cache reuse). Predefined models include Qwen2.5-Coder series (30B, 7B, 3B, 1.5B, 0.5B) and gpt-oss 20B.
Predefined hardware-specific environments eliminate manual llama.cpp parameter tuning; environment concept groups models per-task (completion vs chat vs embeddings vs tools) allowing users to run different model sizes simultaneously; Qwen2.5-Coder series provides 5 size variants (30B-0.5B) for hardware-specific optimization
More user-friendly than raw llama.cpp CLI because presets handle parameter tuning; more flexible than Ollama's single-model-at-a-time approach because environments support multiple models per-task
mcp (model context protocol) tool integration with schema-based function calling
Medium confidenceIntegrates with VS Code-installed MCP Servers to expose tools for use by chat and agentic workflows. The extension discovers available MCP tools, parses their schemas, and passes them to the LLM as function-calling definitions. Users manually select which MCP tools to enable per-session. Tools are invoked by the LLM during chat or agent execution with arguments generated by the model based on tool schemas.
Uses MCP (Model Context Protocol) for standardized tool integration instead of custom API bindings; schema-based function calling allows LLM to autonomously invoke tools with generated arguments; tools run locally on MCP Servers without cloud dependency
Standardized MCP protocol vs Copilot's proprietary tool integration; local tool execution vs cloud-based tool services like Anthropic's tool use API
keybinding-driven suggestion acceptance with granular control
Medium confidenceProvides multiple keybindings for accepting code suggestions with different granularity levels: Tab accepts full suggestion, Shift+Tab accepts only first line, Ctrl+Right accepts next word. Ctrl+L manually triggers suggestion generation. Ctrl+Shift+M opens the llama-vscode menu. This design allows developers to accept suggestions at the level of detail they need without full acceptance or rejection.
Multi-level suggestion acceptance (full, first-line, word-level) via distinct keybindings provides granular control without modal dialogs; Tab for full acceptance matches GitHub Copilot convention for familiarity
More granular control than Copilot (which only offers full acceptance or rejection); word-level acceptance unique among code completion tools
automatic llama.cpp installation and lifecycle management
Medium confidenceProvides one-click installation of llama.cpp server via VS Code command palette ('Install/Upgrade llama.cpp'). On Mac and Windows, the extension automatically downloads and installs appropriate binaries. On Linux, users must manually install from source or binaries. The extension manages llama.cpp server lifecycle (start/stop) and exposes configuration options for batch size, context size, and cache reuse parameters via llama.cpp CLI flags.
One-click llama.cpp installation on Mac/Windows eliminates manual compilation or binary management; integrated server lifecycle management within VS Code eliminates need for separate terminal/process manager
Simpler than raw llama.cpp setup which requires manual binary download and CLI configuration; more integrated than Ollama which requires separate application
status bar integration with quick access menu
Medium confidenceDisplays extension status in VS Code status bar (bottom right) with clickable access to the llama-vscode menu. Status bar shows current model/environment selection and server status. Clicking status bar or pressing Ctrl+Shift+M opens menu for model selection, environment switching, and configuration. This provides quick access to extension controls without opening settings or command palette.
Status bar integration provides always-visible indication of active model and server status; single-click menu access eliminates command palette navigation for frequent model switching
More discoverable than Copilot's settings-buried model selection; faster than command palette for frequent switching
explorer sidebar llama agent ui for task management
Medium confidenceProvides a dedicated Explorer sidebar panel for Llama Agent functionality, displaying agent tasks, execution status, and results. The sidebar UI allows users to initiate agentic workflows, monitor execution progress, and view agent-generated code changes. Integration with VS Code's Explorer sidebar keeps agent workflows visible alongside file tree and other sidebar panels.
Dedicated Explorer sidebar panel for agent workflows keeps agentic tasks visible alongside file navigation; integrates agent execution monitoring directly into VS Code UI without separate window
More integrated than external agent dashboards; sidebar placement provides persistent visibility vs modal dialogs
Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.
Related Artifactssharing capabilities
Artifacts that share capabilities with llama-vscode, ranked by overlap. Discovered automatically through the match graph.
CodeGemma
Google's code-specialized Gemma model.
Codestral
Mistral's dedicated 22B code generation model.
Mistral: Codestral 2508
Mistral's cutting-edge language model for coding released end of July 2025. Codestral specializes in low-latency, high-frequency tasks such as fill-in-the-middle (FIM), code correction and test generation. [Blog Post](https://mistral.ai/news/codestral-25-08)
CodeLlama 70B
Meta's 70B specialized code generation model.
CodeLlama (7B, 13B, 34B, 70B)
Meta's CodeLlama — Llama-based model specialized for code — code-specialized
mistral-inference
<br>[mistral-finetune](https://github.com/mistralai/mistral-finetune) |Free|
Best For
- ✓Solo developers building locally-hosted coding assistants
- ✓Teams with strict data residency requirements who cannot use cloud-based completion
- ✓Developers on resource-constrained hardware wanting lightweight completion
- ✓Developers working with multi-file codebases who need cross-file context awareness
- ✓Teams on resource-constrained hardware (laptops, older machines) needing latency optimization
- ✓Projects with strict context size requirements (embedded systems, firmware development)
- ✓Non-technical users unfamiliar with llama.cpp parameter tuning
- ✓Developers with multiple machines (desktop, laptop, server) wanting one-click switching
Known Limitations
- ⚠FIM-compatible models only — standard chat models cannot be used for completion
- ⚠Quality degrades significantly on CPU-only hardware; Qwen2.5-Coder 0.5B recommended for <8GB VRAM
- ⚠Generation time configurable but hardware-dependent; cannot guarantee sub-100ms latency on low-end machines
- ⚠Context window limited by available VRAM; larger files may require context truncation
- ⚠Context window size is hardware-dependent; larger windows increase latency exponentially
- ⚠Cache reuse mechanism adds complexity; incorrect cache-reuse values may cause stale context
Requirements
Input / Output
UnfragileRank
UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.
About
Local LLM-assisted text completion using llama.cpp
Categories
Alternatives to llama-vscode
Are you the builder of llama-vscode?
Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.
Get the weekly brief
New tools, rising stars, and what's actually worth your time. No spam.
Data Sources
Looking for something else?
Search →