Adeptiv GenAI Tracing SDK

Adeptiv GenAI is a lightweight, vendor-neutral OpenTelemetry tracing SDK for LLMs, agents, and AI workflows.

It captures latency, execution flow, hashes, and metadata for all AI use cases.

Key Features

• Trace-only observability (no response normalization)
• Works with any LLM (OpenAI, Anthropic, Gemini, local models)
• Supports chat, summarization, agents, tools, RAG
• Sync & async compatible
• Enterprise-safe (hashing, redaction, previews)
• OpenTelemetry compatible

This ensures zero lock-in and maximum compatibility.

Installation

pip install adeptiv-ai-evaluator-sdk

Adeptiv GenAI Tracing SDK

Tracing an LLM Call

SDK configuration

config.api_key = "" #project Key 
config.project_name = "customer-support-bot" # Project Name


from adeptiv_evaluator_sdk import trace_llm

@trace_llm(model="gpt-4o", operation="chat", workflow_id="")
def chat(prompt):
    return llm.invoke(prompt)

chat("Hello world")

# Adeptiv GenAI Tracing Agents SDK

from adeptiv_evaluator_sdk import trace_llm

@trace_agent("support_agent", model="gpt-4o",workflow_id="")
async def run_agent(query):
    return await agent.run(query)

Containment

When a containment rule in Adeptiv acts on an agent (pause it, block a tool, allow only approved models, slow it down), the SDK enforces it inside your process. Only the agent the rule acted on is affected; every other agent keeps working.

The SDK keeps the use case's policy in memory and refreshes it in the background (every 15 s by default), so a check costs about a microsecond and never makes a network call. An action stays until someone resumes the agent in Adeptiv; if Adeptiv cannot be reached, the last policy stays in force. If the policy has never been fetched, nothing is enforced: an Adeptiv outage never stops your agents.

Only calls traced with contained=True are checked; @trace alone never is, and an app with no contained call makes no policy requests. Name agents the way they are named in Adeptiv:

from adeptiv_evaluator_sdk import trace, ContainmentError

@trace(operation="agent", agent_name="Refund Agent", contained=True)
def refund_agent(question):             # pause, approved models, slow down
    ...

@trace(operation="tool", contained=True)
def issue_refund(order_id):             # blocked for the current agent?
    ...

@trace(operation="chat", model="gpt-4.1", contained=True)
def ask_model(prompt):                  # outside the approved models?
    ...

try:
    reply = refund_agent(question)
except ContainmentError as exc:        # AgentPaused, ToolBlocked, ModelNotApproved, RateLimited
    reply = exc.fallback_message       # "A team member will reply to you shortly." or the rule's message

A refused call still shows on its span, marked with the action. A contained agent call makes its agent the current one, so contained tool and model calls inside it are checked for that agent.

For a tool dispatcher or a model call you cannot trace, check it before it runs; the agent is the one of the enclosing contained agent call:

from adeptiv_evaluator_sdk import guard_tool, guard_model

for call in response.tool_calls:
    guard_tool(call.name)              # raises ToolBlocked if this tool is blocked
    run_tool(call)
guard_model("gpt-4.1")                 # raises ModelNotApproved outside the approved list

Inside a @trace span, a refused or delayed call marks it with adeptiv.containment.action, adeptiv.containment.outcome (blocked / delayed) and adeptiv.containment.event_id, so Adeptiv can show the containment held.