final changes

.env.example

@@ -7,6 +7,7 @@ PINECONE_API_KEY=your_pinecone_api_key_here
 PINECONE_INDEX_NAME=ikarus
 PINECONE_DIMENSION=1024
 PINECONE_ENVIRONMENT=us-east-1-aws
+PINECONE_REGION=us-east-1
 
 # Data Configuration
 DATA_PATH=./data/dataset.csv

app/config.py

@@ -11,6 +11,7 @@ class Settings(BaseSettings):
     PINECONE_INDEX_NAME: str
     PINECONE_DIMENSION: int = 1024
     PINECONE_ENVIRONMENT: str = "us-east-1-aws"
+    PINECONE_REGION: str = "us-east-1"
     
     # Data Configuration
     DATA_PATH: str = "data/dataset.csv"

app/main.py

@@ -2,8 +2,7 @@ import asyncio
 import logging
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from app.services.recommendation_service import RecommendationService
-from app.models import Product
+from app.routes import recommendations, analytics, chat
 
 # Setup logging
 
@@ -25,31 +24,26 @@ allow_methods=["*"],
 allow_headers=["*"],
 )
 
-recommendation_service = RecommendationService()
+# Register routers
+app.include_router(recommendations.router)
+app.include_router(chat.router)
+app.include_router(analytics.router)
 
 @app.on_event("startup")
 async def startup_event():
-"""Run background indexing on startup."""
-logger.info("🚀 Starting up application...")
-try:
-logger.info("🔄 Starting background product indexing...")
-asyncio.create_task(recommendation_service.index_products())
-except Exception as e:
-logger.error(f"❌ Error during background indexing: {e}")
+    """Run background indexing on startup."""
+    logger.info("🚀 Starting up application...")
+    try:
+        from app.services.recommendation_service import recommendation_service
+        logger.info("🔄 Starting background product indexing...")
+        asyncio.create_task(recommendation_service.index_products())
+    except Exception as e:
+        logger.error(f"❌ Error during background indexing: {e}")
 
 @app.get("/")
 async def root():
-return {"message": "✅ Ikarus Furniture Recommendation API is running!"}
+    return {"message": "✅ Ikarus Furniture Recommendation API is running!"}
 
 @app.get("/health")
 async def health():
-return {"status": "ok"}
-
-@app.post("/recommend")
-async def recommend(product: Product):
-recommendations = await recommendation_service.recommend_products(product)
-return recommendations
-
-@app.post("/generate-description")
-async def generate_description(product: Product):
-return await recommendation_service.generate_description(product)
+    return {"status": "ok"}

app/models.py

@@ -22,8 +22,8 @@ class RecommendationRequest(BaseModel):
     include_description: bool = True
 
 class GeneratedDescription(BaseModel):
+    text: str
     original: Optional[str] = None
-    generated: str
     timestamp: datetime = Field(default_factory=datetime.now)
 
 class RecommendedProduct(BaseModel):

app/routes/recommendations.py

@@ -15,10 +15,10 @@ from app.utils.data_loader import data_loader
 
 logger = logging.getLogger(__name__)
 
-router = APIRouter(prefix="/recommendations", tags=["Recommendations"])
+router = APIRouter(prefix="/api/recommendations", tags=["Recommendations"])
 
 
-@router.post("/", response_model=RecommendationResponse)
+@router.post("/search", response_model=RecommendationResponse)
 async def get_recommendations(req: RecommendationRequest):
     """
     Generate product recommendations based on a user's query.
@@ -91,3 +91,64 @@ async def get_recommendations(req: RecommendationRequest):
     except Exception as e:
         logger.error(f"❌ Error during recommendation: {e}", exc_info=True)
         raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/similar/{product_id}")
+async def get_similar_products(product_id: str, top_k: int = 5):
+    """
+    Get similar products based on a product ID.
+    """
+    try:
+        logger.info(f"🔍 Finding similar products for: {product_id}")
+        
+        # Get the product
+        product = data_loader.get_product_by_id(product_id)
+        if not product:
+            raise HTTPException(status_code=404, detail=f"Product {product_id} not found")
+        
+        # Get product embedding
+        product_vector = embedding_service.encode_product(product)
+        
+        # Query for similar products (top_k + 1 to exclude the product itself)
+        results = vector_db.query_vectors(product_vector, top_k=top_k + 1)
+        
+        # Build similar products list (skip first result as it's the same product)
+        similar_products = []
+        for match in results[1:top_k + 1]:
+            metadata = match.get("metadata", {}) if isinstance(match, dict) else getattr(match, "metadata", {})
+            
+            similar_product = Product(
+                uniq_id=metadata.get("uniq_id", ""),
+                title=metadata.get("title", "Unknown Product"),
+                brand=metadata.get("brand", None),
+                description=metadata.get("description", None),
+                price=metadata.get("price", None),
+                categories=metadata.get("categories", "").split(",") if isinstance(metadata.get("categories"), str) else [],
+                images=metadata.get("images", []),
+                manufacturer=metadata.get("manufacturer", None),
+                package_dimensions=metadata.get("package_dimensions", None),
+                country_of_origin=metadata.get("country_of_origin", None),
+                material=metadata.get("material", None),
+                color=metadata.get("color", None),
+            )
+            
+            similar_products.append(
+                RecommendedProduct(
+                    product=similar_product,
+                    score=float(match.get("score", 0.0) if isinstance(match, dict) else getattr(match, "score", 0.0)),
+                    generated_description=None,
+                )
+            )
+        
+        logger.info(f"✅ Found {len(similar_products)} similar products")
+        return {
+            "product_id": product_id,
+            "similar_products": similar_products,
+            "total": len(similar_products)
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"❌ Error finding similar products: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))

app/services/embedding_service.py

@@ -31,6 +31,51 @@ class EmbeddingService:
                 self.model = None
         else:
             logger.info("Gemini embedding not available; using local fallback.")
+    
+    async def embed_text(self, text: str) -> List[float]:
+        """Generate embedding for text query."""
+        try:
+            if self.model:
+                try:
+                    response = genai.embed_content(model=self.model, content=text, task_type="retrieval_query")
+                    emb = None
+                    if isinstance(response, dict) and "embedding" in response:
+                        emb = response["embedding"]
+                    else:
+                        emb = getattr(response, "embedding", None) or getattr(response, "embeddings", None)
+                    if emb:
+                        return list(emb)
+                except Exception as e:
+                    logger.warning("Provider embedding failed, falling back to local: %s", e)
+            return _text_to_vector(text, dim=settings.PINECONE_DIMENSION)
+        except Exception as e:
+            logger.exception("Error embedding text: %s", e)
+            raise
+    
+    def encode_product(self, product) -> List[float]:
+        """Encode product for embedding. (Synchronous wrapper)"""
+        from app.models import Product
+        text = " ".join(filter(None, [
+            getattr(product, "title", "") or "",
+            getattr(product, "brand", "") or "",
+            getattr(product, "description", "") or "",
+            getattr(product, "material", "") or "",
+            getattr(product, "color", "") or "",
+            ",".join(getattr(product, "categories", []) if getattr(product, "categories", None) else []),
+        ]))
+        if self.model:
+            try:
+                response = genai.embed_content(model=self.model, content=text, task_type="retrieval_document")
+                emb = None
+                if isinstance(response, dict) and "embedding" in response:
+                    emb = response["embedding"]
+                else:
+                    emb = getattr(response, "embedding", None) or getattr(response, "embeddings", None)
+                if emb:
+                    return list(emb)
+            except Exception as e:
+                logger.warning("Provider embedding failed, falling back to local: %s", e)
+        return _text_to_vector(text, dim=settings.PINECONE_DIMENSION)
 
 def _text_to_vector(text: str, dim: int = 1536):
     """Deterministic pseudo-embedding using SHA256 hashed chunks -> vector of floats in [-1,1]."""

app/services/genai_service.py

@@ -6,7 +6,7 @@ suitable for local testing and development.
 import logging
 from typing import List
 from app.config import settings
-from app.models import Product, GeneratedDescription
+from app.models import Product, GeneratedDescription, ChatMessage
 
 logger = logging.getLogger(__name__)
 try:
@@ -17,15 +17,17 @@ except Exception:
 
 class GenAIService:
     def __init__(self):
-        self.model = None
+        self.client = None
+        self.model_name = None
         if _HAS_GENAI and getattr(settings, "GEMINI_API_KEY", None):
             try:
                 genai.configure(api_key=settings.GEMINI_API_KEY)
-                self.model = getattr(settings, "GEMINI_MODEL", None) or "gpt-4o-mini"
-                logger.info("GenAI provider initialized with model %s", self.model)
+                self.model_name = getattr(settings, "GEMINI_MODEL", "gemini-2.5-flash")
+                self.client = genai.GenerativeModel(self.model_name)
+                logger.info("GenAI provider initialized with model %s", self.model_name)
             except Exception as e:
                 logger.warning("Failed to initialize GenAI provider, using local fallback: %s", e)
-                self.model = None
+                self.client = None
         else:
             logger.info("GenAI provider not available; using local fallback.")
 
@@ -41,37 +43,39 @@ class GenAIService:
             color = getattr(product, "color", "") or ""
             generated = f"{title} by {brand}. {desc} Material: {material}. Color: {color}."
             # Try provider if available
-            if self.model:
+            if self.client:
                 try:
                     prompt = f"Write a short product description for the following product:\n\nTitle: {title}\nBrand: {brand}\nDescription: {desc}\nMaterial: {material}\nColor: {color}\n\nKeep it under 80 words."
-                    response = genai.generate_text(model=self.model, prompt=prompt) if hasattr(genai, "generate_text") else None
-                    text = None
-                    if isinstance(response, dict):
-                        text = response.get("candidates", [{}])[0].get("content")
-                    elif response is not None:
-                        text = getattr(response, "text", None) or getattr(response, "content", None)
-                    if text:
-                        generated = text
+                    response = self.client.generate_content(prompt)
+                    if response and hasattr(response, 'text'):
+                        generated = response.text
                 except Exception as e:
                     logger.warning("External GenAI generation failed, using fallback: %s", e)
             # Return a simple GeneratedDescription-like object (dict) to avoid tight coupling
-            return GeneratedDescription(text=generated)
+            return GeneratedDescription(text=generated, original=desc)
         except Exception as e:
             logger.exception("Error generating product description: %s", e)
             return GeneratedDescription(text=str(e))
+    
+    async def generate_description(self, product: Product) -> str:
+        """Generate a product description and return just the text."""
+        try:
+            desc = self.generate_product_description(product)
+            return desc.text
+        except Exception as e:
+            logger.error(f"Error generating description: {e}")
+            return f"{product.title} - {product.description or 'No description available'}"
 
     def conversational_response(self, user_query: str, products: List[Product]) -> str:
         """Return a conversational assistant message. Fallback to simple template if provider unavailable."""
         try:
-            if self.model:
+            if self.client:
                 # Try provider chat style if available
                 try:
                     prompt = f"User asked: {user_query}\nReturn a short helpful message and summarize top {min(3,len(products))} product titles."
-                    response = genai.generate_text(model=self.model, prompt=prompt) if hasattr(genai, "generate_text") else None
-                    if isinstance(response, dict):
-                        return response.get("candidates", [{}])[0].get("content", "") or ""
-                    elif response is not None:
-                        return getattr(response, "text", "") or getattr(response, "content", "") or ""
+                    response = self.client.generate_content(prompt)
+                    if response and hasattr(response, 'text'):
+                        return response.text
                 except Exception as e:
                     logger.warning("External GenAI conversational failed: %s", e)
             # Local fallback
@@ -82,6 +86,56 @@ class GenAIService:
         except Exception as e:
             logger.exception("Error building conversational response: %s", e)
             return "Sorry, something went wrong."
+    
+    async def chat_response(self, message: str, conversation_history: List[ChatMessage]) -> str:
+        """Generate a chat response based on user message and conversation history."""
+        try:
+            if self.client:
+                try:
+                    # Build context from conversation history
+                    context = "\n".join([f"{msg.role}: {msg.content}" for msg in conversation_history[-5:]])
+                    prompt = f"""You are a helpful furniture shopping assistant. Based on the conversation history, respond to the user's query.
+
+Conversation History:
+{context}
+
+User: {message}
+
+Assistant:"""
+                    response = self.client.generate_content(prompt)
+                    if response and hasattr(response, 'text'):
+                        return response.text
+                except Exception as e:
+                    logger.warning(f"GenAI chat failed, using fallback: {e}")
+            
+            # Fallback response
+            return f"I understand you're looking for furniture. Let me find some recommendations for you based on: {message}"
+        except Exception as e:
+            logger.error(f"Error generating chat response: {e}")
+            return "I'm here to help you find furniture. What are you looking for?"
+    
+    def enhance_query(self, query: str) -> str:
+        """Enhance user query for better semantic search."""
+        try:
+            if self.client:
+                try:
+                    prompt = f"""Expand this furniture search query to include related terms and synonyms for better search results. Keep it concise (under 50 words).
+
+Query: {query}
+
+Expanded query:"""
+                    response = self.client.generate_content(prompt)
+                    if response and hasattr(response, 'text'):
+                        enhanced = response.text.strip()
+                        if enhanced and len(enhanced) < 200:
+                            return enhanced
+                except Exception as e:
+                    logger.warning(f"Query enhancement failed: {e}")
+            # Fallback: return original query
+            return query
+        except Exception as e:
+            logger.error(f"Error enhancing query: {e}")
+            return query
 
 # Global instance
 genai_service = GenAIService()

app/services/recommendation_service.py

@@ -26,15 +26,21 @@ class RecommendationService:
 
             for product in products:
                 try:
-                    embedding = await embedding_service.encode_product(product)
+                    # Use synchronous encode_product method
+                    embedding = embedding_service.encode_product(product)
                     metadata = {
                         "uniq_id": product.uniq_id,
                         "title": product.title,
                         "brand": product.brand or "",
+                        "description": product.description or "",
                         "price": product.price or "",
                         "categories": ",".join(product.categories) if product.categories else "",
+                        "images": product.images or [],
                         "material": product.material or "",
                         "color": product.color or "",
+                        "manufacturer": product.manufacturer or "",
+                        "package_dimensions": product.package_dimensions or "",
+                        "country_of_origin": product.country_of_origin or "",
                     }
                     vectors.append((product.uniq_id, embedding, metadata))
                 except Exception as e:
@@ -120,7 +126,8 @@ class RecommendationService:
                 logger.warning(f"Product not found: {product_id}")
                 return []
 
-            product_embedding = await embedding_service.encode_product(product)
+            # Use synchronous encode_product method
+            product_embedding = embedding_service.encode_product(product)
             results = vector_db.query_vectors(product_embedding, top_k=top_k + 1)
 
             recommendations = []