ragaai-catalyst 2.1.4.1b1__tar.gz → 2.1.5b0__tar.gz

{ragaai_catalyst-2.1.4.1b1 → ragaai_catalyst-2.1.5b0}/.gitignore

@@ -5,6 +5,7 @@ ragaai_catalyst.egg-info/
 .DS_Store 
 test_files/
 __pycache__/
+*/model_costs.json
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

{ragaai_catalyst-2.1.4.1b1/ragaai_catalyst.egg-info → ragaai_catalyst-2.1.5b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: ragaai_catalyst
-Version: 2.1.4.1b1
+Version: 2.1.5b0
 Summary: RAGA AI CATALYST
 Author-email: Kiran Scaria <kiran.scaria@raga.ai>, Kedar Gaikwad <kedar.gaikwad@raga.ai>, Dushyant Mahajan <dushyant.mahajan@raga.ai>, Siddhartha Kosti <siddhartha.kosti@raga.ai>, Ritika Goel <ritika.goel@raga.ai>, Vijay Chaurasia <vijay.chaurasia@raga.ai>
 Requires-Python: <3.13,>=3.9
@@ -34,7 +34,6 @@ Requires-Dist: psutil~=6.0.0
 Requires-Dist: py-cpuinfo~=9.0.0
 Requires-Dist: requests~=2.32.3
 Requires-Dist: GPUtil~=1.4.0
-Requires-Dist: astor>=0.8.1
 Requires-Dist: ipynbname
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"

ragaai_catalyst-2.1.5b0/examples/custom_tracer_example.py

@@ -0,0 +1,125 @@
+from ragaai_catalyst.tracers import Tracer
+from ragaai_catalyst import RagaAICatalyst
+import asyncio
+import os
+import requests
+from dotenv import load_dotenv
+load_dotenv()
+from litellm import completion
+import openai
+from openai import OpenAI
+import sys
+from pathlib import Path
+
+# Add the project root to sys.path
+project_root = Path(__file__).resolve().parent
+sys.path.append(str(project_root))
+
+from ragaai_catalyst.tracers.agentic_tracing.tracers.main_tracer import AgenticTracing
+import json
+from typing import Dict, List, Any
+import time
+
+
+catalyst = RagaAICatalyst(
+    access_key=os.getenv("RAGAAI_CATALYST_ACCESS_KEY"),
+    secret_key=os.getenv("RAGAAI_CATALYST_SECRET_KEY"),
+    base_url=os.getenv("RAGAAI_CATALYST_BASE_URL"),
+)
+# Initialize tracer
+tracer = Tracer(
+    project_name="cost_testing",
+    dataset_name="sync_sample_llm_testing_openai",
+    tracer_type="anything",
+    metadata={
+        "model": "gpt-3.5-turbo",
+        "environment": "production"
+    },
+    pipeline={
+        "llm_model": "gpt-3.5-turbo",
+        "vector_store": "faiss",
+        "embed_model": "text-embedding-ada-002",
+    }
+)
+load_dotenv()
+
+tracer.start()
+
+
+@tracer.trace_custom(name="process_data", custom_type="data_processor", trace_variables=False)
+def process_data(data):
+    """Example function showing custom function tracing with line traces"""
+    processed = []
+    total = 0
+    print('my name is khan1')
+    for i, item in enumerate(data):
+        value = item * 2
+        total += value
+        processed.append(value)
+        if i == len(data) - 1:
+            average = total / len(data)
+            print('average is', average)
+    
+    return processed
+
+@tracer.trace_custom(name="calculate_statistics", custom_type="data_processor", trace_variables=False)
+def calculate_statistics(numbers):
+    """Example function using the trace_custom decorator without line traces"""
+    stats = {}
+    
+    # Calculate mean
+    total = sum(numbers)
+    count = len(numbers)
+    mean = total / count
+    stats['mean'] = mean
+    
+    # Calculate range
+    min_val = min(numbers)
+    max_val = max(numbers)
+    diff = max_val - min_val
+    stats['range'] = diff
+
+    print('my name is khan2')
+    print('stats are', stats)
+    
+    return stats
+
+@tracer.trace_custom(name="network_call", custom_type="network_call", trace_variables=True)
+def weather_tool(destination='kerela'):
+    api_key = os.environ.get("OPENWEATHERMAP_API_KEY")
+    base_url = "http://api.openweathermap.org/data/2.5/weather"
+
+    params = {"q": destination, "appid": api_key, "units": "metric"}
+    print("Calculating weather for:", destination)
+    try:
+        response = requests.get(base_url, params=params)
+        response.raise_for_status()
+        data = response.json()
+
+        weather_description = data["weather"][0]["description"]
+        temperature = data["main"]["temp"]
+        
+        actual_result = f"{weather_description.capitalize()}, {temperature:.1f}°C"
+        
+        return actual_result
+    except requests.RequestException:
+        return "Weather data not available."
+
+
+def main():
+    try:
+        # Example data processing
+        data = [1, 2, 3, 4, 5]
+        processed_data = process_data(data)
+        print("Processed Data:", processed_data)
+        stats = calculate_statistics(processed_data)
+        print("Statistics:", stats)
+        weather_result = weather_tool()
+        print("Weather Result:", weather_result)
+        
+    except Exception as e:
+        print(f"Error in main: {str(e)}")
+
+if __name__ == "__main__":
+    main()
+    tracer.stop()

ragaai_catalyst-2.1.5b0/examples/finance.py

@@ -0,0 +1,161 @@
+import requests
+from bs4 import BeautifulSoup
+import yfinance as yf
+from datetime import datetime
+import pandas as pd
+from litellm import completion
+import os
+from typing import List, Dict
+import json
+from urllib.parse import urlparse
+from dotenv import load_dotenv
+from ragaai_catalyst.tracers import Tracer
+from ragaai_catalyst import RagaAICatalyst
+load_dotenv()
+
+catalyst = RagaAICatalyst(
+    access_key=os.getenv("RAGAAI_CATALYST_ACCESS_KEY"),
+    secret_key=os.getenv("RAGAAI_CATALYST_SECRET_KEY"),
+    base_url=os.getenv("RAGAAI_CATALYST_BASE_URL"),
+)
+
+# Initialize tracer
+tracer = Tracer(
+    project_name="alteryx_copilot-tan",
+    dataset_name="testing-3",
+    tracer_type="Agentic",
+)
+
+tracer.start()
+class FinancialReportGenerator:
+    @tracer.trace_tool("scrape_website")
+    def scrape_website(self, url: str) -> str:
+        """
+        Scrape content from a given URL
+        """
+        try:
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+            response = requests.get(url, headers=headers)
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Remove script and style elements
+            for script in soup(["script", "style"]):
+                script.decompose()
+                
+            text = soup.get_text(separator=' ', strip=True)
+            return text
+        except Exception as e:
+            print(f"Error scraping {url}: {str(e)}")
+            return ""
+    
+    @tracer.trace_llm(name="analyze_sentiment")
+    def analyze_sentiment(self, text: str) -> Dict:
+        """
+        Analyze sentiment of text using LiteLLM
+        """
+        try:
+            response = completion(
+                model="gpt-3.5-turbo",
+                messages=[{
+                    "role": "system",
+                    "content": "Analyze the following text and provide sentiment analysis focused on financial implications. Return a JSON with 'sentiment' (positive/negative/neutral), 'confidence' (0-1), and 'key_points'."
+                }, {
+                    "role": "user",
+                    "content": text
+                }],
+                max_tokens=500
+            )
+            
+            return json.loads(response.choices[0].message.content)
+        except Exception as e:
+            print(f"Error in sentiment analysis: {str(e)}")
+            return {"sentiment": "neutral", "confidence": 0, "key_points": []}
+        
+    @tracer.trace_llm(name="get_report")
+    def get_report(self, report_prompt: str) -> str:
+        response = completion(
+                model="gpt-3.5-turbo",
+                messages=[{
+                    "role": "system",
+                    "content": "You are a financial analyst. Generate a comprehensive financial report based on the provided data. Include market analysis, stock performance, and key insights."
+                }, {
+                    "role": "user",
+                    "content": report_prompt
+                }],
+                max_tokens=1500
+            )
+        print("Report generated successfully.")
+        return response.choices[0].message.content
+
+    @tracer.trace_agent(name="generate_report")
+    def generate_report(self, urls: List[str]) -> str:
+        """
+        Generate a comprehensive financial report from multiple sources
+        """
+        # Collect data from all sources
+        website_contents = []
+        sentiments = []
+        
+        print("Processing URLs...")
+        # Process URLs
+        for url in urls:
+            content = self.scrape_website(url)
+            if content:
+                website_contents.append({
+                    "url": url,
+                    "content": content,
+                    "domain": urlparse(url).netloc
+                })
+                print(f"Scraped content from {url}")
+                
+                # Analyze sentiment
+                print("Analyzing sentiment...")
+                sentiments.append(self.analyze_sentiment(content))
+        
+        print("Generating report...")
+        # Generate report using LiteLLM
+        report_prompt = self._create_report_prompt(website_contents, sentiments)
+
+        report = self.get_report(report_prompt)
+        return report
+
+    @tracer.trace_tool("create_report_prompt")
+    def _create_report_prompt(self, website_contents: List[Dict], sentiments: List[Dict]) -> str:
+        print("Creating report prompt...")
+        """
+        Create a structured prompt for report generation
+        """
+        prompt = "Generate a financial report based on the following data:\n\n"
+        
+        # Add website content summaries
+        prompt += "News and Analysis:\n"
+        for content in website_contents:
+            prompt += f"Source: {content['domain']}\n"
+            prompt += f"Key points from sentiment analysis:\n"
+            for sentiment in sentiments:
+                prompt += f"- Sentiment: {sentiment['sentiment']}\n"
+                prompt += f"- Key points: {', '.join(sentiment['key_points'])}\n"
+
+        prompt += "\nPlease provide a comprehensive analysis including:\n"
+        prompt += "1. Market Overview\n"
+        prompt += "2. Stock Analysis\n"
+        prompt += "3. News Impact Analysis\n"
+        prompt += "4. Key Insights and Recommendations\n"
+        
+        return prompt
+
+# Example usage
+if __name__ == "__main__":
+    generator = FinancialReportGenerator()
+    
+    # Example URLs and stock symbols
+    urls = [
+        "https://money.rediff.com/news/market/rupee-hits-record-low-of-85-83-against-us-dollar/20623520250108",
+        "https://indianexpress.com/article/business/banking-and-finance/rbi-asks-credit-bureaus-banks-to-pay-rs-100-compensation-per-day-for-delay-in-data-updation-9765814/"
+    ]
+    
+    report = generator.generate_report(urls)
+    print(report)
+    tracer.stop()

ragaai_catalyst-2.1.5b0/examples/travel_agent/agents.py

@@ -0,0 +1,50 @@
+from tools import (
+    llm_call,
+    weather_tool,
+    currency_converter_tool,
+    flight_price_estimator_tool,
+)
+from ragaai_catalyst import trace_agent, current_span
+
+class ItineraryAgent:
+    def __init__(self, persona="Itinerary Agent"):
+        self.persona = persona
+
+    @trace_agent(name="plan_itinerary", agent_type="travel_planner", version="1.0.0")
+    def plan_itinerary(self, user_preferences, duration=3):
+        # Add metrics for the planning process
+        current_span().add_metrics(
+            name="itinerary_planning",
+            score=0.8,
+            reasoning="Planning comprehensive travel itinerary",
+            cost=0.01,
+            latency=0.5,
+        )
+        
+        # Get weather information
+        weather = weather_tool(user_preferences["destination"])
+
+        # Get currency conversion if needed
+        if "budget_currency" in user_preferences and user_preferences["budget_currency"] != "USD":
+            budget = currency_converter_tool(
+                user_preferences["budget"], user_preferences["budget_currency"], "USD"
+            )
+        else:
+            budget = user_preferences["budget"]
+
+        # Get flight price estimation
+        flight_price = flight_price_estimator_tool(
+            user_preferences["origin"], user_preferences["destination"]
+        )
+
+        # Prepare prompt for the LLM
+        prompt = f"""As a {self.persona}, create a {duration}-day itinerary for a trip to {user_preferences['destination']}.
+        Weather: {weather}
+        Budget: ${budget}
+        Flight Price: {flight_price}
+        Preferences: {user_preferences.get('preferences', 'No specific preferences')}
+        
+        Please provide a detailed day-by-day itinerary."""
+
+        # Generate itinerary using LLM
+        return llm_call(prompt)

ragaai_catalyst-2.1.5b0/examples/travel_agent/config.py

@@ -0,0 +1,24 @@
+import sys 
+import os
+from dotenv import load_dotenv
+
+from ragaai_catalyst import RagaAICatalyst, init_tracing
+from ragaai_catalyst.tracers import Tracer
+import uuid
+
+
+def initialize_tracing():
+    catalyst = RagaAICatalyst(
+        access_key=os.getenv("RAGAAI_CATALYST_ACCESS_KEY"),
+        secret_key=os.getenv("RAGAAI_CATALYST_SECRET_KEY"),
+        # base_url=os.getenv("RAGAAI_CATALYST_BASE_URL"),
+    )
+
+    tracer = Tracer(
+        project_name="Trace_testing",
+        dataset_name="travel_agent_dataset",
+        tracer_type="Agentic",
+    )
+
+    init_tracing(catalyst=catalyst, tracer=tracer)
+    return tracer

ragaai_catalyst-2.1.5b0/examples/travel_agent/main.py

@@ -0,0 +1,115 @@
+from dotenv import load_dotenv
+from tools import (
+    llm_call,
+    weather_tool,
+    currency_converter_tool,
+    flight_price_estimator_tool,
+)
+from agents import ItineraryAgent
+from config import initialize_tracing
+from ragaai_catalyst import trace_agent, current_span
+
+# Load environment variables
+load_dotenv()
+
+# Initialize distributed tracing
+tracer = initialize_tracing()
+
+@trace_agent(name="travel_agent", agent_type="main", version="1.0.0")
+def travel_agent():
+    # Add metrics for the main session
+    current_span().add_metrics(
+        name="travel_planning_session",
+        score=0.9,
+        reasoning="Main travel planning session",
+        cost=0.05,
+        latency=1.0,
+    )
+    
+    print("Welcome to the Personalized Travel Planner!\n")
+
+    # Get user input
+    user_input = input("Please describe your ideal vacation: ")
+
+    # Extract preferences
+    preferences_prompt = f"""
+    Extract key travel preferences from the following user input:
+    "{user_input}"
+
+    Please provide the extracted information in this format:
+    Destination:
+    Activities:
+    Budget:
+    Duration (in days):
+    """
+    extracted_preferences = llm_call(preferences_prompt, name="extract_preferences")
+    print("\nExtracted Preferences:")
+    print(extracted_preferences)
+
+    # Parse extracted preferences
+    preferences = {}
+    for line in extracted_preferences.split("\n"):
+        if ":" in line:
+            key, value = line.split(":", 1)
+            preferences[key.strip()] = value.strip()
+
+    # Validate extracted preferences
+    required_keys = ["Destination", "Activities", "Budget", "Duration (in days)"]
+    if not all(key in preferences for key in required_keys):
+        print("\nCould not extract all required preferences. Please try again.")
+        return
+
+    # Fetch additional information
+    weather = weather_tool(preferences["Destination"])
+    print(f"\nWeather in {preferences['Destination']}: {weather}")
+
+    # Get departure city
+    print("Please enter your departure city: ")
+    origin = input()
+    flight_price = flight_price_estimator_tool(origin, preferences["Destination"])
+    print(flight_price)
+
+    # Plan itinerary
+    itinerary_agent = ItineraryAgent()
+    itinerary = itinerary_agent.plan_itinerary(
+        {
+            "destination": preferences["Destination"],
+            "origin": origin,
+            "budget": float(preferences["Budget"].replace("$", "")),
+            "budget_currency": "USD",
+        },
+        int(preferences["Duration (in days)"]),
+    )
+    print("\nPlanned Itinerary:")
+    print(itinerary)
+
+    # Currency conversion
+    budget_amount = float(preferences["Budget"].replace("$", "").replace(",", ""))
+    converted_budget = currency_converter_tool(budget_amount, "USD", "INR")
+    if converted_budget:
+        print(f"\nBudget in INR: {converted_budget:.2f} INR")
+    else:
+        print("\nCurrency conversion not available.")
+
+    # Generate travel summary
+    summary_prompt = f"""
+    Summarize the following travel plan:
+
+    Destination: {preferences['Destination']}
+    Activities: {preferences['Activities']}
+    Budget: {preferences['Budget']}
+    Duration: {preferences['Duration (in days)']} days
+    Itinerary: {itinerary}
+    Weather: {weather}
+    Flight Price: {flight_price}
+
+    Travel Summary:
+    """
+    travel_summary = llm_call(summary_prompt, name="generate_summary")
+    print("\nTravel Summary:")
+    print(travel_summary)
+
+if __name__ == "__main__":
+    with tracer:
+        travel_agent()
+    

ragaai_catalyst-2.1.5b0/examples/travel_agent/tools.py

@@ -0,0 +1,88 @@
+import os
+import random
+import requests
+from dotenv import load_dotenv
+from openai import OpenAI
+
+from ragaai_catalyst import trace_llm, trace_tool, current_span
+
+# Load environment variables
+load_dotenv()
+
+@trace_llm(name="llm_call", model="gpt-4o-mini")
+def llm_call(prompt, max_tokens=512, model="gpt-4o-mini", name="default"):
+    client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
+    current_span().add_metrics(
+        name=f"Q/A_v3_{random.randint(1, 10000)}", 
+        score=0.3, 
+        reasoning="Some Reason 1", 
+        cost=0.0003, 
+        latency=0.002
+    )
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "user", "content": prompt}],
+        max_tokens=max_tokens,
+        temperature=0.7,
+    )
+
+    return response.choices[0].message.content.strip()
+
+@trace_tool(name="weather_tool", tool_type="api")
+def weather_tool(destination):
+    api_key = os.environ.get("OPENWEATHERMAP_API_KEY")
+    base_url = "http://api.openweathermap.org/data/2.5/weather"
+    current_span().add_metrics(
+        name="Q/A_v2",
+        score=0.3,
+        reasoning="Some Reason 2",
+        cost=0.00036,
+        latency=0.0021,
+    )
+    params = {"q": destination, "appid": api_key, "units": "metric"}
+    print("Calculating weather for:", destination)
+    try:
+        response = requests.get(base_url, params=params)
+        response.raise_for_status()
+        data = response.json()
+        return f"{data['weather'][0]['description'].capitalize()}, {data['main']['temp']:.1f}°C"
+    except requests.RequestException:
+        return "Weather data not available."
+
+@trace_tool(name="currency_converter", tool_type="api")
+def currency_converter_tool(amount, from_currency, to_currency):
+    api_key = os.environ.get("EXCHANGERATE_API_KEY")
+    base_url = f"https://v6.exchangerate-api.com/v6/{api_key}/pair/{from_currency}/{to_currency}"
+    current_span().add_metrics(
+        name="Q/A_v2",
+        score=0.11,
+        reasoning="Some Reason 4",
+        cost=0.0009,
+        latency=0.0089,
+    )
+
+    try:
+        response = requests.get(base_url)
+        response.raise_for_status()
+        data = response.json()
+
+        if data["result"] == "success":
+            rate = data["conversion_rate"]
+            return amount * rate
+        else:
+            return None
+    except requests.RequestException:
+        return None
+
+@trace_tool(name="flight_price_estimator", tool_type="mock")
+def flight_price_estimator_tool(origin, destination):
+    current_span().add_metrics(
+        name="Q/A_v1",
+        score=0.67,
+        reasoning="Some Reason 3",
+        cost=0.0067,
+        latency=0.0011,
+    )
+    # This is a mock function. In a real scenario, you'd integrate with a flight API.
+    return f"Estimated price from {origin} to {destination}: $500-$1000"

{ragaai_catalyst-2.1.4.1b1 → ragaai_catalyst-2.1.5b0}/pyproject.toml

@@ -9,7 +9,7 @@ readme = "README.md"
 requires-python = ">=3.9,<3.13"
 # license = {file = "LICENSE"}
 
-version = "2.1.4.1.beta.1"
+version = "2.1.5.beta.0"
 authors = [
     {name = "Kiran Scaria", email = "kiran.scaria@raga.ai"},
     {name = "Kedar Gaikwad", email = "kedar.gaikwad@raga.ai"},
@@ -48,7 +48,6 @@ dependencies = [
     "py-cpuinfo~=9.0.0",
     "requests~=2.32.3",
     "GPUtil~=1.4.0",
-    "astor>=0.8.1",
     "ipynbname",
 ]
 

ragaai_catalyst-2.1.5b0/ragaai_catalyst/__init__.py

@@ -0,0 +1,30 @@
+from .experiment import Experiment
+from .ragaai_catalyst import RagaAICatalyst
+from .utils import response_checker
+from .dataset import Dataset
+from .prompt_manager import PromptManager
+from .evaluation import Evaluation
+from .synthetic_data_generation import SyntheticDataGeneration
+from .guardrails_manager import GuardrailsManager
+from .guard_executor import GuardExecutor
+from .tracers import Tracer, init_tracing, trace_agent, trace_llm, trace_tool, current_span, trace_custom
+
+
+
+
+__all__ = [
+    "Experiment", 
+    "RagaAICatalyst", 
+    "Tracer", 
+    "PromptManager", 
+    "Evaluation",
+    "SyntheticDataGeneration", 
+    "GuardrailsManager", 
+    "GuardExecutor",
+    "init_tracing", 
+    "trace_agent", 
+    "trace_llm",
+    "trace_tool",
+    "current_span",
+    "trace_custom"
+]

ragaai_catalyst-2.1.5b0/ragaai_catalyst/tracers/__init__.py

@@ -0,0 +1,19 @@
+from .tracer import Tracer
+from .distributed import (
+    init_tracing,
+    trace_agent,
+    trace_llm,
+    trace_tool,
+    current_span,
+    trace_custom,
+)
+
+__all__ = [
+    "Tracer",
+    "init_tracing",
+    "trace_agent", 
+    "trace_llm",
+    "trace_tool",
+    "current_span",
+    "trace_custom"
+]