Connect Cursor IDE to Local Ollama: 2026 Setup

Why Run Ollama Models Inside Cursor IDE?

Related: Run OpenHands Locally with Ollama: Step-by-Step Guide →

Cursor has become the primary editor for engineers who want deep AI integration directly in their workflow. However, sending proprietary codebases to cloud-hosted endpoints like OpenAI or Anthropic is a non-starter for strict enterprise security compliance, air-gapped environments, or developers building on plane flights.

Connecting Cursor to a local Ollama instance solves the privacy issue while eliminating per-token API bills. You trade off cloud-scale reasoning for zero data leakage, low latency on local networks, and offline functionality.

+-------------------------------------------------------------+
|                         CURSOR IDE                          |
|                                                             |
|  [ Chat Panel ]        [ Inline Edit ]     [ Tab Complete ] |
+-------+-----------------------+-------------------+---------+
        |                       |                   |
        +-----------------------+-------------------+
                                |
             OpenAI-compatible REST API Calls
             Base URL: http://localhost:11434/v1
                                |
                                v
+-------------------------------------------------------------+
|                       LOCAL OLLAMA                          |
|                                                             |
|   +-------------------+    +----------------------------+   |
|   |  qwen2.5-coder    |    |  deepseek-r1:14b           |   |
|   |  (32k context)    |    |  (Reasoning/Architecture)  |   |
|   +-------------------+    +----------------------------+   |
+-------------------------------------------------------------+

Local models are not a toy setup anymore. Open-source coding weights now provide near-instant responses for function generation, refactoring, and inline completions without paying monthly subscriptions or hitting rate limits.

The hardware trade-off comes down to VRAM. To run local coding models alongside Cursor comfortably, you need sufficient memory bandwidth:

• 16GB VRAM / Unified Memory: Comfortable for qwen2.5-coder:7b or qwen2.5-coder:14b at Q4 quantization.
• 24GB to 32GB Memory: Sweet spot for running qwen2.5-coder:14b at 32k context windows, or qwen2.5-coder:32b for complex system architecture.
• 64GB+ Memory: Required for running 70B models or maintaining huge parallel context windows without system swap thrashing.

Step-by-Step: Pointing Cursor to Your Local Ollama Engine

Related: Enable Ollama Parallel Requests Without OOM Crashes →

Cursor doesn't ship with an explicit "Ollama" button in its settings panel. Instead, it relies on the fact that modern versions of Ollama host an OpenAI-compatible REST API endpoint natively on port 11434. By overriding Cursor's default OpenAI Base URL, we can trick the IDE into routing all model traffic to our local machine.

Step 1: Start and Verify Your Local Ollama Service

Make sure Ollama is running on your system. Open your terminal and run:

ollama serve

Verify that the local OpenAI endpoint is operational by hitting the models endpoint via curl:

curl http://localhost:11434/v1/models

You should receive a JSON response listing all locally downloaded models. If this fails with a connection refused error, your Ollama service is bound to a non-standard port or blocked by a local firewall.

Step 2: Override the OpenAI Base URL in Cursor

1. Open Cursor and press Cmd + , (macOS) or Ctrl + , (Windows/Linux) to open Settings.
2. Click on the Cursor Settings gear icon in the top-right of the window (or navigate to Models in the sidebar).
3. Expand the OpenAI API Key section.
4. Set the OpenAI Base URL to: http://localhost:11434/v1
5. Input a dummy key into the OpenAI API Key field. Enter ollama or sk-local-123456789. Cursor requires a string in this field to initialize the client request headers, even though local Ollama ignores auth tokens.

+-------------------------------------------------------+
| Cursor Settings -> Models                             |
+-------------------------------------------------------+
| OpenAI API Key  : [ sk-ollama-local                 ] |
| Override Base URL: [ http://localhost:11434/v1       ] |
+-------------------------------------------------------+

Step 3: Disable Default Cloud Models

Cursor attempts to call standard cloud models like gpt-4o or claude-3-5-sonnet by default. Because your local Ollama instance does not host these specific model aliases, Cursor will return 404 Not Found errors if they remain active.

In the same Models settings menu:

• Toggle off gpt-4, gpt-4o, gpt-3.5-turbo, and all claude models.
• Click Add Model at the bottom of the model list.
• Enter the exact model name string as registered in your local Ollama library (e.g., qwen2.5-coder:14b).
• Click Save.

Model Selection and Mapping: What Actually Works for Code

Related: Connect Claude Code CLI to Local Ollama Models →

Not every model in Ollama's library handles Cursor's system prompts well. Cursor formats inline edits and chat prompts using complex multi-turn system instructions that cause smaller, instruction-untuned models to hallucinate or generate raw system prompt artifacts.

1. Qwen 2.5 Coder (14B & 32B)

The qwen2.5-coder series is the undisputed champion for local Cursor integration. Trained specifically on code repos, it understands context markers, generates valid diffs, and respects strict JSON/Markdown outputs required by editor sidebars.

Pull the 14B variant for mid-range systems:

ollama pull qwen2.5-coder:14b

If you have 24GB+ VRAM (RTX 4090 or Apple Silicon M-series Pro/Max with 36GB+ Unified Memory), pull the 32B model:

ollama pull qwen2.5-coder:32b

2. DeepSeek R1 (14B & 32B Distill)

For deep logic debugging, system architecture queries, or complex refactoring inside the Cursor Chat sidebar, distilled DeepSeek R1 models perform exceptionally well.

ollama pull deepseek-r1:14b

Note: Reasoning models generate <think> block outputs. While excellent for side-by-side chat panels, avoid using reasoning models for auto-completions or direct inline edits, as they will attempt to output their step-by-step thinking directly into your source code file.

Registering Custom Names in Cursor

In Cursor's model configuration panel, model names must match the exact string returned by ollama list.

Fine-Tuning Context Windows and Fixing Timeout Errors

Related: Set Up Aider CLI with Ollama and Qwen 2.5 Coder →

The primary failure point when connecting Cursor to Ollama is the Context Window Limit.

By default, standard Ollama models initialize with a native context length of 2,048 tokens (num_ctx 2048). Cursor, however, aggregates your current active editor tab, imports, open files, and git status into the system prompt. This easily injects 8,000 to 20,000 tokens per request.

When Cursor pushes a 12,000-token prompt to an unmodified Ollama model running a 2,048-token context, Ollama will either silently truncate the input—causing chaotic code outputs—or throw a HTTP 500 Internal Server Error / Timeout inside Cursor.

Creating a Extended Context Modelfile

To fix context-related crashes, you must explicit override the num_ctx setting inside a custom Ollama Modelfile.

Create a file on your local machine named Modelfile-qwen-cursor:

FROM qwen2.5-coder:14b

Set default context length to 32,768 tokens

PARAMETER num_ctx 32768

Increase temperature slightly for fluid code generation

PARAMETER temperature 0.2

Tweak stop tokens to match Cursor's edit blocks

PARAMETER stop "<|im_start|>" PARAMETER stop "<|im_end|>"

Now, build the customized local model image via the terminal:

ollama create qwen2.5-coder-32k -f ./Modelfile-qwen-cursor

Once the build process completes, open Cursor Settings, navigate to Models, and add qwen2.5-coder-32k to your model list. Select this new model variant in your editor chat window.

+-----------------------------------------------------------------+
| TERMINAL                                                        |
| $ ollama create qwen2.5-coder-32k -f ./Modelfile-qwen-cursor    |
| Transferring system manifest                                    |
| Creating model layer...                                         |
| Writing manifest...                                             |
| Success                                                         |
+-----------------------------------------------------------------+

Increasing Timeouts in Cursor

When offloading large context frames to local GPUs, generation delay for the first token (TTFT) can spike. If Cursor times out waiting for Ollama to process prompt tokens, you must adjust the backend execution parameters.

If you hit generation drops or silent failures during full-file refactoring, add this setting directly into your user settings.json in Cursor:

{
  "http.timeout": 300,
  "cursor.general.agentTimeout": 300000
}

Essential Environment Variables for Zero-Latency Local Inference

Related: Run Bolt.diy Locally with Ollama: Free v0 Alternative →

Running Ollama as a standard background tray application can cause aggressive VRAM swapping. When Cursor stays idle for 5 minutes, Ollama unloads the model from your GPU VRAM to free up system memory. When you send your next prompt, your editor will freeze for 10-15 seconds while the model re-initializes back into VRAM.

Configure these system environment variables to optimize local backend performance for developer tools.

macOS Configuration (~/.zshrc or ~/.zprofile)

# Keep models loaded in VRAM permanently (prevents 15-second reload delay)
export OLLAMA_KEEP_ALIVE="24h"

Allow CORS requests from Cursor's internal Electron rendering processes

export OLLAMA_ORIGINS="*"

Process parallel sub-requests sent by Cursor file indexing

export OLLAMA_NUM_PARALLEL=4

Apply the changes:

source ~/.zshrc

Linux Configuration (/etc/systemd/system/ollama.service.d/override.conf)

If running Ollama via systemd on Linux, set environment variables directly in the service configuration:

[Service]
Environment="OLLAMA_KEEP_ALIVE=24h"
Environment="OLLAMA_ORIGINS=*"
Environment="OLLAMA_NUM_PARALLEL=4"

Reload and restart the service:

sudo systemctl daemon-reload
sudo systemctl restart ollama

Windows Configuration (PowerShell System Variables)

Open PowerShell as Administrator and run:

[System.Environment]::SetEnvironmentVariable('OLLAMA_KEEP_ALIVE', '24h', 'User')
[System.Environment]::SetEnvironmentVariable('OLLAMA_ORIGINS', '*', 'User')
[System.Environment]::SetEnvironmentVariable('OLLAMA_NUM_PARALLEL', '4', 'User')

Restart Ollama from the system tray for these variables to take effect.

Performance Comparison: Local Qwen 2.5 Coder vs. Cloud Models

Related: Kokoro TTS in Open WebUI: Zero-Latency Local Voice Setup →

How does a local Ollama model running inside Cursor perform relative to managed cloud APIs?

We benchmarked generation speeds and latency using identical code generation prompts (building a concurrent worker pool in Go with unit tests) across different hardware configurations.

Local inference running qwen2.5-coder:14b on dedicated hardware beats cloud endpoints on Time To First Token. It starts rendering code edits instantaneously because there is no network round-trip, handshake, or cloud queueing delay.

While Claude 3.5 Sonnet still holds an edge on architectural decisions across thousands of files, local models are substantially faster for everyday function generation, boilerplate creation, and targeted refactoring.

Frequently Asked Questions

Can local Ollama models run Cursor's full codebase indexing (@codebase)?

Yes, but with caveats. Cursor's @codebase feature constructs vector embeddings for your project files. While Cursor handles the local vector indexing natively on your CPU/GPU, passing large chunks of context retrieved from @codebase directly to a local Ollama model requires a 32k context window. Ensure you build a custom Modelfile with PARAMETER num_ctx 32768 as shown above, or local context retrieval will fail or truncate.

Why does Cursor show "Connection Refused" when using http://127.0.0.1:11434/v1?

Cursor runs inside an Electron shell where network routing handles loopback adapters differently depending on platform settings. Using http://localhost:11434/v1 instead of http://127.0.0.1:11434/v1 usually fixes loopback resolution issues. Also, ensure you set OLLAMA_ORIGINS="*" in your environment variables to stop cross-origin browser security restrictions from blocking preflight requests.

How do I get tab completion (Copilot-style inline autocomplete) working with Ollama models?

Cursor's real-time inline tab completion uses a custom, low-latency speculative decoding engine provided by Cursor's cloud infrastructure. By default, setting an OpenAI Base URL override changes the model handling for the Chat Window (Cmd+L) and Inline Edit (Cmd+K), but does not override tab completions. To date, Cursor does not officially expose a local hook for full Copilot-style tab completion via local Ollama instances.

What happens if I try to run a 70B model on 16GB of VRAM?

If the total model size exceeds available VRAM, Ollama offloads execution layers onto your system CPU and RAM. While it will run without crashing, execution speed drops drastically—often down to 1-2 tokens per second. For interactive use in Cursor, always pick a model size and quantization level (Q4_K_M is standard) that fits completely inside your available VRAM or Apple Silicon Unified Memory.