Comprehensive comparison for Prompt Engineering technology in AI applications

from langchain.prompts import PromptTemplate, ChatPromptTemplate, SystemMessagePromptTemplate, HumanMessagePromptTemplate
from langchain.chat_models import ChatOpenAI
from langchain.output_parsers import PydanticOutputParser
from pydantic import BaseModel, Field, validator
from typing import List, Optional
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Define output schema for structured responses
class ProductRecommendation(BaseModel):
    product_name: str = Field(description="Name of the recommended product")
    reason: str = Field(description="Reason for recommendation")
    confidence_score: float = Field(description="Confidence score between 0 and 1")
    
    @validator('confidence_score')
    def validate_confidence(cls, v):
        if not 0 <= v <= 1:
            raise ValueError('Confidence score must be between 0 and 1')
        return v

class RecommendationResponse(BaseModel):
    recommendations: List[ProductRecommendation] = Field(description="List of product recommendations")
    total_count: int = Field(description="Total number of recommendations")

# Initialize output parser
output_parser = PydanticOutputParser(pydantic_object=RecommendationResponse)

# Create system message template with best practices
system_template = """You are an expert e-commerce product recommendation assistant.
Your goal is to provide personalized, relevant product recommendations based on user preferences and purchase history.
Always be helpful, accurate, and consider user budget constraints.

{format_instructions}
"""

# Create human message template with input variables
human_template = """Based on the following customer profile, provide 3 product recommendations:

Customer ID: {customer_id}
Previous Purchases: {purchase_history}
Budget Range: ${min_budget} - ${max_budget}
Preferred Categories: {preferred_categories}
Special Requirements: {special_requirements}

Please ensure recommendations are within budget and align with customer preferences."""

# Build chat prompt template
system_message_prompt = SystemMessagePromptTemplate.from_template(system_template)
human_message_prompt = HumanMessagePromptTemplate.from_template(human_template)

chat_prompt = ChatPromptTemplate.from_messages([
    system_message_prompt,
    human_message_prompt
])

def get_product_recommendations(
    customer_id: str,
    purchase_history: List[str],
    min_budget: float,
    max_budget: float,
    preferred_categories: List[str],
    special_requirements: Optional[str] = "None"
) -> Optional[RecommendationResponse]:
    """Generate product recommendations using LangChain prompts with error handling."""
    
    try:
        # Validate inputs
        if min_budget < 0 or max_budget < min_budget:
            raise ValueError("Invalid budget range")
        
        if not customer_id or not purchase_history:
            raise ValueError("Customer ID and purchase history are required")
        
        # Initialize LLM
        llm = ChatOpenAI(model="gpt-4", temperature=0.7)
        
        # Format the prompt with actual values
        formatted_prompt = chat_prompt.format_prompt(
            format_instructions=output_parser.get_format_instructions(),
            customer_id=customer_id,
            purchase_history=", ".join(purchase_history),
            min_budget=min_budget,
            max_budget=max_budget,
            preferred_categories=", ".join(preferred_categories),
            special_requirements=special_requirements
        )
        
        logger.info(f"Generating recommendations for customer: {customer_id}")
        
        # Get LLM response
        response = llm(formatted_prompt.to_messages())
        
        # Parse structured output
        parsed_response = output_parser.parse(response.content)
        
        logger.info(f"Successfully generated {parsed_response.total_count} recommendations")
        
        return parsed_response
        
    except ValueError as ve:
        logger.error(f"Validation error: {str(ve)}")
        return None
    except Exception as e:
        logger.error(f"Error generating recommendations: {str(e)}")
        return None

# Example usage
if __name__ == "__main__":
    result = get_product_recommendations(
        customer_id="CUST-12345",
        purchase_history=["Laptop", "Wireless Mouse", "USB-C Cable"],
        min_budget=50.0,
        max_budget=200.0,
        preferred_categories=["Electronics", "Accessories"],
        special_requirements="Prefer eco-friendly products"
    )
    
    if result:
        print(f"Total Recommendations: {result.total_count}")
        for rec in result.recommendations:
            print(f"\n- {rec.product_name}")
            print(f"  Reason: {rec.reason}")
            print(f"  Confidence: {rec.confidence_score:.2f}")
    else:
        print("Failed to generate recommendations")