Lokale Agentenprogrammierung zum günstigen Preis: 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 really useful if you'd like GPU passthrough on Home windows

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

# 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 the moment downloading or working fashions

# Optionally available: 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 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 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) when 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 total KV cache upfront.
PARAMETER num_ctx 65536

# Temperature -- 0.2 is intentionally low for agentic coding.
# Greater temperature introduces variability in device name parameter
# formatting that causes Claude Code's device validator to reject calls.
# For inventive duties, you'll set this larger. 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 forestall device name loops the place Gemma 4 retries the identical
# failed device name with almost equivalent parameters indefinitely.
PARAMETER repeat_penalty 1.15

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

# System immediate -- reinforces coding agent conduct and specific
# device use self-discipline. Gemma 4 advantages from being reminded to
# decide to device 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 modifying them. By no means assume file contents.
- Make one centered change at a time and confirm it earlier than continuing.
- When a device name fails, look at the error fastidiously earlier than retrying.
  Don't retry with equivalent parameters. Diagnose first.
- Want surgical edits over full file rewrites.
- Run checks after every significant change, not after a batch of adjustments.
- If you're unsure in regards to the codebase construction, learn extra recordsdata
  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 listing
# 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?"
# Count on 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 venture 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 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. Device calling round-trip

Conditions:
  pip set up httpx

The best way 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 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 title
TIMEOUT         = 120.0             # Seconds -- era may be sluggish on first name


def check_ollama_health() -> bool:
    """
    Test 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? Strive: ollama serve")
        return False


def check_model_available() -> bool:
    """
    Test 2: Confirm the particular 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("title") for m in information.get("fashions", ()))

        # Normalize: Ollama could add ":newest" if not specified
        normalized = (m.cut up(":")(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"         Obtainable fashions: {', '.be a 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 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.
    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": (
            {
                "function": "person",
                "content material": "Reply with precisely: VERIFICATION_OK"
            }
        )
    }

    headers = {
        "Content material-Sort":      "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

        information = response.json()

        # Anthropic Messages API response construction:
        # { "content material": ({"kind": "textual content", "textual content": "..."}), "stop_reason": "..." }
        content_blocks = information.get("content material", ())
        text_blocks    = (b for b in content_blocks if b.get("kind") == "textual content")

        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:
    """
    Test 4: Confirm device calling works end-to-end.
    That is crucial 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: Device calling verification")

    # A minimal device definition utilizing the Anthropic perform calling schema
    instruments = (
        {
            "title": "read_file",
            "description": "Learn the contents of a file on the given path.",
            "input_schema": {
                "kind": "object",
                "properties": {
                    "path": {
                        "kind": "string",
                        "description": "Absolutely the or relative file path to learn"
                    }
                },
                "required": ("path")
            }
        }
    )

    payload = {
        "mannequin": MODEL_NAME,
        "max_tokens": 256,
        "instruments": instruments,
        # Drive the mannequin to name a device moderately 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": (
            {
                "function": "person",
                "content material": "Learn the file at /tmp/take a look at.py and present me its contents."
            }
        )
    }

    headers = {
        "Content material-Sort":      "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("kind") == "tool_use")

        if not tool_blocks:
            print("  (FAIL) Mannequin didn't produce a tool_use block")
            print("         This implies device calling just isn't 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("title", "")
        tool_input = tool_call.get("enter", {})

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

        # Sanity test: did it name the proper device with the proper parameter?
        if tool_name == "read_file" and "path" in tool_input:
            print(f"         Device title and parameter are right.")
        else:
            print(f"         WARNING: Sudden device title or lacking 'path' parameter.")
            print(f"         The mannequin known as a device however not the anticipated one.")

        return True

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


def predominant():
    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 = (test() for test 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(outcomes) 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__":
    predominant()

pip set up httpx
python verify_local_setup.py

# Navigate to a venture 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 just isn't 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 protecting all public strategies.
# > Run the checks and repair any failures.
# > The objective 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("checks/test_user_service.py", (take a look at content material))
  Written: 312 strains

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

→ read_file("src/user_service.py")  (focused re-read of update_email methodology)
  ...

→ write_file("checks/test_user_service.py", (corrected take a look at))
  Patched test_update_email_invalid assertion

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