fyp

app/routes/search.py

@@ -1,21 +1,21 @@
 # ============================================================
-# app/routes/search.py - AIDA Dedicated Search Endpoint
+# app/routes/search.py - AIDA Live Search via WebSocket
 # ============================================================
 """
-Dedicated search endpoint for AIDA AI-powered property search.
-This endpoint is designed for search bars where users type natural language queries.
+Real-time search endpoint for AIDA AI-powered property search.
+WebSocket-based for live search as user types in search bar.
 No intent detection - directly processes search queries and returns listings.
 """
 
+import json
 import logging
-from fastapi import APIRouter, Depends, HTTPException, status
-from pydantic import BaseModel, Field
-from typing import Optional, List
-from bson import ObjectId
+import asyncio
+from datetime import datetime
+from fastapi import APIRouter, WebSocket, Query, WebSocketDisconnect
 
 from app.database import get_db
+from app.core.security import verify_token
 from app.models.listing import Listing
-from app.guards.jwt_guard import get_current_user
 
 # Import existing search logic
 from app.ai.agent.nodes.search_query import (
@@ -32,34 +32,6 @@ router = APIRouter(tags=["AIDA Search"])
 logger = logging.getLogger(__name__)
 
 
-# ============================================================
-# REQUEST/RESPONSE SCHEMAS
-# ============================================================
-
-class SearchRequestDto(BaseModel):
-    """Search request DTO"""
-    query: str = Field(
-        ..., 
-        min_length=1,
-        description="Natural language search query (e.g., 'I want a house of 52k in Cotonou')"
-    )
-    limit: Optional[int] = Field(
-        default=10,
-        ge=1,
-        le=50,
-        description="Maximum number of results to return"
-    )
-
-
-class SearchResponseDto(BaseModel):
-    """Search response DTO"""
-    success: bool
-    message: str  # AIDA's friendly message
-    data: List[dict]  # Standard listing format
-    total: int
-    search_params: Optional[dict] = None  # Extracted search parameters for debugging
-
-
 # ============================================================
 # AIDA MESSAGE GENERATOR
 # ============================================================
@@ -69,10 +41,7 @@ def generate_aida_message(
     search_params: dict,
     currency: str = "XOF"
 ) -> str:
-    """
-    Generate a short, friendly message from AIDA based on search results.
-    This is a lightweight version - no LLM call for speed.
-    """
+    """Generate a short, friendly message from AIDA based on search results."""
     count = len(results)
     location = search_params.get("location", "")
     max_price = search_params.get("max_price")
@@ -80,7 +49,6 @@ def generate_aida_message(
     listing_type = search_params.get("listing_type")
     bedrooms = search_params.get("bedrooms")
     
-    # Build context parts
     parts = []
     
     if location:
@@ -109,56 +77,35 @@ def generate_aida_message(
     
     if count == 0:
         if context:
-            return f"I couldn't find any properties {context}. Try adjusting your search criteria!"
-        return "I couldn't find any properties matching your search. Try a different query!"
+            return f"I couldn't find any properties {context}. Try adjusting your search!"
+        return "I couldn't find any properties matching your search."
     elif count == 1:
         if context:
-            return f"I found 1 property {context}! 🏠"
-        return "I found 1 property that matches your search! 🏠"
+            return f"Found 1 property {context}! 🏠"
+        return "Found 1 property! 🏠"
     else:
         if context:
             return f"Found {count} properties {context}! 🏠"
-        return f"Found {count} properties matching your search! 🏠"
+        return f"Found {count} properties! 🏠"
 
 
 # ============================================================
-# SEARCH ENDPOINT
+# SEARCH PROCESSING
 # ============================================================
 
-@router.post("/", response_model=SearchResponseDto)
-async def aida_search(
-    dto: SearchRequestDto,
-    current_user: Optional[dict] = Depends(get_current_user),
-):
+async def process_search(query: str, limit: int = 10) -> dict:
     """
-    AIDA AI-powered property search.
-    
-    Send a natural language query like:
-    - "I want a house of 52k in Cotonou"
-    - "2 bedroom apartment near the beach"
-    - "Cheap room for students in Porto-Novo"
-    
-    AIDA will:
-    1. Extract search parameters (location, price, bedrooms, etc.)
-    2. Search the database using hybrid search (semantic + filters)
-    3. Return listings in standard API format with a friendly message
-    
-    Requires: Bearer token in Authorization header
+    Process a search query and return formatted results.
     """
     
-    logger.info(f"AIDA Search: {dto.query[:50]}...")
-    
     try:
-        # STEP 1: Extract search parameters from natural language
-        search_params = await extract_search_params(dto.query)
+        # Extract search parameters from natural language
+        search_params = await extract_search_params(query)
         
         if not search_params:
-            logger.warning("Could not extract search parameters")
             search_params = {}
         
-        logger.info(f"Extracted params: {search_params}")
-        
-        # STEP 2: Infer currency from location
+        # Infer currency from location
         currency = "XOF"
         if search_params.get("location"):
             inferred = await infer_currency_from_location(search_params["location"])
@@ -167,82 +114,193 @@ async def aida_search(
             else:
                 currency = inferred or "XOF"
         
-        # STEP 3: Perform search
-        # Priority: MongoDB for location searches (exact match), Qdrant for semantic
+        # Perform search
         results = []
         
         if search_params.get("location"):
-            # Use MongoDB for exact location match
             results = await search_listings(search_params)
             
-            # If no results, try semantic search
             if not results:
-                logger.info("No exact matches, trying semantic search...")
                 results, _ = await search_listings_hybrid(
-                    user_query=dto.query,
+                    user_query=query,
                     search_params=search_params,
-                    limit=dto.limit,
+                    limit=limit,
                     mode="relaxed"
                 )
         else:
-            # Use semantic search for general queries
             results, _ = await search_listings_hybrid(
-                user_query=dto.query,
+                user_query=query,
                 search_params=search_params,
-                limit=dto.limit,
+                limit=limit,
                 mode="strict"
             )
             
             if not results:
                 results, _ = await search_listings_hybrid(
-                    user_query=dto.query,
+                    user_query=query,
                     search_params=search_params,
-                    limit=dto.limit,
+                    limit=limit,
                     mode="relaxed"
                 )
         
-        # STEP 4: Format listings to standard API format
+        # Format listings to standard API format
         formatted_listings = []
-        for doc in results[:dto.limit]:
-            # Ensure _id is string
+        for doc in results[:limit]:
             if "_id" in doc and not isinstance(doc["_id"], str):
                 doc["_id"] = str(doc["_id"])
             
-            # Remove internal fields (vector search metadata)
             doc.pop("_relevance_score", None)
             doc.pop("_is_suggestion", None)
             doc.pop("location_lower", None)
             doc.pop("listing_type_lower", None)
             
             try:
-                # Use Listing model to validate and format
                 listing = Listing(**doc)
                 formatted_listings.append(listing.model_dump(by_alias=True))
             except Exception as e:
-                # If validation fails, just use raw doc
                 logger.warning(f"Listing validation failed: {e}")
                 formatted_listings.append(doc)
         
-        # STEP 5: Generate AIDA message
+        # Generate AIDA message
         message = generate_aida_message(
             results=formatted_listings,
             search_params=search_params,
             currency=currency
         )
         
-        logger.info(f"Search complete: {len(formatted_listings)} results")
-        
-        return SearchResponseDto(
-            success=True,
-            message=message,
-            data=formatted_listings,
-            total=len(formatted_listings),
-            search_params=search_params
-        )
+        return {
+            "success": True,
+            "message": message,
+            "data": formatted_listings,
+            "total": len(formatted_listings),
+            "search_params": search_params,
+            "query": query,
+        }
     
     except Exception as e:
-        logger.error(f"AIDA Search error: {e}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Search failed: {str(e)}"
-        )
+        logger.error(f"Search processing error: {e}")
+        return {
+            "success": False,
+            "message": f"Search failed: {str(e)}",
+            "data": [],
+            "total": 0,
+            "query": query,
+        }
+
+
+# ============================================================
+# WEBSOCKET SEARCH ENDPOINT
+# ============================================================
+
+@router.websocket("/ws/search")
+async def websocket_search_endpoint(
+    websocket: WebSocket,
+    token: str = Query(...),
+):
+    """
+    WebSocket endpoint for real-time AIDA search.
+    Search runs as user types - no need to click send.
+    
+    Connect with: ws://localhost:8000/ws/search?token=YOUR_JWT_TOKEN
+    
+    Send messages:
+    {"type": "search", "query": "I want a house of 52k in Cotonou", "limit": 10}
+    {"type": "ping"}
+    
+    Receive messages:
+    {"type": "search_results", "success": true, "message": "...", "data": [...], "total": 5}
+    {"type": "searching", "query": "..."}  # Sent when search starts
+    {"type": "pong"}
+    {"type": "error", "message": "..."}
+    """
+    
+    # Verify JWT token
+    try:
+        user = verify_token(token)
+        if not user:
+            await websocket.close(code=4001, reason="Unauthorized")
+            return
+        logger.info(f"[WS Search] User authenticated: {user.get('email', 'unknown')}")
+    except Exception as e:
+        logger.error(f"[WS Search] Token verification failed: {e}")
+        await websocket.close(code=4001, reason="Unauthorized")
+        return
+    
+    await websocket.accept()
+    logger.info("[WS Search] Client connected")
+    
+    # Track current search task for cancellation
+    current_search_task = None
+    
+    try:
+        while True:
+            # Receive message from client
+            data = await websocket.receive_text()
+            message = json.loads(data)
+            
+            msg_type = message.get("type")
+            
+            if msg_type == "search":
+                query = message.get("query", "").strip()
+                limit = message.get("limit", 10)
+                
+                if not query:
+                    await websocket.send_json({
+                        "type": "search_results",
+                        "success": True,
+                        "message": "Start typing to search...",
+                        "data": [],
+                        "total": 0,
+                        "query": "",
+                    })
+                    continue
+                
+                # Cancel previous search if still running
+                if current_search_task and not current_search_task.done():
+                    current_search_task.cancel()
+                    try:
+                        await current_search_task
+                    except asyncio.CancelledError:
+                        pass
+                
+                # Notify client that search is starting
+                await websocket.send_json({
+                    "type": "searching",
+                    "query": query,
+                    "timestamp": datetime.utcnow().isoformat(),
+                })
+                
+                # Start search in background task
+                async def do_search():
+                    try:
+                        result = await process_search(query, limit)
+                        result["type"] = "search_results"
+                        result["timestamp"] = datetime.utcnow().isoformat()
+                        await websocket.send_json(result)
+                    except asyncio.CancelledError:
+                        pass
+                    except Exception as e:
+                        logger.error(f"[WS Search] Search error: {e}")
+                        await websocket.send_json({
+                            "type": "error",
+                            "message": str(e),
+                        })
+                
+                current_search_task = asyncio.create_task(do_search())
+            
+            elif msg_type == "ping":
+                await websocket.send_json({"type": "pong"})
+            
+            else:
+                await websocket.send_json({
+                    "type": "error",
+                    "message": f"Unknown message type: {msg_type}",
+                })
+    
+    except WebSocketDisconnect:
+        logger.info("[WS Search] Client disconnected")
+    except Exception as e:
+        logger.error(f"[WS Search] Error: {e}")
+    finally:
+        if current_search_task and not current_search_task.done():
+            current_search_task.cancel()

main.py

@@ -246,7 +246,7 @@ app.include_router(listing_router, prefix="/api/listings", tags=["Listings"])
 app.include_router(user_public_router, prefix="/api/users", tags=["Users"])
 app.include_router(ws_router, tags=["WebSocket"])
 app.include_router(reviews_router, prefix="/api/reviews", tags=["Reviews"])
-app.include_router(search_router, prefix="/api/search", tags=["AIDA Search"])
+app.include_router(search_router, tags=["AIDA Search"])
 
 logger.info("=" * 70)
 logger.info("✅ All routers registered successfully")