Comprehensive comparison for AI technology in Agent Framework applications

import os
from typing import Optional
from atomic_agents.agents.base_agent import BaseAgent, BaseAgentConfig
from atomic_agents.lib.components.system_prompt_generator import SystemPromptGenerator
from atomic_agents.lib.components.agent_memory import AgentMemory
from instructor import OpenAISchema
from pydantic import Field

# Define output schema for structured responses
class ProductRecommendation(OpenAISchema):
    """Schema for product recommendation response"""
    product_name: str = Field(..., description="Name of the recommended product")
    reason: str = Field(..., description="Reason for recommendation")
    price_range: str = Field(..., description="Expected price range")
    confidence_score: float = Field(..., description="Confidence score between 0 and 1")

# Define input schema
class CustomerQuery(OpenAISchema):
    """Schema for customer product query"""
    query: str = Field(..., description="Customer's product search query")
    budget: Optional[float] = Field(None, description="Customer's budget in USD")
    preferences: Optional[str] = Field(None, description="Additional preferences")

# Configure the agent
class ProductRecommendationAgent:
    def __init__(self, api_key: str):
        # Initialize system prompt
        system_prompt = SystemPromptGenerator(
            background=[
                "You are an expert product recommendation assistant.",
                "You analyze customer needs and suggest appropriate products."
            ],
            steps=[
                "Analyze the customer's query and budget constraints",
                "Consider their preferences and requirements",
                "Provide a relevant product recommendation with justification"
            ],
            output_instructions=[
                "Always provide a confidence score based on query clarity",
                "Include realistic price ranges",
                "Be concise but informative in your reasoning"
            ]
        )
        
        # Configure agent with memory
        config = BaseAgentConfig(
            client=self._get_openai_client(api_key),
            model="gpt-4",
            system_prompt_generator=system_prompt,
            memory=AgentMemory(max_messages=10),
            output_schema=ProductRecommendation
        )
        
        self.agent = BaseAgent(config)
    
    def _get_openai_client(self, api_key: str):
        """Initialize OpenAI client with error handling"""
        try:
            from openai import OpenAI
            return OpenAI(api_key=api_key)
        except Exception as e:
            raise ValueError(f"Failed to initialize OpenAI client: {str(e)}")
    
    def recommend(self, customer_query: CustomerQuery) -> ProductRecommendation:
        """Generate product recommendation based on customer query"""
        try:
            # Build context-aware prompt
            prompt = f"Customer query: {customer_query.query}"
            if customer_query.budget:
                prompt += f"\nBudget: ${customer_query.budget}"
            if customer_query.preferences:
                prompt += f"\nPreferences: {customer_query.preferences}"
            
            # Run agent with structured output
            response = self.agent.run(prompt)
            
            # Validate response
            if response.confidence_score < 0.3:
                raise ValueError("Low confidence recommendation - query may be too vague")
            
            return response
        
        except Exception as e:
            # Handle errors gracefully
            return ProductRecommendation(
                product_name="Unable to recommend",
                reason=f"Error processing request: {str(e)}",
                price_range="N/A",
                confidence_score=0.0
            )

# Usage example
if __name__ == "__main__":
    api_key = os.getenv("OPENAI_API_KEY")
    agent = ProductRecommendationAgent(api_key)
    
    query = CustomerQuery(
        query="I need a laptop for video editing",
        budget=1500.0,
        preferences="prefer lightweight and long battery life"
    )
    
    recommendation = agent.recommend(query)
    print(f"Product: {recommendation.product_name}")
    print(f"Reason: {recommendation.reason}")
    print(f"Price: {recommendation.price_range}")
    print(f"Confidence: {recommendation.confidence_score}")