ragaai-catalyst 2.0.7__py3-none-any.whl → 2.0.7.2b1__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/utils/api_utils.py

@@ -0,0 +1,18 @@
+import requests
+
+def fetch_analysis_trace(base_url, trace_id):
+    """
+    Fetches the analysis trace data from the server.
+
+    :param base_url: The base URL of the server (e.g., "http://localhost:3000").
+    :param trace_id: The ID of the trace to fetch.
+    :return: The JSON response from the server if successful, otherwise None.
+    """
+    try:
+        url = f"{base_url}/api/analysis_traces/{trace_id}"
+        response = requests.get(url)
+        response.raise_for_status()  # Raise an error for bad responses (4xx, 5xx)
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching analysis trace: {e}")
+        return None

ragaai_catalyst/tracers/agentic_tracing/utils/data_classes.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass, field
+from typing import Dict, List, Any, Optional
+
+
+@dataclass
+class ProjectInfo:
+    project_name: str
+    start_time: float
+    end_time: float = field(default=0)
+    duration: float = field(default=0)
+    total_cost: float = field(default=0)
+    total_tokens: int = field(default=0)
+
+
+@dataclass
+class SystemInfo:
+    project_id: int
+    os_name: str
+    os_version: str
+    python_version: str
+    cpu_info: str
+    memory_total: float
+    installed_packages: str
+
+
+@dataclass
+class LLMCall:
+    name: str
+    model_name: str
+    input_prompt: str
+    output_response: str
+    tool_call: Dict
+    token_usage: Dict[str, int]
+    cost: Dict[str, float]
+    start_time: float = field(default=0)
+    end_time: float = field(default=0)
+    duration: float = field(default=0)
+
+
+@dataclass
+class ToolCall:
+    name: str
+    input_parameters: Dict[str, Any]
+    output: Any
+    start_time: float
+    end_time: float
+    duration: float
+    errors: Optional[str] = None
+
+
+@dataclass
+class AgentCall:
+    name: str
+    input_parameters: Dict[str, Any]
+    output: Any
+    start_time: float
+    end_time: float
+    duration: float
+    tool_calls: List[Dict[str, Any]]
+    llm_calls: List[Dict[str, Any]]
+    errors: Optional[str] = None

ragaai_catalyst/tracers/agentic_tracing/utils/generic.py

@@ -0,0 +1,32 @@
+import os
+import logging
+
+
+def get_db_path():
+    db_filename = "trace_data.db"
+
+    # First, try the package directory
+    package_dir = os.path.dirname(os.path.abspath(__file__))
+    public_dir = os.path.join(package_dir, "..", "ui", "dist")
+    package_db_path = os.path.join(public_dir, db_filename)
+
+    # Ensure the directory exists
+    os.makedirs(os.path.dirname(package_db_path), exist_ok=True)
+
+    if os.path.exists(os.path.dirname(package_db_path)):
+        logging.debug(f"Using package database: {package_db_path}")
+        return f"sqlite:///{package_db_path}"
+
+    # Then, try the local directory
+    local_db_path = os.path.join(os.getcwd(), "agentneo", "ui", "dist", db_filename)
+    if os.path.exists(os.path.dirname(local_db_path)):
+        logging.debug(f"Using local database: {local_db_path}")
+        return f"sqlite:///{local_db_path}"
+
+    # Finally, try the local "/dist" directory
+    local_dist_path = os.path.join(os.getcwd(), "dist", db_filename)
+    if os.path.exists(os.path.dirname(local_dist_path)):
+        logging.debug(f"Using local database: {local_dist_path}")
+        return f"sqlite:///{local_dist_path}"
+
+    return f"sqlite:///{package_db_path}"

ragaai_catalyst/tracers/agentic_tracing/utils/llm_utils.py

@@ -0,0 +1,181 @@
+from .data_classes import LLMCall
+from .trace_utils import (
+    calculate_cost,
+    convert_usage_to_dict,
+    load_model_costs,
+)
+from importlib import resources
+import json
+import os
+
+
+# Load the Json configuration
+try:
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    model_costs_path = os.path.join(current_dir, "model_costs.json")
+    with open(model_costs_path, "r") as file:
+        config = json.load(file)
+except FileNotFoundError:
+    from importlib.resources import files
+    with (files("") / "model_costs.json").open("r") as file:
+        config = json.load(file)
+
+
+
+def extract_llm_output(result):
+
+    # import pdb
+
+    # pdb.set_trace()
+    # Initialize variables
+    model_name = None
+    output_response = ""
+    function_call = None
+    tool_call = None
+    token_usage = {}
+    cost = {}
+
+    # Try to get model_name from result or result.content
+    model_name = None
+    if hasattr(result, "model"):
+        model_name = result.model
+    elif hasattr(result, "content"):
+        try:
+            content_dict = json.loads(result.content)
+            model_name = content_dict.get("model", None)
+        except (json.JSONDecodeError, TypeError):
+            model_name = None
+
+    # Try to get choices from result or result.content
+    choices = None
+    if hasattr(result, "choices"):
+        choices = result.choices
+    elif hasattr(result, "content"):
+        try:
+            content_dict = json.loads(result.content)
+            choices = content_dict.get("choices", None)
+        except (json.JSONDecodeError, TypeError):
+            choices = None
+
+    if choices and len(choices) > 0:
+        first_choice = choices[0]
+
+        # Get message or text
+        message = None
+        if hasattr(first_choice, "message"):
+            message = first_choice.message
+        elif isinstance(first_choice, dict) and "message" in first_choice:
+            message = first_choice["message"]
+
+        if message:
+            # For chat completion
+            # Get output_response
+            if hasattr(message, "content"):
+                output_response = message.content
+            elif isinstance(message, dict) and "content" in message:
+                output_response = message["content"]
+
+            # Get function_call
+            if hasattr(message, "function_call"):
+                function_call = message.function_call
+            elif isinstance(message, dict) and "function_call" in message:
+                function_call = message["function_call"]
+
+            # Get tool_calls (if any)
+            if hasattr(message, "tool_calls"):
+                tool_call = message.tool_calls
+            elif isinstance(message, dict) and "tool_calls" in message:
+                tool_call = message["tool_calls"]
+        else:
+            # For completion
+            # Get output_response
+            if hasattr(first_choice, "text"):
+                output_response = first_choice.text
+            elif isinstance(first_choice, dict) and "text" in first_choice:
+                output_response = first_choice["text"]
+            else:
+                output_response = ""
+
+            # No message, so no function_call or tool_call
+            function_call = None
+            tool_call = None
+    else:
+        output_response = ""
+        function_call = None
+        tool_call = None
+
+    # Set tool_call to function_call if tool_call is None
+    if not tool_call:
+        tool_call = function_call
+
+    # Parse tool_call
+    parsed_tool_call = None
+    if tool_call:
+        if isinstance(tool_call, dict):
+            arguments = tool_call.get("arguments", "{}")
+            name = tool_call.get("name", "")
+        else:
+            # Maybe it's an object with attributes
+            arguments = getattr(tool_call, "arguments", "{}")
+            name = getattr(tool_call, "name", "")
+        try:
+            if isinstance(arguments, str):
+                arguments = json.loads(arguments)
+            else:
+                arguments = arguments  # If already a dict
+        except json.JSONDecodeError:
+            arguments = {}
+        parsed_tool_call = {"arguments": arguments, "name": name}
+
+    # Try to get token_usage from result.usage or result.content
+    usage = None
+    if hasattr(result, "usage"):
+        usage = result.usage
+    elif hasattr(result, "content"):
+        try:
+            content_dict = json.loads(result.content)
+            usage = content_dict.get("usage", {})
+        except (json.JSONDecodeError, TypeError):
+            usage = {}
+    else:
+        usage = {}
+
+    token_usage = convert_usage_to_dict(usage)
+
+    # Load model costs
+    model_costs = load_model_costs()
+
+    # Calculate cost
+    if model_name in model_costs:
+        model_config = model_costs[model_name]
+        input_cost_per_token = model_config.get("input_cost_per_token", 0.0)
+        output_cost_per_token = model_config.get("output_cost_per_token", 0.0)
+        reasoning_cost_per_token = model_config.get(
+            "reasoning_cost_per_token", output_cost_per_token
+        )
+    else:
+        # Default costs or log a warning
+        print(
+            f"Warning: Model '{model_name}' not found in config. Using default costs."
+        )
+        input_cost_per_token = 0.0
+        output_cost_per_token = 0.0
+        reasoning_cost_per_token = 0.0
+
+    cost = calculate_cost(
+        token_usage,
+        input_cost_per_token=input_cost_per_token,
+        output_cost_per_token=output_cost_per_token,
+        reasoning_cost_per_token=reasoning_cost_per_token,
+    )
+
+    llm_data = LLMCall(
+        name="",
+        model_name=model_name,
+        input_prompt="",  # Not available here
+        output_response=output_response,
+        token_usage=token_usage,
+        cost=cost,
+        tool_call=parsed_tool_call,
+    )
+    return llm_data