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 greater (as of Might 2026)

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

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

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

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

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

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

# Stipulations: 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 periods.
# 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 programs.
# Enhance to 131072 (128K) if in case you have headroom on 24 GB+ programs.
# Don't go above 131072 until you have got profiled your reminiscence utilization
# underneath 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 greater. For agentic loops: low.
PARAMETER temperature 0.2

# top_p -- nucleus sampling threshold. 0.9 retains era centered
# whereas avoiding the repetition loops that top_p=1.0 can produce on
# lengthy agentic periods.
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 practically similar parameters indefinitely.
PARAMETER repeat_penalty 1.15

# num_predict -- most tokens per response. 4096 is adequate for
# most code patches. Enhance to 8192 if you happen to commonly generate
# giant recordsdata in a single era.
PARAMETER num_predict 4096

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

When working with code:
- Learn recordsdata earlier than modifying 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, look at the error rigorously earlier than retrying.
  Don't retry with similar parameters. Diagnose first.
- Choose surgical edits over full file rewrites.
- Run exams after every significant change, not after a batch of modifications.
- In case you are unsure in regards to the codebase construction, learn extra recordsdata
  quite than guessing.

Be exact and methodical. Keep away from explaining what you might be about to do
when you might 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 hundreds and responds
ollama run gemma4-claude "What's the time complexity of binary search and why?"
# Anticipate a transparent, concise technical response inside just a few 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 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. Primary Anthropic Messages API name
  3. Software calling round-trip

Stipulations:
  pip set up httpx

The best way 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 on the market
  [PASS] Anthropic Messages API name profitable
  [PASS] Software 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 -- era could be sluggish on first name


def check_ollama_health() -> bool:
    """
    Verify 1: Confirm Ollama is operating and responding.
    Hits the basis 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:
    """
    Verify 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 record: {e}")
        return False


def check_messages_api() -> bool:
    """
    Verify 3: Ship a fundamental Anthropic Messages API name to the native endpoint.
    Verifies the request format, mannequin routing, and fundamental era 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 basis -- 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

        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:
    """
    Verify 4: Confirm instrument calling works end-to-end.
    That is a very powerful 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 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: Software 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 quite 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

        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 is just not working appropriately.")
            print("         Agentic Claude Code periods 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] Software calling: mannequin produced a sound tool_use block")
        print(f"         Software referred to as: {tool_name}")
        print(f"         Parameters:  {json.dumps(tool_input)}")

        # Sanity test: did it name the precise instrument with the precise parameter?
        if tool_name == "read_file" and "path" in tool_input:
            print(f"         Software identify and parameter are right.")
        else:
            print(f"         WARNING: Surprising 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 essential():
    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__":
    essential()

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 is just not 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 masking all public strategies.
# > Run the exams and repair any failures.
# > The purpose is a clear pytest run with no skips.

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

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

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

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

→ bash("python -m pytest exams/test_user_service.py -v 2>&1")
  Working 14 exams...
  FAILED exams/test_user_service.py::test_update_email_invalid
    AssertionError: Anticipated ValidationError, bought 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