kalibr 1.2.6__py3-none-any.whl → 1.2.9__py3-none-any.whl

kalibr/pricing.py

@@ -0,0 +1,245 @@
+"""Centralized pricing data for all LLM vendors.
+
+This module serves as the single source of truth for model pricing across
+the entire Kalibr SDK. All cost adapters and instrumentation modules should
+use this pricing data to ensure consistency.
+
+All prices are in USD per 1 million tokens, matching the format used by
+major LLM providers (OpenAI, Anthropic, etc.) on their pricing pages.
+
+Version: 2026-01
+Last Updated: January 2026
+"""
+
+from typing import Dict, Optional, Tuple
+
+# Pricing version for tracking updates
+PRICING_VERSION = "2026-01"
+
+# All prices in USD per 1M tokens
+MODEL_PRICING: Dict[str, Dict[str, Dict[str, float]]] = {
+    "openai": {
+        # GPT-5 models (future-proofing)
+        "gpt-5": {"input": 5.00, "output": 15.00},
+        "gpt-5-turbo": {"input": 2.50, "output": 7.50},
+        # GPT-4 models
+        "gpt-4": {"input": 30.00, "output": 60.00},
+        "gpt-4-turbo": {"input": 10.00, "output": 30.00},
+        "gpt-4o": {"input": 2.50, "output": 10.00},
+        "gpt-4o-mini": {"input": 0.15, "output": 0.60},
+        # GPT-3.5 models
+        "gpt-3.5-turbo": {"input": 0.50, "output": 1.50},
+        "gpt-3.5-turbo-16k": {"input": 1.00, "output": 2.00},
+    },
+    "anthropic": {
+        # Claude 4 models (future-proofing)
+        "claude-4-opus": {"input": 15.00, "output": 75.00},
+        "claude-4-sonnet": {"input": 3.00, "output": 15.00},
+        # Claude 3.5/3.7 models (Sonnet 4 is actually Claude 3.7)
+        "claude-sonnet-4": {"input": 3.00, "output": 15.00},
+        "claude-3-7-sonnet": {"input": 3.00, "output": 15.00},
+        "claude-3-5-sonnet": {"input": 3.00, "output": 15.00},
+        # Claude 3 models
+        "claude-3-opus": {"input": 15.00, "output": 75.00},
+        "claude-3-sonnet": {"input": 3.00, "output": 15.00},
+        "claude-3-haiku": {"input": 0.25, "output": 1.25},
+        # Claude 2 models
+        "claude-2.1": {"input": 8.00, "output": 24.00},
+        "claude-2.0": {"input": 8.00, "output": 24.00},
+        "claude-instant-1.2": {"input": 0.80, "output": 2.40},
+    },
+    "google": {
+        # Gemini 2.5 models
+        "gemini-2.5-pro": {"input": 1.25, "output": 5.00},
+        "gemini-2.5-flash": {"input": 0.075, "output": 0.30},
+        # Gemini 2.0 models
+        "gemini-2.0-flash": {"input": 0.075, "output": 0.30},
+        "gemini-2.0-flash-thinking": {"input": 0.075, "output": 0.30},
+        # Gemini 1.5 models
+        "gemini-1.5-pro": {"input": 1.25, "output": 5.00},
+        "gemini-1.5-flash": {"input": 0.075, "output": 0.30},
+        "gemini-1.5-flash-8b": {"input": 0.0375, "output": 0.15},
+        # Gemini 1.0 models
+        "gemini-1.0-pro": {"input": 0.50, "output": 1.50},
+        "gemini-pro": {"input": 0.50, "output": 1.50},  # Alias
+    },
+}
+
+# Default fallback pricing per vendor (highest tier pricing for safety)
+DEFAULT_PRICING: Dict[str, Dict[str, float]] = {
+    "openai": {"input": 30.00, "output": 60.00},  # GPT-4 pricing
+    "anthropic": {"input": 15.00, "output": 75.00},  # Claude 3 Opus pricing
+    "google": {"input": 1.25, "output": 5.00},  # Gemini 1.5 Pro pricing
+}
+
+
+def normalize_model_name(vendor: str, model_name: str) -> str:
+    """Normalize model name to match pricing table keys.
+
+    Handles version suffixes, date stamps, and common variations.
+
+    Args:
+        vendor: Vendor name (openai, anthropic, google)
+        model_name: Raw model name from API
+
+    Returns:
+        Normalized model name that matches pricing table, or original if no match
+
+    Example:
+        >>> normalize_model_name("openai", "gpt-4o-2024-05-13")
+        'gpt-4o'
+        >>> normalize_model_name("anthropic", "claude-3-5-sonnet-20240620")
+        'claude-3-5-sonnet'
+    """
+    vendor = vendor.lower()
+    model_lower = model_name.lower()
+
+    # Get vendor pricing table
+    vendor_models = MODEL_PRICING.get(vendor, {})
+
+    # Direct match
+    if model_lower in vendor_models:
+        return model_lower
+
+    # OpenAI fuzzy matching
+    if vendor == "openai":
+        # Remove date suffixes like -20240513
+        base_model = model_lower.split("-2")[0] if "-2" in model_lower else model_lower
+
+        # Try direct match on base
+        if base_model in vendor_models:
+            return base_model
+
+        # Fuzzy match in priority order
+        if "gpt-4o-mini" in model_lower:
+            return "gpt-4o-mini"
+        elif "gpt-4o" in model_lower:
+            return "gpt-4o"
+        elif "gpt-5-turbo" in model_lower:
+            return "gpt-5-turbo"
+        elif "gpt-5" in model_lower:
+            return "gpt-5"
+        elif "gpt-4-turbo" in model_lower:
+            return "gpt-4-turbo"
+        elif "gpt-4" in model_lower:
+            return "gpt-4"
+        elif "gpt-3.5-turbo-16k" in model_lower:
+            return "gpt-3.5-turbo-16k"
+        elif "gpt-3.5" in model_lower:
+            return "gpt-3.5-turbo"
+
+    # Anthropic fuzzy matching
+    elif vendor == "anthropic":
+        # Try fuzzy matching for versioned models
+        if "claude-3.5-sonnet" in model_lower or "claude-3-5-sonnet" in model_lower:
+            return "claude-3-5-sonnet"
+        elif "claude-sonnet-4" in model_lower or "sonnet-4" in model_lower:
+            return "claude-sonnet-4"
+        elif "claude-3-7-sonnet" in model_lower:
+            return "claude-3-7-sonnet"
+        elif "claude-4-opus" in model_lower:
+            return "claude-4-opus"
+        elif "claude-4-sonnet" in model_lower:
+            return "claude-4-sonnet"
+        elif "claude-3-opus" in model_lower:
+            return "claude-3-opus"
+        elif "claude-3-sonnet" in model_lower:
+            return "claude-3-sonnet"
+        elif "claude-3-haiku" in model_lower:
+            return "claude-3-haiku"
+        elif "claude-2.1" in model_lower:
+            return "claude-2.1"
+        elif "claude-2.0" in model_lower or "claude-2" in model_lower:
+            return "claude-2.0"
+        elif "claude-instant" in model_lower:
+            return "claude-instant-1.2"
+
+    # Google fuzzy matching
+    elif vendor == "google":
+        # Try fuzzy matching for versioned models
+        if "gemini-2.5-pro" in model_lower:
+            return "gemini-2.5-pro"
+        elif "gemini-2.5-flash" in model_lower:
+            return "gemini-2.5-flash"
+        elif "gemini-2.0-flash-thinking" in model_lower:
+            return "gemini-2.0-flash-thinking"
+        elif "gemini-2.0-flash" in model_lower:
+            return "gemini-2.0-flash"
+        elif "gemini-1.5-flash-8b" in model_lower:
+            return "gemini-1.5-flash-8b"
+        elif "gemini-1.5-flash" in model_lower:
+            return "gemini-1.5-flash"
+        elif "gemini-1.5-pro" in model_lower:
+            return "gemini-1.5-pro"
+        elif "gemini-1.0-pro" in model_lower or "gemini-pro" in model_lower:
+            return "gemini-pro"
+
+    # Return original if no match found
+    return model_lower
+
+
+def get_pricing(
+    vendor: str, model_name: str
+) -> Tuple[Dict[str, float], str]:
+    """Get pricing for a specific vendor and model.
+
+    Args:
+        vendor: Vendor name (openai, anthropic, google)
+        model_name: Model identifier
+
+    Returns:
+        Tuple of (pricing dict with 'input' and 'output' keys in USD per 1M tokens,
+                  normalized model name used)
+
+    Example:
+        >>> pricing, normalized = get_pricing("openai", "gpt-4o")
+        >>> print(pricing)
+        {'input': 2.50, 'output': 10.00}
+        >>> print(normalized)
+        'gpt-4o'
+    """
+    vendor = vendor.lower()
+    normalized_model = normalize_model_name(vendor, model_name)
+
+    # Get vendor pricing table
+    vendor_models = MODEL_PRICING.get(vendor, {})
+
+    # Try to get pricing for normalized model
+    pricing = vendor_models.get(normalized_model)
+
+    # Fall back to default vendor pricing if not found
+    if pricing is None:
+        pricing = DEFAULT_PRICING.get(vendor, {"input": 20.00, "output": 60.00})
+
+    return pricing, normalized_model
+
+
+def compute_cost(
+    vendor: str, model_name: str, input_tokens: int, output_tokens: int
+) -> float:
+    """Compute cost in USD for given vendor, model, and token counts.
+
+    This is a convenience function that combines pricing lookup and cost calculation.
+
+    Args:
+        vendor: Vendor name (openai, anthropic, google)
+        model_name: Model identifier
+        input_tokens: Number of input tokens
+        output_tokens: Number of output tokens
+
+    Returns:
+        Cost in USD (rounded to 6 decimal places)
+
+    Example:
+        >>> cost = compute_cost("openai", "gpt-4o", 1000, 500)
+        >>> print(f"${cost:.6f}")
+        $0.007500
+    """
+    pricing, _ = get_pricing(vendor, model_name)
+
+    # Calculate cost (pricing is per 1M tokens)
+    input_cost = (input_tokens / 1_000_000) * pricing["input"]
+    output_cost = (output_tokens / 1_000_000) * pricing["output"]
+
+    return round(input_cost + output_cost, 6)
+

kalibr/router.py

@@ -4,14 +4,47 @@ Kalibr Router - Intelligent model routing with outcome learning.
 
 import os
 import logging
+import uuid
 from typing import Any, Callable, Dict, List, Optional, Union
 
+from opentelemetry import trace as otel_trace
+from opentelemetry.trace import SpanContext, TraceFlags, NonRecordingSpan, set_span_in_context
+from opentelemetry.context import Context
+
 logger = logging.getLogger(__name__)
 
 # Type for paths - either string or dict
 PathSpec = Union[str, Dict[str, Any]]
 
 
+def _create_context_with_trace_id(trace_id_hex: str) -> Optional[Context]:
+    """Create an OTel context with a specific trace_id.
+
+    This allows child spans to inherit the intelligence service's trace_id,
+    enabling JOINs between outcomes and traces tables.
+    """
+    try:
+        # Convert 32-char hex string to 128-bit int
+        trace_id_int = int(trace_id_hex, 16)
+        if trace_id_int == 0:
+            return None
+
+        # Create span context with our trace_id
+        span_context = SpanContext(
+            trace_id=trace_id_int,
+            span_id=0xDEADBEEF,  # Placeholder, real span will have its own
+            is_remote=True,  # Treat as remote parent so new span_id is generated
+            trace_flags=TraceFlags(TraceFlags.SAMPLED),
+        )
+
+        # Create a non-recording parent span and set in context
+        parent_span = NonRecordingSpan(span_context)
+        return set_span_in_context(parent_span)
+    except (ValueError, TypeError) as e:
+        logger.warning(f"Could not create OTel context with trace_id: {e}")
+        return None
+
+
 class Router:
     """
     Routes LLM requests to the best model based on learned outcomes.
@@ -23,6 +56,30 @@ class Router:
             success_when=lambda out: len(out) > 100
         )
         response = router.completion(messages=[...])
+
+    Examples:
+        # Simple auto-reporting
+        router = Router(
+            goal="extract_email",
+            paths=["gpt-4o", "claude-sonnet-4"],
+            success_when=lambda out: "@" in out
+        )
+        response = router.completion(messages=[...])
+        # report() called automatically
+
+        # Manual reporting for complex validation
+        router = Router(
+            goal="book_meeting",
+            paths=["gpt-4o", "claude-sonnet-4"]
+        )
+        response = router.completion(messages=[...])
+        # ... complex validation logic ...
+        router.report(success=meeting_booked)
+
+    Warning:
+        Router is not thread-safe. For concurrent requests, create separate
+        Router instances per thread/task. For sequential requests in a single
+        thread, Router can be reused across multiple completion() calls.
     """
 
     def __init__(
@@ -41,7 +98,16 @@ class Router:
             paths: List of models or path configs. Examples:
                    ["gpt-4o", "claude-3-sonnet"]
                    [{"model": "gpt-4o", "tools": ["search"]}]
-            success_when: Optional function to auto-evaluate success from output
+                   [{"model": "gpt-4o", "params": {"temperature": 0.7}}]
+            success_when: Optional function to auto-evaluate success from LLM output.
+                         Takes the output string and returns True/False.
+                         When provided, report() is called automatically after completion().
+                         Use for simple validations (output length, contains key string).
+                         For complex validation (API calls, multi-step checks), omit this
+                         and call report() manually.
+                         Examples:
+                             success_when=lambda out: len(out) > 0  # Not empty
+                             success_when=lambda out: "@" in out     # Contains email
             exploration_rate: Override exploration rate (0.0-1.0)
             auto_register: If True, register paths on init
         """
@@ -49,6 +115,7 @@ class Router:
         self.success_when = success_when
         self.exploration_rate = exploration_rate
         self._last_trace_id: Optional[str] = None
+        self._last_model_id: Optional[str] = None
         self._last_decision: Optional[dict] = None
         self._outcome_reported = False
 
@@ -106,19 +173,22 @@ class Router:
             **kwargs: Additional args passed to provider
 
         Returns:
-            OpenAI-compatible ChatCompletion response
+            OpenAI-compatible ChatCompletion response with added attribute:
+                - kalibr_trace_id: Trace ID for explicit outcome reporting
         """
         from kalibr.intelligence import decide
-        from kalibr.context import get_trace_id
 
         # Reset state for new request
         self._outcome_reported = False
 
-        # Get routing decision (or use forced model)
+        # Step 1: Get routing decision FIRST (before creating span)
+        decision = None
+        model_id = None
+        tool_id = None
+        params = {}
+
         if force_model:
             model_id = force_model
-            tool_id = None
-            params = {}
             self._last_decision = {"model_id": model_id, "forced": True}
         else:
             try:
@@ -128,44 +198,84 @@ class Router:
                 params = decision.get("params") or {}
                 self._last_decision = decision
             except Exception as e:
-                # Fallback to first path if routing fails
                 logger.warning(f"Routing failed, using fallback: {e}")
                 model_id = self._paths[0]["model"]
                 tool_id = self._paths[0].get("tools")
                 params = self._paths[0].get("params") or {}
                 self._last_decision = {"model_id": model_id, "fallback": True, "error": str(e)}
 
-        # Dispatch to provider
-        try:
-            response = self._dispatch(model_id, messages, tool_id, **{**params, **kwargs})
-            self._last_trace_id = get_trace_id()
+        # Step 2: Determine trace_id
+        decision_trace_id = self._last_decision.get("trace_id") if self._last_decision else None
 
-            # Auto-report if success_when provided
-            if self.success_when and not self._outcome_reported:
-                try:
-                    output = response.choices[0].message.content or ""
-                    success = self.success_when(output)
-                    self.report(success=success)
-                except Exception as e:
-                    logger.warning(f"Auto-outcome evaluation failed: {e}")
+        if decision_trace_id:
+            trace_id = decision_trace_id
+        else:
+            trace_id = uuid.uuid4().hex  # Fallback: generate OTel-compatible format
+
+        self._last_trace_id = trace_id
+        self._last_model_id = model_id
+
+        # Step 3: Create OTel context with intelligence trace_id
+        otel_context = _create_context_with_trace_id(trace_id) if decision_trace_id else None
+
+        # Step 4: Create span with custom context (child spans inherit trace_id)
+        tracer = otel_trace.get_tracer("kalibr.router")
+
+        with tracer.start_as_current_span(
+            "kalibr.router.completion",
+            context=otel_context,
+            attributes={
+                "kalibr.goal": self.goal,
+                "kalibr.trace_id": trace_id,
+                "kalibr.model_id": model_id,
+            }
+        ) as router_span:
+            # Add decision attributes
+            if force_model:
+                router_span.set_attribute("kalibr.forced", True)
+            elif decision:
+                router_span.set_attribute("kalibr.path_id", decision.get("path_id", ""))
+                router_span.set_attribute("kalibr.reason", decision.get("reason", ""))
+                router_span.set_attribute("kalibr.exploration", decision.get("exploration", False))
+                router_span.set_attribute("kalibr.confidence", decision.get("confidence", 0.0))
+            else:
+                router_span.set_attribute("kalibr.fallback", True)
 
-            return response
+            # Step 5: Dispatch to provider
+            try:
+                response = self._dispatch(model_id, messages, tool_id, **{**params, **kwargs})
 
-        except Exception as e:
-            # Auto-report failure
-            self._last_trace_id = get_trace_id()
-            if not self._outcome_reported:
-                try:
-                    self.report(success=False, reason=f"provider_error: {type(e).__name__}")
-                except:
-                    pass
-            raise
+                # Auto-report if success_when provided
+                if self.success_when and not self._outcome_reported:
+                    try:
+                        output = response.choices[0].message.content or ""
+                        success = self.success_when(output)
+                        self.report(success=success)
+                    except Exception as e:
+                        logger.warning(f"Auto-outcome evaluation failed: {e}")
+
+                # Add trace_id to response for explicit linkage
+                response.kalibr_trace_id = trace_id
+                return response
+
+            except Exception as e:
+                router_span.set_attribute("error", True)
+                router_span.set_attribute("error.type", type(e).__name__)
+
+                # Auto-report failure
+                if not self._outcome_reported:
+                    try:
+                        self.report(success=False, reason=f"provider_error: {type(e).__name__}")
+                    except:
+                        pass
+                raise
 
     def report(
         self,
         success: bool,
         reason: Optional[str] = None,
         score: Optional[float] = None,
+        trace_id: Optional[str] = None,
     ):
         """
         Report outcome for the last completion.
@@ -174,18 +284,17 @@ class Router:
             success: Whether the task succeeded
             reason: Optional failure reason
             score: Optional quality score (0.0-1.0)
+            trace_id: Optional explicit trace ID (uses last completion's trace_id if not provided)
         """
         if self._outcome_reported:
-            logger.warning("Outcome already reported for this request")
+            logger.warning("Outcome already reported for this completion. Each completion() requires a separate report() call.")
             return
 
         from kalibr.intelligence import report_outcome
-        from kalibr.context import get_trace_id
 
-        trace_id = self._last_trace_id or get_trace_id()
+        trace_id = trace_id or self._last_trace_id
         if not trace_id:
-            logger.warning("No trace_id available for outcome reporting")
-            return
+            raise ValueError("Must call completion() before report(). No trace_id available.")
 
         try:
             report_outcome(
@@ -194,6 +303,7 @@ class Router:
                 success=success,
                 score=score,
                 failure_reason=reason,
+                model_id=self._last_model_id,
             )
             self._outcome_reported = True
         except Exception as e:

kalibr/simple_tracer.py

@@ -19,6 +19,8 @@ Capsule Usage (automatic when middleware is active):
     def process_request(request: Request, prompt: str):
         # Capsule automatically updated with this hop
         return llm_call(prompt)
+
+Note: Uses centralized pricing from kalibr.pricing module.
 """
 
 import json
@@ -31,6 +33,8 @@ from datetime import datetime, timezone
 from functools import wraps
 from typing import Callable, Optional
 
+from kalibr.pricing import compute_cost
+
 try:
     import requests
 except ImportError:
@@ -53,7 +57,7 @@ def send_event(payload: dict):
         print("[Kalibr SDK] ❌ requests library not available")
         return
 
-    url = os.getenv("KALIBR_COLLECTOR_URL", "https://api.kalibr.systems/api/ingest")
+    url = os.getenv("KALIBR_COLLECTOR_URL", "https://kalibr-backend.fly.dev/api/ingest")
     api_key = os.getenv("KALIBR_API_KEY")
     if not api_key:
         print("[Kalibr SDK] ⚠️  KALIBR_API_KEY not set, traces will not be sent")
@@ -155,21 +159,18 @@ def trace(
             actual_input_tokens = input_tokens or kwargs.get("input_tokens", 1000)
             actual_output_tokens = output_tokens or kwargs.get("output_tokens", 500)
 
-            # Cost calculation (simplified pricing)
-            # OpenAI GPT-4o: ~$2.50/1M input, ~$10/1M output
-            # Anthropic Claude-3-Sonnet: ~$3/1M input, ~$15/1M output
-            pricing_map = {
-                "openai": {"gpt-4o": 0.00000250, "gpt-4": 0.00003000},
-                "anthropic": {"claude-3-sonnet": 0.00000300, "claude-3-opus": 0.00001500},
-                "google": {"gemini-pro": 0.00000125},
-            }
-
-            # Get unit price
-            provider_pricing = pricing_map.get(provider, {})
-            unit_price_usd = provider_pricing.get(model, 0.00002000)  # Default $0.02/1M
+            # Cost calculation using centralized pricing
+            # This ensures consistency with all other cost adapters
+            total_cost_usd = compute_cost(
+                vendor=provider,
+                model_name=model,
+                input_tokens=actual_input_tokens,
+                output_tokens=actual_output_tokens,
+            )
 
-            # Calculate total cost
-            total_cost_usd = (actual_input_tokens + actual_output_tokens) * unit_price_usd
+            # Calculate unit price for backward compatibility (total cost / total tokens)
+            total_tokens = actual_input_tokens + actual_output_tokens
+            unit_price_usd = total_cost_usd / total_tokens if total_tokens > 0 else 0.0
 
             # Build payload
             payload = {

kalibr/trace_capsule.py

@@ -28,6 +28,7 @@ Usage:
 """
 
 import json
+import threading
 import uuid
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
@@ -85,12 +86,16 @@ class TraceCapsule:
         # Phase 3C: Context token propagation (keep as UUID for consistency)
         self.context_token = context_token or str(uuid.uuid4())
         self.parent_context_token = parent_context_token
+        # Thread-safety: Lock for protecting concurrent append_hop operations
+        self._lock = threading.Lock()
 
     def append_hop(self, hop: Dict[str, Any]) -> None:
         """Append a new hop to the capsule.
 
         Maintains a rolling window of last N hops to keep payload compact.
         Updates aggregate metrics automatically.
+        
+        Thread-safe: Uses internal lock to protect concurrent modifications.
 
         Args:
             hop: Dictionary containing hop metadata
@@ -111,22 +116,24 @@ class TraceCapsule:
                 "agent_name": "code-writer"
             })
         """
-        # Add hop_index
-        hop["hop_index"] = len(self.last_n_hops)
+        # Thread-safe update of capsule state
+        with self._lock:
+            # Add hop_index
+            hop["hop_index"] = len(self.last_n_hops)
 
-        # Append to history
-        self.last_n_hops.append(hop)
+            # Append to history
+            self.last_n_hops.append(hop)
 
-        # Maintain rolling window (keep last N hops)
-        if len(self.last_n_hops) > self.MAX_HOPS:
-            self.last_n_hops.pop(0)
+            # Maintain rolling window (keep last N hops)
+            if len(self.last_n_hops) > self.MAX_HOPS:
+                self.last_n_hops.pop(0)
 
-        # Update aggregates
-        self.aggregate_cost_usd += hop.get("cost_usd", 0.0)
-        self.aggregate_latency_ms += hop.get("duration_ms", 0.0)
+            # Update aggregates
+            self.aggregate_cost_usd += hop.get("cost_usd", 0.0)
+            self.aggregate_latency_ms += hop.get("duration_ms", 0.0)
 
-        # Update timestamp
-        self.timestamp = datetime.now(timezone.utc).isoformat()
+            # Update timestamp
+            self.timestamp = datetime.now(timezone.utc).isoformat()
 
     def get_last_hop(self) -> Optional[Dict[str, Any]]:
         """Get the most recent hop.

kalibr/utils.py

@@ -38,8 +38,8 @@ def load_config_from_env() -> Dict[str, str]:
         "workflow_id": os.getenv("KALIBR_WORKFLOW_ID", "default-workflow"),
         "sandbox_id": os.getenv("SANDBOX_ID", "local"),
         "runtime_env": os.getenv("RUNTIME_ENV", "local"),
-        "api_endpoint": os.getenv("KALIBR_API_ENDPOINT", "https://api.kalibr.systems/api/v1/traces"),
-        "collector_url": os.getenv("KALIBR_COLLECTOR_URL", "https://api.kalibr.systems/api/ingest"),
+        "api_endpoint": os.getenv("KALIBR_API_ENDPOINT", "https://kalibr-backend.fly.dev/api/v1/traces"),
+        "collector_url": os.getenv("KALIBR_COLLECTOR_URL", "https://kalibr-backend.fly.dev/api/ingest"),
     }
     return config