Capturing Documents

import base64
import langwatch
from openai import OpenAI

langwatch.setup()


def data_url(path: str, media_type: str) -> str:
    encoded = base64.b64encode(open(path, "rb").read()).decode("utf-8")
    return f"data:{media_type};base64,{encoded}"


@langwatch.trace(name="read invoice")
def read_invoice(prompt: str, path: str) -> str:
    client = OpenAI()
    langwatch.get_current_trace().autotrack_openai_calls(client)

    completion = client.chat.completions.create(
        model="gpt-5-mini",
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": prompt},
                    {
                        "type": "file",
                        "file": {
                            "filename": "invoice.pdf",
                            "file_data": data_url(path, "application/pdf"),
                        },
                    },
                ],
            }
        ],
    )
    return completion.choices[0].message.content or ""


read_invoice("What is the invoice number and the total due?", "invoice.pdf")

import base64
import langwatch
from anthropic import Anthropic
from openinference.instrumentation.anthropic import AnthropicInstrumentor

langwatch.setup(instrumentors=[AnthropicInstrumentor()])


@langwatch.trace(name="read invoice")
def read_invoice(prompt: str, path: str) -> str:
    client = Anthropic()
    encoded = base64.b64encode(open(path, "rb").read()).decode("utf-8")

    message = client.messages.create(
        model="claude-haiku-4-5-20251001",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": prompt},
                    {
                        "type": "document",
                        "source": {
                            "type": "base64",
                            "media_type": "application/pdf",
                            "data": encoded,
                        },
                    },
                ],
            }
        ],
    )
    return message.content[0].text


read_invoice("What is the invoice number and the total due?", "invoice.pdf")

import asyncio

import langwatch
from google.adk import Agent, Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types
from openinference.instrumentation.google_adk import GoogleADKInstrumentor

langwatch.setup(instrumentors=[GoogleADKInstrumentor()])

APP_NAME = "document-reader"
USER_ID = "caller-1"
SESSION_ID = "session-1"


def ask(prompt: str, path: str) -> str:
    agent = Agent(
        name="document_agent",
        model="gemini-2.5-flash",
        instruction="Answer the user's question about the attached document directly.",
    )
    session_service = InMemorySessionService()
    asyncio.run(
        session_service.create_session(
            app_name=APP_NAME, user_id=USER_ID, session_id=SESSION_ID
        )
    )
    runner = Runner(agent=agent, app_name=APP_NAME, session_service=session_service)

    message = types.Content(
        role="user",
        parts=[
            types.Part(text=prompt),
            types.Part.from_bytes(
                data=open(path, "rb").read(), mime_type="application/pdf"
            ),
        ],
    )

    for event in runner.run(
        user_id=USER_ID, session_id=SESSION_ID, new_message=message
    ):
        if event.is_final_response():
            return event.content.parts[0].text
    return ""


ask("What is the invoice number and the total due?", "invoice.pdf")