Native Agentic Programming on the Low-cost: Claude Code + Ollama + Gemma4

# macOS and Linux -- one-line set up
curl -fsSL https://ollama.com/set up.sh | sh

# Confirm model -- have to be 0.14.0+ for Anthropic Messages API help
# The Anthropic-compatible endpoint was added in January 2026
ollama model
# Anticipated: ollama model is 0.22.x or larger (as of Might 2026)

# Home windows: obtain the native installer from https://ollama.com
# WSL2 is advisable if you would like GPU passthrough on Home windows

curl http://localhost:11434
# Anticipated response: Ollama is working

# The 26B MoE -- advisable for this setup (~18 GB obtain)
ollama pull gemma4:26b

# Whilst you wait, affirm the obtain is progressing
ollama ps
# Reveals at the moment downloading or working fashions

# Elective: additionally pull the 31B for comparability on succesful {hardware}
ollama pull gemma4:31b

# Verify the pull accomplished
ollama record
# Ought to present gemma4:26b with dimension and modification date

# Stipulations: Node.js 18 or later
node --version   # Verify you're on 18+

# Set up Claude Code CLI globally
npm set up -g @anthropic-ai/claude-code

# Confirm the set up
claude --version

# ~/.ollama/Modelfiles/gemma4-claude
# Gemma 4 26B MoE variant tuned for Claude Code agentic classes.
# Bakes context window, temperature, and system immediate into the mannequin
# so each Claude Code session begins with the proper configuration.
#
# Construct with:
#   mkdir -p ~/.ollama/Modelfiles
#   ollama create gemma4-claude -f ~/.ollama/Modelfiles/gemma4-claude

FROM gemma4:26b

# Context window -- 65536 tokens (64K) is the tested-safe ground for actual
# codebases with out triggering swap on 16-18 GB VRAM techniques.
# Enhance to 131072 (128K) if in case you have headroom on 24 GB+ techniques.
# Don't go above 131072 until you've gotten profiled your reminiscence utilization
# below load -- Ollama pre-allocates the complete KV cache upfront.
PARAMETER num_ctx 65536

# Temperature -- 0.2 is intentionally low for agentic coding.
# Larger temperature introduces variability in instrument name parameter
# formatting that causes Claude Code's instrument validator to reject calls.
# For artistic duties, you'll set this larger. For agentic loops: low.
PARAMETER temperature 0.2

# top_p -- nucleus sampling threshold. 0.9 retains technology centered
# whereas avoiding the repetition loops that top_p=1.0 can produce on
# lengthy agentic classes.
PARAMETER top_p 0.9

# repeat_penalty -- penalizes the mannequin for repeating tokens.
# 1.15 helps forestall instrument name loops the place Gemma 4 retries the identical
# failed instrument name with practically equivalent parameters indefinitely.
PARAMETER repeat_penalty 1.15

# num_predict -- most tokens per response. 4096 is adequate for
# most code patches. Enhance to 8192 in case you usually generate
# massive recordsdata in a single technology.
PARAMETER num_predict 4096

# System immediate -- reinforces coding agent habits and specific
# instrument use self-discipline. Gemma 4 advantages from being reminded to
# decide to instrument calls moderately than describing what it will do.
SYSTEM """You're a senior software program engineer working as a coding agent.

When working with code:
- Learn recordsdata earlier than enhancing them. By no means assume file contents.
- Make one centered change at a time and confirm it earlier than continuing.
- When a instrument name fails, study the error rigorously earlier than retrying.
  Don't retry with equivalent parameters. Diagnose first.
- Want surgical edits over full file rewrites.
- Run exams after every significant change, not after a batch of adjustments.
- If you're unsure concerning the codebase construction, learn extra recordsdata
  moderately than guessing.

Be exact and methodical. Keep away from explaining what you're about to do
when you would merely do it."""

# Create the Modelfiles listing if it doesn't exist
mkdir -p ~/.ollama/Modelfiles

# Save the Modelfile content material from above to this path, then construct:
ollama create gemma4-claude -f ~/.ollama/Modelfiles/gemma4-claude

# Confirm the variant was created
ollama record
# Ought to present gemma4-claude alongside gemma4:26b

# Fast smoke take a look at -- confirm it masses and responds
ollama run gemma4-claude "What's the time complexity of binary search and why?"
# Count on a transparent, concise technical response inside a number of seconds

{
  "env": {
    "ANTHROPIC_BASE_URL": "http://localhost:11434",

    "ANTHROPIC_AUTH_TOKEN": "ollama",

    "ANTHROPIC_API_KEY": "",

    "ANTHROPIC_MODEL": "gemma4-claude",

    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gemma4-claude",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gemma4-claude",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "gemma4-claude",

    "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS": "1"
  }
}

# In your mission root
mkdir -p .claude

cat > .claude/settings.json << 'EOF'
{
  "env": {
    "ANTHROPIC_BASE_URL": "http://localhost:11434",
    "ANTHROPIC_AUTH_TOKEN": "ollama",
    "ANTHROPIC_API_KEY": "",
    "ANTHROPIC_MODEL": "gemma4-claude",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "gemma4-claude",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gemma4-claude",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "gemma4-claude",
    "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS": "1"
  }
}
EOF

pip set up httpx   # Async HTTP shopper for the verification script

#!/usr/bin/env python3
"""
verify_local_setup.py

Verifies the complete Claude Code + Ollama + Gemma 4 stack earlier than use.
Runs three checks in sequence:
  1. Ollama well being and mannequin availability
  2. Fundamental Anthropic Messages API name
  3. Instrument calling round-trip

Stipulations:
  pip set up httpx

Methods to run:
  python verify_local_setup.py

Anticipated output on a working setup:
  [PASS] Ollama is working on localhost:11434
  [PASS] Mannequin 'gemma4-claude' is offered
  [PASS] Anthropic Messages API name profitable
  [PASS] Instrument calling: mannequin produced a sound tool_use block
  All checks handed -- Claude Code + Ollama + Gemma 4 is prepared.
"""

import httpx
import json
import sys

# ── Configuration ─────────────────────────────────────────────────────────────
OLLAMA_BASE_URL = "http://localhost:11434"
MODEL_NAME      = "gemma4-claude"   # Should match your Modelfile variant identify
TIMEOUT         = 120.0             # Seconds -- technology could be gradual on first name


def check_ollama_health() -> bool:
    """
    Verify 1: Confirm Ollama is working and responding.
    Hits the foundation endpoint which returns 'Ollama is working' when wholesome.
    """
    print("nCheck 1: Ollama well being")
    attempt:
        response = httpx.get(OLLAMA_BASE_URL, timeout=5.0)
        if "Ollama is working" in response.textual content:
            print(f"  [PASS] Ollama is working on {OLLAMA_BASE_URL}")
            return True
        else:
            print(f"  [FAIL] Surprising response: {response.textual content[:100]}")
            return False
    besides httpx.ConnectError:
        print(f"  [FAIL] Can't hook up with {OLLAMA_BASE_URL}")
        print("         Is Ollama working? Strive: ollama serve")
        return False


def check_model_available() -> bool:
    """
    Verify 2: Confirm the precise mannequin variant is offered in Ollama.
    Makes use of the /api/tags endpoint which lists all pulled fashions.
    """
    print("nCheck 2: Mannequin availability")
    attempt:
        response = httpx.get(f"{OLLAMA_BASE_URL}/api/tags", timeout=5.0)
        knowledge     = response.json()
        fashions   = [m["name"] for m in knowledge.get("fashions", [])]

        # Normalize: Ollama might add ":newest" if not specified
        normalized = [m.split(":")[0] for m in fashions]

        if MODEL_NAME in fashions or MODEL_NAME in normalized:
            print(f"  [PASS] Mannequin '{MODEL_NAME}' is offered")
            return True
        else:
            print(f"  [FAIL] Mannequin '{MODEL_NAME}' not discovered")
            print(f"         Out there fashions: {', '.be part of(fashions) or 'none'}")
            print(f"         Run: ollama create {MODEL_NAME} -f ~/.ollama/Modelfiles/gemma4-claude")
            return False
    besides Exception as e:
        print(f"  [FAIL] Error checking mannequin record: {e}")
        return False


def check_messages_api() -> bool:
    """
    Verify 3: Ship a primary Anthropic Messages API name to the native endpoint.
    Verifies the request format, mannequin routing, and primary technology work.
    Makes use of the identical /v1/messages path and request schema that Claude Code makes use of.
    Notice: Claude Code makes use of http://localhost:11434 (root), not /v1.
    The Anthropic-compatible API is at /api/chat or the foundation -- Ollama routes it.
    """
    print("nCheck 3: Anthropic Messages API name")

    payload = {
        "mannequin": MODEL_NAME,
        "max_tokens": 100,
        "messages": [
            {
                "role": "user",
                "content": "Reply with exactly: VERIFICATION_OK"
            }
        ]
    }

    headers = {
        "Content material-Kind":      "software/json",
        "x-api-key":         "ollama",            # Required by the API spec; worth ignored regionally
        "anthropic-version": "2023-06-01"         # Required model header
    }

    attempt:
        response = httpx.submit(
            f"{OLLAMA_BASE_URL}/v1/messages",
            json=payload,
            headers=headers,
            timeout=TIMEOUT
        )

        if response.status_code != 200:
            print(f"  [FAIL] HTTP {response.status_code}: {response.textual content[:200]}")
            return False

        knowledge = response.json()

        # Anthropic Messages API response construction:
        # { "content material": [{"type": "text", "text": "..."}], "stop_reason": "..." }
        content_blocks = knowledge.get("content material", [])
        text_blocks    = [b for b in content_blocks if b.get("type") == "text"]

        if not text_blocks:
            print(f"  [FAIL] No textual content content material in response: {json.dumps(knowledge, indent=2)}")
            return False

        response_text = text_blocks[0].get("textual content", "")
        print(f"  [PASS] Anthropic Messages API name profitable")
        print(f"         Mannequin response: {response_text[:80]}")
        return True

    besides Exception as e:
        print(f"  [FAIL] Request failed: {e}")
        return False


def check_tool_calling() -> bool:
    """
    Verify 4: Confirm instrument calling works end-to-end.
    That is crucial verify for Claude Code agentic use.
    Claude Code depends on the mannequin accurately producing tool_use blocks
    for each file operation, shell command, and code execution.

    Sends a easy instrument definition and a immediate that ought to set off it.
    Verifies the mannequin returns a tool_use block (not simply textual content describing the decision).
    """
    print("nCheck 4: Instrument calling verification")

    # A minimal instrument definition utilizing the Anthropic perform calling schema
    instruments = [
        {
            "name": "read_file",
            "description": "Read the contents of a file at the given path.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "The absolute or relative file path to read"
                    }
                },
                "required": ["path"]
            }
        }
    ]

    payload = {
        "mannequin": MODEL_NAME,
        "max_tokens": 256,
        "instruments": instruments,
        # Power the mannequin to name a instrument moderately than reply in textual content.
        # tool_choice: {"kind": "any"} requires any instrument use.
        # Take away this if testing whether or not the mannequin self-selects instruments.
        "tool_choice": {"kind": "any"},
        "messages": [
            {
                "role": "user",
                "content": "Read the file at /tmp/test.py and show me its contents."
            }
        ]
    }

    headers = {
        "Content material-Kind":      "software/json",
        "x-api-key":         "ollama",
        "anthropic-version": "2023-06-01"
    }

    attempt:
        response = httpx.submit(
            f"{OLLAMA_BASE_URL}/v1/messages",
            json=payload,
            headers=headers,
            timeout=TIMEOUT
        )

        if response.status_code != 200:
            print(f"  [FAIL] HTTP {response.status_code}: {response.textual content[:200]}")
            return False

        knowledge           = response.json()
        content_blocks = knowledge.get("content material", [])
        tool_blocks    = [b for b in content_blocks if b.get("type") == "tool_use"]

        if not tool_blocks:
            print("  [FAIL] Mannequin didn't produce a tool_use block")
            print("         This implies instrument calling isn't working accurately.")
            print("         Agentic Claude Code classes will fail on file operations.")
            print(f"         Full response: {json.dumps(knowledge, indent=2)}")
            return False

        tool_call  = tool_blocks[0]
        tool_name  = tool_call.get("identify", "")
        tool_input = tool_call.get("enter", {})

        print(f"  [PASS] Instrument calling: mannequin produced a sound tool_use block")
        print(f"         Instrument known as: {tool_name}")
        print(f"         Parameters:  {json.dumps(tool_input)}")

        # Sanity verify: did it name the suitable instrument with the suitable parameter?
        if tool_name == "read_file" and "path" in tool_input:
            print(f"         Instrument identify and parameter are appropriate.")
        else:
            print(f"         WARNING: Surprising instrument identify or lacking 'path' parameter.")
            print(f"         The mannequin known as a instrument however not the anticipated one.")

        return True

    besides Exception as e:
        print(f"  [FAIL] Request failed: {e}")
        return False


def foremost():
    print("=" * 60)
    print("Claude Code + Ollama + Gemma 4 Setup Verification")
    print("=" * 60)

    checks = [
        check_ollama_health,
        check_model_available,
        check_messages_api,
        check_tool_calling,
    ]

    outcomes = [check() for check in checks]

    print("n" + "=" * 60)
    handed = sum(outcomes)
    whole  = len(outcomes)

    if all(outcomes):
        print(f"All {whole} checks handed.")
        print("Claude Code + Ollama + Gemma 4 is prepared.")
        print(f"nLaunch with: claude")
        sys.exit(0)
    else:
        failed_checks = [i + 1 for i, r in enumerate(results) if not r]
        print(f"{handed}/{whole} checks handed. Failed: {failed_checks}")
        print("Resolve the failures above earlier than utilizing Claude Code regionally.")
        sys.exit(1)


if __name__ == "__main__":
    foremost()

pip set up httpx
python verify_local_setup.py

# Navigate to a mission listing
cd ~/tasks/my-service

# Verify Claude Code sees the native configuration
claude --version
# Confirm it doesn't immediate for an Anthropic API key -- if it does,
# the settings.json isn't being learn accurately

# Begin an agentic session
claude

# Inside Claude Code, give the agent a concrete activity:
# > Analyze the UserService class in src/user_service.py.
# > Write a pytest take a look at suite masking all public strategies.
# > Run the exams and repair any failures.
# > The objective is a clear pytest run with no skips.

→ read_file("src/user_service.py")
  Studying 247 traces...

→ list_files("src/")
  Discovered: user_service.py, fashions.py, db.py, exceptions.py

→ read_file("src/fashions.py")
  Studying 89 traces...

→ write_file("exams/test_user_service.py", [test content])
  Written: 312 traces

→ bash("python -m pytest exams/test_user_service.py -v 2>&1")
  Operating 14 exams...
  FAILED exams/test_user_service.py::test_update_email_invalid
    AssertionError: Anticipated ValidationError, acquired None

→ read_file("src/user_service.py")  [targeted re-read of update_email method]
  ...

→ write_file("exams/test_user_service.py", [corrected test])
  Patched test_update_email_invalid assertion

→ bash("python -m pytest exams/test_user_service.py -v 2>&1")
  14 handed in 1.23s