Observability for LLM apps

Currai traces every prompt, token, and tool call so you can debug, measure, and ship your LLM app with confidence.

√Drop-in Python & TypeScript SDKs
√Full traces, tokens & cost in one view
√Langfuse & OpenTelemetry compatible
√Self-serve dashboards, plan-based retention

from currai import Currai

currai = Currai(public_key="pk-lf-...", secret_key="sk-lf-...")

# trace one LLM call end to end
trace = currai.trace(name="chat-turn", user_id="user-1")

gen = trace.generation(
    name="openai.chat.completions",
    model="gpt-4o-mini",
    input=messages,
)
gen.end(output=reply, usage={"input": 312, "output": 88})

↗Join the waitlist

See inside your LLM app

01INSTRUMENT

Trace any app in 5 lines

Drop the SDK into your Python or TypeScript app and start sending traces immediately.

Instrument your app

02GENERATIONS

Every prompt and completion

Capture inputs, outputs, model and parameters for every LLM call.

See your generations

03NESTED TRACES

Spans, tools & chains

Visualize the full tree of a request — retrievers, tools, and nested calls.

Follow a trace

04COST & TOKENS

Token cost, tracked for you

Input/output tokens and cost rolled up per trace, model, and day.

Track your cost

05SESSIONS & USERS

Group by session and user

Stitch multi-turn conversations together and slice by end user.

Group your traces

06COMPATIBLE

Works with your stack

Byte-compatible with Langfuse SDKs and OpenTelemetry — point them at Currai and go.

Bring your SDK

07MANAGED

We run the infra

Hosted ingestion, storage, and dashboards. No ClickHouse to babysit.

Skip the ops

08RETENTION

Your data, your retention

Plan-based retention with usage billed on processed data, not per trace.

See pricing

From print() to production tracing

01

Install the SDK and wrap your first LLM call. That's the whole setup.

↗Send your first trace

Trace your first call 🧵

from currai import Currai

currai = Currai(public_key="pk-lf-...", secret_key="sk-lf-...")

trace = currai.trace(name="chat-turn", user_id="user-1")

02

End the generation with token usage and Currai computes the cost for you.

↗Track tokens & cost

Capture tokens & cost 💸

gen = trace.generation(name="openai.chat", model="gpt-4o-mini", input=messages)

completion = client.chat.completions.create(model="gpt-4o-mini", messages=messages)

gen.end(
    output=completion.choices[0].message.content,
    usage={
        "input": completion.usage.prompt_tokens,
        "output": completion.usage.completion_tokens,
        "total": completion.usage.total_tokens,
        "unit": "TOKENS",
    },
)

03

Pass a session and user id to group multi-turn conversations into one view.

↗Group your traces

Sessions & users 👥

trace = currai.trace(
    name="chat-turn",
    session_id="sess-42",
    user_id="user-1",
    tags=["chatbot", "production"],
)

await currai.flush_async()  # required before short-lived processes exit

04

Already on Langfuse? Keep your code — just point the base URL at Currai.

↗Migrate in one line

Drop-in compatible 🔌

from langfuse import Langfuse

client = Langfuse(
    public_key="pk-lf-...",
    secret_key="sk-lf-...",
    host="https://currai.app",  # only this line changes
)

05

Install the Currai skill so your AI coding agent knows how to add traces to your code for you.

↗Add the Currai skill

Teach your agent to instrument 🧠

# drop the Currai skill into your AI coding agent
npx @currai/skills install currai

# now ask your agent: "add Currai tracing to my Python app"
# it wraps your LLM calls: currai.trace(...).generation(...)

Questions, answered

What is Currai?

Currai is observability for LLM apps. It traces every prompt, token, and tool call your app makes so you can debug, measure, and ship with confidence — full traces, token usage, and cost in one view. Drop in the Python or TypeScript SDK and you get a hosted dashboard without running any infrastructure yourself.

How long does it take to get my first trace?

About five minutes. Install the SDK with pip install currai or npm i currai, paste your public / secret key pair, and wrap a single LLM call. There's no agent to deploy and no collector to run — the first request you make shows up in the dashboard right away.

Which languages and frameworks do you support?

Currai ships first-class Python and TypeScript SDKs, and it's byte-compatible with the Langfuse SDKs and OpenTelemetry. If you're already instrumented, you migrate by changing a single host line — your existing trace code, spans, and exporters keep working.

Will tracing slow down my app?

No. Traces are batched and flushed in the background, so instrumentation never blocks a request. In short-lived processes you call flush() (or flush_async()) before exit to make sure everything is sent.

How is pricing calculated?

Usage is billed on the data Currai actually processes — measured in processed bytes — not on a flat per-trace fee. Large traces and tiny traces are priced for what they are, so your cost tracks real volume instead of row counts.

How long is my data retained?

Retention follows your plan, so you keep traces for as long as your plan's window allows. You can export or delete your data on demand at any time.

Do I have to run any infrastructure?

None. Currai hosts ingestion, columnar storage, and dashboards for you — there's no ClickHouse to babysit. It scales with your traffic so you watch data, not infrastructure.