ragaai-catalyst 1.0.8.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

ragaai_catalyst/prompt_manager.py

@@ -3,7 +3,7 @@ import requests
 import json
 import re
 from .ragaai_catalyst import RagaAICatalyst
-import pdb
+import copy
 
 class PromptManager:
     NUM_PROJECTS = 100
@@ -21,36 +21,28 @@ class PromptManager:
             ValueError: If the project is not found.
         """
         self.project_name = project_name
-        self.headers = {
-                "Content-Type": "application/json",
-                "Authorization": f'Bearer {os.getenv("RAGAAI_CATALYST_TOKEN")}',
-                "X-Project-Name": self.project_name
-            }
         self.base_url = f"{RagaAICatalyst.BASE_URL}/playground/prompt"
         self.timeout = 10
+        self.size = 100 #Number of projects to fetch
 
         try:
             response = requests.get(
-                f"{RagaAICatalyst.BASE_URL}/projects",
-                params={
-                    "size": str(self.NUM_PROJECTS),
-                    "page": "0",
-                    "type": "llm",
-                },
+                f"{RagaAICatalyst.BASE_URL}/v2/llm/projects?size={self.size}",
                 headers={
-                    "Content-Type": "application/json",
                     "Authorization": f'Bearer {os.getenv("RAGAAI_CATALYST_TOKEN")}',
                 },
-                timeout=self.TIMEOUT,
+                timeout=self.timeout,
             )
             response.raise_for_status()
-        except requests.RequestException as e:
-            raise requests.RequestException(f"Error fetching projects: {str(e)}")
+            # logger.debug("Projects list retrieved successfully")
 
-        try:
             project_list = [
                 project["name"] for project in response.json()["data"]["content"]
             ]
+            self.project_id = [
+            project["id"] for project in response.json()["data"]["content"] if project["name"]==project_name
+            ][0]
+
         except (KeyError, json.JSONDecodeError) as e:
             raise ValueError(f"Error parsing project list: {str(e)}")
 
@@ -58,6 +50,12 @@ class PromptManager:
             raise ValueError("Project not found. Please enter a valid project name")
 
 
+        self.headers = {
+                "Authorization": f'Bearer {os.getenv("RAGAAI_CATALYST_TOKEN")}',
+                "X-Project-Id": str(self.project_id)
+            }
+
+
     def list_prompts(self):
         """
         List all available prompts.
@@ -164,6 +162,7 @@ class Prompt:
 
         Raises:
             requests.RequestException: If there's an error with the API request.
+            ValueError: If there's an error parsing the prompt list.
         """
         try:
             response = requests.get(url, headers=headers, timeout=timeout)
@@ -175,7 +174,7 @@ class Prompt:
         except (KeyError, json.JSONDecodeError) as e:
             raise ValueError(f"Error parsing prompt list: {str(e)}")
 
-    def get_response_by_version(self, base_url, headers, timeout, prompt_name, version):
+    def _get_response_by_version(self, base_url, headers, timeout, prompt_name, version):
         """
         Get a specific version of a prompt.
 
@@ -184,7 +183,15 @@ class Prompt:
             headers (dict): The headers to be used in the request.
             timeout (int): The timeout for the request.
             prompt_name (str): The name of the prompt.
-            version (str): The version of the prompt."""
+            version (str): The version of the prompt.
+
+        Returns:
+            response: The response object containing the prompt version data.
+
+        Raises:
+            requests.RequestException: If there's an error with the API request.
+            ValueError: If there's an error parsing the prompt version.
+        """
         try:
             response = requests.get(f"{base_url}/version/{prompt_name}?version={version}",
                                     headers=headers, timeout=timeout)
@@ -195,7 +202,23 @@ class Prompt:
             raise ValueError(f"Error parsing prompt version: {str(e)}")
         return response
 
-    def get_response(self, base_url, headers, timeout, prompt_name, version):
+    def _get_response(self, base_url, headers, timeout, prompt_name):
+        """
+        Get the latest version of a prompt.
+
+        Args:
+            base_url (str): The base URL for the API.
+            headers (dict): The headers to be used in the request.
+            timeout (int): The timeout for the request.
+            prompt_name (str): The name of the prompt.
+
+        Returns:
+            response: The response object containing the latest prompt version data.
+
+        Raises:
+            requests.RequestException: If there's an error with the API request.
+            ValueError: If there's an error parsing the prompt version.
+        """
         try:
             response = requests.get(f"{base_url}/version/{prompt_name}",
                                 headers=headers, timeout=timeout)
@@ -206,7 +229,7 @@ class Prompt:
             raise ValueError(f"Error parsing prompt version: {str(e)}")
         return response
 
-    def get_prompt_by_version(self, base_url, headers, timeout, prompt_name, version):
+    def _get_prompt_by_version(self, base_url, headers, timeout, prompt_name, version):
         """
         Get a specific version of a prompt.
 
@@ -223,7 +246,7 @@ class Prompt:
         Raises:
             requests.RequestException: If there's an error with the API request.
         """
-        response = self.get_response_by_version(base_url, headers, timeout, prompt_name, version)
+        response = self._get_response_by_version(base_url, headers, timeout, prompt_name, version)
         prompt_text = response.json()["data"]["docs"][0]["textFields"]
         return prompt_text
 
@@ -245,12 +268,12 @@ class Prompt:
             requests.RequestException: If there's an error with the API request.
         """
         if version:
-            response = self.get_response_by_version(base_url, headers, timeout, prompt_name, version)
+            response = self._get_response_by_version(base_url, headers, timeout, prompt_name, version)
             prompt_text = response.json()["data"]["docs"][0]["textFields"]
             prompt_parameters = response.json()["data"]["docs"][0]["modelSpecs"]["parameters"]
             model = response.json()["data"]["docs"][0]["modelSpecs"]["model"]
         else:
-            response = self.get_response(base_url, headers, timeout, prompt_name)
+            response = self._get_response(base_url, headers, timeout, prompt_name)
             prompt_text = response.json()["data"]["docs"][0]["textFields"]
             prompt_parameters = response.json()["data"]["docs"][0]["modelSpecs"]["parameters"]
             model = response.json()["data"]["docs"][0]["modelSpecs"]["model"]
@@ -272,6 +295,7 @@ class Prompt:
 
         Raises:
             requests.RequestException: If there's an error with the API request.
+            ValueError: If there's an error parsing the prompt versions.
         """
         try:
             response = requests.get(f"{base_url}/{prompt_name}/version",
@@ -280,7 +304,7 @@ class Prompt:
             version_names = [version["name"] for version in response.json()["data"]]
             prompt_versions = {}
             for version in version_names:
-                prompt_versions[version] = self.get_prompt_by_version(base_url, headers, timeout, prompt_name, version)
+                prompt_versions[version] = self._get_prompt_by_version(base_url, headers, timeout, prompt_name, version)
             return prompt_versions
         except requests.RequestException as e:
             raise requests.RequestException(f"Error listing prompt versions: {str(e)}")
@@ -299,20 +323,43 @@ class PromptObject:
             model (str): The model of the prompt.
         """
         self.text = text
-        self.variables = self._extract_variables()
         self.parameters = parameters
         self.model = model
+    
+    def _extract_variable_from_content(self, content):
+        """
+        Extract variables from the content.
+
+        Args:
+            content (str): The content containing variables.
 
-    def _extract_variables(self):
+        Returns:
+            list: A list of variable names found in the content.
         """
-        Extract variables from the prompt text.
+        pattern = r'\{\{(.*?)\}\}'
+        matches = re.findall(pattern, content)
+        variables = [match.strip() for match in matches if '"' not in match]
+        return variables
+
+    def _add_variable_value_to_content(self, content, user_variables):
+        """
+        Add variable values to the content.
+
+        Args:
+            content (str): The content containing variables.
+            user_variables (dict): A dictionary of user-provided variable values.
 
         Returns:
-            list: A list of variable names found in the prompt text.
+            str: The content with variables replaced by their values.
         """
-        user_content = next(item["content"] for item in self.text if item["role"] == "user")
-        return [var.strip('{}') for var in user_content.split('{{')[1:]]
-    
+        variables = self._extract_variable_from_content(content)
+        for key, value in user_variables.items():
+            if not isinstance(value, str):
+                raise ValueError(f"Value for variable '{key}' must be a string, not {type(value).__name__}")
+            if key in variables:
+                content = content.replace(f"{{{{{key}}}}}", value)
+        return content
+
     def compile(self, **kwargs):
         """
         Compile the prompt by replacing variables with provided values.
@@ -326,27 +373,23 @@ class PromptObject:
         Raises:
             ValueError: If there are missing or extra variables, or if a value is not a string.
         """
-        required_variables = set(self.get_variables())
+        required_variables = self.get_variables()
         provided_variables = set(kwargs.keys())
 
-        missing_variables = required_variables - provided_variables
-        extra_variables = provided_variables - required_variables
+        missing_variables = [item for item in required_variables if item not in provided_variables]
+        extra_variables = [item for item in provided_variables if item not in required_variables]
 
         if missing_variables:
             raise ValueError(f"Missing variable(s): {', '.join(missing_variables)}")
         if extra_variables:
             raise ValueError(f"Extra variable(s) provided: {', '.join(extra_variables)}")
-        # pdb.set_trace()
 
-        # compiled_prompt = self.text
-        user_content = next(item["content"] for item in self.text if item["role"] == "user")
+        updated_text = copy.deepcopy(self.text)
 
-        for key, value in kwargs.items():
-            if not isinstance(value, str):
-                raise ValueError(f"Value for variable '{key}' must be a string, not {type(value).__name__}")
-            user_content = user_content.replace(f"{{{{{key}}}}}", value)
-        compiled_prompt = [{"content": user_content if item["role"] == "user" else item["content"], "role": item["role"]} for item in self.text]
-        return compiled_prompt
+        for item in updated_text:
+            item["content"] = self._add_variable_value_to_content(item["content"], kwargs)
+
+        return updated_text
     
     def get_variables(self):
         """
@@ -355,28 +398,43 @@ class PromptObject:
         Returns:
             list: A list of variable names found in the prompt text.
         """
-        pattern = r'\{\{(.*?)\}\}'
-        user_content = next(item["content"] for item in self.text if item["role"] == "user")
-        matches = re.findall(pattern, user_content)
-        return [match.strip() for match in matches if '"' not in match]
+        variables = set()
+        for item in self.text:
+            content = item["content"]
+            for var in self._extract_variable_from_content(content):
+                variables.add(var)
+        if variables:
+            return list(variables)
+        else:
+            return []
     
-    # Function to convert value based on type
-    def convert_value(self, value, type_):
+    def _convert_value(self, value, type_):
+        """
+        Convert value based on type.
+
+        Args:
+            value: The value to be converted.
+            type_ (str): The type to convert the value to.
+
+        Returns:
+            The converted value.
+        """
         if type_ == "float":
             return float(value)
         elif type_ == "int":
             return int(value)
         return value  # Default case, return as is
 
-    def get_parameters(self):
+    def get_model_parameters(self):
         """
         Get all parameters in the prompt text.
 
         Returns:
             dict: A dictionary of parameters found in the prompt text.
         """
-        parameters = {param["name"]: self.convert_value(param["value"], param["type"]) for param in self.parameters}
+        parameters = {param["name"]: self._convert_value(param["value"], param["type"]) for param in self.parameters}
         parameters["model"] = self.model
-        return parameters
+        return parameters    
     
-    
+    def get_prompt_content(self):
+        return self.text

ragaai_catalyst/ragaai_catalyst.py

@@ -57,14 +57,15 @@ class RagaAICatalyst:
         if base_url:
             RagaAICatalyst.BASE_URL = base_url
             try:
+                self.get_token()
                 os.environ["RAGAAI_CATALYST_BASE_URL"] = base_url
             except requests.exceptions.RequestException:
                 raise ConnectionError(
                     "The provided base_url is not accessible. Please re-check the base_url."
                 )
-
-        # Get the token from the server
-        self.get_token()
+        else:
+            # Get the token from the server
+            self.get_token()
 
         # Set the API keys, if  available
         if self.api_keys:
@@ -187,7 +188,24 @@ class RagaAICatalyst:
             logger.error("Token(s) not set")
             return None
 
-    def create_project(self, project_name, type="llm", description=""):
+    def project_use_cases(self):
+        try:
+            headers = {
+            "Authorization": f'Bearer {os.getenv("RAGAAI_CATALYST_TOKEN")}',
+            }
+            response = requests.get(
+                f"{RagaAICatalyst.BASE_URL}/v2/llm/usecase",
+                headers=headers,
+                timeout=self.TIMEOUT
+            )
+            response.raise_for_status()  # Use raise_for_status to handle HTTP errors
+            usecase = response.json()["data"]["usecase"]
+            return usecase
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Failed to retrieve project use cases: {e}")
+            return []
+
+    def create_project(self, project_name, usecase="Q/A", type="llm"):
         """
         Creates a project with the given project_name, type, and description.
 
@@ -199,23 +217,32 @@ class RagaAICatalyst:
         Returns:
             str: A message indicating the success or failure of the project creation.
         """
-        json_data = {"name": project_name, "type": type, "description": description}
+        # Check if the project already exists
+        existing_projects = self.list_projects()
+        if project_name in existing_projects:
+            raise ValueError(f"Project name '{project_name}' already exists. Please choose a different name.")
+
+        usecase_list = self.project_use_cases()
+        if usecase not in usecase_list:
+            raise ValueError(f"Select a valid usecase from {usecase_list}")
+        
+        json_data = {"name": project_name, "type": type, "usecase": usecase}
         headers = {
             "Content-Type": "application/json",
             "Authorization": f'Bearer {os.getenv("RAGAAI_CATALYST_TOKEN")}',
         }
         try:
             response = requests.post(
-                f"{RagaAICatalyst.BASE_URL}/projects",
+                f"{RagaAICatalyst.BASE_URL}/v2/llm/project",
                 headers=headers,
                 json=json_data,
                 timeout=self.TIMEOUT,
             )
             response.raise_for_status()
             print(
-                f"Project Created Successfully with name {response.json()['data']['name']}"
+                f"Project Created Successfully with name {response.json()['data']['name']} & usecase {usecase}"
             )
-            return f'Project Created Successfully with name {response.json()["data"]["name"]}'
+            return f'Project Created Successfully with name {response.json()["data"]["name"]} & usecase {usecase}'
 
         except requests.exceptions.HTTPError as http_err:
             if response.status_code == 401:
@@ -226,7 +253,7 @@ class RagaAICatalyst:
                 )
                 try:
                     response = requests.post(
-                        f"{RagaAICatalyst.BASE_URL}/projects",
+                        f"{RagaAICatalyst.BASE_URL}/v2/llm/project",
                         headers=headers,
                         json=json_data,
                         timeout=self.TIMEOUT,
@@ -257,6 +284,9 @@ class RagaAICatalyst:
             )
             return "An unexpected error occurred while creating the project"
 
+    def get_project_id(self, project_name):
+        pass
+
     def list_projects(self, num_projects=100):
         """
         Retrieves a list of projects with the specified number of projects.
@@ -267,25 +297,18 @@ class RagaAICatalyst:
         Returns:
             list: A list of project names retrieved successfully.
         """
-        params = {
-            "size": str(num_projects),
-            "page": "0",
-            "type": "llm",
-        }
         headers = {
-            "Content-Type": "application/json",
             "Authorization": f'Bearer {os.getenv("RAGAAI_CATALYST_TOKEN")}',
         }
         try:
             response = requests.get(
-                f"{RagaAICatalyst.BASE_URL}/projects",
-                params=params,
+                f"{RagaAICatalyst.BASE_URL}/v2/llm/projects?size={num_projects}",
                 headers=headers,
                 timeout=self.TIMEOUT,
             )
             response.raise_for_status()
             logger.debug("Projects list retrieved successfully")
-            # return [project["name"] for project in response.json()["data"]["content"]]
+
             project_list = [
                 project["name"] for project in response.json()["data"]["content"]
             ]
@@ -300,8 +323,7 @@ class RagaAICatalyst:
                 )
                 try:
                     response = requests.get(
-                        f"{RagaAICatalyst.BASE_URL}/projects",
-                        params=params,
+                        f"{RagaAICatalyst.BASE_URL}/v2/llm/projects",
                         headers=headers,
                         timeout=self.TIMEOUT,
                     )
@@ -400,3 +422,6 @@ class RagaAICatalyst:
             else:
                 logger.error("Failed to list metrics: %s", str(http_err))
                 return f"Failed to list metrics: {response.json().get('message', 'Unknown error')}"
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Failed to list metrics: {e}")
+            return []

ragaai_catalyst/tracers/exporters/file_span_exporter.py

@@ -86,13 +86,15 @@ class FileSpanExporter(SpanExporter):
             logger.debug(f"Writing jsonl file: {self.filename}")
             f.write(json.dumps(export_data) + "\n")
 
+
         if os.path.exists(json_file_path):
             with open(json_file_path, "r") as f:
                 data = json.load(f)
                 data.append(export_data)
             with open(json_file_path, "w") as f:
                 logger.debug(f"Appending to json file: {json_file_path}")
-                json.dump(data, f)
+                json.dump(data, f)    
+    
         else:
             with open(json_file_path, "w") as f:
                 logger.debug(f"Writing json  file: {json_file_path}")
@@ -102,7 +104,6 @@ class FileSpanExporter(SpanExporter):
                     # self._upload_task = self._run_async(self._upload_traces(json_file_path= self.sync_file))
                     self._run_async(self._upload_traces(json_file_path=self.sync_file))
                 self.sync_file = json_file_path
-
         # asyncio.run(self.server_upload(json_file_path))
 
     def _run_async(self, coroutine):

ragaai_catalyst/tracers/exporters/raga_exporter.py

@@ -7,6 +7,7 @@ from tqdm import tqdm
 import requests
 from ...ragaai_catalyst import RagaAICatalyst
 import shutil
+import pdb
 
 logger = logging.getLogger(__name__)
 
@@ -27,9 +28,22 @@ class RagaExporter:
         "log_source": "metadata",
         "vector_store": "pipeline",
     }
+    SCHEMA_MAPPING_NEW = {
+        "trace_id": {"columnType": "traceId"},
+        "trace_uri": {"columnType": "traceUri"},
+        "prompt": {"columnType": "prompt"},
+        "response":{"columnType": "response"},
+        "context": {"columnType": "context"},
+        "llm_model": {"columnType":"pipeline"},
+        "recorded_on": {"columnType": "metadata"},
+        "embed_model": {"columnType":"pipeline"},
+        "log_source": {"columnType": "metadata"},
+        "vector_store":{"columnType":"pipeline"},
+        "feedback": {"columnType":"feedBack"}
+    }
     TIMEOUT = 10
 
-    def __init__(self, project_name):
+    def __init__(self, project_name, dataset_name):
         """
         Initializes a new instance of the RagaExporter class.
 
@@ -41,6 +55,7 @@ class RagaExporter:
             Exception: If the schema check fails or the schema creation fails.
         """
         self.project_name = project_name
+        self.dataset_name = dataset_name
         RagaExporter.BASE_URL = (
             os.getenv("RAGAAI_CATALYST_BASE_URL")
             if os.getenv("RAGAAI_CATALYST_BASE_URL")
@@ -55,15 +70,14 @@ class RagaExporter:
             )
         if not os.getenv("RAGAAI_CATALYST_TOKEN"):
             get_token()
-        status_code = self._check_schema()
-        if status_code == 404:
-            create_status_code = self._create_schema()
-            if create_status_code != 200:
-                raise Exception(
-                    "Failed to create schema. Please consider raising an issue."
-                )
-        elif status_code != 200:
-            raise Exception("Failed to check schema. Please consider raising an issue.")
+
+        create_status_code = self._create_schema()
+        if create_status_code != 200:
+            raise Exception(
+                "Failed to create schema. Please consider raising an issue."
+            )
+        # elif status_code != 200:
+        #     raise Exception("Failed to check schema. Please consider raising an issue.")
 
     def _check_schema(self):
         """
@@ -95,6 +109,7 @@ class RagaExporter:
     
 
         def compare_schemas(base_schema, project_schema):
+
             differences = []
             for key, base_value in base_schema.items():
                 if key not in project_schema:
@@ -117,12 +132,13 @@ class RagaExporter:
         if response.status_code != 200:
             return response.status_code
         if response.status_code == 200:
-            project_schema = response.json()["data"]
-            base_schema = RagaExporter.SCHEMA_MAPPING
-            is_same, _ = compare_schemas(base_schema, project_schema)
-            if not is_same:
-                raise Exception(f"Trace cannot be logged to this Project because of schema difference. Create a new project to log trace")
-            return response.status_code
+            pass
+            # project_schema = response.json()["data"]
+            # base_schema = RagaExporter.SCHEMA_MAPPING
+            # is_same, _ = compare_schemas(base_schema, project_schema)
+            # if not is_same:
+            #     raise Exception(f"Trace cannot be logged to this Project because of schema difference. Create a new project to log trace")
+            # return response.status_code
         return response.status_code
 
     def _create_schema(self):
@@ -152,19 +168,21 @@ class RagaExporter:
                 "X-Project-Name": self.project_name,
             }
             json_data = {
-                "projectName": self.project_name,
-                "schemaMapping": RagaExporter.SCHEMA_MAPPING,
+                "datasetName": self.dataset_name,
+                "schemaMapping": RagaExporter.SCHEMA_MAPPING_NEW,
                 "traceFolderUrl": None,
             }
             response = requests.post(
-                f"{RagaExporter.BASE_URL}/v1/llm/master-dataset",
+                f"{RagaExporter.BASE_URL}/v1/llm/dataset/logs",
                 headers=headers,
                 json=json_data,
                 timeout=RagaExporter.TIMEOUT,
             )
+
             return response
 
         response = make_request()
+
         if response.status_code == 401:
             get_token()  # Fetch a new token and set it in the environment
             response = make_request()  # Retry the request
@@ -178,6 +196,7 @@ class RagaExporter:
         return status_code
 
     async def get_presigned_url(self, session, num_files):
+        # pdb.set_trace()
         """
         Asynchronously retrieves a presigned URL from the RagaExporter API.
 
@@ -194,8 +213,10 @@ class RagaExporter:
         """
 
         async def make_request():
+            # pdb.set_trace()
+
             json_data = {
-                "projectName": self.project_name,
+                "datasetName": self.dataset_name,
                 "numFiles": num_files,
             }
             headers = {
@@ -210,10 +231,9 @@ class RagaExporter:
                 timeout=RagaExporter.TIMEOUT,
             ) as response:
 
-                # print(json_response)
                 json_data = await response.json()
-                return response, json_data
 
+                return response, json_data
         response, json_data = await make_request()
         await self.response_checker_async(response, "RagaExporter.get_presigned_url")
         if response.status == 401:
@@ -250,8 +270,8 @@ class RagaExporter:
             }
 
             json_data = {
-                "projectName": self.project_name,
-                "traceUri": trace_uri,
+                "datasetName": self.dataset_name,
+                "presignedUrl": trace_uri,
             }
 
             async with session.post(
@@ -276,6 +296,8 @@ class RagaExporter:
         return response.status
 
     async def upload_file(self, session, url, file_path):
+        # pdb.set_trace()
+        # print('url', url)
         """
         Asynchronously uploads a file using the given session, url, and file path.
         Supports both regular and Azure blob storage URLs.
@@ -295,9 +317,8 @@ class RagaExporter:
                 "Content-Type": "application/json",
             }
 
-            if "blob.core.windows.net" in url:  # Azure
-                headers["x-ms-blob-type"] = "BlockBlob"
-
+            # if "blob.core.windows.net" in url:  # Azure
+            #     headers["x-ms-blob-type"] = "BlockBlob"
             print(f"Uploading traces...")
             logger.debug(f"Uploading file:{file_path} with url {url}")
 
@@ -324,6 +345,8 @@ class RagaExporter:
         return response.status
 
     async def check_and_upload_files(self, session, file_paths):
+        # print(file_paths)
+        # pdb.set_trace()
         """
         Checks if there are files to upload, gets presigned URLs, uploads files, and streams them if successful.