Haiku 5.5 Python integration

A Haiku 5.5 Python integration is a good starting point when your input already lives in a data pipeline, a scheduled job or a local analysis script. Keep the first program small: read one synthetic record, send one request and inspect the complete response before writing a loop over a directory of customer files.

This walkthrough targets Anthropic's native service through its official package. The code is illustrative, not a paid execution report. Site credits purchased here do not authenticate this script. For the provider and endpoint distinctions, read the API quickstart before adapting an existing gateway client.

Set up the Haiku 5.5 Python environment

Create a virtual environment for the application and install the official package into that environment. Use the same interpreter for installation and execution; installing with one Python executable and running with another is a common explanation for an import that appears to be missing immediately after installation.

python -m venv .venv
# Activate this environment using your operating system's normal command.
python -m pip install anthropic

The current Python SDK documentation specifies Python 3.10 or later. Record your working interpreter and package versions in the project dependency files. Avoid upgrading a shared notebook environment halfway through an experiment: the next run should use the same parser and transport behavior as the previous one.

Set the server process's environment variable before starting Python. A development secret file is useful only if your runner actually loads it; naming a file does not make every Python process read it automatically. Keep that file outside version control. In a notebook, never print the entire environment to check whether a key exists.

Send one bounded request

This Haiku 5.5 Python example asks for a label for an invented support message. It uses an explicit timeout and disables automatic retries so the first debugging run has one observable attempt. Running the program with a working key can incur charges on your Anthropic account.

import os
from anthropic import Anthropic

def extract_text(message):
    return "\n".join(
        block.text for block in message.content if block.type == "text"
    )

def classify(client, source):
    message = client.messages.create(
        model="claude-haiku-5-5",
        max_tokens=2048,
        system="Classify the request as billing or technical. Return one label.",
        messages=[{"role": "user", "content": source}],
    )
    if message.stop_reason != "end_turn":
        raise ValueError(f"Unexpected completion: {message.stop_reason}")
    label = extract_text(message).strip().lower()
    if label not in {"billing", "technical"}:
        raise ValueError("Response did not contain an accepted label")
    return label

if __name__ == "__main__":
    with Anthropic(
        api_key=os.environ["ANTHROPIC_API_KEY"],
        timeout=45.0,
        max_retries=0,
    ) as client:
        print(classify(client, "Please resend the invoice for my test order."))

The expected label for this authored fixture is billing. That is an acceptance criterion, not an observed answer. If the response differs, preserve the failure for investigation instead of replacing it with the expected label. Otherwise your test can appear perfect while hiding a broken prompt or response parser.

The small output allowance is a test choice, not a model limit. Larger reasoning tasks need a different budget and may need streaming. Do not increase the budget simply because a classification failed: first inspect whether the error concerns authentication, an unsupported argument, an incomplete answer or an incorrect label.

Keep Python objects separate from business records

The Haiku 5.5 Python SDK returns a structured message, not just a string. Selecting text blocks by their declared type keeps your application from treating reasoning or tool content as customer-facing text. The helper above joins text blocks, then the task-specific function applies a stricter label check.

That division matters when you later replace classification with extraction. The transport adapter should return a normalized response with completion status and usage. A separate validator decides whether an invoice date is valid, whether a currency belongs to the allowed set and whether a claimed value appears in the source. Avoid teaching one generic text helper every business rule.

Retain identifiers alongside records. A spreadsheet row number can change when somebody sorts the sheet; an immutable application record ID remains usable for a retry. Save the prompt version and a source revision with each accepted result so a reviewer can reconstruct what the script actually examined.

Test Haiku 5.5 Python code without an API key

The classify function accepts its client as an argument. That lets an offline test supply a tiny fake instead of reaching the network. The following fixture checks your response-handling code; it cannot establish that the model will choose the correct label on real data.

from types import SimpleNamespace

class FakeMessages:
    def create(self, **request):
        assert request["model"] == "claude-haiku-5-5"
        return SimpleNamespace(
            stop_reason="end_turn",
            content=[SimpleNamespace(type="text", text="billing")],
        )

fake = SimpleNamespace(messages=FakeMessages())
assert classify(fake, "Synthetic invoice request") == "billing"

Extend this test with an empty content list, an unfamiliar label and a response stopped at its output limit. Each should produce a deliberate failure state. A test that only checks the happy-path string leaves the most consequential parser decisions unexamined. Also verify that importing the module never starts a network request.

For a Haiku 5.5 Python batch script, test file handling separately. Use temporary directories and invented rows. Confirm that a failed item does not overwrite an earlier accepted result, that rerunning a completed item does not create duplicate rows, and that the output still contains the original record identifiers after sorting.

Add concurrency only after measuring one worker

An asynchronous client can let a Python process wait on several independent requests without dedicating a thread to each. It does not grant additional account capacity. Start with a bounded number of in-flight items and measure queue wait separately from provider response time; those delays require different remedies.

A useful Haiku 5.5 Python worker has an intake queue, an attempt budget and a place to persist outcomes. If one item receives a rate limit, reduce pressure across the worker pool instead of letting every task retry immediately. Keep one retry owner: either a measured SDK policy or your queue's policy, with the combined attempt count understood.

Cancellation needs an explicit record outcome. A task cancelled locally may have reached the provider, so do not mark it as definitely unbilled. Write an interrupted status, retain the application job ID and consult the provider's available usage evidence. An empty local output file says nothing about upstream computation.

Make notebooks reproducible

Interactive notebooks hide state unusually well. A cell may be using a client created hours earlier, an outdated prompt string or credentials from a previous shell. Restart the kernel and execute the notebook from top to bottom before calling an example reproducible. Record configuration without revealing the secret itself.

Keep exploratory cells away from bulk execution. Require an explicit record limit during development, and print the selected record IDs before the paid phase begins. A dataframe filter returning all rows instead of ten is an application bug that can become a spending incident when generation sits directly inside a row iterator.

When a Haiku 5.5 Python experiment becomes a service, move its prompt, parser and acceptance tests into ordinary modules. Leave charts and inspection in the notebook. This makes code review possible without depending on which cells the author happened to execute, and lets the same fixtures run in continuous integration without credentials.

Diagnose failures from the narrowest evidence

Start with the exception class, HTTP status when present, request identifier and a sanitized description of the input. Never attach a raw customer dataset to an issue report merely because the SDK error includes request context. A synthetic reproduction often reveals a malformed parameter just as clearly.

For a Haiku 5.5 Python import failure, inspect the interpreter first. For a provider rejection, compare the actual request to the model-specific migration guidance. For an accepted but incorrect answer, inspect the taxonomy and examples. These are different classes of defect; retrying all of them makes the program slower without making it more correct.

Finally, keep provider usage separate from your acceptance count. Ten returned responses with four rejected labels are six useful outcomes, not ten successful business records. The classification workflow explains how to inspect those errors before expanding the workload. Your Haiku 5.5 Python integration is ready to grow when its failures remain visible, attributable and recoverable.