Update flask_Character.py

flask_Character.py

@@ -301,14 +301,14 @@ If a category has no items, its list should be empty (e.g., "contacts": []).
 Here is the required JSON schema for each category:
 
 - **contacts**: List of Contact objects.
-  Each Contact object must have:
+    Each Contact object must have:
     - `name` (string, full name)
     - `last_name` (string, last name) - You should infer this from the full name.
     - `email` (string, optional, null if not present)
     - `phone_number` (string, optional, null if not present)
 
 - **appointments**: List of Appointment objects.
-  Each Appointment object must have:
+    Each Appointment object must have:
     - `title` (string, short, meaningful title in Italian based on the meeting's purpose)
     - `description` (string, summary of the meeting's goal)
     - `start_date` (string, YYYY-MM-DD. If not explicitly mentioned, use "{prompt_today_str}" for "today", or "{prompt_tomorrow_str}" for "tomorrow")
@@ -317,7 +317,7 @@ Here is the required JSON schema for each category:
     - `end_time` (string, optional, e.g., "11:00 AM", null if not present)
 
 - **tasks**: List of Task objects.
-  Each Task object must have:
+    Each Task object must have:
     - `task_title` (string, short summary of action item)
     - `task_description` (string, more detailed explanation)
     - `due_date` (string, YYYY-MM-DD. Infer from context, e.g., "entro domani" becomes "{prompt_tomorrow_str}", "today" becomes "{prompt_today_str}")
@@ -390,163 +390,11 @@ def _generate_response_internal(
         traceback.print_exc() # Print full traceback to logs
         raise # Re-raise the exception so it can be caught by handle_single_reply_request
 
-# --- Batching and Caching Configuration ---
-MAX_BATCH_SIZE = 20
-BATCH_TIMEOUT = 0.5 # seconds (Adjust based on expected LLM response time and desired latency)
 
-reply_request_queue: List[Tuple[GenerateReplyRequest, asyncio.Future, float]] = []
-reply_queue_lock = asyncio.Lock()
-reply_queue_condition = asyncio.Condition(lock=reply_queue_lock)
-batch_processor_task: Optional[asyncio.Task] = None
-
-
-# --- Batch Processor and Handler ---
-async def handle_single_reply_request(request_data: GenerateReplyRequest, future: asyncio.Future):
-    """Handles a single request: checks cache, calls LLM, stores result, and sets future."""
-    print(f"[{datetime.now()}] Handle single reply: Starting for email_text_start='{request_data.email_text[:50]}'...")
-    if future.cancelled():
-        print(f"[{datetime.now()}] Handle single reply: Future cancelled. Aborting.")
-        return
-    try:
-        if generated_replies_collection is None:
-            print(f"[{datetime.now()}] Handle single reply: DB collection 'generated_replies_collection' is None.")
-            if not future.done():
-                future.set_exception(HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Database service not available for caching/storage."))
-            return
-
-        cache_query = {
-            "original_email_text": request_data.email_text,
-            "language": request_data.language,
-            "length": request_data.length,
-            "style": request_data.style,
-            "tone": request_data.tone,
-            "emoji": request_data.emoji,
-        }
-        print(f"[{datetime.now()}] Handle single reply: Checking cache for reply...")
-        # Use await asyncio.to_thread for blocking MongoDB operations
-        cached_reply_doc = await asyncio.to_thread(generated_replies_collection.find_one, cache_query)
-
-        if cached_reply_doc:
-            print(f"[{datetime.now()}] Handle single reply: Reply found in cache. ID: {str(cached_reply_doc['_id'])}")
-            response = {
-                "reply": cached_reply_doc["generated_reply_text"],
-                "stored_id": str(cached_reply_doc["_id"]),
-                "cached": True
-            }
-            if not future.done():
-                future.set_result(response)
-            print(f"[{datetime.now()}] Handle single reply: Cache result set on future.")
-            return
-
-        print(f"[{datetime.now()}] Handle single reply: Reply not in cache. Calling LLM...")
-        reply_content = await asyncio.to_thread(
-            _generate_response_internal,
-            request_data.email_text,
-            request_data.groq_api_key,
-            request_data.language,
-            request_data.length,
-            request_data.style,
-            request_data.tone,
-            request_data.emoji
-        )
-        print(f"[{datetime.now()}] Handle single reply: LLM call completed. Reply length: {len(reply_content)}.")
-
-        reply_data_to_store = GeneratedReplyData(
-            original_email_text=request_data.email_text,
-            generated_reply_text=reply_content,
-            language=request_data.language,
-            length=request_data.length,
-            style=request_data.style,
-            tone=request_data.tone,
-            emoji=request_data.emoji
-        )
-        print(f"[{datetime.now()}] Handle single reply: Storing reply in DB...")
-        # Use model_dump for Pydantic v2
-        reply_data_dict = reply_data_to_store.model_dump(by_alias=True, exclude_none=True, exclude={'id'})
-
-        insert_result = await asyncio.to_thread(generated_replies_collection.insert_one, reply_data_dict)
-        stored_id = str(insert_result.inserted_id)
-        print(f"[{datetime.now()}] Handle single reply: Reply stored in DB. ID: {stored_id}")
-
-        final_response = {
-            "reply": reply_content,
-            "stored_id": stored_id,
-            "cached": False
-        }
-        if not future.done():
-            future.set_result(final_response)
-        print(f"[{datetime.now()}] Handle single reply: Final result set on future.")
-
-    except Exception as e:
-        print(f"[{datetime.now()}] Handle single reply: EXCEPTION: {e}")
-        traceback.print_exc() # Print full traceback to logs
-        if not future.done():
-            # Set the exception on the future so the client can catch it
-            future.set_exception(HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Failed to generate reply: {e}"))
-        print(f"[{datetime.now()}] Handle single reply: Exception set on future.")
-
-
-async def process_reply_batches():
-    """Continuously processes requests from the reply_request_queue in batches."""
-    global reply_request_queue
-    print(f"[{datetime.now()}] Batch processor task started.")
-    while True:
-        batch_to_fire: List[Tuple[GenerateReplyRequest, asyncio.Future]] = []
-        async with reply_queue_condition:
-            if not reply_request_queue:
-                print(f"[{datetime.now()}] Batch processor: Queue empty, waiting for requests...")
-                # Wait for new requests or timeout
-                await reply_queue_condition.wait()
-                # After waking up, re-check if queue is still empty
-                if not reply_request_queue:
-                    print(f"[{datetime.now()}] Batch processor: Woke up, queue still empty. Continuing loop.")
-                    continue
-
-            now = asyncio.get_event_loop().time()
-            # Safety check: ensure queue is not empty before accessing index 0
-            if reply_request_queue:
-                oldest_item_timestamp = reply_request_queue[0][2]
-            else:
-                # If queue became empty while waiting, loop again
-                print(f"[{datetime.now()}] Batch processor: Queue became empty before processing. Restarting loop.")
-                continue
-
-            print(f"[{datetime.now()}] Batch processor: Woke up. Queue size: {len(reply_request_queue)}. Oldest item age: {now - oldest_item_timestamp:.2f}s")
-
-            # Condition to trigger batch processing: queue is full OR timeout reached for oldest item
-            if len(reply_request_queue) >= MAX_BATCH_SIZE or \
-               (now - oldest_item_timestamp >= BATCH_TIMEOUT):
-                num_to_take = min(len(reply_request_queue), MAX_BATCH_SIZE)
-                for _ in range(num_to_take):
-                    # Safety check: ensure queue is not empty before popping
-                    if reply_request_queue:
-                        req, fut, _ = reply_request_queue.pop(0)
-                        batch_to_fire.append((req, fut))
-                print(f"[{datetime.now()}] Batch processor: Firing batch of {len(batch_to_fire)} requests.")
-            else:
-                # Calculate time to wait for the next batch or timeout
-                time_to_wait = BATCH_TIMEOUT - (now - oldest_item_timestamp)
-                print(f"[{datetime.now()}] Batch processor: Not enough requests or timeout not reached. Waiting for {time_to_wait:.2f}s.")
-                try:
-                    await asyncio.wait_for(reply_queue_condition.wait(), timeout=time_to_wait)
-                except asyncio.TimeoutError:
-                    print(f"[{datetime.now()}] Batch processor: wait timed out.")
-                    pass # Loop will re-evaluate and likely fire the batch
-
-        if batch_to_fire:
-            tasks = [handle_single_reply_request(req_data, fut) for req_data, fut in batch_to_fire]
-            print(f"[{datetime.now()}] Batch processor: Awaiting completion of {len(tasks)} single reply tasks.")
-            await asyncio.gather(*tasks)
-            print(f"[{datetime.now()}] Batch processor: Batch processing complete.")
-        else:
-            # Short sleep to prevent busy-waiting if queue is empty but not waiting
-            await asyncio.sleep(0.001)
-
-
-# ---------------------- FastAPI Application ----------------------
+# --- FastAPI Application ---
 app = FastAPI(
     title="Email Assistant API",
-    description="API for extracting structured data from emails and generating intelligent replies using Groq LLMs, with MongoDB integration, dynamic date handling, batching, and caching.",
+    description="API for extracting structured data from emails and generating intelligent replies using Groq LLMs, with MongoDB integration, dynamic date handling, and caching.",
     version="1.1.0",
     docs_url="/", # Sets Swagger UI to be the root path
     redoc_url="/redoc"
@@ -574,10 +422,10 @@ async def global_exception_handler_wrapper(request, exc):
     )
 
 
-# --- FastAPI Event Handlers for MongoDB & Batch Processor ---
+# --- FastAPI Event Handlers for MongoDB ---
 @app.on_event("startup")
 async def startup_event():
-    global client, db, extracted_emails_collection, generated_replies_collection, batch_processor_task
+    global client, db, extracted_emails_collection, generated_replies_collection
     print(f"[{datetime.now()}] FastAPI app startup sequence initiated.")
     try:
         # Connect to MongoDB
@@ -588,13 +436,6 @@ async def startup_event():
         generated_replies_collection = db[GENERATED_REPLIES_COLLECTION]
         print(f"[{datetime.now()}] Successfully connected to MongoDB: {DB_NAME}")
 
-        # Start the batch processor task if not already running
-        if batch_processor_task is None or batch_processor_task.done():
-            batch_processor_task = asyncio.create_task(process_reply_batches())
-            print(f"[{datetime.now()}] Batch processor task for replies started.")
-        else:
-            print(f"[{datetime.now()}] Batch processor task for replies is already running or being initialized.")
-
     except (ConnectionFailure, OperationFailure) as e:
         print(f"[{datetime.now()}] ERROR: MongoDB Connection/Operation Failure: {e}")
         client = None
@@ -602,7 +443,7 @@ async def startup_event():
         extracted_emails_collection = None
         generated_replies_collection = None
     except Exception as e:
-        print(f"[{datetime.now()}] ERROR: An unexpected error occurred during MongoDB connection or batch startup: {e}")
+        print(f"[{datetime.now()}] ERROR: An unexpected error occurred during MongoDB connection startup: {e}")
         traceback.print_exc()
         client = None
         db = None
@@ -619,25 +460,13 @@ async def startup_event():
             print(f"[{datetime.now()}] MongoDB client or db object is None after connection attempt in startup. Database likely not connected.")
             if client is None or db is None:
                 client = None; db = None; extracted_emails_collection = None; generated_replies_collection = None
-        print(f"[{datetime.now()}] FastAPI app startup sequence completed for MongoDB client & Batch Processor initialization.")
+        print(f"[{datetime.now()}] FastAPI app startup sequence completed for MongoDB client initialization.")
 
 
 @app.on_event("shutdown")
 async def shutdown_event():
-    global client, batch_processor_task
+    global client
     print(f"[{datetime.now()}] FastAPI app shutting down.")
-    if batch_processor_task:
-        batch_processor_task.cancel()
-        try:
-            await batch_processor_task
-            print(f"[{datetime.now()}] Batch processor task awaited.")
-        except asyncio.CancelledError:
-            print(f"[{datetime.now()}] Batch processor task for replies cancelled during shutdown.")
-        except Exception as e:
-            print(f"[{datetime.now()}] Error during batch processor task shutdown: {e}")
-            traceback.print_exc()
-        batch_processor_task = None
-
     if client:
         client.close()
         print(f"[{datetime.now()}] MongoDB client closed.")
@@ -647,7 +476,7 @@ async def shutdown_event():
 @app.get("/health", summary="Health Check")
 async def health_check():
     """
-    Checks the health of the API, including MongoDB connection and batch processor status.
+    Checks the health of the API, including MongoDB connection.
     """
     db_status = "MongoDB not connected."
     db_ok = False
@@ -661,206 +490,202 @@ async def health_check():
             db_status = f"MongoDB connection error: {e}"
             db_ok = False
 
-    batch_processor_status = "Batch processor not running."
-    if batch_processor_task is not None:
-        if not batch_processor_task.done():
-            batch_processor_status = "Batch processor is running."
-        else:
-            if batch_processor_task.exception():
-                batch_processor_status = f"Batch processor task ended with exception: {batch_processor_task.exception()}"
-            else:
-                batch_processor_status = "Batch processor task is done (may have completed or cancelled)."
-    else:
-        batch_processor_status = "Batch processor task has not been initialized."
-
     if db_ok:
-        return {"status": "ok", "message": "Email Assistant API is up.", "database": db_status, "batch_processor": batch_processor_status}
+        return {"status": "ok", "message": "Email Assistant API is up.", "database": db_status}
     else:
         raise HTTPException(
-            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-            detail={"message": "Service unavailable due to issues.", "database": db_status, "batch_processor": batch_processor_status}
+            status_code=503,
+            detail={"message": "Service unavailable.", "database": db_status}
         )
 
 
-@app.post("/extract-data", response_model=ExtractedData, summary="Extract structured data from an email and store in MongoDB")
-async def extract_email_data(request: ProcessEmailRequest):
+@app.post("/generate-reply", response_model=GenerateReplyResponse, summary="Generate a smart reply to an email")
+async def generate_email_reply(request: GenerateReplyRequest):
     """
-    Receives an email, extracts contacts, appointments, and tasks using an LLM,
-    and stores the extracted data in MongoDB.
+    Generates a smart reply to the provided email text using an LLM.
+    The generated reply is also stored in MongoDB for caching and historical purposes.
     """
-    print(f"[{datetime.now()}] /extract-data: Received request.")
-    if extracted_emails_collection is None:
-        print(f"[{datetime.now()}] /extract-data: MongoDB collection is None.")
-        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="MongoDB not available for extracted email storage. Check server startup logs.")
+    if generated_replies_collection is None:
+        raise HTTPException(status_code=503, detail="MongoDB not available for generated_replies.")
+
     try:
-        current_date_val = date.today()
-        print(f"[{datetime.now()}] /extract-data: Calling internal processing function.")
-        extracted_data = await asyncio.to_thread(
-            _process_email_internal, request.email_text, request.groq_api_key, current_date_val
+        # Check cache first
+        cache_query = {
+            "original_email_text": request.email_text,
+            "language": request.language,
+            "length": request.length,
+            "style": request.style,
+            "tone": request.tone,
+            "emoji": request.emoji,
+        }
+        print(f"[{datetime.now()}] /generate-reply: Checking cache for reply...")
+        # Use asyncio.to_thread for blocking MongoDB operations
+        cached_reply_doc = await asyncio.to_thread(generated_replies_collection.find_one, cache_query)
+
+        if cached_reply_doc:
+            print(f"[{datetime.now()}] /generate-reply: Reply found in cache. ID: {str(cached_reply_doc['_id'])}")
+            return GenerateReplyResponse(
+                reply=cached_reply_doc["generated_reply_text"],
+                stored_id=str(cached_reply_doc["_id"]),
+                cached=True
+            )
+
+        # If not in cache, directly call the internal LLM function
+        print(f"[{datetime.now()}] /generate-reply: Reply not in cache. Calling LLM for generation...")
+        reply_content = await asyncio.to_thread(
+            _generate_response_internal,
+            request.email_text,
+            request.groq_api_key,
+            request.language,
+            request.length,
+            request.style,
+            request.tone,
+            request.emoji
         )
-        print(f"[{datetime.now()}] /extract-data: Internal processing complete. Preparing for DB insert.")
+        print(f"[{datetime.now()}] /generate-reply: LLM call completed. Storing newly generated reply in MongoDB.")
 
-        extracted_data_dict = extracted_data.model_dump(by_alias=True, exclude_none=True)
-        # Convert date objects to datetime for MongoDB storage if they are just date objects
-        # Pydantic's default `date` handling might serialize to ISO string, but for
-        # internal MongoDB storage, sometimes `datetime` is preferred for consistency.
-        if 'appointments' in extracted_data_dict:
-            for appt in extracted_data_dict['appointments']:
-                if isinstance(appt.get('start_date'), date):
-                    appt['start_date'] = datetime.combine(appt['start_date'], datetime.min.time())
-                if isinstance(appt.get('end_date'), date) and appt.get('end_date') is not None:
-                    appt['end_date'] = datetime.combine(appt['end_date'], datetime.min.time())
-        if 'tasks' in extracted_data_dict:
-            for task_item in extracted_data_dict['tasks']:
-                if isinstance(task_item.get('due_date'), date):
-                    task_item['due_date'] = datetime.combine(task_item['due_date'], datetime.min.time())
+        # Prepare data for storage
+        reply_data_to_store = GeneratedReplyData(
+            original_email_text=request.email_text,
+            generated_reply_text=reply_content,
+            language=request.language,
+            length=request.length,
+            style=request.style,
+            tone=request.tone,
+            emoji=request.emoji
+        )
+        # Use model_dump for Pydantic v2. Exclude 'id' as it's generated by MongoDB.
+        reply_data_dict = reply_data_to_store.model_dump(by_alias=True, exclude_none=True, exclude={'id'})
 
-        print(f"[{datetime.now()}] /extract-data: Inserting into MongoDB...")
-        result = await asyncio.to_thread(extracted_emails_collection.insert_one, extracted_data_dict)
-        print(f"[{datetime.now()}] /extract-data: Data inserted into MongoDB. ID: {result.inserted_id}")
+        # Insert into MongoDB
+        insert_result = await asyncio.to_thread(generated_replies_collection.insert_one, reply_data_dict)
+        stored_id = str(insert_result.inserted_id) # Convert ObjectId to string for the response
 
-        extracted_data.id = result.inserted_id
-        return extracted_data
-    except ValueError as e:
-        print(f"[{datetime.now()}] /extract-data: ValueError: {e}")
-        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(e))
+        print(f"[{datetime.now()}] /generate-reply: Reply stored in MongoDB. ID: {stored_id}")
+
+        # Return the response as per GenerateReplyResponse model
+        return GenerateReplyResponse(
+            reply=reply_content,
+            stored_id=stored_id,
+            cached=False # Always False since we just generated it
+        )
     except Exception as e:
-        print(f"[{datetime.now()}] /extract-data: Unhandled Exception: {e}")
         traceback.print_exc()
-        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Internal server error during data extraction: {e}")
-
+        # Ensure consistent error response
+        raise HTTPException(status_code=500, detail=f"Error generating or storing reply: {str(e)}")
 
-@app.post("/extract-data-excel", summary="Extract structured data and download as Excel (also stores in MongoDB)")
-async def extract_email_data_excel(request: ProcessEmailRequest):
-    """
-    Placeholder for future functionality to extract data and provide as an Excel download.
-    Currently disabled.
-    """
-    raise HTTPException(status_code=status.HTTP_501_NOT_IMPLEMENTED, detail="Excel functionality is currently disabled.")
-
-
-@app.post("/generate-reply", response_model=GenerateReplyResponse, summary="Generate a smart reply to an email (batched & cached)")
-async def generate_email_reply(request: GenerateReplyRequest):
+@app.post("/extract-data", response_model=ExtractedData, summary="Extract structured data from an email")
+async def extract_email_data(request: ProcessEmailRequest):
     """
-    Generates an intelligent email reply based on specified parameters (language, length, style, tone, emoji).
-    Uses a batch processing system with caching for efficiency.
+    Extracts contacts, appointments, and tasks from the provided email text.
     """
-    print(f"[{datetime.now()}] /generate-reply: Received request.")
-    if generated_replies_collection is None or batch_processor_task is None or reply_queue_condition is None:
-        print(f"[{datetime.now()}] /generate-reply: Service not initialized. gen_replies_coll={generated_replies_collection is not None}, batch_task={batch_processor_task is not None}, queue_cond={reply_queue_condition is not None}")
-        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Reply generation service not fully initialized. Check server logs for database or batch processor issues.")
-
-    future = asyncio.Future()
-    current_time = asyncio.get_event_loop().time()
-
-    async with reply_queue_condition:
-        reply_request_queue.append((request, future, current_time))
-        reply_queue_condition.notify() # Notify the batch processor that a new request is available
-        print(f"[{datetime.now()}] /generate-reply: Request added to queue, notifying batch processor. Queue size: {len(reply_request_queue)}")
+    if extracted_emails_collection is None:
+        raise HTTPException(status_code=503, detail="MongoDB not available.")
+    
+    current_date = date.today() # Get current date for context
 
+    print(f"[{datetime.now()}] /extract-data: Received request.")
     try:
-        # Debugging: Increase timeout significantly to allow full tracing in logs
-        client_timeout = BATCH_TIMEOUT + 60.0 # Example: 0.5s batch + 60s LLM response buffer = 60.5s total timeout
-        print(f"[{datetime.now()}] /generate-reply: Waiting for future result with timeout {client_timeout}s.")
-        result = await asyncio.wait_for(future, timeout=client_timeout)
-        print(f"[{datetime.now()}] /generate-reply: Future result received. Returning data.")
-        return result
-    except asyncio.TimeoutError:
-        print(f"[{datetime.now()}] /generate-reply: Client timeout waiting for future after {client_timeout}s. Future done: {future.done()}")
-        if not future.done():
-            future.cancel() # Cancel if it's still pending
-        raise HTTPException(status_code=status.HTTP_504_GATEWAY_TIMEOUT, detail=f"Request timed out after {client_timeout}s waiting for batch processing. The LLM might be busy or the request queue too long. Check server logs for more details.")
+        print(f"[{datetime.now()}] /extract-data: Calling internal processing function.")
+        # Run blocking LLM call in a thread pool
+        extracted_data = await asyncio.to_thread(_process_email_internal, request.email_text, request.groq_api_key, current_date)
+        
+        print(f"[{datetime.now()}] /extract-data: Internal processing complete. Preparing for DB insert.")
+        # Convert Pydantic model to dictionary for MongoDB insert, handling _id alias
+        # Use model_dump for Pydantic v2
+        data_to_insert = extracted_data.model_dump(by_alias=True, exclude_none=True, exclude={'id'})
+
+        print(f"[{datetime.now()}] /extract-data: Inserting into MongoDB...")
+        # Use asyncio.to_thread for blocking MongoDB insert operation
+        insert_result = await asyncio.to_thread(extracted_emails_collection.insert_one, data_to_insert)
+        
+        # Update the extracted_data object with the MongoDB-generated ID
+        extracted_data.id = str(insert_result.inserted_id)
+        print(f"[{datetime.now()}] /extract-data: Data inserted into MongoDB. ID: {extracted_data.id}")
+        
+        return extracted_data
+    except ValueError as ve:
+        raise HTTPException(status_code=400, detail=str(ve))
     except Exception as e:
-        if isinstance(e, HTTPException):
-            print(f"[{datetime.now()}] /generate-reply: Caught HTTPException: {e.status_code} - {e.detail}")
-            raise e # Re-raise FastAPI HTTPExceptions
-        print(f"[{datetime.now()}] /generate-reply: Unhandled Exception: {e}")
-        traceback.print_exc()
-        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Error processing your reply request: {str(e)}. Check server logs for more details.")
+        traceback.print_exc() # Print full traceback for debugging
+        raise HTTPException(status_code=500, detail=f"An internal server error occurred: {e}")
 
 
-@app.get("/query-extracted-emails", response_model=List[ExtractedData], summary="Query extracted emails from MongoDB")
-async def query_extracted_emails_endpoint(query_params: ExtractedEmailQuery = Depends()):
-    print(f"[{datetime.now()}] /query-extracted-emails: Received request with params: {query_params.model_dump_json()}")
+@app.get("/query-extracted-emails", response_model=List[ExtractedData], summary="Query stored extracted email data")
+async def query_extracted_emails(query_params: ExtractedEmailQuery = Depends()):
+    """
+    Queries extracted email data from MongoDB based on various filters.
+    """
     if extracted_emails_collection is None:
-        print(f"[{datetime.now()}] /query-extracted-emails: MongoDB collection is None.")
-        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="MongoDB not available for querying extracted emails.")
-    mongo_query: Dict[str, Any] = {}
+        raise HTTPException(status_code=503, detail="MongoDB not available.")
+
+    mongo_query = {}
     if query_params.contact_name:
-        mongo_query["contacts.name"] = {"$regex": query_params.contact_name, "$options": "i"} # Case-insensitive regex
+        # Case-insensitive partial match on contact name or last name
+        mongo_query["$or"] = [
+            {"contacts.name": {"$regex": query_params.contact_name, "$options": "i"}},
+            {"contacts.last_name": {"$regex": query_params.contact_name, "$options": "i"}}
+        ]
     if query_params.appointment_title:
         mongo_query["appointments.title"] = {"$regex": query_params.appointment_title, "$options": "i"}
     if query_params.task_title:
         mongo_query["tasks.task_title"] = {"$regex": query_params.task_title, "$options": "i"}
 
-    if query_params.from_date or query_params.to_date:
-        date_query: Dict[str, datetime] = {}
-        if query_params.from_date:
-            date_query["$gte"] = datetime.combine(query_params.from_date, datetime.min.time())
-        if query_params.to_date:
-            # Query up to the end of the 'to_date' day
-            date_query["$lt"] = datetime.combine(query_params.to_date + timedelta(days=1), datetime.min.time())
-        if date_query :
-            mongo_query["processed_at"] = date_query
-    print(f"[{datetime.now()}] /query-extracted-emails: MongoDB query built: {mongo_query}")
+    # Date range filtering for processed_at
+    date_query = {}
+    if query_params.from_date:
+        date_query["$gte"] = datetime.combine(query_params.from_date, datetime.min.time())
+    if query_params.to_date:
+        date_query["$lte"] = datetime.combine(query_params.to_date, datetime.max.time())
+    if date_query:
+        mongo_query["processed_at"] = date_query
 
     try:
-        # Use await asyncio.to_thread for blocking MongoDB operations
-        cursor = extracted_emails_collection.find(mongo_query).sort("processed_at", -1).limit(query_params.limit)
-        extracted_docs_raw = await asyncio.to_thread(list, cursor)
-        print(f"[{datetime.now()}] /query-extracted-emails: Found {len(extracted_docs_raw)} documents.")
-
-        results = []
-        for doc_raw in extracted_docs_raw:
-            # Convert datetime objects back to date for Pydantic model validation if necessary
-            if 'appointments' in doc_raw:
-                for appt in doc_raw['appointments']:
-                    if isinstance(appt.get('start_date'), datetime): appt['start_date'] = appt['start_date'].date()
-                    if isinstance(appt.get('end_date'), datetime): appt['end_date'] = appt['end_date'].date()
-            if 'tasks' in doc_raw:
-                for task_item in doc_raw['tasks']:
-                    if isinstance(task_item.get('due_date'), datetime): task_item['due_date'] = task_item['due_date'].date()
-            results.append(ExtractedData(**doc_raw))
-        print(f"[{datetime.now()}] /query-extracted-emails: Returning {len(results)} results.")
-        return results
+        # Use asyncio.to_thread for blocking MongoDB find operation
+        cursor = await asyncio.to_thread(extracted_emails_collection.find, mongo_query)
+        # Use to_list to limit results and convert to list
+        results = await asyncio.to_thread(lambda: list(cursor.limit(query_params.limit)))
+        
+        # Convert MongoDB documents to ExtractedData Pydantic models
+        return [ExtractedData(**doc) for doc in results]
     except Exception as e:
-        print(f"[{datetime.now()}] /query-extracted-emails: Unhandled Exception during query: {e}")
         traceback.print_exc()
-        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Error querying extracted emails: {e}")
+        raise HTTPException(status_code=500, detail=f"Error querying extracted emails: {e}")
 
 
-@app.get("/query-generated-replies", response_model=List[GeneratedReplyData], summary="Query generated replies from MongoDB")
-async def query_generated_replies_endpoint(query_params: GeneratedReplyQuery = Depends()):
-    print(f"[{datetime.now()}] /query-generated-replies: Received request with params: {query_params.model_dump_json()}")
+@app.get("/query-generated-replies", response_model=List[GeneratedReplyData], summary="Query stored generated replies")
+async def query_generated_replies(query_params: GeneratedReplyQuery = Depends()):
+    """
+    Queries generated email replies from MongoDB based on various filters.
+    """
     if generated_replies_collection is None:
-        print(f"[{datetime.now()}] /query-generated-replies: MongoDB collection is None.")
-        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="MongoDB not available for querying generated replies.")
-    mongo_query: Dict[str, Any] = {}
-    if query_params.language: mongo_query["language"] = query_params.language
-    if query_params.style: mongo_query["style"] = query_params.style
-    if query_params.tone: mongo_query["tone"] = query_params.tone
-
-    if query_params.from_date or query_params.to_date:
-        date_query: Dict[str, datetime] = {}
-        if query_params.from_date:
-            date_query["$gte"] = datetime.combine(query_params.from_date, datetime.min.time())
-        if query_params.to_date:
-            date_query["$lt"] = datetime.combine(query_params.to_date + timedelta(days=1), datetime.min.time())
-        if date_query:
-            mongo_query["generated_at"] = date_query
-    print(f"[{datetime.now()}] /query-generated-replies: MongoDB query built: {mongo_query}")
+        raise HTTPException(status_code=503, detail="MongoDB not available.")
+
+    mongo_query = {}
+    if query_params.language:
+        mongo_query["language"] = query_params.language
+    if query_params.style:
+        mongo_query["style"] = query_params.style
+    if query_params.tone:
+        mongo_query["tone"] = query_params.tone
+
+    # Date range filtering for generated_at
+    date_query = {}
+    if query_params.from_date:
+        date_query["$gte"] = datetime.combine(query_params.from_date, datetime.min.time())
+    if query_params.to_date:
+        date_query["$lte"] = datetime.combine(query_params.to_date, datetime.max.time())
+    if date_query:
+        mongo_query["generated_at"] = date_query
 
     try:
-        # Use await asyncio.to_thread for blocking MongoDB operations
-        cursor = generated_replies_collection.find(mongo_query).sort("generated_at", -1).limit(query_params.limit)
-        generated_docs_raw = await asyncio.to_thread(list, cursor)
-        print(f"[{datetime.now()}] /query-generated-replies: Found {len(generated_docs_raw)} documents.")
-        results = []
-        for doc_raw in generated_docs_raw:
-            results.append(GeneratedReplyData(**doc_raw))
-        print(f"[{datetime.now()}] /query-generated-replies: Returning {len(results)} results.")
-        return results
+        # Use asyncio.to_thread for blocking MongoDB find operation
+        cursor = await asyncio.to_thread(generated_replies_collection.find, mongo_query)
+        # Use to_list to limit results and convert to list
+        results = await asyncio.to_thread(lambda: list(cursor.limit(query_params.limit)))
+        
+        # Convert MongoDB documents to GeneratedReplyData Pydantic models
+        return [GeneratedReplyData(**doc) for doc in results]
     except Exception as e:
-        print(f"[{datetime.now()}] /query-generated-replies: Unhandled Exception during query: {e}")
         traceback.print_exc()
-        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=f"Error querying generated replies: {e}")
+        raise HTTPException(status_code=500, detail=f"Error querying generated replies: {e}")