Connect Avante.nvim to Local Ollama: 2026 Neovim Guide

Why Ditch Cursor for Avante.nvim and Local Ollama?

Related: LiteLLM Proxy Local Ollama Setup: Unified AI Gateway →

The appeal of Cursor was never its proprietary editor fork. It was the seamless UI interaction: side-by-side code application, inline diff previews, and project-aware contextual edits. However, sending proprietary backend logic or sensitive microservice code to external endpoints is a non-starter for many compliance environments. Beyond privacy, cloud latency and API rate limits ruin flow state during heavy refactoring sessions.

Avante.nvim brings that exact Cursor workflow directly inside native Neovim. When combined with local Ollama backends, you get zero-latency autocomplete, offline code generation, and zero subscription fees.

Running local LLMs inside Neovim used to mean settling for weak 7-billion-parameter models that hallucinated basic syntax. The hardware and open-weights landscape shifted dramatically. Models like Qwen 2.5 Coder and DeepSeek-R1 deliver benchmark results that match or surpass proprietary cloud models on daily software engineering tasks.

Setting up an avante nvim ollama setup is not without friction. Out of the box, default configurations often cause buffer streaming crashes, missing response chunks, truncated context windows, and inline diff corruption. This guide walks through configuring Avante.nvim with local Ollama models in Lua, tuning VRAM parameters, and fixing streaming bottlenecks.

Hardware Requirements and Ollama Model Preparation

Related: Connect AnythingLLM to Local Ollama: 2026 Setup Guide →

Local inference for code generation requires predictable memory bandwidth and sufficient VRAM. While CPU inference via llama.cpp is possible, it is too slow for real-time code completion and interactive diffs. Aim for generation speeds of at least 25 tokens per second.

Here is what you need depending on your target model:

• 14B Models (Qwen 2.5 Coder 14B / DeepSeek-R1 Distill 14B): Minimum 12 GB VRAM (RTX 3060/4070 or Apple Silicon M-series with 18 GB+ unified memory).
• 32B Models (Qwen 2.5 Coder 32B): Minimum 24 GB VRAM (RTX 3090/4090 or Apple Silicon M-series with 36 GB+ unified memory).

Pulling the Models

Start by fetching the base models via Ollama. Open your terminal and run:

# High-speed general code editing and completion
ollama pull qwen2.5-coder:14b-instruct-q4_K_M

Deep reasoning and complex algorithm planning

ollama pull deepseek-r1:14b

Fixing the Ollama Default Context Cut-off

By default, Ollama allocates a small context window (typically 2048 or 4096 tokens) unless explicitly overridden. When Avante.nvim scans your active buffer, cursor position, and project files, the prompt context quickly exceeds 4000 tokens. When this happens, Ollama drops older tokens silently, leading to truncated code blocks or total API failure.

You must adjust Ollama's runtime environment variables and define higher context memory limits (num_ctx). Set these environment variables in your shell configuration (.bashrc, .zshrc, or systemd service):

export OLLAMA_KEEP_ALIVE="24h"
export OLLAMA_NUM_PARALLEL="2"

Restart your Ollama service after modifying environment variables:

systemctl --user restart ollama

Complete Lua Configuration for Avante.nvim

Related: Run Dify Locally with Ollama: Step-by-Step Setup Guide →

Avante.nvim supports custom provider configurations through Lua. While Avante includes built-in providers, configuring Ollama via its OpenAI-compatible REST endpoint (/v1) gives you full control over system prompts, temperature settings, and payload overrides.

Below is a battle-tested lazy.nvim specification. It defines custom local configurations for both Qwen 2.5 Coder and DeepSeek-R1, complete with parameter overrides to stop payload rejection.

Place this configuration inside your Neovim plugin directory (for example, ~/.config/nvim/lua/plugins/avante.lua):

return {
  "yetone/avante.nvim",
  event = "VeryLazy",
  lazy = false,
  version = false, -- Set to false to pull latest fixes
  opts = {
    provider = "qwen_coder",
    auto_suggestions_provider = "qwen_coder",
    
    -- Configure custom local providers
    custom_providers = {
      qwen_coder = {
        __inherited_from = "openai",
        api_key_name = "",
        endpoint = "http://127.0.0.1:11434/v1",
        model = "qwen2.5-coder:14b-instruct-q4_K_M",
        parse_curl_args = function(opts, code_opts)
          return {
            url = opts.endpoint .. "/chat/completions",
            headers = {
              ["Content-Type"] = "application/json",
            },
            body = {
              model = opts.model,
              messages = require("avante.providers").openai.parse_messages(code_opts),
              temperature = 0,
              max_tokens = 8192,
              stream = true,
              -- Critical Ollama parameters passed via request body
              options = {
                num_ctx = 16384,
                num_predict = 8192,
              },
            },
          }
        end,
        parse_response_data = function(data_stream, event_state, opts)
          require("avante.providers").openai.parse_response_data(data_stream, event_state, opts)
        end,
      },
      deepseek_r1 = {
        __inherited_from = "openai",
        api_key_name = "",
        endpoint = "http://127.0.0.1:11434/v1",
        model = "deepseek-r1:14b",
        parse_curl_args = function(opts, code_opts)
          return {
            url = opts.endpoint .. "/chat/completions",
            headers = {
              ["Content-Type"] = "application/json",
            },
            body = {
              model = opts.model,
              messages = require("avante.providers").openai.parse_messages(code_opts),
              temperature = 0.6,
              stream = true,
              options = {
                num_ctx = 16384,
              },
            },
          }
        end,
        parse_response_data = function(data_stream, event_state, opts)
          require("avante.providers").openai.parse_response_data(data_stream, event_state, opts)
        end,
      },
    },

-- UI and Behavior Configurations behaviour = { auto_suggestions = false, -- Enable if you want real-time inline completion list_models = true, minimize_diff = true, auto_apply_diff_after_generation = false, }, windows = { position = "right", width = 38, sidebar_header = { enabled = true, align = "center", rounded = true, }, input = { prefix = "> ", height = 8, }, edit = { border = "rounded", start_insert = true, }, ask = { floating = false, start_insert = true, border = "rounded", }, }, }, build = "make", dependencies = { "stevearc/dressing.nvim", "nvim-lua/plenary.nvim", "MunifTanjim/nui.nvim", --- Optional dependencies for rich UI rendering "hrsh7th/nvim-cmp", "nvim-tree/nvim-web-devicons", { "HakonHarnes/img-clip.nvim", event = "VeryLazy", opts = { default = { embed_image_as_base64 = false, prompt_for_file_name = false, drag_and_drop = { insert_mode = true, }, }, }, }, { 'MeanderingProgrammer/render-markdown.nvim', ft = { "markdown", "Avante" }, opts = { file_types = { "markdown", "Avante" }, }, }, }, }

This avante nvim provider config guarantees that your local model requests pass the options.num_ctx payload directly to Ollama. Without passing options.num_ctx within parse_curl_args, Ollama resets your context length back to system defaults, breaking large file refactoring.

DeepSeek-R1 vs. Qwen 2.5 Coder: Local Benchmarks

Related: Zed Editor Ollama Setup: Fast Local AI Coding Guide →

Selecting the right avante.nvim local model depends on your hardware and task requirements. While both models run locally via Ollama, their architecture dictates how they process Neovim editor buffers.

Qwen 2.5 Coder is optimized for fast raw code generation. It matches standard developer instructions immediately, making it ideal as a primary cursor alternative neovim ollama engine. DeepSeek-R1 excels at architectural decisions, but its reasoning chain introduces formatting challenges during direct file modification.

Troubleshooting Streaming Crashes and Context Cut-offs

Related: Run LM Studio Headless on Linux: Full CLI Setup Guide →

Integrating local AI models inside a Neovim terminal process introduces complex async stream management issues. Below are the three most common failures encountered during an avante nvim ollama setup and how to resolve them.

1. Buffer Streaming Crashes (HTTP 400 / JSON Parse Error)

In your custom_providers table:

-- Ensure max_tokens doesn't exceed Ollama's num_ctx allocation
body = {
  model = opts.model,
  temperature = 0,
  max_tokens = 4096, -- Keep under num_ctx ceiling
  options = {
    num_ctx = 16384,
  }
}

2. DeepSeek-R1 <think> Tags Breaking Inline Diffs

opts = {
  system_prompt = "You are an AI coding assistant. You must output raw code fixes directly. Do not output any <think> or reasoning tags in your response. Output only valid code.",
}

Alternatively, switch to qwen_coder for auto-apply inline refactoring, and reserve deepseek_r1 strictly for interactive chat via :AvanteAsk.

3. Out-Of-Memory (OOM) GPU Soft Locks

# Unload models after 10 minutes of inactivity instead of keeping them pinned
export OLLAMA_KEEP_ALIVE="10m"

Frequently Asked Questions

Why does Avante.nvim show empty responses with my local Ollama model?

Empty responses occur when the model endpoint accepts the network request but fails to format the payload in an OpenAI-compatible JSON schema. Ensure your custom_providers Lua definition explicitly passes stream = true and points to the /v1/chat/completions endpoint path rather than raw native Ollama endpoints like /api/generate.

Can I use multi-file code editing with local 14B models?

Yes. However, performance depends on context allocation. A 14B model like Qwen 2.5 Coder can scan 3 to 5 open files effectively provided your num_ctx parameter is set to at least 16384 tokens. For larger codebases spanning dozens of modules, upgrade to a 32B model parameter size or use fine-tuned vector indexing plugins like neovim-remote alongside Avante.

How do I switch between Qwen 2.5 Coder and DeepSeek-R1 on the fly?

You can switch providers dynamically without restarting Neovim. Run the :AvanteSwitchProvider command within Neovim to select any configuration defined inside your custom_providers Lua block, or write a quick keymap:

vim.keymap.set("n", "<leader>aq", "<cmd>AvanteSwitchProvider qwen_coder<cr>", { desc = "Switch to Qwen Coder" })
vim.keymap.set("n", "<leader>ad", "<cmd>AvanteSwitchProvider deepseek_r1<cr>", { desc = "Switch to DeepSeek R1" })

What is the optimal temperature setting for local Neovim coding models?

For precise code modifications, set temperature = 0. This disables stochastic sampling and enforces deterministic output, preventing syntax errors in language constructs. If you are using local models to write initial docstrings or design system architecture, increase the temperature to 0.4 or 0.6.