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 -- 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 https://ollama.com
# WSL2 is advisable in order for you 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

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

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

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

# Conditions: Node.js 18 or later
node --version   # Affirm you might be 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 flooring for actual
# codebases with out triggering swap on 16-18 GB VRAM programs.
# Enhance to 131072 (128K) in case you have headroom on 24 GB+ programs.
# Don't go above 131072 except you might have profiled your reminiscence utilization
# beneath 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 era 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 stop instrument name loops the place Gemma 4 retries the identical
# failed instrument name with almost similar parameters indefinitely.
PARAMETER repeat_penalty 1.15

# num_predict -- most tokens per response. 4096 is ample for
# most code patches. Enhance to 8192 in case you recurrently generate
# giant information in a single era.
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 could do.
SYSTEM """You're a senior software program engineer working as a coding agent.

When working with code:
- Learn information earlier than modifying them. By no means assume file contents.
- Make one targeted change at a time and confirm it earlier than continuing.
- When a instrument name fails, look at the error rigorously earlier than retrying.
  Don't retry with similar parameters. Diagnose first.
- Desire surgical edits over full file rewrites.
- Run assessments after every significant change, not after a batch of modifications.
- In case you are unsure in regards to the codebase construction, learn extra information
  moderately than guessing.

Be exact and methodical. Keep away from explaining what you might be about to do
when you could possibly 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 checklist
# 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 couple 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 undertaking 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 consumer 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. Device calling round-trip

Conditions:
  pip set up httpx

Tips on how 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 on the market
  [PASS] Anthropic Messages API name profitable
  [PASS] Device 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 = "http://localhost:11434"
MODEL_NAME      = "gemma4-claude"   # Should match your Modelfile variant identify
TIMEOUT         = 120.0             # Seconds -- era will be gradual on first name


def check_ollama_health() -> bool:
    """
    Examine 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] Sudden response: {response.textual content[:100]}")
            return False
    besides httpx.ConnectError:
        print(f"  [FAIL] Can not hook up with {OLLAMA_BASE_URL}")
        print("         Is Ollama working? Attempt: ollama serve")
        return False


def check_model_available() -> bool:
    """
    Examine 2: Confirm the precise mannequin variant is on the market 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)
        information     = response.json()
        fashions   = [m["name"] for m in information.get("fashions", [])]

        # Normalize: Ollama could 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 on the market")
            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 checklist: {e}")
        return False


def check_messages_api() -> bool:
    """
    Examine 3: Ship a primary Anthropic Messages API name to the native endpoint.
    Verifies the request format, mannequin routing, and primary era work.
    Makes use of the identical /v1/messages path and request schema that Claude Code makes use of.
    Observe: 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":      "utility/json",
        "x-api-key":         "ollama",            # Required by the API spec; worth ignored domestically
        "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

        information = response.json()

        # Anthropic Messages API response construction:
        # { "content material": [{"type": "text", "text": "..."}], "stop_reason": "..." }
        content_blocks = information.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(information, 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:
    """
    Examine 4: Confirm instrument calling works end-to-end.
    That is crucial verify 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 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: Device calling verification")

    # A minimal instrument 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,
        # Pressure 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":      "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

        information           = response.json()
        content_blocks = information.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 shouldn't be working appropriately.")
            print("         Agentic Claude Code classes will fail on file operations.")
            print(f"         Full response: {json.dumps(information, indent=2)}")
            return False

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

        print(f"  [PASS] Device calling: mannequin produced a legitimate tool_use block")
        print(f"         Device referred to as: {tool_name}")
        print(f"         Parameters:  {json.dumps(tool_input)}")

        # Sanity verify: did it name the correct instrument with the correct parameter?
        if tool_name == "read_file" and "path" in tool_input:
            print(f"         Device identify and parameter are right.")
        else:
            print(f"         WARNING: Sudden instrument identify or lacking 'path' parameter.")
            print(f"         The mannequin referred to 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)
    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 domestically.")
        sys.exit(1)


if __name__ == "__main__":
    foremost()

pip set up httpx
python verify_local_setup.py

# Navigate to a undertaking listing
cd ~/tasks/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 shouldn't be being learn appropriately

# 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 overlaying all public strategies.
# > Run the assessments and repair any failures.
# > The aim 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")
  Operating 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