Learning Center

Learn Observyze
Step by Step

From your first API call to advanced circuit breaker configuration — we've got tutorials for every skill level.

Quick Start Guide

Get up and running in 5 minutes

1

Create Account

Sign up for a free account at observyze.com

2

Get API Key

Navigate to Settings → API Keys and create your first key

3

Configure Provider Keys

Add your AI provider keys (OpenAI, Anthropic, etc.) in Settings → Provider Keys

4

Enable Features (Optional)

Go to Settings → Organization to enable Hallucination Scoring, Circuit Breaker, Bug Bounty, and Prompt Tuning

5

Make Your First Request

Use the proxy gateway or SDK to start tracing

Example Request
curl -X POST "https://api.observyze.com/api/v1/proxy/openai/v1/chat/completions" \
  -H "Authorization: Bearer ob_xxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-4o", "messages": [{"role": "user", "content": "Hello!"}]}'

Environment Setup

Your API key contains embedded organization info. Get it from Dashboard → Settings → API Keys

You're ready to go!

Your API key gives you access to all Observyze features. Just set this as your auth header and you're good to go.

All Tutorials

Choose a topic based on your experience level

5 minBeginner

Quick Start Guide

Get up and running with Observyze in under 5 minutes

Start Tutorial
3 minBeginner

Zero-Code Proxy Setup

Add observability to your AI calls without changing logic

Start Tutorial
10 minIntermediate

SDK Integration

Use our client libraries for deeper integration

Start Tutorial
8 minIntermediate

Setting Up Alerts

Configure cost, safety, and latency alerts

Start Tutorial
5 minIntermediate

Team & Permissions

Manage organization members and access roles

Start Tutorial
12 minAdvanced

Circuit Breakers

Implement safety gates to protect your production

Start Tutorial
8 minAdvanced

Hallucination Scoring

Evaluate traces for factual accuracy and grounding

Start Tutorial
10 minAdvanced

Trace Replay & Debugging

Re-run traces with modifications to test prompts

Start Tutorial
6 minAdvanced

Bug Bounty

Auto-detect critical failure patterns in production

Start Tutorial
10 minAdvanced

Prompt Tuning

AI-powered prompt optimization based on failure patterns

Start Tutorial

Deep Dive: Zero-Code Proxy

The Proxy Gateway is the fastest way to add observability. Just change your base URL — no code changes required.

Step 1: Update Your Client

TypeScript / Node.js
const openai = new OpenAI({
  apiKey: process.env.OBSERVYZE_KEY,
  baseURL: 'https://api.observyze.com/api/v1/proxy/openai/v1'
});
Python
client = OpenAI(
  api_key=os.environ["OBSERVYZE_KEY"],
  base_url="https://api.observyze.com/api/v1/proxy/openai/v1"
)

Step 2: Response Headers

Every response includes additional headers for tracking:

x-obs-trace-idob_trace_8f29c1a2...
x-obs-duration-ms452
x-obs-cost-usd0.00125
x-obs-key-sourcevault | env | header

Step 3: Supported Providers

OpenAI
/proxy/openai/v1
Anthropic
/proxy/anthropic
Google
/proxy/google/v1
OpenRouter
/proxy/openrouter/v1
Azure
/proxy/azure/v1
Cohere
/proxy/cohere/v1
Mistral
/proxy/mistral/v1
Groq
/proxy/groq/v1

SDK Integration

For deeper observability, use our SDK to instrument your AI clients. Get automatic span tracking, custom metadata, and full control over trace data.

Install the SDK

npm install @observyze/sdk

Initialize ObservyzeClient

Basic Setup
import { ObservyzeClient } from '@observyze/sdk';

const nw = new ObservyzeClient({
  apiKey: process.env.OBSERVYZE_API_KEY,
  organizationId: 'your-org-id'
});
With Options
const nw = new ObservyzeClient({
  apiKey: process.env.OBSERVYZE_API_KEY,
  projectId: 'my-project',
  flushInterval: 5000,
  debug: true
});

Instrument OpenAI

Wrap your OpenAI client to automatically capture all requests:

import { ObservyzeClient, wrapOpenAI } from '@observyze/sdk';
import OpenAI from 'openai';

const nw = new ObservyzeClient({ apiKey: process.env.OBSERVYZE_API_KEY });

// Create and wrap your OpenAI client
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
const tracedOpenAI = wrapOpenAI(openai, nw);

// Use the traced client - all calls are automatically instrumented
const response = await tracedOpenAI.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Hello!' }]
});

Instrument Anthropic

Wrap your Anthropic client for Claude integration:

import { ObservyzeClient, wrapAnthropic } from '@observyze/sdk';
import { Anthropic } from '@anthropic-ai/sdk';

const nw = new ObservyzeClient({ apiKey: process.env.OBSERVYZE_API_KEY });

// Create and wrap your Anthropic client
const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const tracedAnthropic = wrapAnthropic(anthropic, nw);

// Use the traced client
const response = await tracedAnthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Hello!' }]
});

Custom Tracing

For complete control, create custom spans and traces:

import { ObservyzeClient, SpanType } from '@observyze/sdk';

const nw = new ObservyzeClient({ apiKey: process.env.OBSERVYZE_API_KEY });

// Start a custom trace
const trace = await nw.startTrace({
  name: 'agent-workflow',
  projectId: 'my-project',
  metadata: { userId: 'user-123' }
});

// Add spans for different operations
const llmSpan = await nw.startSpan({
  name: 'llm-call',
  type: SpanType.LLM,
  input: { model: 'gpt-4o', messages: [...] },
  metadata: { temperature: 0.7 }
});

const toolSpan = await nw.startSpan({
  name: 'tool-execution',
  type: SpanType.TOOL,
  input: { tool: 'search', query: '...' }
});

// Complete spans
await llmSpan.complete({
  output: { content: 'LLM response...' },
  metadata: { tokens: 150 }
});

await toolSpan.complete({
  output: { results: [...] }
});

// Complete the trace
await trace.complete({ status: 'success' });

Supported AI Providers

OpenAI
wrapOpenAI
Anthropic
wrapAnthropic
Google AI
wrapGemini
Cohere
wrapCohere

Platform Features

Everything you need to monitor, secure, and optimize your AI infrastructure

Trace Explorer

Search, filter, and analyze every AI request with full span-level detail

Debugging

Replay traces with step-by-step execution timeline and inspector panel

Cost Analytics

Track spend per model, project, and time period with real-time dashboards

Alert Rules

Configure thresholds for cost, latency, and safety with multiple notification channels

Team Management

Organization → Projects → Teams with Owner/Admin/Developer/Viewer roles

Audit Logs

Complete visibility into all system actions for SOC2/HIPAA compliance

Provider Keys

Securely store and manage AI provider credentials with AES-256-GCM encryption

Circuit Breakers

Automatic halting of dangerous requests based on evaluation scores

Prompt Hub

Version, test, and deploy prompts across your agentic workflows

Hallucination Scoring

Evaluate your AI traces for factual accuracy and grounding using LLM-based analysis. This helps identify when models generate content not supported by inputs.

Step-by-Step: Score a Trace

1
Enable Hallucination Scoring

Go to Settings → Organization and toggle "Hallucination Scoring" to ON. Click "Save Feature Settings".

2
Go to Traces

Navigate to /traces from the sidebar or click "View All Traces" in Quick Actions.

3
Select a Trace

Click on any trace to open the trace detail view with the waterfall timeline.

4
Score Hallucination

In the Inspector panel (right side), click "Score Hallucination" button. The score will appear in a toast notification.

5
View Results

The hallucination score (0-1) is stored in trace metadata. Score < 0.3 = Good, 0.3-0.7 = Warning, > 0.7 = Critical.

How It Works

The Evaluation Service analyzes each trace using LLM evaluators with fallback models to ensure reliability:

  • Sends trace spans to the evaluation service
  • Uses OpenRouter with automatic fallback (Mistral → Gemma → Llama → Phi-3)
  • Returns hallucination score (0-1) and reasoning
  • Results are stored in trace metadata

Scoring via UI

Navigate to any trace detail page and click "Score Hallucination" in the Inspector panel:

Traces → [Select Trace] → Inspector → Score Hallucination
Requires Developer role or higher

Scoring via API

curl -X POST "https://api.observyze.com/api/v1/traces/tr_xxx/evaluate" \
  -H "Authorization: Bearer ob_xxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json"

# Response:
{
  "success": true,
  "score": 0.15,
  "details": {
    "reasoning": "The output accurately reflects...",
    "evaluated_by": "mistralai/mistral-7b-instruct:free"
  }
}

Trace Replay & Debugging

Re-run traces with modifications to test prompt changes, agent logic, or tool configurations without affecting production.

Replay Modes

Simulation Mode
Runs locally with randomized duration/cost deltas. No actual API calls. Useful for quick testing when no webhook is configured.
Webhook Mode
Re-injects the trace into your agent via webhook URL. Executes real API calls with modified inputs. Best for end-to-end testing.

Using Replay in UI

  1. Open any trace detail page
  2. Click "Replay Trace" at the top to enter debugging mode
  3. Select a span in the waterfall view
  4. Edit the input in the Inspector panel
  5. Click "Dispatch Replay to Agent"
  6. View results in the toast notification

Replay via API

# With webhook (re-inject into agent)
curl -X POST "https://api.observyze.com/api/v1/traces/tr_xxx/replay" \
  -H "Authorization: Bearer ob_xxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "webhook_url": "https://your-agent.com/webhook",
    "modified_spans": [
      {
        "span_id": "span_123",
        "input": {"messages": [{"role": "user", "content": "New prompt"}]}
      }
    ]
  }"

# Without webhook (local simulation)
curl -X POST "https://api.observyze.com/api/v1/traces/tr_xxx/replay" \
  -H "Authorization: Bearer ob_xxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{"modified_spans": []}'

Circuit Breakers

Automatic safety gates that halt or alert when agent behavior exceeds configured thresholds. Protects your production from harmful outputs or runaway costs.

Step-by-Step: Enable & Configure

1
Enable Circuit Breaker

Go to Settings → Organization and toggle "Circuit Breaker" to ON. Click "Save Feature Settings".

2
Navigate to Safety Dashboard

Click "Safety Dashboard" in Quick Actions, or go to /safety from the sidebar.

3
Configure Thresholds

Set hallucination score, safety score, consecutive failures, and failure window. Click "Configure" to edit values.

4
Set Action

Choose action: Halt (block requests), Alert (notify only), or Log (record silently).

5
Save & Monitor

Click "Save Changes". When thresholds are exceeded, the circuit breaker will take the configured action.

Configuration Options

Thresholds

Hallucination Score0.7 (70%)
Safety Score0.7 (70%)
Consecutive Failures3
Failure Window5 min

Actions

Halt - Block all agent calls immediately
Alert - Send notification, continue
Log - Record event silently

Managing via UI

Navigate to the Safety page to configure circuit breakers:

Dashboard → Safety
Configure thresholds, actions, and view bounty reports

Circuit Breaker API

# Get current config
curl "https://api.observyze.com/api/v1/optimization/circuit-breaker" \
  -H "Authorization: Bearer ob_xxxxxxxxxxxxxxxx"

# Update config
curl -X POST "https://api.observyze.com/api/v1/optimization/circuit-breaker" \
  -H "Authorization: Bearer ob_xxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "enabled": true,
    "thresholds": {
      "hallucination_score": 0.5,
      "safety_score": 0.5,
      "consecutive_failures": 3,
      "failure_window_minutes": 5
    },
    "action": "halt",
    "cooldown_seconds": 60
  }'

Bug Bounty

Automated vulnerability detection that identifies critical failure patterns in your production traces. Helps you catch and fix issues before they impact users.

Step-by-Step: Enable & Use

1
Enable Bug Bounty

Go to Settings → Organization and toggle "Bug Bounty" to ON. Click "Save Feature Settings".

2
Navigate to Safety Dashboard

Click "Safety Dashboard" in Quick Actions, or go to /safety from the sidebar.

3
Run Auto-Detect

Click "Run Auto-Detect" button at the top of the Safety page to scan for failure patterns.

4
View Reports

Bug bounty reports appear in the "Bug Bounty Reports" panel with severity levels (critical/high/medium/low).

How It Works

The Bug Bounty system continuously monitors your traces and automatically detects failure patterns:

  • Runs auto-detection to find failure clusters above threshold
  • Classifies issues by severity (critical/high/medium/low)
  • Stores detected bugs as bounty reports
  • Shows hallucination score per report

Running Auto-Detect

Click "Run Auto-Detect" on the Safety page to manually trigger detection:

Dashboard → Safety → Run Auto-Detect
Scans for persistent failure clusters

Bug Bounty API

# Get bounty history
curl "https://api.observyze.com/api/v1/bug-bounty/history" \
  -H "Authorization: Bearer ob_xxxxxxxxxxxxxxxx"

# Trigger auto-detect
curl -X POST "https://api.observyze.com/api/v1/bug-bounty/auto-detect" \
  -H "Authorization: Bearer ob_xxxxxxxxxxxxxxxx"

# Response:
{
  "detected": 2,
  "bounties": [
    {
      "bounty_id": "bty_xxx",
      "trace_id": "tr_xxx",
      "severity": "critical",
      "hallucination_score": 0.85
    }
  ]
}

Prompt Tuning

AI-powered prompt optimization based on failure patterns. Analyzes your traces to identify issues and generates optimized prompts to fix them.

Step-by-Step: Optimize Your Prompts

1
Enable Prompt Tuning

Go to Settings → Organization and toggle "Prompt Tuning" to ON. Click "Save Feature Settings".

2
Navigate to Prompt Hub

Click "Prompt Hub" in Quick Actions, or go to /prompts from the sidebar.

3
Select a Prompt

Choose a prompt from your Prompt Hub that has failure patterns (errors/timeouts).

4
Request Optimization

Click "Optimize" or "Auto-Tune" button. The system will analyze failure patterns and generate an optimized prompt.

5
Apply & Test

Review the optimized prompt, apply it to your agent, and test with new traces to verify improvements.

How It Works

The Prompt Tuning service analyzes failure patterns and generates optimized prompts:

  • Scans your traces for error and timeout patterns
  • Identifies common failure categories (format, context, instruction issues)
  • Uses LLM to generate improved prompts
  • Provides rationale for each improvement

Ready to get started?

Start with zero code changes using the Proxy Gateway, or use our SDKs for deeper integration.

Prompt Hub

Create, version, test, and deploy AI prompts with full lifecycle management. Use variables, track changes, and optimize with AI-powered suggestions.

What is Prompt Hub?

Prompt Hub is your central repository for managing AI prompts across all your agents and workflows. It provides version control, variables, testing, and AI-powered optimization.

Use Cases
  • • Store system prompts for all agents
  • • Version control prompt changes
  • • A/B test different prompts
  • • Rollback to stable versions
Benefits
  • • Single source of truth for prompts
  • • Track who changed what
  • • AI optimization suggestions
  • • Production-ready workflows

Step-by-Step: Using Prompt Hub

1
Create a Prompt

Go to /prompts and click "New Prompt Template". Add your prompt content with variables like {{variable_name}}.

2
Use in Your Code

Reference the prompt by ID in your agent code. This ensures consistency and allows you to update prompts without redeploying code.

3
Track Versions

Every edit creates a new version. View history, compare versions, and tag stable versions as "Production".

4
Enable AI Optimization

Go to Settings → Organization and enable "Prompt Tuning". The AI will analyze your traces for failure patterns.

5
Apply Optimizations

Go to /prompts/optimization to see AI suggestions. Review and apply them to improve your agent's performance.

Using Variables

Define variables in your prompts using {{variable_name}} syntax:

You are a helpful assistant for a {company_name}.

Your response style should be:
- Tone: {tone}
- Detail level: {detail_level}

User query: {query}

When using the prompt, provide values for company_name, tone, detail_level, and query.

Version Control

Prompt Hub tracks all changes automatically:

Version 3 - Production (current)
Version 2 - Draft
Version 1 - Archived

Ready to get started?

Start with zero code changes using the Proxy Gateway, or use our SDKs for deeper integration.