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

# macOS and Linux -- one-line set up
curl -fsSL  | sh

# Confirm model -- should be 0.14.0+ for Anthropic Messages API assist
# 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 
# WSL2 is beneficial if you would like GPU passthrough on Home windows

curl 
# Anticipated response: Ollama is operating

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

# When you wait, verify the obtain is progressing
ollama ps
# Exhibits at present downloading or operating fashions

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

# Affirm the pull accomplished
ollama listing
# Ought to present gemma4:26b with measurement and modification date

# Stipulations: Node.js 18 or later
node --version   # Affirm 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 right 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) in case you have headroom on 24 GB+ techniques.
# Don't go above 131072 until you will have profiled your reminiscence utilization
# underneath load -- Ollama pre-allocates the total KV cache upfront.
PARAMETER num_ctx 65536

# Temperature -- 0.2 is intentionally low for agentic coding.
# Increased temperature introduces variability in device name parameter
# formatting that causes Claude Code's device 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 targeted
# 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 device name loops the place Gemma 4 retries the identical
# failed device name with practically equivalent parameters indefinitely.
PARAMETER repeat_penalty 1.15

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

# System immediate -- reinforces coding agent habits and express
# device use self-discipline. Gemma 4 advantages from being reminded to
# decide to device calls relatively than describing what it could 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 targeted change at a time and confirm it earlier than continuing.
- When a device name fails, study the error rigorously earlier than retrying.
  Don't retry with equivalent parameters. Diagnose first.
- Favor surgical edits over full file rewrites.
- Run assessments after every significant change, not after a batch of adjustments.
- In case you are unsure in regards to the codebase construction, learn extra recordsdata
  relatively than guessing.

Be exact and methodical. Keep away from explaining what you're about to do
when you possibly can 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 listing
# Ought to present gemma4-claude alongside gemma4:26b

# Fast smoke check -- 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": "

    "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": "
    "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 total Claude Code + Ollama + Gemma 4 stack earlier than use.
Runs three checks in sequence:
  1. Ollama well being and mannequin availability
  2. Primary Anthropic Messages API name
  3. Instrument calling round-trip

Stipulations:
  pip set up httpx

Easy methods to run:
  python verify_local_setup.py

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

import httpx
import json
import sys

# ── Configuration ─────────────────────────────────────────────────────────────
OLLAMA_BASE_URL = "
MODEL_NAME      = "gemma4-claude"   # Should match your Modelfile variant identify
TIMEOUT         = 120.0             # Seconds -- technology might be sluggish on first name


def check_ollama_health() -> bool:
    """
    Test 1: Confirm Ollama is operating and responding.
    Hits the foundation endpoint which returns 'Ollama is operating' when wholesome.
    """
    print("nCheck 1: Ollama well being")
    attempt:
        response = httpx.get(OLLAMA_BASE_URL, timeout=5.0)
        if "Ollama is operating" in response.textual content:
            print(f"  [PASS] Ollama is operating 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 not connect with {OLLAMA_BASE_URL}")
        print("         Is Ollama operating? Strive: ollama serve")
        return False


def check_model_available() -> bool:
    """
    Test 2: Confirm the precise mannequin variant is accessible 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 accessible")
            return True
        else:
            print(f"  [FAIL] Mannequin '{MODEL_NAME}' not discovered")
            print(f"         Accessible 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 listing: {e}")
        return False


def check_messages_api() -> bool:
    """
    Test 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  (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":      "utility/json",
        "x-api-key":         "ollama",            # Required by the API spec; worth ignored regionally
        "anthropic-version": "2023-06-01"         # Required model header
    }

    attempt:
        response = httpx.publish(
            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:
    """
    Test 4: Confirm device calling works end-to-end.
    That is an important test for Claude Code agentic use.
    Claude Code depends on the mannequin appropriately producing tool_use blocks
    for each file operation, shell command, and code execution.

    Sends a easy device 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 device definition utilizing the Anthropic operate 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,
        # Drive the mannequin to name a device relatively than reply in textual content.
        # tool_choice: {"kind": "any"} requires any device 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":      "utility/json",
        "x-api-key":         "ollama",
        "anthropic-version": "2023-06-01"
    }

    attempt:
        response = httpx.publish(
            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 device calling will not be working appropriately.")
            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 legitimate tool_use block")
        print(f"         Instrument referred to as: {tool_name}")
        print(f"         Parameters:  {json.dumps(tool_input)}")

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

        return True

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


def principal():
    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)
    complete  = len(outcomes)

    if all(outcomes):
        print(f"All {complete} 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}/{complete} checks handed. Failed: {failed_checks}")
        print("Resolve the failures above earlier than utilizing Claude Code regionally.")
        sys.exit(1)


if __name__ == "__main__":
    principal()

pip set up httpx
python verify_local_setup.py

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

# Affirm Claude Code sees the native configuration
claude --version
# Confirm it doesn't immediate for an Anthropic API key -- if it does,
# the settings.json will not be being learn appropriately

# Begin an agentic session
claude

# Inside Claude Code, give the agent a concrete job:
# > Analyze the UserService class in src/user_service.py.
# > Write a pytest check suite protecting all public strategies.
# > Run the assessments and repair any failures.
# > The purpose 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("assessments/test_user_service.py", [test content])
  Written: 312 traces

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

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

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

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