Quickstart

curl -X POST https://untrace.dev/api/v1/traces \
  -H "Authorization: Bearer utr_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4",
    "provider": "openai",
    "prompt_tokens": 50,
    "completion_tokens": 100,
    "total_tokens": 150,
    "latency_ms": 1234,
    "timestamp": "2024-01-15T10:00:00Z"
  }'

# Basic routing by model
- name: "GPT-4 to LangSmith"
  condition:
    model: "gpt-4*"
  destination: "langsmith"

# Route errors for debugging
- name: "Errors to Langfuse"
  condition:
    status: "error"
  destination: "langfuse"

# Cost-based routing
- name: "Expensive requests"
  condition:
    cost: "> 0.10"
  destinations:
    - platform: "langsmith"
    - platform: "webhook"
      url: "https://alerts.example.com"

response = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Test trace"}]
)
print(f"Trace ID: {response.headers.get('X-Untrace-ID')}")

init({
  apiKey: 'utr_your_api_key',
  debug: true  // Enables detailed logging
});

// Separate configurations by environment
const untrace = init({
  apiKey: process.env.UNTRACE_API_KEY,
  environment: process.env.NODE_ENV,

  // Sample less in production
  samplingRate: process.env.NODE_ENV === 'production' ? 0.1 : 1.0,

  // Different routing per environment
  routingRules: process.env.NODE_ENV === 'production'
    ? productionRules
    : developmentRules
});

# Untrace works with all providers simultaneously
import openai
import anthropic
from langchain.chat_models import ChatOpenAI

# All are automatically instrumented
openai_client = openai.OpenAI()
anthropic_client = anthropic.Anthropic()
langchain_model = ChatOpenAI()

# Traces from all providers flow through Untrace

# Route only a sample of expensive requests
- name: "Sample GPT-4"
  condition:
    model: "gpt-4"
  destination: "langsmith"
  sample_rate: 0.1  # Only 10%

# But capture all errors
- name: "All Errors"
  condition:
    error: true
  destination: "langsmith"
  sample_rate: 1.0  # 100%

// app/instrumentation.ts
export async function register() {
  if (process.env.NEXT_RUNTIME === 'nodejs') {
    const { init } = await import('@untrace/sdk');
    init({ apiKey: process.env.UNTRACE_API_KEY });
  }
}

# main.py
from fastapi import FastAPI
from untrace import Untrace

app = FastAPI()
untrace = Untrace(api_key="utr_your_api_key")

@app.on_event("startup")
async def startup():
    untrace.init()

# Automatic instrumentation
from untrace import init
init(api_key="utr_your_api_key")

# Your LangChain code - automatically traced
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationChain

llm = ChatOpenAI(model="gpt-4")
chain = ConversationChain(llm=llm)