ragaai-catalyst 2.1.5b29__py3-none-any.whl → 2.1.5b31__py3-none-any.whl

ragaai_catalyst/synthetic_data_generation.py

@@ -1,25 +1,28 @@
 import os
-from groq import Groq
-import google.generativeai as genai
-import openai
-import PyPDF2
+import ast
 import csv
+import json
+import random
+import PyPDF2
 import markdown
 import pandas as pd
-import json
-from litellm import completion
-import litellm
 from tqdm import tqdm
+
+import openai
 import tiktoken
-# import internal_api_completion
-# import proxy_call
+import litellm
+import google.generativeai as genai
+from groq import Groq
+from litellm import completion
+
 from .internal_api_completion import api_completion as internal_api_completion
 from .proxy_call import api_completion as proxy_api_completion
-# from ragaai_catalyst import internal_api_completion
-# from ragaai_catalyst import proxy_call
-import ast
 
-# dotenv.load_dotenv()
+from typing import Optional, List, Dict, Any
+
+import logging
+
+logger = logging.getLogger(__name__)
 
 class SyntheticDataGeneration:
     """
@@ -329,6 +332,59 @@ class SyntheticDataGeneration:
 
         json_data = json.loads(content)
         return pd.DataFrame(json_data)
+    
+    def _generate_raw_llm_response(self, text, system_message: Optional[str] = None, model_config: Dict[str, Any] = dict(), api_key=None):
+        """
+        Generate questions using LiteLLM which supports multiple providers (OpenAI, Groq, Gemini, etc.).
+
+        Args:
+            text (str): The input text to generate questions from.
+            system_message (str): The system message for the AI model.
+            model_config (dict): Configuration dictionary containing model details.
+                Required keys:
+                - model: The model identifier (e.g., "gpt-4", "gemini-pro", "mixtral-8x7b-32768")
+                Optional keys:
+                - api_base: Custom API base URL if needed
+                - max_tokens: Maximum tokens in response
+                - temperature: Temperature for response generation
+            api_key (str, optional): The API key for the model provider.
+
+        Returns:
+            pandas.DataFrame: A DataFrame containing the generated questions and answers.
+
+        Raises:
+            Exception: If there's an error in generating the response.
+        """
+        messages = [
+            {"role": "system", "content": system_message},
+            {"role": "user", "content": text}
+        ]
+
+        completion_params = {
+            "model": model_config.get("model", 'gpt-4o'),
+            "messages": messages,
+            "api_key": api_key
+        }
+
+        if "api_base" in model_config:
+            completion_params["api_base"] = model_config["api_base"]
+        if "api_version" in model_config:
+            completion_params["api_version"] = model_config["api_version"]
+        if "max_tokens" in model_config:
+            completion_params["max_tokens"] = model_config["max_tokens"]
+        if "temperature" in model_config:
+            completion_params["temperature"] = model_config["temperature"]
+        if 'provider' in model_config:
+            completion_params['model'] = f'{model_config["provider"]}/{model_config["model"]}'
+
+        try:
+            response = completion(**completion_params)
+        except Exception as e:
+            if any(error in str(e).lower() for error in ["invalid api key", "incorrect api key", "unauthorized", "authentication"]):
+                raise ValueError(f"Invalid API key provided for {model_config.get('provider', 'the specified')} provider")
+            raise Exception(f"Error calling LLM API: {str(e)}")
+
+        return response.choices[0].message.content
 
     def _parse_response(self, response, provider):
         """
@@ -478,6 +534,291 @@ class SyntheticDataGeneration:
             list: A list of supported AI providers.
         """
         return ['gemini', 'openai','azure']
+    
+    def _get_init_ex_gen_prompt(self):
+        prompt = '''
+You are an expert example generator. Your task is to produce creative, relevant and varied examples according to the user instructions. 
+
+**Inputs**
+User Instruction: The user will provide guidance on how to generate examples, possibly accompanied by their own examples.
+User Examples[Optional]: The user may supply examples.
+User Context[Optional]: The user may supply context to generate the examples from.
+No of Examples: The total number of examples to produce.
+
+**Steps to follow**
+1. Carefully analyze the user's instruction
+2. If user examples are provided, check whether the user’s instructions refer to them specifically.
+3. If user context is provided, understand it thoroughly and identify relevant parts to generate examples.
+4. Comply with the system’s guidelines to generate examples, incorporating any user examples or user context as needed.
+
+**Output Format**:  
+- Present examples in a multiline string with each line a separate example.  
+- Avoid markdown or special formatting.
+- Omit any boilerplate texts.
+
+**Instructions for Diversity**:  
+- Vary the examples by context, tone, and (if applicable) technical complexity.
+- Include edge cases or unconventional scenarios.  
+- Ensure no two examples are conceptually identical.
+
+**Final Notes**:  
+- Focus on both originality and practical relevance.
+- Avoid repetitiveness in the examples.
+'''
+        return prompt
+    
+    def _get_iter_ex_gen_prompt(self):
+        prompt = '''
+You are an expert example generator. Your task is to produce creative, relevant and varied examples according to the user instructions. 
+
+**Inputs**
+User Instruction: The user will provide guidance on how to generate examples, possibly accompanied by their own examples.
+User Examples[Optional]: The user may supply examples.
+User Context[Optional]: The user may supply context to generate the examples from.
+No of Examples: The total number of examples to produce.
+Relevant Examples: Any examples that are relevant to the user's instruction.
+Irrelevant Examples: Any examples that are not relevant to the user's instruction.
+
+**Steps to follow**
+1. Carefully analyze the user's instruction
+2. If user examples are provided, check whether the user’s instructions refer to them specifically.
+3. If user context is provided, understand it thoroughly and identify relevant parts to generate examples.
+4. Review the relevant and irrelevant examples present, understanding the differences in them.
+5. Comply with the user's instruction to generate examples, similar to relevant examples and dissimilar to irrelevant ones.
+
+**Output Format**:  
+- Present examples in a multiline sting with each line a separate example.  
+- Avoid markdown or special formatting.
+- Omit any boilerplate texts.
+
+**Instructions for Diversity**:  
+- Vary the examples by context, tone, and (if applicable) technical complexity.
+- Include edge cases or unconventional scenarios.  
+- Ensure no two examples are conceptually identical.
+
+**Final Notes**:  
+- Focus on both originality and practical relevance.
+- Avoid repetitiveness in the examples.
+'''
+        return prompt
+    
+    def _generate_examples_iter(
+            self, 
+            user_instruction: str, 
+            user_examples: Optional[List[str] | str] = None, 
+            user_context: Optional[str] = None, 
+            relevant_examples: List[str]=[], 
+            irrelevant_examples: List[str]=[], 
+            no_examples: Optional[int] = None, 
+            model_config: Dict[str, Any] = dict(), 
+            api_key: Optional[str] = None
+            ):
+        if no_examples is None:
+            no_examples = 5
+        relevant_examples_str = '\n'.join(relevant_examples)
+        irrelevant_examples_str = '\n'.join(irrelevant_examples)
+        user_message = f'**User Instruction:** {user_instruction}'
+        user_message += f'\n\n**No of Examples:** {no_examples}'
+        if user_examples:
+            if isinstance(user_examples, str):
+                user_examples_str = user_examples
+            elif isinstance(user_examples, list):
+                user_examples_str = "\n".join(user_examples)
+            else:
+                raise ValueError(f'Expected string or list of strings as user_examples got {type(user_examples)}')
+            user_message += f"\n\n**User Examples:** \n{user_examples_str}"
+        if relevant_examples:
+            user_message += f'\n\n**Relevant Examples:** \n{relevant_examples_str}'
+        if irrelevant_examples:
+            user_message += f'\n\n**Irrelevant Examples:** \n{irrelevant_examples_str}'
+        if user_context:
+            user_message += f'\n\n**User Context:** \n{user_context}'
+        system_prompt = self._get_iter_ex_gen_prompt()
+        return self._generate_raw_llm_response(user_message, system_prompt, model_config=model_config, api_key=api_key)
+    
+    def _generate_examples(
+            self, 
+            user_instruction:str, 
+            user_examples:Optional[List[str]|str]=None, 
+            user_context: Optional[str] = None, 
+            no_examples:Optional[int]=None, 
+            model_config: Dict[str, Any] = dict(), 
+            api_key: Optional[str] = None
+            ):
+        if no_examples is None:
+            no_examples = 5
+        user_message = f"**User Instruction:** {user_instruction}"
+        if user_examples:
+            if isinstance(user_examples, str):
+                user_examples_str = user_examples
+            elif isinstance(user_examples, list):
+                user_examples_str = "\n".join(user_examples)
+            else:
+                raise ValueError(f'Expected string or list of strings as user_examples got {type(user_examples)}')
+            user_message += f"\n\n**User Examples:** \n{user_examples_str}"
+        if user_context:
+            user_message += f'\n\n**User Context:** \n{user_context}'
+        user_message += f'\n\n**No of Examples:** {no_examples}'
+        init_system_prompt = self._get_init_ex_gen_prompt()
+        return self._generate_raw_llm_response(user_message, init_system_prompt, model_config=model_config, api_key=api_key)
+    
+    def _get_valid_examples(self, user_indices_str: str, examples: List[str]):
+        valid_examples = []
+        try:
+            user_indices = user_indices_str.strip().split(',')
+            for index_str in user_indices:
+                try:
+                    index = int(index_str)
+                    if index <= 0 or index > len(examples):
+                        continue
+                except ValueError as e:
+                    continue
+                valid_examples.append(examples[index-1])
+        except Exception as e:
+            print(f'Error: {e}')
+        return valid_examples
+    
+    def generate_examples(
+        self, 
+        user_instruction: str, 
+        user_examples:Optional[List[str] | str] = None, 
+        user_context: Optional[str] = None, 
+        no_examples: Optional[int] = None, 
+        model_config: Optional[Dict[str, Any]] = None, 
+        api_key: Optional[str] = None, 
+        max_iter: int = 0,
+        **kwargs
+        ):
+        if not model_config:
+            model_config = {}
+        provider = model_config.get("provider")
+        api_base = model_config.get("api_base")
+        api_version = model_config.get("api_version")
+        self._initialize_client(provider, api_key, api_base, api_version, internal_llm_proxy=kwargs.get("internal_llm_proxy", None))
+
+        if no_examples is None:
+            no_examples = 5
+        assert no_examples >= 0, 'The number of examples cannot be less than 0'
+        relevant_examples = []
+        irrelevant_examples = []
+        max_relevant_examples = 5
+        max_irrelevant_examples = 10
+        while len(relevant_examples) <= max_relevant_examples or len(irrelevant_examples) <= max_irrelevant_examples:
+            if max_iter <= 0:
+                break
+            if len(relevant_examples) > max_relevant_examples:
+                relevant_examples = random.sample(relevant_examples, max_relevant_examples)
+            if len(irrelevant_examples) > max_irrelevant_examples:
+                irrelevant_examples = random.sample(irrelevant_examples, max_irrelevant_examples)
+            if relevant_examples or irrelevant_examples:
+                examples_str = self._generate_examples_iter(
+                    user_instruction = user_instruction, 
+                    user_examples = user_examples, 
+                    relevant_examples = relevant_examples, 
+                    irrelevant_examples = irrelevant_examples, 
+                    model_config = model_config, 
+                    api_key = api_key
+                    )
+            else:
+                examples_str = self._generate_examples(
+                    user_instruction = user_instruction, 
+                    user_examples = user_examples, 
+                    user_context = user_context, 
+                    model_config = model_config, 
+                    api_key = api_key
+                )
+            examples = [example for example in examples_str.split('\n') if example.strip()]
+            print('Generated Examples:')
+            for i, example in enumerate(examples):
+                print(f'{i+1}. {example}')
+            relevant_indices = input('Enter the indices of relevant examples (comma-separated): ').strip()
+            if relevant_indices:
+                relevant_examples.extend(self._get_valid_examples(relevant_indices, examples))
+            irrelevant_indices = input('Enter the indices of irrelevant examples (comma-separated): ').strip()
+            if irrelevant_indices:
+                irrelevant_examples.extend(self._get_valid_examples(irrelevant_indices, examples))
+            max_iter -= 1
+        if len(relevant_examples) > max_relevant_examples:
+            fin_relevant_examples = random.sample(relevant_examples, max_relevant_examples)
+        else:
+            fin_relevant_examples = relevant_examples
+        if len(irrelevant_examples) > max_irrelevant_examples:
+            fin_irrelevant_examples = random.sample(irrelevant_examples, max_irrelevant_examples)
+        else:
+            fin_irrelevant_examples = irrelevant_examples
+        if relevant_examples or irrelevant_examples:
+            if len(relevant_examples) < no_examples:
+                more_no_examples = no_examples - len(relevant_examples)
+                final_examples_str = self._generate_examples_iter(
+                    user_instruction = user_instruction, 
+                    user_examples = user_examples, 
+                    user_context = user_context, 
+                    relevant_examples = fin_relevant_examples, 
+                    irrelevant_examples = fin_irrelevant_examples, 
+                    no_examples = more_no_examples, 
+                    model_config = model_config, 
+                    api_key = api_key
+                    )
+                final_examples = [example for example in final_examples_str.split('\n') if example.strip()]
+                final_examples.extend(relevant_examples)
+            else:
+                final_examples = random.sample(relevant_examples, no_examples)
+        else:
+            final_examples_str = self._generate_examples(
+                user_instruction = user_instruction, 
+                user_examples = user_examples, 
+                user_context = user_context, 
+                no_examples = no_examples, 
+                model_config = model_config, 
+                api_key = api_key
+            )
+            final_examples = [example for example in final_examples_str.split('\n') if example.strip()]
+        return final_examples
+
+    
+    def generate_examples_from_csv(
+            self, 
+            csv_path: str, 
+            dst_csv_path: Optional[str] = None, 
+            no_examples: Optional[int] = None, 
+            model_config: Optional[Dict[str, Any]] = None, 
+            api_key: Optional[str] = None, 
+            **kwargs
+            ):
+        if no_examples is None:
+            no_examples = 5
+        assert no_examples >= 0, 'The number of examples cannot be less than  0'
+        df = pd.read_csv(csv_path)
+        assert 'user_instruction' in df.columns, 'The csv must have a column named user_instruction'
+        fin_df_list = []
+        for i, row in df.iterrows():
+            user_instruction = row['user_instruction']
+            user_examples = row.get('user_examples')
+            user_context = row.get('user_context')
+            row_dict = row.to_dict()
+            try:
+                examples = self.generate_examples(
+                    user_instruction = user_instruction, 
+                    user_examples = user_examples, 
+                    user_context = user_context, 
+                    no_examples = no_examples, 
+                    model_config = model_config, 
+                    api_key = api_key
+                )
+            except Exception as e:
+                continue
+            row_dict['generated_examples'] = examples
+            fin_df_list.append(row_dict)
+        fin_df = pd.DataFrame(fin_df_list)
+        csv_file, csv_ext = os.path.splitext(csv_path)
+        if not dst_csv_path:
+            dst_csv_path = csv_file + '_with_examples' + csv_ext
+        dst_dir = os.path.dirname(dst_csv_path)
+        if dst_dir:
+            os.makedirs(dst_dir, exist_ok=True)
+        fin_df.to_csv(dst_csv_path)
+        logger.info(f'CSV with generated examples saved at {dst_csv_path}')
+
 
 # Usage:
 # from synthetic_data_generation import SyntheticDataGeneration

ragaai_catalyst/tracers/agentic_tracing/tracers/base.py

@@ -18,13 +18,9 @@ from ragaai_catalyst.tracers.agentic_tracing.data.data_structure import (
     Resources,
     Component,
 )
-from ragaai_catalyst.tracers.agentic_tracing.upload.upload_agentic_traces import UploadAgenticTraces
-from ragaai_catalyst.tracers.agentic_tracing.upload.upload_code import upload_code
-from ragaai_catalyst.tracers.agentic_tracing.upload.upload_trace_metric import upload_trace_metric
 from ragaai_catalyst.tracers.agentic_tracing.utils.file_name_tracker import TrackName
 from ragaai_catalyst.tracers.agentic_tracing.utils.zip_list_of_unique_files import zip_list_of_unique_files
 from ragaai_catalyst.tracers.agentic_tracing.utils.span_attributes import SpanAttributes
-from ragaai_catalyst.tracers.agentic_tracing.utils.create_dataset_schema import create_dataset_schema_with_trace
 from ragaai_catalyst.tracers.agentic_tracing.utils.system_monitor import SystemMonitor
 
 import logging
@@ -179,7 +175,10 @@ class BaseTracer:
         )
 
     def stop(self):
-        """Stop the trace and save to JSON file"""
+        """Stop the trace and save to JSON file.
+        Trace upload will happen in a separate process and continue even if the main program exits.
+        """
+        from ..upload.trace_upload_manager import TraceUploadManager, TraceUploadTask
         if hasattr(self, "trace"):
             self.trace.data[0]["end_time"] = datetime.now().astimezone().isoformat()
             self.trace.end_time = datetime.now().astimezone().isoformat()
@@ -263,45 +262,25 @@ class BaseTracer:
 
             logger.info(" Traces saved successfully.")
             logger.debug(f"Trace saved to {filepath}")
-            # Upload traces
-
-            json_file_path = str(filepath)
-            project_name = self.project_name
-            project_id = self.project_id
-            dataset_name = self.dataset_name
-            user_detail = self.user_details
-            base_url = RagaAICatalyst.BASE_URL
-
-            ## create dataset schema
-            response = create_dataset_schema_with_trace(
-                dataset_name=dataset_name, project_name=project_name
-            )
-
-            ##Upload trace metrics
-            response = upload_trace_metric(
-                json_file_path=json_file_path,
-                dataset_name=self.dataset_name,
+            # Submit trace upload task to the manager
+            upload_task = TraceUploadTask(
+                json_file_path=str(filepath),
                 project_name=self.project_name,
-            )
-
-            upload_traces = UploadAgenticTraces(
-                json_file_path=json_file_path,
-                project_name=project_name,
-                project_id=project_id,
-                dataset_name=dataset_name,
-                user_detail=user_detail,
-                base_url=base_url,
-            )
-            upload_traces.upload_agentic_traces()
-
-            # Upload Codehash
-            response = upload_code(
+                project_id=self.project_id,
+                dataset_name=self.dataset_name,
+                user_detail=self.user_details,
+                base_url=RagaAICatalyst.BASE_URL,
                 hash_id=hash_id,
                 zip_path=zip_path,
-                project_name=project_name,
-                dataset_name=dataset_name,
+                max_retries=2,  # Allow 2 retries
+                retry_delay=1.0  # 1 second between retries
             )
-            print(response)
+            
+            # Get upload manager singleton and submit task
+            upload_manager = TraceUploadManager()
+            upload_manager.submit_upload(upload_task)
+            
+            logger.info(f"Trace upload task submitted and will continue in background")
 
         # Cleanup
         self.components = []
@@ -899,8 +878,6 @@ class BaseTracer:
 
         return {"workflow": sorted_interactions}
 
-    # TODO: Add support for execute metrics. Maintain list of all metrics to be added for this span
-
     def execute_metrics(self,
                         name: str,
                         model: str,

ragaai_catalyst/tracers/agentic_tracing/tracers/llm_tracer.py

@@ -12,7 +12,6 @@ import contextvars
 import traceback
 import importlib
 import sys
-from litellm import model_cost
 import logging
 
 try:
@@ -48,12 +47,9 @@ class LLMTracerMixin:
         super().__init__(*args, **kwargs)
         self.file_tracker = TrackName()
         self.patches = []
-        try:
-            self.model_costs = model_cost
-        except Exception as e:
-            self.model_costs = {
-                "default": {"input_cost_per_token": 0.0, "output_cost_per_token": 0.0}
-            }
+        # Get model costs from manager
+        from ..utils.cost_manager import cost_manager
+        self.cost_manager = cost_manager  # Store reference to cost manager
         self.MAX_PARAMETERS_TO_DISPLAY = 10
         self.current_llm_call_name = contextvars.ContextVar(
             "llm_call_name", default=None
@@ -626,12 +622,8 @@ class LLMTracerMixin:
             # TODO TO check i/p and o/p is according or not
             input = input_data["args"] if hasattr(input_data, "args") else input_data
             output = output_data.output_response if output_data else None
-            #print("Prompt input:",input)
             prompt = self.convert_to_content(input)
-            #print("Prompt Output: ",prompt)
-            #print("Response input: ",output)
             response = self.convert_to_content(output)
-            #print("Response output: ",response)
 
             # TODO: Execute & Add the User requested metrics here
             formatted_metrics = BaseTracer.get_formatted_metric(self.span_attributes_dict, self.project_id, name)
@@ -778,7 +770,7 @@ class LLMTracerMixin:
                     token_usage = extract_token_usage(result)
             else:
                 token_usage = extract_token_usage(result)
-            cost = calculate_llm_cost(token_usage, model_name, self.model_costs)
+            cost = calculate_llm_cost(token_usage, model_name)
             parameters = extract_parameters(kwargs)
             input_data = extract_input_data(args, kwargs, result)
 
@@ -887,7 +879,7 @@ class LLMTracerMixin:
                     token_usage = extract_token_usage(result)
             else:
                 token_usage = extract_token_usage(result)
-            cost = calculate_llm_cost(token_usage, model_name, self.model_costs)
+            cost = calculate_llm_cost(token_usage, model_name)
             parameters = extract_parameters(kwargs)
             input_data = extract_input_data(args, kwargs, result)
 

ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py

@@ -2,6 +2,7 @@ import requests
 import json
 import os
 from datetime import datetime
+from urllib.parse import urlparse, urlunparse
 
 
 class UploadAgenticTraces:
@@ -20,12 +21,71 @@ class UploadAgenticTraces:
         self.base_url = base_url
         self.timeout = 30
 
-
+    @staticmethod
+    def _normalize_url_core(url):
+        """Normalize the core domain of a URL by removing common prefixes and handling ports.
+        
+        Args:
+            url (str): The URL to normalize
+            
+        Returns:
+            str: The normalized core domain
+        """
+        parsed = urlparse(url.rstrip('/'))
+        netloc = parsed.netloc.lower()
+        
+        # Split host and port
+        host = netloc.split(':')[0]
+        
+        # Remove common prefixes
+        if host.startswith('www.'):
+            host = host[4:]
+        
+        return host
+    
+    def _reconcile_urls(self, presigned_url, base_url):
+        """Reconcile two URLs by using the base URL's core if they differ.
+        
+        Args:
+            presigned_url (str): The presigned URL from the server
+            base_url (str): The base URL to compare against
+            
+        Returns:
+            str: The reconciled URL
+        """
+        # Get normalized core domains
+        presigned_core = self._normalize_url_core(presigned_url)
+        base_core = self._normalize_url_core(base_url)
+        
+        # If cores are same, return original presigned URL
+        if presigned_core == base_core:
+            return presigned_url
+            
+        # Parse URLs
+        parsed_base = urlparse(base_url.rstrip('/'))
+        parsed_presigned = urlparse(presigned_url)
+        
+        # Remove API version paths from base_url if present
+        base_path = parsed_base.path
+        for suffix in ['/api', '/v1']:
+            if base_path.endswith(suffix):
+                base_path = base_path[:-len(suffix)]
+        
+        # Construct new URL using components
+        return urlunparse((
+            parsed_base.scheme,
+            parsed_base.netloc,
+            parsed_presigned.path,  # Use presigned path
+            parsed_presigned.params,
+            parsed_presigned.query,
+            parsed_presigned.fragment
+        ))
+    
     def _get_presigned_url(self):
         payload = json.dumps({
-                "datasetName": self.dataset_name,
-                "numFiles": 1,
-            })
+            "datasetName": self.dataset_name,
+            "numFiles": 1,
+        })
         headers = {
             "Content-Type": "application/json",
             "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
@@ -33,14 +93,16 @@ class UploadAgenticTraces:
         }
 
         try:
-            response = requests.request("GET", 
-                                        f"{self.base_url}/v1/llm/presigned-url", 
-                                        headers=headers, 
-                                        data=payload,
-                                        timeout=self.timeout)
+            response = requests.request(
+                "GET", 
+                f"{self.base_url}/v1/llm/presigned-url", 
+                headers=headers, 
+                data=payload,
+                timeout=self.timeout
+            )
             if response.status_code == 200:
-                presignedUrls = response.json()["data"]["presignedUrls"][0]
-                return presignedUrls
+                presigned_url = response.json()["data"]["presignedUrls"][0]
+                return self._reconcile_urls(presigned_url, self.base_url)
         except requests.exceptions.RequestException as e:
             print(f"Error while getting presigned url: {e}")
             return None

ragaai_catalyst/tracers/agentic_tracing/upload/upload_code.py

@@ -4,6 +4,7 @@ import json
 import os
 import logging
 from ragaai_catalyst.ragaai_catalyst import RagaAICatalyst
+from .upload_agentic_traces import UploadAgenticTraces
 logger = logging.getLogger(__name__)
 
 def upload_code(hash_id, zip_path, project_name, dataset_name):
@@ -61,7 +62,8 @@ def _fetch_presigned_url(project_name, dataset_name):
                                     timeout=99999)
 
         if response.status_code == 200:
-            return response.json()["data"]["presignedUrls"][0]
+            presigned_url = response.json()["data"]["presignedUrls"][0]
+            return UploadAgenticTraces._reconcile_urls(presigned_url, RagaAICatalyst.BASE_URL)
         else:
             raise Exception(f"Failed to fetch code hashes: {response.json()['message']}")
     except requests.exceptions.RequestException as e:

ragaai_catalyst/tracers/agentic_tracing/utils/create_dataset_schema.py

@@ -6,6 +6,7 @@ from ragaai_catalyst.tracers.agentic_tracing.tracers.base import RagaAICatalyst
 
 def create_dataset_schema_with_trace(project_name, dataset_name):
     def make_request():
+        import pdb; pdb.set_trace()
         headers = {
             "Content-Type": "application/json",
             "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",