How to Use Claude Code With Ollama and Qwen3-Coder

You can use Claude Code with Ollama as a local coding setup, but the wording matters. You are not running Anthropic’s Claude model locally. You are using Claude Code as the coding harness and asking Ollama to serve a local coding model such as Qwen3-Coder.

That difference is the whole article.

If you only want to chat with a local model, plain Ollama is enough. If you want a project-aware coding assistant that can inspect files, reason through a repository, suggest changes, and work inside a terminal loop, you need a harness around the model.

Claude Code can be that harness. Ollama can be the local model runtime. A coding model like Qwen3-Coder can be the local model behind the loop.

This guide walks through what the setup does, what hardware makes sense, how to connect the pieces, and where the limits still are.

If you are brand new to local models, start with the broader Local AI for Beginners guide first. If you already have Ollama running and want to test a local coding agent workflow, this is the practical path.

Use plain Ollama when you want local model chat.
Use Claude Code + Ollama when you want a coding harness around that local model.

What This Setup Actually Does

Claude Code is Anthropic’s terminal-based coding tool. It can work inside a project, inspect files, propose edits, run commands, and help with software tasks from the command line.

Ollama is the local model runtime. It downloads and runs models on your own machine.

Qwen3-Coder is a coding-focused model family available through Ollama. The official Qwen team describes Qwen3-Coder as a model line built for coding and agentic software engineering tasks.

When these pieces are connected, the basic flow looks like this:

You open Claude Code inside a project. Claude Code sends model requests to a local Ollama-compatible endpoint. Ollama runs the selected coding model. Claude Code then uses that model response inside the coding loop.

Think of it as separating the harness from the model.

Claude Code provides the coding workflow. Ollama provides the local backend. Qwen3-Coder provides the local coding model.

That is why calling this “free Claude Code” is a little sloppy. The better description is: Claude Code with a local Ollama model backend.

How Claude Code Agents, Models, and Commands Fit Together

A lot of searches around this topic mix together three different ideas: Claude Code agents, Claude Code models, and Claude Code commands.

The model is the reasoning engine. In the normal hosted setup, that usually means Anthropic’s models. In this local setup, the model is served by Ollama, such as Qwen3-Coder.

The agent behavior comes from the harness around the model. Claude Code can inspect files, plan work, suggest edits, and run commands because it is operating inside a terminal workflow with project context and tool access.

The commands are how you steer that workflow. You still decide what project to open, what the assistant is allowed to inspect, whether it can edit files, and what review step happens before you accept the change.

That is why a local coding agent is not just “Ollama plus a prompt.” Ollama supplies the local model. Claude Code supplies the coding harness. Your review loop supplies the judgment.

Why Not Just Use Ollama by Itself?

Plain Ollama is great when you want to ask a local model a question, test a prompt, expose a local API, or plug local AI into a workflow.

But plain Ollama is not automatically a coding agent. It can answer coding questions, but it is not automatically moving through your repository with a project-aware workflow.

That harness layer is the reason this setup is interesting.

Plain Ollama is usually enough for small isolated questions. Claude Code plus Ollama makes more sense when you want the model to work inside a real codebase, read files, suggest a change, and help you review the result.

The tradeoff is simple: the local model still has to be capable enough. A strong harness around a weak local model still gives you a weak coding assistant. The tool loop helps, but it does not magically upgrade the model’s judgment.

Why Qwen3-Coder Is a Good Starting Point

Qwen3-Coder is a practical place to start because it is built for coding work instead of general chat alone. Ollama lists Qwen3-Coder in its model library, and the official Qwen3-Coder release notes describe the family around coding and agentic software engineering use cases.

The default Ollama model page currently points people toward a 30B Qwen3-Coder option for local use. Larger variants exist, but they are not normal laptop territory. If you are trying this on a personal machine, start with the smaller practical option before daydreaming about giant models that want workstation-class memory.

For broader model selection, use the Best Ollama Models for Beginners guide. For this specific article, the important decision is not “which model is the internet’s favorite today.” It is whether the model is strong enough, local enough, and fast enough for the work you want to do.

Hardware Expectations

Claude Code itself is not the heavy part. Running the local model is the heavy part.

For simple experiments, a machine with 16 GB of memory can teach you the setup, especially with smaller coding models. I would not expect the larger Qwen3-Coder options to feel smooth there.

A more realistic baseline is 32 GB of RAM or unified memory, or a GPU with around 24 GB of VRAM, if you want to test a larger coding model without constant frustration.

A comfortable local setup is closer to 48 GB to 64 GB of unified memory, or a workstation GPU with enough VRAM for the model and context you want to use. This is where local coding agents start to feel like a real tool instead of a patience exercise.

Context length matters too. Ollama’s context length documentation notes that longer coding tasks may need larger context windows. Ollama’s Claude Code guidance recommends a large context setting for coding-tool use because coding agents often need to keep project structure, instructions, diffs, and tool results in memory.

That does not mean “turn context to the moon” and hope for the best. Larger context uses more memory. Start practical, test, and increase only when you have a reason.

Step 1: Install and Test Ollama

Install Ollama from the official Ollama download page.

After installation, confirm the command works:

ollama --version

Then pull the coding model:

ollama pull qwen3-coder

Run a tiny direct test before involving Claude Code:

ollama run qwen3-coder "Write a small JavaScript function that validates an email string."

If Ollama is painfully slow by itself, the Claude Code harness will not make it fast. Fix the local model side first.

If this is your first time with Ollama, use the Ollama tutorial for beginners before layering a coding agent on top.

Step 2: Install Claude Code

Install Claude Code from Anthropic’s official Claude Code setup documentation. Follow the current official install path for your operating system, because install commands can change over time.

After installation, check that the CLI is available:

claude --version

Do this part normally first. Do not debug Ollama, environment variables, context settings, and Claude Code installation all at once. That is how a small setup turns into a three-hour terminal archaeology session.

Step 3: Connect Claude Code to Ollama

Ollama provides an Anthropic-compatible local path for Claude Code. The official Ollama Anthropic compatibility notes cover the Claude Code setup and the local endpoint behavior in more detail.

The simple launch pattern is:

ollama launch claude --model qwen3-coder

You can also configure the integration first:

ollama launch claude --config

If you need to understand the manual version, Claude Code can be pointed at a compatible endpoint with environment variables. Claude Code documents provider and configuration settings in its official docs, and Ollama exposes a local server on localhost:11434.

export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model qwen3-coder

If your shell already has Anthropic API variables set, check them before troubleshooting:

env | grep ANTHROPIC

If Claude Code keeps using the wrong provider, your environment is usually the first place to look.

Step 4: Test It on a Safe Project

Do not point your first local coding-agent test at production code.

Use a small folder with Git initialized:

mkdir local-coding-agent-test
cd local-coding-agent-test
git init

Add one tiny file:

cat > app.js <<'EOF'
function add(a, b) {
  return a + b
}

console.log(add(2, 3))
EOF

Then launch the local Claude Code setup and use a boring test prompt:

Read this tiny project. Add a simple test file for the add function, then explain what you changed before running anything.

Boring is good here. Boring tells you whether the wiring works.

You are checking whether the model can inspect the project, understand a small task, propose a change, and stay inside the boundaries you gave it.

Step 5: Keep a Human Review Loop

Local does not mean safe by default.

Before accepting any change, check what files changed, whether the assistant touched unrelated code, whether it invented dependencies, whether the tests actually ran, and whether the explanation matches the diff.

The simple review loop is:

git status
git diff
npm test

Use the local coding agent for leverage, not blind trust. This is the same pattern behind most practical AI workflows: clear input, clear task, useful output, human review.

If you want the broader decision framework, read When an AI Agent Is the Wrong Tool. A coding agent is powerful, but it is still the wrong tool when the task is vague, risky, or better solved by a simple scripted workflow.

What Works Well

This setup works best for contained coding tasks: explaining unfamiliar files, drafting small utility functions, writing tests, cleaning documentation, reviewing a simple diff, and exploring a repo without spending cloud model credits on every question.

It is especially useful when the code is already local, the task is low-risk, and the review step is easy to run.

For example, I would be comfortable using it to inspect a small local script, write a README, suggest a test, or explain where a simple bug might live.

I would be much more careful using it around payment code, production deployments, database migrations, security-sensitive changes, or unfamiliar frameworks that require current documentation.

Where It Struggles

This is not a perfect replacement for hosted coding models.

You may run into slow responses, weaker long-horizon planning, tool-call mistakes, context pressure on larger repositories, and inconsistent test-fix loops. A local model can also be less aware of current APIs and recently changed libraries.

The model also does not automatically become web-connected. If your local model does not have a browser or search tool wired into the harness, assume it knows what is in the repo, the prompt, and its training data. For current setup details, verify against official documentation.

Does This Avoid Paid Credits?

For local model inference, yes. If Claude Code is correctly routed to Ollama and Ollama is running the model locally, those model responses are not using Anthropic API credits.

But “free” has footnotes.

Your computer is doing the work. That means memory pressure, battery use, heat, slower output on weaker hardware, and setup time. You still need internet to download installers and model files. And the local model may not match the quality of the hosted model you are used to.

So the honest version is this:

This can reduce per-request model spend for coding experiments, but you pay with hardware, setup time, and more review discipline.

A Starter Prompt for the First Real Test

When you try this on a real project, start with a constrained prompt:

Act as a cautious local coding assistant.

Goal:
Help me understand and improve this project without making broad changes.

Task:
First inspect the repository structure. Then identify the smallest useful improvement we could make.

Constraints:
- Do not edit files yet.
- Do not install dependencies.
- Do not run destructive commands.
- Explain what you found in plain English.
- Recommend one small next step.

Review:
After I approve the next step, make the smallest safe change and show me the diff.

That prompt keeps the assistant from sprinting straight into edits. It also matches the right mental model for local coding agents: small steps, clear constraints, human review.

Final Takeaway

Claude Code plus Ollama plus Qwen3-Coder is not a trick for running Claude locally.

It is more useful than that.

It is a way to separate the coding harness from the model backend. Claude Code gives you the project-aware terminal workflow. Ollama gives you local inference. Qwen3-Coder gives you a coding-focused local model.

If your hardware can handle it, this is a practical setup for learning, experimenting, conserving credits, and building small local tools without sending every coding prompt to a paid model API.

Just keep the review loop.

Local AI is powerful, but it is still better when a human is steering.

Frequently Asked Questions

Is this actually Claude running locally?

No. This setup uses Claude Code as the coding interface and Ollama as the local model backend. The local model is something like Qwen3-Coder, not Anthropic’s Claude model.

Do I need Anthropic API credits for this?

If Claude Code is correctly routed to Ollama, the model responses come from your local Ollama model instead of Anthropic’s API. That means those local responses are not spending Anthropic API credits. You still need to install and configure the tooling correctly.

What model should I start with?

Start with qwen3-coder if your machine has enough memory. If it feels too slow, use a smaller coding model and treat the setup as a learning experiment first.

How much memory do I need?

For larger local coding models, 32 GB is a more realistic baseline than 16 GB, and 48 GB to 64 GB gives you more breathing room. The exact requirement depends on the model, quantization, context length, and what else is running on your machine.

Can this browse the web?

Not by default. A local model running through Ollama does not automatically gain web access. If you need current documentation, check official sources or use a tool that explicitly has browser/search access.

Is this safe for production coding?

Use it carefully. It can help with real code, but start with small changes, tests, documentation, and low-risk improvements. For production-sensitive work, keep a strong human review step and verify anything involving security, payments, infrastructure, or current framework behavior.