Comprehensive comparison for AI technology in applications

from haystack import Pipeline
from haystack.components.builders import PromptBuilder
from haystack.components.generators import OpenAIGenerator
from haystack.components.retrievers.in_memory import InMemoryBM25Retriever
from haystack.document_stores.in_memory import InMemoryDocumentStore
from haystack.dataclasses import Document
from typing import List, Dict, Optional
import logging

logger = logging.getLogger(__name__)

class ProductSupportRAG:
    """RAG system for product support queries with error handling"""
    
    def __init__(self, api_key: str, product_docs: List[Dict[str, str]]):
        try:
            self.document_store = InMemoryDocumentStore()
            self._initialize_documents(product_docs)
            self.pipeline = self._build_pipeline(api_key)
        except Exception as e:
            logger.error(f"Failed to initialize ProductSupportRAG: {e}")
            raise
    
    def _initialize_documents(self, product_docs: List[Dict[str, str]]):
        """Load product documentation into document store"""
        if not product_docs:
            raise ValueError("product_docs cannot be empty")
        
        documents = [
            Document(content=doc["content"], meta={"title": doc.get("title", "Untitled")})
            for doc in product_docs
        ]
        self.document_store.write_documents(documents)
        logger.info(f"Loaded {len(documents)} documents into store")
    
    def _build_pipeline(self, api_key: str) -> Pipeline:
        """Construct RAG pipeline with retriever and generator"""
        template = """
You are a helpful product support assistant. Use the following context to answer the user's question.
If the context doesn't contain relevant information, say so politely.

Context:
{% for doc in documents %}
- {{ doc.content }}
{% endfor %}

Question: {{ question }}

Answer:
"""
        
        pipeline = Pipeline()
        pipeline.add_component("retriever", InMemoryBM25Retriever(document_store=self.document_store, top_k=3))
        pipeline.add_component("prompt_builder", PromptBuilder(template=template))
        pipeline.add_component("llm", OpenAIGenerator(api_key=api_key, model="gpt-3.5-turbo"))
        
        pipeline.connect("retriever.documents", "prompt_builder.documents")
        pipeline.connect("prompt_builder", "llm")
        
        return pipeline
    
    def query(self, question: str) -> Optional[str]:
        """Process support query and return answer"""
        if not question or not question.strip():
            logger.warning("Empty question received")
            return "Please provide a valid question."
        
        try:
            result = self.pipeline.run({
                "retriever": {"query": question},
                "prompt_builder": {"question": question}
            })
            
            answer = result["llm"]["replies"][0] if result.get("llm", {}).get("replies") else None
            
            if not answer:
                logger.error("No answer generated from pipeline")
                return "Sorry, I couldn't generate an answer. Please try again."
            
            return answer
            
        except Exception as e:
            logger.error(f"Error processing query: {e}")
            return "An error occurred while processing your request."

# Example usage
if __name__ == "__main__":
    product_docs = [
        {"title": "Returns", "content": "Returns are accepted within 30 days with receipt."},
        {"title": "Shipping", "content": "Standard shipping takes 5-7 business days."},
        {"title": "Warranty", "content": "All products have a 1-year manufacturer warranty."}
    ]
    
    rag_system = ProductSupportRAG(api_key="your-api-key", product_docs=product_docs)
    answer = rag_system.query("What is your return policy?")
    print(f"Answer: {answer}")