llm-anthropic plugin

Instead of manual budget modes, Claude 4.6 models use adaptive thinking (thinking: {type: "adaptive"}). The model dynamically decides when and how much to think. You can enable this using the -o thinking 1 option.

To verify if a model used thinking, you can inspect the response logs for content block types like ['thinking', 'text'].

uv run llm -m claude-sonnet-4.6 -o thinking 1 "What is the square root of 97 to 3 decimal places?"

Claude Opus 4.8 and Claude 5 models support updating system instructions part-way through a conversation. This is useful for changing behavior while preserving prompt cache hits on earlier turns.

To use this, pass a system message within an explicit messages= chain. The plugin automatically handles the API placement rules.

Warning: Models older than Opus 4.8 will raise a ValueError if a system message appears anywhere other than the start of the chain.

import llm
from llm import system, user, assistant

model = llm.get_model("claude-opus-5")
response = model.prompt(messages=[
    system("You are a helpful assistant."),
    user("Say hi to me, briefly"),
    assistant("Hi there!"),
    system("New instruction: reply only in French from now on"),
    user("Say goodbye to me, briefly"),
])
print(response.text())  # Au revoir !

Install the llm-anthropic plugin into the same environment where you have the llm CLI installed.

llm install llm-anthropic

Before using the plugin, you must set your Anthropic API key. You can do this via the llm keys command or by setting the ANTHROPIC_API_KEY environment variable.

To set it via the CLI:

1. Run llm keys set anthropic.
2. Paste your key when prompted.

llm keys set anthropic
# Paste key here

Stop sequences tell the model to stop generating text when it encounters specific strings. You can pass a single string for one sequence or a JSON array for multiple sequences.

# Single stop sequence
llm -m claude-sonnet-5 'Fun facts about pelicans' \
  -o stop-sequences "beak"

# Multiple stop sequences (JSON array)
llm -m claude-sonnet-5 'Fun facts about pelicans' \
  -o stop-sequences '["beak", "feathers"]'

The project uses pytest-recording to capture Anthropic API responses. To record new responses or update existing ones, use the --record-mode flag. You must have a valid Anthropic API key stored in llm first.

# 1. Set your key first
llm keys set anthropic

# 2. Record a new API interaction for a test
PYTEST_ANTHROPIC_API_KEY="$(llm keys get anthropic)" uv run pytest --record-mode once

# 3. Re-record all cassettes and fix inline snapshots
rm tests/cassettes/test_anthropic/*.yaml
PYTEST_ANTHROPIC_API_KEY="$(llm keys get anthropic)" uv run pytest --record-mode all --inline-snapshot=fix

# 4. Re-record a specific test
rm tests/cassettes/test_anthropic/test_thinking_prompt.yaml
PYTEST_ANTHROPIC_API_KEY="$(llm keys get anthropic)" uv run pytest -k test_thinking_prompt --record-mode once --inline-snapshot=fix

To develop locally, create a virtual environment, install the package in editable mode with dev dependencies, and run tests using pytest or uv.

# Setup environment
cd llm-anthropic
python3 -m venv venv
source venv/bin/activate

# Install dependencies
pip install -e . --group dev

# Run tests
pytest

# Using uv
uv run pytest
uv run llm 'your prompt here'

You can verify the availability of the new Claude 4.6 models by listing all registered models and filtering for '4.6'. The models are available via the following aliases:

• claude-sonnet-4.6 (Sonnet 4.6)
• claude-opus-4.6 (Opus 4.6)

uv run llm models | grep "4\.6"

The prefill option allows you to set the beginning of the model's response. This is highly effective for forcing specific formats like JSON by starting the response with a character like {.

You can also use hide_prefill (set to true) to prevent the prefill text from being echoed back in the final output. This is useful when using code block delimiters as prefill to get clean code responses.

# Force JSON output by prefilling with '{'
llm -m claude-sonnet-5 'Fun data about pelicans' \
  -o prefill '{'

# Get clean Python code without Markdown wrappers
llm -m claude-haiku-4.5 'Short python function describing a pelican' \
  -o prefill '```python' \
  -o hide_prefill true \
  -o stop_sequences '```'

The thinking_effort parameter allows you to control token spend independently of whether adaptive thinking is enabled.

Supported values:

• low
• medium
• high
• max (Note: max is only supported by claude-opus-4.6. Attempting to use max with Sonnet 4.6 will result in an error.)

Use the -o thinking_effort <level> flag to set the effort.

uv run llm -m claude-sonnet-4.6 -o thinking_effort low "What is the capital of France?"