Clarifai developer on retainer: raw bytes passed as image input causes TypeError on every vision request for 5 weeks — clarifai 10.5.0 requires Inputs.get_image_inputs_from_bytes() — Clarifai developer on monthly retainer

clarifai 10.5.0 • Python 3.11 • GPT-4o vision model via Clarifai • raw image_bytes passed directly to model.predict(inputs=image_bytes) • SDK v10 iterates inputs and receives integers • TypeError: 'int' object has no attribute 'data' on every request • 100% vision failure for 5 weeks • fix: Inputs.get_image_inputs_from_bytes(input_id, image_bytes) • 1.5h retainer engagement

Westfield Vision Ltd. built an automated document analysis pipeline in May 2026 using GPT-4o vision hosted on Clarifai. The pipeline processed scanned invoice images — 300 images per day — extracting structured fields for accounts payable. A developer wrote the initial integration using a code example from a Stack Overflow answer dated 2023, which used the legacy clarifai SDK v9 gRPC proto API. The team had installed clarifai 10.5.0 (the current SDK version). Every image analysis request raised TypeError: 'int' object has no attribute 'data'. The pipeline never processed a single invoice successfully. Over five weeks, the team investigated CLARIFAI_PAT authentication, model URL format, image encoding (PNG vs. JPEG), and image size limits before engaging a retainer developer.

The clarifai Python SDK underwent a complete API redesign between v9 and v10. In v9, image inputs were constructed using protobuf objects: Input(data=Data(image=Image(base64=image_bytes))). In v10, inputs are constructed using factory methods on the Inputs class: Inputs.get_image_inputs_from_bytes(input_id='img_001', image_bytes=image_bytes). When the team passed raw bytes to model.predict(inputs=image_bytes), the SDK’s internal iteration code iterated over the bytes object, yielding integers (0–255 for each byte). The SDK attempted to call .data on each integer, raising TypeError immediately. The error message did not mention the Inputs factory API — it mentioned integers and attributes — which led the team to investigate unrelated root causes.

The document analysis code at the time of the engagement:

# invoice_analyzer.py
# Westfield Vision Ltd.
# clarifai 10.5.0, Python 3.11
# GPT-4o vision via Clarifai

from clarifai.client.model import Model
import os

model = Model(
    url="https://clarifai.com/openai/chat-completion/models/gpt-4-vision",
    pat=os.environ["CLARIFAI_PAT"],
)

def analyze_invoice(image_bytes: bytes, invoice_id: str) -> str:
    """Extract structured fields from invoice image via GPT-4o on Clarifai."""
    # ← PROBLEM: raw bytes passed directly to inputs parameter.
    # clarifai SDK v10 expects inputs to be constructed via Inputs factory
    # methods — not raw bytes, not base64 strings, not proto objects.
    #
    # SDK v10 internal behavior when bytes is passed:
    #   for item in inputs:  # iterating bytes yields integers (0-255)
    #       item.data         # int has no attribute 'data' → TypeError
    #
    # The legacy v9 API (does NOT work with clarifai 10.x):
    #   from clarifai_grpc.proto.clarifai.api.resources_pb2 import Image, Data, Input
    #   inputs = [Input(data=Data(image=Image(base64=image_bytes)))]
    #
    # Neither the bytes directly nor the v9 proto objects work in v10.
    response = model.predict(
        inputs=image_bytes,  # ← WRONG: raw bytes, not a ClarifaiInput list
        inference_params={"temperature": 0.1},
    )
    # Never reached — TypeError raised before predict() processes the input.
    return response.outputs[0].data.text.raw


# The error raised on every request:
# TypeError: 'int' object has no attribute 'data'
# Traceback line: clarifai/client/model.py, in predict
#   for inp in inputs:
#       inp.data  ← inp is an int (byte value), not an Input object
#
# Team investigation over 5 weeks:
# - Week 1-2: CLARIFAI_PAT authentication (was correct)
# - Week 3:   model URL format variations
# - Week 4:   image encoding format (PNG vs JPEG, with/without base64)
# - Week 5:   image size reduction (hypothesis: too large for SDK)
# None resolved it — the root cause was the input construction API.

The clarifai SDK v9 vs. v10 input API difference

The clarifai SDK v9 and v10 have completely different input construction APIs. The v9 API used gRPC protobuf objects and was the standard shown in most blog posts, tutorials, and Stack Overflow answers written before 2024. The v10 API uses factory methods on an Inputs class. The two APIs are not compatible — using v9-style input construction with clarifai 10.x raises TypeError on every request. Any code example referencing clarifai_grpc.proto, Input(data=Data(image=Image(...))), or the StubV2 gRPC client is using the v9 API and will not work with clarifai 10.x.

# clarifai SDK input API: v9 (legacy) vs. v10 (current)
#
# ─── clarifai v9 (legacy — does NOT work with clarifai 10.x) ───────────────
# from clarifai_grpc.proto.clarifai.api.resources_pb2 import Image, Data, Input
# inputs = [Input(data=Data(image=Image(base64=image_bytes)))]
# response = stub.PostModelOutputs(...)   ← gRPC call, not model.predict()
#
# ─── clarifai v10 (current) ────────────────────────────────────────────────
# from clarifai.client.model import Model
# from clarifai.client.input import Inputs
#
# model = Model(url="https://clarifai.com/{user_id}/{app_id}/models/{model_id}")
#
# Image from bytes:
image_input = Inputs.get_image_inputs_from_bytes(
    input_id="invoice_001",   # ← must be non-empty string, unique per request
    image_bytes=image_bytes,  # ← the raw bytes object
)
# Image from URL:
image_input = Inputs.get_image_inputs_from_url(
    input_id="invoice_001",
    image_url="https://example.com/invoice.png",
)
# Image from local file:
image_input = Inputs.get_image_inputs_from_file(
    input_id="invoice_001",
    image_file="/path/to/invoice.png",
)
#
# model.predict() takes a list of input objects — the factory returns the list.
# For vision + text (multimodal):
from clarifai.client.input import Inputs as CInputs
text_and_image = CInputs.get_multimodal_input(
    input_id="invoice_001",
    image_bytes=image_bytes,
    raw_text="Extract all line items, totals, and vendor name.",
)
response = model.predict(inputs=[text_and_image])
#
# Text output from vision model:
output_text = response.outputs[0].data.text.raw  # ← NOT response.choices[0]...

The fix: use Inputs.get_image_inputs_from_bytes()

# invoice_analyzer.py — FIXED
# Westfield Vision Ltd.
# clarifai 10.5.0, Python 3.11

from clarifai.client.model import Model
from clarifai.client.input import Inputs
import uuid
import os

model = Model(
    url="https://clarifai.com/openai/chat-completion/models/gpt-4-vision",
    pat=os.environ["CLARIFAI_PAT"],
)

EXTRACTION_PROMPT = (
    "Extract all line items, vendor name, invoice date, subtotal, tax, and total. "
    "Return as JSON with keys: vendor, date, line_items (list), subtotal, tax, total."
)

def analyze_invoice(image_bytes: bytes, invoice_id: str) -> str:
    """Extract structured fields from invoice image via GPT-4o on Clarifai."""
    # ← FIX 1: Use Inputs.get_multimodal_input() for vision + text input.
    # This constructs the correct ClarifaiInput object for clarifai SDK v10.
    # input_id must be a unique non-empty string — use the invoice_id.
    image_input = Inputs.get_multimodal_input(
        input_id=invoice_id,          # ← unique per request, non-empty
        image_bytes=image_bytes,      # ← bytes, not passed directly to predict()
        raw_text=EXTRACTION_PROMPT,
    )

    # ← FIX 1: Pass the constructed input object in a list to predict().
    response = model.predict(
        inputs=[image_input],  # ← list of ClarifaiInput objects
        inference_params={"temperature": 0.1, "max_tokens": 1024},
    )

    # ← FIX 2: Read output from response.outputs[0].data.text.raw
    # (not response.choices[0].message.content like OpenAI SDK)
    return response.outputs[0].data.text.raw


# For image-only inputs (no text prompt):
def analyze_invoice_image_only(image_bytes: bytes, invoice_id: str) -> str:
    """Use image-only input for models that take a system prompt instead."""
    # ← FIX: Inputs.get_image_inputs_from_bytes() for image-only input.
    image_input = Inputs.get_image_inputs_from_bytes(
        input_id=invoice_id,
        image_bytes=image_bytes,
    )
    response = model.predict(inputs=image_input)  # factory returns a list
    return response.outputs[0].data.text.raw


# ← FIX 3: Generate unique input_id per request to avoid confusion in
# concurrent or batch workflows.
def make_input_id(prefix: str = "img") -> str:
    return f"{prefix}_{uuid.uuid4().hex[:8]}"

Why five weeks of investigation found nothing

The Westfield team’s error message — TypeError: 'int' object has no attribute 'data' — pointed directly to the input iteration code inside the SDK, but the team read it as a data corruption or encoding issue rather than an API usage error. They spent two weeks investigating CLARIFAI_PAT authentication on the hypothesis that the SDK was failing to initialize and returning a degenerate object. They spent one week trying different image encoding formats: passing base64-encoded strings, PIL Image objects, and BytesIO objects instead of raw bytes. All of these also failed because none of them were ClarifaiInput objects.

The fourth week was spent investigating image size: the team hypothesized that their invoice images (typically 1.5–3 MB) exceeded a size limit and that the SDK was corrupting the bytes during internal processing. They resized images to under 100 KB and retried — same TypeError, different byte count.

The retainer developer searched the clarifai GitHub repository for get_image_inputs_from_bytes, found the factory method in clarifai/client/input.py, and compared it to the code being used. The fix was replacing model.predict(inputs=image_bytes) with model.predict(inputs=Inputs.get_image_inputs_from_bytes(input_id=invoice_id, image_bytes=image_bytes)). The first test request returned a successful invoice extraction. Total diagnosis time: under ten minutes. The engagement’s remaining time was spent adding the multimodal prompt, reading the output correctly from response.outputs[0].data.text.raw, and adding a CI integration test.

Validation

# Validation benchmark (October 30, 2026)
# 50-invoice batch, GPT-4o vision via Clarifai
# clarifai 10.5.0, Python 3.11

# Before fix (raw bytes passed to inputs parameter):
# Invoices processed:                     0 / 50   (0%)
# TypeError on every request:            50 / 50 (100%)
# Error: TypeError: 'int' object has no attribute 'data'
# Team diagnosis: CLARIFAI_PAT auth, image encoding, image size
# Duration: 5 weeks May–October 2026

# After fix (Inputs.get_multimodal_input() with image_bytes + prompt):
# Invoices processed:                    50 / 50 (100%)
# TypeError:                              0 / 50   (0%)
# Successful JSON extractions:           48 / 50  (96%)  ← 2 had ambiguous layouts
# Average inference latency (p50):      ~3.2s  (GPT-4o vision, 1024 token output)
# Average inference latency (p95):      ~5.8s

# Production result (Westfield Vision Ltd.):
# Vision request success rate:  0% → 100%
# Authentication changes:       zero (CLARIFAI_PAT was correct all along)
# Image format changes:         zero (raw bytes was correct, just wrong input API)
# Image size changes:           zero (size was never the issue)
# Fix: replace raw bytes with Inputs.get_multimodal_input(input_id, image_bytes, raw_text)
# Read output from response.outputs[0].data.text.raw, not response.choices[0]
# 1.5h retainer engagement.
# Triage: 0.3h — reproduce TypeError; confirm SDK version; find Inputs factory API.
# Root cause: 0.3h — confirm v9 vs. v10 API change; identify correct factory method.
# Fix: 0.4h — implement Inputs.get_multimodal_input(); add extraction prompt; fix output read.
# Validation: 0.5h — 50-invoice batch; 100% request success; CI test added.

Related retainer posts

Track retainer hours without a client portal

HourTab turns your time-tracker CSV into a public URL your client bookmarks. No login. No portal. CSV in, URL out.

See pricing →