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
Create Account
Sign up for a free account at observyze.com
Get API Key
Navigate to Settings → API Keys and create your first key
Configure Provider Keys
Add your AI provider keys (OpenAI, Anthropic, etc.) in Settings → Provider Keys
Enable Features (Optional)
Go to Settings → Organization to enable Hallucination Scoring, Circuit Breaker, Bug Bounty, and Prompt Tuning
Make Your First Request
Use the proxy gateway or SDK to start tracing
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
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
Quick Start Guide
Get up and running with Observyze in under 5 minutes
Zero-Code Proxy Setup
Add observability to your AI calls without changing logic
SDK Integration
Use our client libraries for deeper integration
Setting Up Alerts
Configure cost, safety, and latency alerts
Team & Permissions
Manage organization members and access roles
Circuit Breakers
Implement safety gates to protect your production
Hallucination Scoring
Evaluate traces for factual accuracy and grounding
Trace Replay & Debugging
Re-run traces with modifications to test prompts
Bug Bounty
Auto-detect critical failure patterns in production
Prompt Tuning
AI-powered prompt optimization based on failure patterns
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
const openai = new OpenAI({
apiKey: process.env.OBSERVYZE_KEY,
baseURL: 'https://api.observyze.com/api/v1/proxy/openai/v1'
});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:
Step 3: Supported Providers
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/sdkInitialize ObservyzeClient
import { ObservyzeClient } from '@observyze/sdk';
const nw = new ObservyzeClient({
apiKey: process.env.OBSERVYZE_API_KEY,
organizationId: 'your-org-id'
});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
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
Go to Settings → Organization and toggle "Hallucination Scoring" to ON. Click "Save Feature Settings".
Navigate to /traces from the sidebar or click "View All Traces" in Quick Actions.
Click on any trace to open the trace detail view with the waterfall timeline.
In the Inspector panel (right side), click "Score Hallucination" button. The score will appear in a toast notification.
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:
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
Using Replay in UI
- Open any trace detail page
- Click "Replay Trace" at the top to enter debugging mode
- Select a span in the waterfall view
- Edit the input in the Inspector panel
- Click "Dispatch Replay to Agent"
- 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
Go to Settings → Organization and toggle "Circuit Breaker" to ON. Click "Save Feature Settings".
Click "Safety Dashboard" in Quick Actions, or go to /safety from the sidebar.
Set hallucination score, safety score, consecutive failures, and failure window. Click "Configure" to edit values.
Choose action: Halt (block requests), Alert (notify only), or Log (record silently).
Click "Save Changes". When thresholds are exceeded, the circuit breaker will take the configured action.
Configuration Options
Thresholds
Actions
Managing via UI
Navigate to the Safety page to configure circuit breakers:
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
Go to Settings → Organization and toggle "Bug Bounty" to ON. Click "Save Feature Settings".
Click "Safety Dashboard" in Quick Actions, or go to /safety from the sidebar.
Click "Run Auto-Detect" button at the top of the Safety page to scan for failure patterns.
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:
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
Go to Settings → Organization and toggle "Prompt Tuning" to ON. Click "Save Feature Settings".
Click "Prompt Hub" in Quick Actions, or go to /prompts from the sidebar.
Choose a prompt from your Prompt Hub that has failure patterns (errors/timeouts).
Click "Optimize" or "Auto-Tune" button. The system will analyze failure patterns and generate an optimized prompt.
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.
- • Store system prompts for all agents
- • Version control prompt changes
- • A/B test different prompts
- • Rollback to stable versions
- • Single source of truth for prompts
- • Track who changed what
- • AI optimization suggestions
- • Production-ready workflows
Step-by-Step: Using Prompt Hub
Go to /prompts and click "New Prompt Template". Add your prompt content with variables like {{variable_name}}.
Reference the prompt by ID in your agent code. This ensures consistency and allows you to update prompts without redeploying code.
Every edit creates a new version. View history, compare versions, and tag stable versions as "Production".
Go to Settings → Organization and enable "Prompt Tuning". The AI will analyze your traces for failure patterns.
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:
Ready to get started?
Start with zero code changes using the Proxy Gateway, or use our SDKs for deeper integration.