Initial commit of RAG FastAPI project

.gitignore

@@ -0,0 +1,10 @@
+.env
+env
+# Environment variables file
+.env.local
+.env.*.local
+
+__pycache__
+*.pyc
+*.pyo
+venv

Dockerfile

@@ -0,0 +1,21 @@
+# Use a slim Python base
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /code
+
+# Install system deps (if you need Mongo client, etc.)
+RUN apt-get update && apt-get install -y build-essential
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app code
+COPY ./app /code/app
+
+# Expose port
+EXPOSE 7860
+
+# Run FastAPI with uvicorn
+CMD ["uvicorn", "run:app", "--host", "0.0.0.0", "--port", "7860"]

config.py

@@ -0,0 +1,16 @@
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+class Settings(BaseSettings):
+    mongodb_atlas_uri: str
+    gemini_api_key: str
+    database_name: str = "product"
+    products_collection: str = "marketplace"
+    conversations_collection: str = "conversations"
+    embeddings_collection: str = "embeddings"
+    port: int = 8000
+    
+    class Config:
+        env_file = ".env"
+
+settings = Settings()

database.py

@@ -0,0 +1,117 @@
+from datetime import datetime
+import motor.motor_asyncio
+from bson import ObjectId
+from typing import List, Optional, Dict, Any
+from config import settings
+import json
+
+class MongoDB:
+    def __init__(self):
+        self.client = motor.motor_asyncio.AsyncIOMotorClient(settings.mongodb_atlas_uri)
+        self.db = self.client[settings.database_name]
+        self.products = self.db[settings.products_collection]
+        self.conversations = self.db[settings.conversations_collection]
+        self.embeddings = self.db[settings.embeddings_collection]
+
+    async def get_product(self, product_id: str) -> Optional[Dict]:
+        return await self.products.find_one({"_id": ObjectId(product_id)})
+
+    async def get_products_by_category(self, category: str, limit: int = 10) -> List[Dict]:
+        # Your database might have different field names for category
+        cursor = self.products.find({"category": category}).limit(limit)
+        return await cursor.to_list(length=limit)
+
+    async def search_products(self, query: Dict, limit: int = 10) -> List[Dict]:
+        cursor = self.products.find(query).limit(limit)
+        return await cursor.to_list(length=limit)
+
+    async def get_all_products(self, limit: int = 50) -> List[Dict]:
+        cursor = self.products.find().limit(limit)
+        return await cursor.to_list(length=limit)
+
+    async def create_product(self, product_data: Dict) -> str:
+        result = await self.products.insert_one(product_data)
+        return str(result.inserted_id)
+
+    async def update_product(self, product_id: str, update_data: Dict) -> bool:
+        result = await self.products.update_one(
+            {"_id": ObjectId(product_id)}, 
+            {"$set": update_data}
+        )
+        return result.modified_count > 0
+
+    async def delete_product(self, product_id: str) -> bool:
+        result = await self.products.delete_one({"_id": ObjectId(product_id)})
+        return result.deleted_count > 0
+
+    async def get_conversation(self, conversation_id: str) -> Optional[Dict]:
+        return await self.conversations.find_one({"_id": ObjectId(conversation_id)})
+
+    async def create_conversation(self, user_id: str) -> str:
+        conversation_data = {
+            "user_id": user_id,
+            "messages": [],
+            "created_at": datetime.now(),
+            "updated_at": datetime.now()
+        }
+        result = await self.conversations.insert_one(conversation_data)
+        return str(result.inserted_id)
+
+    async def add_message_to_conversation(self, conversation_id: str, message: Dict) -> bool:
+        result = await self.conversations.update_one(
+            {"_id": ObjectId(conversation_id)},
+            {
+                "$push": {"messages": message},
+                "$set": {"updated_at": datetime.now()}
+            }
+        )
+        return result.modified_count > 0
+
+    async def get_user_conversations(self, user_id: str, limit: int = 10) -> List[Dict]:
+        cursor = self.conversations.find({"user_id": user_id}).sort("updated_at", -1).limit(limit)
+        return await cursor.to_list(length=limit)
+
+    async def store_embedding(self, text: str, embedding: List[float], metadata: Dict) -> str:
+        doc = {
+            "text": text,
+            "embedding": embedding,
+            "metadata": metadata,
+            "created_at": datetime.now()
+        }
+        result = await self.embeddings.insert_one(doc)
+        return str(result.inserted_id)
+
+    async def find_similar_embeddings(self, embedding: List[float], limit: int = 5) -> List[Dict]:
+        # This is a simplified version - in production, you'd use vector search
+        pipeline = [
+            {
+                "$addFields": {
+                    "similarity": {
+                        "$sqrt": {
+                            "$sum": {
+                                "$map": {
+                                    "input": {"$range": [0, {"$size": "$embedding"}]},
+                                    "as": "idx",
+                                    "in": {
+                                        "$pow": [
+                                            {"$subtract": [
+                                                {"$arrayElemAt": ["$embedding", "$$idx"]},
+                                                {"$arrayElemAt": [embedding, "$$idx"]}
+                                            ]},
+                                            2
+                                        ]
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            },
+            {"$sort": {"similarity": 1}},
+            {"$limit": limit}
+        ]
+        cursor = self.embeddings.aggregate(pipeline)
+        return await cursor.to_list(length=limit)
+
+# Database instance
+db = MongoDB()

gemini_service.py

@@ -0,0 +1,106 @@
+import google.generativeai as genai
+from typing import List, Dict, Any, Optional
+import asyncio
+import aiohttp
+import json
+from config import settings
+
+class GeminiService:
+    def __init__(self):
+        genai.configure(api_key=settings.gemini_api_key)
+        self.model = genai.GenerativeModel('gemini-2.5-flash')
+        
+    async def generate_response(self, prompt: str, context: str = "") -> str:
+        """Generate response using Gemini API with context"""
+        try:
+            full_prompt = f"""
+            Context Information:
+            {context}
+            
+            User Question: {prompt}
+            
+            You are a helpful shopping assistant for Daddy's Shop. Use the context information above to answer the user's question accurately and helpfully. If the context doesn't contain relevant information, use your general knowledge but be honest about limitations.
+            
+            Provide a friendly, professional response focused on helping with shopping needs.
+            """
+            
+            # Run in thread pool since Gemini doesn't have native async support
+            loop = asyncio.get_event_loop()
+            response = await loop.run_in_executor(
+                None, 
+                lambda: self.model.generate_content(full_prompt)
+            )
+            
+            return response.text
+            
+        except Exception as e:
+            print(f"Gemini API error: {e}")
+            return "I apologize, but I'm having trouble processing your request right now. Please try again later."
+
+    async def generate_embedding(self, text: str) -> List[float]:
+        """Generate embeddings for text using Gemini"""
+        try:
+            # Note: Gemini doesn't have direct embedding API, so we'll use a workaround
+            # For production, consider using SentenceTransformers or another embedding service
+            embedding_model = genai.GenerativeModel('embedding-001')
+            
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                None,
+                lambda: genai.embed_content(
+                    model=embedding_model,
+                    content=text,
+                    task_type="retrieval_document"
+                )
+            )
+            
+            return result['embedding']
+            
+        except Exception as e:
+            print(f"Embedding generation error: {e}")
+            # Fallback to simple embedding (in production, use proper embedding model)
+            return [0.0] * 384  # Default dimension
+
+    async def classify_intent(self, message: str) -> Dict[str, Any]:
+        """Classify user intent using Gemini"""
+        prompt = f"""
+        Classify the following user message into one of these intents:
+        - product_inquiry: Questions about products, features, availability
+        - pricing: Questions about costs, discounts, prices
+        - shipping: Questions about delivery, shipping costs, timelines
+        - returns: Questions about returns, refunds, exchanges
+        - support: General customer support, contact information
+        - greeting: Hello, hi, greetings
+        - unknown: Cannot classify
+        
+        Message: "{message}"
+        
+        Return ONLY a JSON object with:
+        {{
+            "intent": "classified_intent",
+            "confidence": 0.95,
+            "entities": ["extracted_entities", "if_any"]
+        }}
+        """
+        
+        try:
+            loop = asyncio.get_event_loop()
+            response = await loop.run_in_executor(
+                None,
+                lambda: self.model.generate_content(prompt)
+            )
+            
+            # Parse JSON response
+            import re
+            json_match = re.search(r'\{.*\}', response.text, re.DOTALL)
+            if json_match:
+                return json.loads(json_match.group())
+            else:
+                return {"intent": "unknown", "confidence": 0.0, "entities": []}
+                
+        except Exception as e:
+            print(f"Intent classification error: {e}")
+            return {"intent": "unknown", "confidence": 0.0, "entities": []}
+
+# Gemini service instance
+gemini_service = GeminiService()

main.py

@@ -0,0 +1,217 @@
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.middleware.cors import CORSMiddleware
+from typing import List, Optional
+import uuid
+from datetime import datetime
+
+from config import settings
+from database import db
+from rag_system import rag_system
+from models import (
+    Product, ProductCreate, ChatRequest, ChatResponse, 
+    SearchRequest, Conversation, ChatMessage
+)
+
+app = FastAPI(
+    title="Daddy's Shop RAG Chatbot API",
+    description="AI-powered shopping assistant with RAG using MongoDB and Gemini",
+    version="1.0.0"
+)
+
+# CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://127.0.0.1:3000", "https://yourdomain.com"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {
+        "message": "Daddy's Shop RAG Chatbot API is running!",
+        "version": "1.0.0",
+        "status": "healthy"
+    }
+
+@app.post("/chat", response_model=ChatResponse)
+async def chat_endpoint(request: ChatRequest):
+    """
+    Main chatbot endpoint with RAG capabilities
+    """
+    try:
+        # Create new conversation if no ID provided
+        if not request.conversation_id:
+            conversation_id = await db.create_conversation(request.user_id)
+        else:
+            conversation_id = request.conversation_id
+            # Verify conversation exists
+            conversation = await db.get_conversation(conversation_id)
+            if not conversation:
+                conversation_id = await db.create_conversation(request.user_id)
+        
+        # Add user message to conversation
+        user_message = ChatMessage(
+            sender="user",
+            text=request.message
+        )
+        await db.add_message_to_conversation(conversation_id, user_message.dict())
+        
+        # Get conversation history for context
+        conversation = await db.get_conversation(conversation_id)
+        history = conversation.get('messages', []) if conversation else []
+        
+        # Generate response using RAG system
+        rag_result = await rag_system.generate_chat_response(request.message, history)
+        
+        # Add bot response to conversation
+        bot_message = ChatMessage(
+            sender="bot",
+            text=rag_result["response"]
+        )
+        await db.add_message_to_conversation(conversation_id, bot_message.dict())
+        
+        return ChatResponse(
+            response=rag_result["response"],
+            conversation_id=conversation_id,
+            suggested_questions=rag_result["suggested_questions"],
+            relevant_products=rag_result["relevant_products"],
+            intent=rag_result["intent"],
+            confidence=rag_result["confidence"]
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Chat processing error: {str(e)}")
+
+@app.get("/products", response_model=List[Product])
+async def get_products(category: Optional[str] = None, limit: int = 20):
+    """Get products with optional category filter"""
+    try:
+        if category:
+            products = await db.get_products_by_category(category, limit)
+        else:
+            products = await db.get_all_products(limit)
+        return products
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching products: {str(e)}")
+
+@app.get("/products/{product_id}", response_model=Product)
+async def get_product(product_id: str):
+    """Get specific product by ID"""
+    product = await db.get_product(product_id)
+    if not product:
+        raise HTTPException(status_code=404, detail="Product not found")
+    return product
+
+@app.post("/products", response_model=dict)
+async def create_product(product: ProductCreate):
+    """Create a new product"""
+    try:
+        product_data = product.dict()
+        product_data["_id"] = str(uuid.uuid4())[:8]  # Simple ID generation
+        product_id = await db.create_product(product_data)
+        return {"message": "Product created successfully", "product_id": product_id}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error creating product: {str(e)}")
+
+@app.post("/search", response_model=List[Product])
+async def search_products(request: SearchRequest):
+    """Semantic search for products"""
+    try:
+        products = await rag_system.retrieve_relevant_products(
+            request.query, 
+            request.category, 
+            request.max_results
+        )
+        return products
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Search error: {str(e)}")
+
+@app.get("/conversations/{user_id}", response_model=List[Conversation])
+async def get_user_conversations(user_id: str, limit: int = 10):
+    """Get user's conversation history"""
+    try:
+        conversations = await db.get_user_conversations(user_id, limit)
+        return conversations
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error fetching conversations: {str(e)}")
+
+@app.get("/intents")
+async def get_available_intents():
+    """Get information about available intents"""
+    return {
+        "intents": [
+            "product_inquiry", "pricing", "shipping", 
+            "returns", "support", "greeting", "unknown"
+        ],
+        "description": "Intent classification for user messages"
+    }
+@app.get("/test-products")
+async def test_products(limit: int = 3):
+    """Test endpoint to see transformed products"""
+    try:
+        products = await db.get_all_products(limit)
+        transformed_products = [rag_system._transform_product_doc(product) for product in products]
+        return {
+            "original_count": len(products),
+            "transformed_count": len(transformed_products),
+            "original_sample": products[0] if products else {},
+            "transformed_sample": transformed_products[0] if transformed_products else {},
+            "all_transformed": transformed_products
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Test error: {str(e)}")
+# Sample data initialization
+@app.on_event("startup")
+async def startup_event():
+    """Initialize sample data if needed"""
+    try:
+        # Check if we have any products
+        products = await db.get_all_products(1)
+        if not products:
+            await _initialize_sample_data()
+    except Exception as e:
+        print(f"Startup initialization error: {e}")
+
+async def _initialize_sample_data():
+    """Initialize sample product data"""
+    sample_products = [
+        {
+            "name": "Wireless Bluetooth Earbuds",
+            "description": "High-quality wireless earbuds with noise cancellation and 24-hour battery life.",
+            "price": 79.99,
+            "category": "electronics",
+            "in_stock": True,
+            "tags": ["wireless", "bluetooth", "audio", "noise-cancellation"],
+            "features": ["Noise Cancellation", "24h Battery", "Water Resistant", "Touch Controls"]
+        },
+        {
+            "name": "Smart Fitness Watch",
+            "description": "Advanced fitness tracker with heart rate monitoring, GPS, and smartphone connectivity.",
+            "price": 199.99,
+            "category": "electronics",
+            "in_stock": True,
+            "tags": ["fitness", "smartwatch", "health", "tracking"],
+            "features": ["Heart Rate Monitor", "GPS", "Sleep Tracking", "Waterproof"]
+        },
+        {
+            "name": "Organic Cotton T-Shirt",
+            "description": "Comfortable and sustainable organic cotton t-shirt available in multiple colors.",
+            "price": 24.99,
+            "category": "clothing",
+            "in_stock": True,
+            "tags": ["cotton", "organic", "sustainable", "casual"],
+            "features": ["Organic Cotton", "Machine Washable", "Multiple Colors"]
+        }
+    ]
+    
+    for product in sample_products:
+        await db.create_product(product)
+    
+    print("Sample data initialized successfully")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=settings.port)

models.py

@@ -0,0 +1,100 @@
+from pydantic import BaseModel, Field, validator
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+from enum import Enum
+
+class ProductCategory(str, Enum):
+    ELECTRONICS = "electronics"
+    CLOTHING = "clothing"
+    HOME = "home"
+    BEAUTY = "beauty"
+    SPORTS = "sports"
+    BOOKS = "books"
+    OTHER = "other"
+
+class ProductCreate(BaseModel):
+    name: str
+    description: str = ""
+    price: float = 0.0
+    category: ProductCategory = ProductCategory.OTHER
+    in_stock: bool = True
+    tags: List[str] = []
+    features: List[str] = []
+    image_url: Optional[str] = None
+
+    @validator('price', pre=True)
+    def validate_price(cls, v):
+        if v is None:
+            return 0.0
+        try:
+            return float(v)
+        except (TypeError, ValueError):
+            return 0.0
+
+    @validator('category', pre=True)
+    def validate_category(cls, v):
+        if isinstance(v, ProductCategory):
+            return v
+        try:
+            return ProductCategory(v)
+        except ValueError:
+            return ProductCategory.OTHER
+
+class Product(BaseModel):
+    id: str
+    name: str
+    description: str = ""
+    price: float = 0.0
+    category: ProductCategory = ProductCategory.OTHER
+    in_stock: bool = True
+    tags: List[str] = []
+    features: List[str] = []
+    image_url: Optional[str] = None
+
+    @validator('price', pre=True)
+    def validate_price(cls, v):
+        if v is None:
+            return 0.0
+        try:
+            return float(v)
+        except (TypeError, ValueError):
+            return 0.0
+
+    @validator('category', pre=True)
+    def validate_category(cls, v):
+        if isinstance(v, ProductCategory):
+            return v
+        try:
+            return ProductCategory(v)
+        except ValueError:
+            return ProductCategory.OTHER
+
+class ChatMessage(BaseModel):
+    sender: str
+    text: str
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+class ChatRequest(BaseModel):
+    message: str
+    conversation_id: Optional[str] = None
+    user_id: Optional[str] = "anonymous"
+
+class ChatResponse(BaseModel):
+    response: str
+    conversation_id: str
+    suggested_questions: List[str] = []
+    relevant_products: List[Product] = []
+    intent: str
+    confidence: float
+
+class SearchRequest(BaseModel):
+    query: str
+    category: Optional[ProductCategory] = None
+    max_results: int = 5
+
+class Conversation(BaseModel):
+    id: str
+    user_id: str
+    messages: List[ChatMessage] = []
+    created_at: datetime = Field(default_factory=datetime.now)
+    updated_at: datetime = Field(default_factory=datetime.now)

rag_system.py

@@ -0,0 +1,285 @@
+from typing import List, Dict, Any, Optional
+from database import db
+from gemini_service import gemini_service
+from models import Product, ProductCategory
+import numpy as np
+from sentence_transformers import SentenceTransformer
+import asyncio
+
+class RAGSystem:
+    def __init__(self):
+        self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+    
+    def _transform_product_doc(self, product_doc: Dict) -> Dict:
+        """Transform MongoDB document to match Product model using actual field names"""
+        try:
+            # Extract fields from your actual database schema
+            product_id = str(product_doc.get('_id', '')) or str(product_doc.get('product_id', ''))
+            
+            # Map to our expected fields
+            transformed = {
+                "id": product_id,
+                "name": product_doc.get('title', 'Unnamed Product'),
+                "description": product_doc.get('product_description', 'No description available'),
+                "price": float(product_doc.get('final_price', 0.0)),
+                "category": self._map_category(product_doc.get('category', 'other')),
+                "in_stock": True,  # Default to True since we don't have this field
+                "tags": self._extract_tags(product_doc),
+                "features": self._extract_features(product_doc),
+                "image_url": self._get_first_image(product_doc.get('images', '')),
+            }
+            
+            return transformed
+            
+        except Exception as e:
+            print(f"Error transforming product {product_doc.get('_id')}: {e}")
+            # Return a safe default product
+            return {
+                "id": str(product_doc.get('_id', 'unknown')),
+                "name": product_doc.get('title', 'Unnamed Product'),
+                "description": "Product information unavailable",
+                "price": 0.0,
+                "category": ProductCategory.OTHER,
+                "in_stock": True,
+                "tags": [],
+                "features": [],
+            }
+    
+    def _map_category(self, raw_category: str) -> ProductCategory:
+        """Map raw category string to ProductCategory enum"""
+        if not raw_category:
+            return ProductCategory.OTHER
+            
+        category_lower = raw_category.lower()
+        
+        # Map based on your actual category values
+        if any(keyword in category_lower for keyword in ['electronic', 'tech', 'computer', 'phone']):
+            return ProductCategory.ELECTRONICS
+        elif any(keyword in category_lower for keyword in ['cloth', 'fashion', 'wear', 'top', 'dress', 'shirt', 'jeans']):
+            return ProductCategory.CLOTHING
+        elif any(keyword in category_lower for keyword in ['home', 'garden', 'furniture', 'decor']):
+            return ProductCategory.HOME
+        elif any(keyword in category_lower for keyword in ['beauty', 'cosmetic', 'skin', 'hair', 'cream', 'mask', 'makeup']):
+            return ProductCategory.BEAUTY
+        elif any(keyword in category_lower for keyword in ['sport', 'fitness', 'exercise', 'gym']):
+            return ProductCategory.SPORTS
+        elif any(keyword in category_lower for keyword in ['book', 'literature']):
+            return ProductCategory.BOOKS
+        else:
+            return ProductCategory.OTHER
+    
+    def _extract_tags(self, product_doc: Dict) -> List[str]:
+        """Extract tags from product details"""
+        tags = []
+        
+        # Add category as a tag
+        category = product_doc.get('category')
+        if category:
+            tags.append(category)
+        
+        # Extract from product details if available
+        details = product_doc.get('product_details', '')
+        if 'Cotton' in details:
+            tags.append('Cotton')
+        if 'Polyester' in details:
+            tags.append('Polyester')
+        
+        return tags
+    
+    def _extract_features(self, product_doc: Dict) -> List[str]:
+        """Extract features from product details"""
+        features = []
+        
+        # Extract key features from product details
+        details = product_doc.get('product_details', '')
+        
+        # Look for common features
+        feature_keywords = [
+            'Machine wash', 'Hand wash', 'Dry clean', 'Cotton', 
+            'Polyester', 'Elastane', 'Spaghetti', 'Sleeveless',
+            'Solid pattern', 'Sweetheart neck'
+        ]
+        
+        for keyword in feature_keywords:
+            if keyword in details:
+                features.append(keyword)
+        
+        # Add rating as a feature
+        rating = product_doc.get('rating')
+        if rating:
+            features.append(f'{rating}★ Rating')
+        
+        # Add delivery options
+        delivery = product_doc.get('delivery_options', '')
+        if 'Pay on delivery' in delivery:
+            features.append('Pay on Delivery')
+        if 'Easy returns' in delivery:
+            features.append('Easy Returns')
+        
+        return features
+    
+    def _get_first_image(self, images_str: str) -> Optional[str]:
+        """Extract first image URL from comma-separated string"""
+        if not images_str:
+            return None
+        images = images_str.split(',')
+        return images[0].strip() if images else None
+
+    # ... rest of your existing methods remain the same
+    async def retrieve_relevant_products(self, query: str, category: Optional[str] = None, limit: int = 5) -> List[Dict]:
+        """Retrieve and transform relevant products"""
+        try:
+            # Generate query embedding
+            query_embedding = await self._get_embedding(query)
+            
+            # Get all products or filtered by category
+            if category:
+                products = await db.get_products_by_category(category, limit=50)
+            else:
+                products = await db.get_all_products(limit=100)
+            
+            # Transform products first
+            transformed_products = [self._transform_product_doc(product) for product in products]
+            
+            # Calculate similarity scores on transformed products
+            scored_products = []
+            for product in transformed_products:
+                product_text = f"{product.get('name', '')} {product.get('description', '')} {' '.join(product.get('tags', []))}"
+                product_embedding = await self._get_embedding(product_text)
+                
+                similarity = self._cosine_similarity(query_embedding, product_embedding)
+                scored_products.append((product, similarity))
+            
+            # Sort by similarity and return top results
+            scored_products.sort(key=lambda x: x[1], reverse=True)
+            return [product for product, score in scored_products[:limit]]
+            
+        except Exception as e:
+            print(f"Product retrieval error: {e}")
+            # Fallback to simple keyword search with transformation
+            return await self._keyword_search_products(query, category, limit)
+    
+    async def _keyword_search_products(self, query: str, category: Optional[str], limit: int) -> List[Dict]:
+        """Fallback keyword-based product search with transformation"""
+        search_terms = query.lower().split()
+        
+        if category:
+            products = await db.get_products_by_category(category, limit=50)
+        else:
+            products = await db.get_all_products(limit=100)
+        
+        # Transform all products first
+        transformed_products = [self._transform_product_doc(product) for product in products]
+        
+        scored_products = []
+        for product in transformed_products:
+            score = 0
+            product_text = f"{product.get('name', '')} {product.get('description', '')} {' '.join(product.get('tags', []))}".lower()
+            
+            for term in search_terms:
+                if term in product_text:
+                    score += 1
+                if term in product.get('name', '').lower():
+                    score += 2  # Higher weight for name matches
+            
+            if score > 0:
+                scored_products.append((product, score))
+        
+        scored_products.sort(key=lambda x: x[1], reverse=True)
+        return [product for product, score in scored_products[:limit]]
+    
+    async def _get_embedding(self, text: str) -> List[float]:
+        """Get embedding for text using available methods"""
+        try:
+            embedding = await gemini_service.generate_embedding(text)
+            if embedding and len(embedding) > 10:
+                return embedding
+        except:
+            pass
+        
+        embedding = self.embedding_model.encode(text)
+        return embedding.tolist()
+    
+    def _cosine_similarity(self, vec1: List[float], vec2: List[float]) -> float:
+        """Calculate cosine similarity between two vectors"""
+        vec1 = np.array(vec1)
+        vec2 = np.array(vec2)
+        
+        dot_product = np.dot(vec1, vec2)
+        norm1 = np.linalg.norm(vec1)
+        norm2 = np.linalg.norm(vec2)
+        
+        if norm1 == 0 or norm2 == 0:
+            return 0.0
+            
+        return dot_product / (norm1 * norm2)
+    
+    async def build_context(self, query: str, relevant_products: List[Dict]) -> str:
+        """Build context string from relevant products for the LLM"""
+        if not relevant_products:
+            return "No specific product information available. Use general knowledge about e-commerce and shopping."
+        
+        context_parts = ["Relevant Products Information:"]
+        
+        for i, product in enumerate(relevant_products, 1):
+            context_parts.append(f"""
+            Product {i}:
+            - Name: {product.get('name', 'N/A')}
+            - Description: {product.get('description', 'N/A')}
+            - Price: ${product.get('price', 'N/A')}
+            - Category: {product.get('category', 'N/A')}
+            - In Stock: {'Yes' if product.get('in_stock') else 'No'}
+            - Features: {', '.join(product.get('features', []))}
+            - Tags: {', '.join(product.get('tags', []))}
+            """)
+        
+        return "\n".join(context_parts)
+    
+    async def generate_chat_response(self, user_message: str, conversation_history: List[Dict] = None) -> Dict[str, Any]:
+        """Generate response using RAG pipeline"""
+        # Classify intent
+        intent_result = await gemini_service.classify_intent(user_message)
+        
+        # Retrieve relevant products (already transformed)
+        relevant_products = await self.retrieve_relevant_products(user_message, limit=3)
+        
+        # Build context
+        context = await self.build_context(user_message, relevant_products)
+        
+        # Generate response using Gemini with context
+        response = await gemini_service.generate_response(user_message, context)
+        
+        # Generate suggested questions based on intent
+        suggested_questions = await self._generate_suggested_questions(intent_result['intent'], relevant_products)
+        
+        return {
+            "response": response,
+            "relevant_products": relevant_products,
+            "suggested_questions": suggested_questions,
+            "intent": intent_result['intent'],
+            "confidence": intent_result['confidence']
+        }
+    
+    async def _generate_suggested_questions(self, intent: str, products: List[Dict]) -> List[str]:
+        """Generate context-aware suggested questions"""
+        base_questions = {
+            "product_inquiry": ["Show me more products", "What are your best sellers?", "Any current deals?"],
+            "pricing": ["Do you offer discounts?", "What's the return policy?", "Any bundle deals?"],
+            "shipping": ["How long does delivery take?", "Do you ship internationally?", "What are shipping costs?"],
+            "returns": ["How do I return an item?", "What's your warranty policy?", "Do you offer exchanges?"],
+            "support": ["Contact customer service", "Store locations", "Business hours"],
+            "default": ["Best sellers", "Current deals", "Shipping info", "Return policy"]
+        }
+        
+        questions = base_questions.get(intent, base_questions["default"])
+        
+        # Add product-specific questions if we have products
+        if products and intent == "product_inquiry":
+            categories = list(set(str(p.get('category')) for p in products))
+            if categories:
+                questions = [f"Show me more {cat} products" for cat in categories[:2]] + questions
+        
+        return questions[:4]
+        
+# RAG system instance
+rag_system = RAGSystem()

run.py

@@ -0,0 +1,11 @@
+import uvicorn
+from config import settings
+
+if __name__ == "__main__":
+    uvicorn.run(
+        "main:app",
+        host="0.0.0.0",
+        port=settings.port,
+        reload=True,  # Enable auto-reload during development
+        log_level="info"
+    )