Six gigabytes is the whole design brief.

Ollama is the runtime. It manages downloads, loads weights onto the GPU, and exposes an OpenAI-compatible HTTP endpoint on port 11434 that every editor extension already knows how to talk to.

Grab OllamaSetup.exe from ollama.com/download and run it. It installs per-user, no admin needed, and starts a background service with a tray icon. Then confirm it's alive:

# PowerShell
ollama --version
curl http://localhost:11434

The second command should return Ollama is running. If it doesn't, open the tray icon and start it manually.

The G15 is a hybrid-graphics laptop — Intel or AMD integrated plus the NVIDIA card. Everything downstream depends on Ollama finding the 3050 and not quietly falling back to CPU.

nvidia-smi

You want to see the RTX 3050 listed, a driver version, and a memory column reading roughly 6144MiB. Note the number already in use with nothing running — that's your Windows desktop tax, usually 400–700 MB, and you never get it back.

Two, not ten. A small chat model and a smaller completion model, chosen so both fit in VRAM simultaneously. Different jobs, different weight classes.

# chat, explanations, single-function work — ~2.5 GB
ollama pull qwen3.5:4b

# fill-in-middle autocomplete — ~1 GB
ollama pull qwen2.5-coder:1.5b-base

Optional, if you later want local embeddings for a document index:

ollama pull nomic-embed-text  # ~275 MB

This is the step that decides whether your setup works. Ollama ships a small default context — a couple of thousand tokens. Any real task overflows it, and instead of erroring, the model silently forgets the beginning of the conversation and starts inventing.

Create a file named exactly Modelfile — no extension:

FROM qwen3.5:4b
PARAMETER num_ctx 8192

Then build the variant and point everything at it from here on:

ollama create qwen3.5:4b-8k -f Modelfile
ollama list

Why 8192 and not 32768: context lives in the KV cache, which sits in VRAM alongside the weights. On this card 8K is generous, 16K is possible if you close everything, and 32K will spill to system RAM and drop you to single-digit tokens per second. Drag the slider at the top of this page to see it happen.

A model that's 90% on the GPU and 10% on the CPU runs at roughly CPU speed. Partial offload is the single most common reason a local setup feels broken, and Ollama won't warn you about it.

Send one prompt, then immediately check what's resident:

ollama run qwen3.5:4b-8k "say hi"
ollama ps

Read the PROCESSOR column. It must say 100% GPU. Anything like 34%/66% CPU/GPU means you've overcommitted — lower num_ctx, close a VRAM consumer, or drop to a smaller model.

For the full picture, the server log records exactly how many layers made it onto the card:

Get-Content "$env:LOCALAPPDATA\Ollama\server.log" -Tail 60 | Select-String "offload"

Three environment variables do most of the work. Set them the same way you set OLLAMA_MODELS, then restart Ollama from the tray.

Twinny, not Cline. Cline is an autonomous agent built to plan across many files and run terminal commands — it needs far more context than this card can hold and will thrash. Twinny is a lighter extension that does the two things a 3050 does well: inline completion and side-panel chat.

Install Twinny from the VS Code marketplace, open its providers panel, and configure two entries. Field labels shift between versions, so match on meaning rather than exact wording:

Anything else speaking the OpenAI API works the same way: base URL http://localhost:11434/v1, any non-empty string as the API key.

Keep search as a tool the model calls, not something baked into the setup. Everything stays offline until you explicitly ask for a lookup.

The zero-cost path is Open WebUI with a self-hosted SearXNG — a browser chat UI over your local Ollama, with a search toggle and no API keys. Run both with Docker Desktop:

docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data --name open-webui \
  ghcr.io/open-webui/open-webui:main

Open localhost:3000, point it at http://host.docker.internal:11434, then add a SearXNG instance under Settings → Web Search.

On a 24 GB card VRAM hygiene is optional. On 6 GB it's the difference between 30 tokens per second and 3.

• Browsers reserve VRAM per window. Hardware acceleration in Chrome or Edge can hold several hundred megabytes. Closing tabs doesn't always release it — close the window.
• Don't run inference and OBS together. The NVENC encoder wants VRAM and it wants it consistently. Given the broadcast work, treat these as mutually exclusive modes rather than trying to tune around it.
• Plug in and set the Windows power mode to Best performance. On battery the 3050 clocks down hard and you'll blame the model.
• Expect fan noise. Sustained generation pins the GPU at 100%. This is normal, not a fault.
• Unload on demand when you need the card back: ollama stop qwen3.5:4b-8k.

--- daily ---
ollama ps                          # what's resident, and on what processor
ollama list                        # installed models and sizes
ollama run qwen3.5:4b-8k           # interactive chat in the terminal
ollama stop qwen3.5:4b-8k          # free the VRAM now

--- managing models ---
ollama pull <model>                # download
ollama rm <model>                  # delete and reclaim disk
ollama create <name> -f Modelfile  # build a tuned variant
ollama show <model>                # context length, quant, licence

--- diagnostics ---
nvidia-smi                         # VRAM total and in use
nvidia-smi -l 2                    # live, refreshing every 2s
curl http://localhost:11434        # is the server up
curl http://localhost:11434/api/tags   # models over HTTP

Nothing above makes a 3050 into an agentic coding machine, and no amount of configuration will. The jump that actually changes what's possible is 24 GB of VRAM — a used RTX 3090 desktop, roughly €600–800 once, which puts a 27B-class model fully on the card with 32K of context and makes autonomous multi-file agents viable.

Until then the honest split is: local models for autocomplete, offline work, and anything you don't want leaving the laptop; cloud models for the hard problems. Most people on this hardware land there, and it works better than trying to force one tool to do both jobs.