decimalai 0.7.1

Open source SDK for manifest-aware agent change management

DecimalAI Python SDK

The open source SDK for DecimalAI — the manifest-aware platform for agent change management.

Installation

pip install decimalai

Requires Python 3.10+ (pip won't install current releases on older Pythons).

See it in 2 minutes

Both flagship workflows ship with a one-command sandbox — realistic data seeded into your workspace, so you don't have to wait to accumulate your own. Set your API key, then run either demo:

export DECIMAL_API_KEY="dai_sk_..."   # from app.decimal.ai/settings

For engineers — catch regressions before they ship

decimalai demo regression   # → impact report: what your next change would break

For prompt engineers — find skills that actually work

decimalai demo skills       # → registry ranked by real production effectiveness

Browsing without an account? Explore the public skill registry — no signup required.

Quick Start

LangChain / LangGraph — Zero-Code Tracing

import decimalai

decimalai.init(langchain=True)  # That's it — all LLM calls auto-traced

# Use LangChain as normal — nothing else changes
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(model="gpt-4o")
result = llm.invoke("Hello!")  # ← Auto-captured by DecimalAI

OpenAI Agents SDK

import decimalai

decimalai.init(openai_agents=True)

Any Framework — Manual Tracing

import decimalai

decimalai.init()

@decimalai.trace(agent_name="my-agent")
def run_agent(query):
    msgs = [{"role": "user", "content": query}]
    resp = openai.chat.completions.create(model="gpt-4o", messages=msgs)
    decimalai.log_llm_call(
        model="gpt-4o",
        input=msgs,
        output={"content": resp.choices[0].message.content},
    )
    return resp.choices[0].message.content

Environment Variable Setup (No Code Changes)

export DECIMAL_API_KEY=dai_sk_...
export DECIMAL_AUTO_TRACE=langchain   # or "openai-agents"
# Just run your app — tracing activates on import
python app.py

What It Does

• Auto-tracing — Captures LLM calls, tool calls, and agent steps with zero code changes
• Agent versioning — Auto-detects tool schemas, prompts, models, and graph topology
• Change detection — Detects when your agent configuration drifts
• Inline evals — Run eval functions on every trace with @decimalai.evals.eval
• Built-in deterministic scores — completion, has_output, tool_compliance, latency, token_efficiency attached to every trace by the SDK (disable with install(..., builtin_evals=False)). These run in your process, not server-side — bare HTTP POST /traces does not auto-score.
• Batch evals — Run evals offline across historical traces
• Dataset pull — One-liner to download versioned training data: decimalai.pull_dataset("ds_abc", "./data.jsonl")
• HuggingFace Hub — Push datasets to HF Hub for instant Axolotl/Unsloth/TRL compatibility
• Fine-tuning — Launch fine-tuning jobs on OpenAI, Together.AI, or Gemini from the platform
• Skills management — Auto-discover SKILL.md files, sync to platform, install from registry
• OTel compatible — Export spans to any OpenTelemetry backend

Skills

DecimalAI auto-discovers your existing SKILL.md files and provides observability — tracking which skills activate, how effective they are, and how they change over time.

Auto-Discovery (Bring Your Own Skills)

If you already have SKILL.md files (from npx skills add, your team's repo, or hand-written), the SDK discovers them automatically:

import decimalai
decimalai.init(api_key="dai_sk_...")

from decimalai.openai_agents import install
install()  # Scans .claude/skills/, .agents/skills/, etc. → syncs to dashboard

Supports 32 agent runtimes: Claude Code, Cursor, Copilot, Windsurf, Continue, and more.

Registry Search & Install

Find community skills and install them in one call:

from decimalai.skill_router import SkillRouter
router = SkillRouter(api_key="dai_sk_...")

# Search the public registry
results = router.search("code review security")

# Install a skill: fork to your org + write to disk for your agents
router.install("pdf", agents=["claude-code", "cursor"])

Status & Update

# Check sync status between local files and platform
status = router.status()
# → {"synced": [...], "modified_locally": [...], "untracked": [...]}

# Pull upstream updates
router.update_skills()

See the full SDK Skills Reference for all methods.

Datasets & Training

Pull Training Data

import decimalai
decimalai.init()

# Pull the latest version to a local file
result = decimalai.pull_dataset("ds_abc123", "./training_data.jsonl")
print(f"Wrote {result['row_count']} rows")

# Pull a specific version
result = decimalai.pull_dataset("ds_abc123", "./data.jsonl", version="v2")

Push to HuggingFace Hub

# Push to HF Hub — instantly loadable by Axolotl, Unsloth, TRL
result = decimalai.push_to_hub("ds_abc123", "my-org/support-agent-sft")

# Now usable everywhere:
# from datasets import load_dataset
# ds = load_dataset("my-org/support-agent-sft")

Load as HuggingFace Dataset (In-Memory)

# Skip files — load directly into your training script
ds = decimalai.load_hf_dataset("ds_abc123")
# → Dataset({features: ['messages'], num_rows: 500})

CLI

# Pull latest version
decimalai datasets pull ds_abc123 -o ./training_data.jsonl

# Pull specific version as Parquet
decimalai datasets pull ds_abc123 -o ./data.parquet --version v2

# Push to HuggingFace Hub
decimalai datasets push-to-hub ds_abc123 my-org/support-agent-sft

Fine-Tuning Providers

Provider	Models	Setup
OpenAI	GPT-4o, GPT-4.1-mini	Dashboard or API
Together.AI	Llama 4, Qwen 3, DeepSeek R1, Mistral	Dashboard or API
Gemini	Gemini 2.5 Flash/Pro	Dashboard or API

Supported Frameworks

Framework	Status	Setup
LangChain / LangGraph	✅	init(langchain=True)
OpenAI Agents SDK	✅	init(openai_agents=True)
Google ADK	✅ (native)	init(adk=True)
Anthropic Claude Agent SDK	✅ (native)	init(claude_agent_sdk=True)
LlamaIndex	✅	init(llamaindex=True)
CrewAI	✅	init(crewai=True)
AutoGen / AG2	✅	init(autogen=True)
Generic (any framework)	✅	@decimalai.trace()
OpenTelemetry	✅	init(otel=True)

Tracing a direct LLM SDK with no agent framework? Use the provider flags: init(openai=True), init(anthropic=True), or init(google=True).

Examples

See the examples/ directory for runnable notebooks with Open in Colab badges:

Notebook	Description	Colab
Quickstart	Full version-aware loop — no LLM key needed
LangChain	Instrument a LangChain agent
OpenAI Agents	Instrument an OpenAI Agents app
Evaluations	Run built-in evaluators on traces
Datasets	Build SFT training datasets
Pull & Push	Pull datasets locally, push to HuggingFace Hub	—
Version-Aware Loop	Detect manifest changes and impact

Open standard: agentversion

The manifests this SDK captures are agentversion manifests — the open spec for agent versioning, diffing, and compatibility decisions that DecimalAI is built on. export_manifest hands a captured manifest to the OSS tooling, so you can diff and gate it in CI with no platform account:

import decimalai
from decimalai.schema.manifest import extract_from_config
from agentversion.diff import diff_manifests              # pip install agentversion
from agentversion.compatibility import classify_compatibility

snap = extract_from_config(agent_name="support-agent", prompts={...}, models={...})
manifest = decimalai.export_manifest(snap)                # → an agentversion manifest dict
print(classify_compatibility(diff_manifests(last_prod, manifest)).recommended_decision)

You can reproduce the platform's diffs and verdicts entirely outside DecimalAI — the SDK is the convenience layer over the open standard.

Documentation

Full docs at docs.decimal.ai

License

MIT — see LICENSE for details.