fix(news): Add time-based filtering and cache-control to /latest endpoint

PROBLEM:
- /api/v1/news/latest endpoint was returning old cached articles
- No time-based filtering on browse queries
- Browser/CDN caching causing stale data display
- Qdrant scroll returning results in insertion order, not by date

SOLUTION:
1. Added days_back parameter to browse() method (default: 7 days for /latest)
2. Implemented Qdrant order_by for server-side sorting by published_at DESC
3. Added fallback for older Qdrant versions without order_by support
4. Added Cache-Control headers to prevent browser/CDN caching
5. Updated VectorStorePort interface to support time-based filtering

CHANGES:
- src/infrastructure/adapters/qdrant_adapter.py:
* Added days_back parameter to browse() method
* Added datetime range filter using published_at field
* Implemented order_by with published_at DESC for server-side sorting
* Added fallback logic for Qdrant versions without order_by support
* Enhanced error handling with retry logic

- src/core/ports/vector_store_port.py:
* Updated browse() interface to include days_back parameter
* Added documentation for time-based filtering

- src/api/routes/news.py:
* Added days_back query parameter (default: 7, range: 1-30)
* Added Cache-Control, Pragma, and Expires headers to prevent caching
* Removed redundant client-side sorting (now done by Qdrant)
* Imported Response from FastAPI for header manipulation

IMPACT:
- Fresh news articles always displayed (last 7 days by default)
- No browser/CDN caching of news results
- Better performance with server-side sorting
- Configurable time window (1-30 days)
- Backward compatible with older Qdrant versions

TESTING:
- Endpoint: GET /api/v1/news/latest?limit=6&days_back=7
- Expected: Articles from last 7 days, sorted newest first
- Headers: Cache-Control: no-cache, no-store, must-revalidate

Version: v2.2

src/api/routes/news.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Query, HTTPException, Depends
+from fastapi import APIRouter, Query, HTTPException, Depends, Response
 from typing import Optional
 from src.core.ports.vector_store_port import VectorStorePort
 from src.core.ports.embedder_port import EmbedderPort
@@ -36,24 +36,34 @@ def _dict_to_article(payload: dict, score: float = None) -> NewsArticle:
 
 @router.get("/latest", response_model=BrowseResponse)
 def get_latest_news(
+    response: Response,
     limit: int = Query(10, le=50),
     source: Optional[str] = None,
     language: Optional[str] = None,
+    days_back: int = Query(7, ge=1, le=30, description="Number of days to look back (default: 7)"),
     vector_store: VectorStorePort = Depends(get_vector_store_port)
 ):
-    """Get latest news articles sorted by publication date"""
+    """Get latest news articles sorted by publication date (default: last 7 days)"""
+    # Prevent caching of news results - always fetch fresh data
+    response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate, max-age=0"
+    response.headers["Pragma"] = "no-cache"
+    response.headers["Expires"] = "0"
+    
     try:
-        result = vector_store.browse(limit=limit, offset=0, source=source, language=language)
+        result = vector_store.browse(
+            limit=limit, 
+            offset=0, 
+            source=source, 
+            language=language,
+            days_back=days_back
+        )
         
-        # Convert Qdrant points to articles and sort by published_at
+        # Convert Qdrant points to articles (already sorted by Qdrant)
         articles = []
         for p in result["articles"]:
             article = _dict_to_article(p.payload or {}, getattr(p, "score", None))
             articles.append(article)
         
-        # Sort by published_at descending (latest first)
-        articles.sort(key=lambda x: x.published_at or "", reverse=True)
-        
         # Ensure next_offset is an integer or None
         next_offset = result.get("next_offset")
         if next_offset is not None and not isinstance(next_offset, int):

src/core/ports/vector_store_port.py

@@ -42,8 +42,9 @@ class VectorStorePort(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def browse(self, limit: int = 20, offset: int = 0, source: Optional[str] = None, language: Optional[str] = None) -> Dict[str, Any]:
+    def browse(self, limit: int = 20, offset: int = 0, source: Optional[str] = None, language: Optional[str] = None, days_back: Optional[int] = None) -> Dict[str, Any]:
         """
         Browses the vector collection with pagination and filtering.
+        days_back: Optional filter to only return articles from the last N days (default: None = all articles)
         """
         pass

src/infrastructure/adapters/qdrant_adapter.py

@@ -316,6 +316,7 @@ class QdrantAdapter(VectorStorePort):
         offset: int = 0,
         source: Optional[str] = None,
         language: Optional[str] = None,
+        days_back: Optional[int] = None,
     ) -> Dict[str, Any]:
         if not self.client:
             return {"articles": [], "next_offset": None}
@@ -329,6 +330,15 @@ class QdrantAdapter(VectorStorePort):
             must.append(models.FieldCondition(
                 key="language", match=models.MatchValue(value=language)
             ))
+        
+        # Add time-based filter for fresh results (default: last 7 days for browse)
+        if days_back is not None:
+            min_date = datetime.utcnow() - timedelta(days=days_back)
+            must.append(models.FieldCondition(
+                key="published_at",
+                range=models.DatetimeRange(gte=min_date)
+            ))
+        
         filter_obj = models.Filter(must=must) if must else None
 
         try:
@@ -340,6 +350,10 @@ class QdrantAdapter(VectorStorePort):
                 offset=offset,
                 with_payload=True,
                 with_vectors=False,
+                order_by=models.OrderBy(
+                    key="published_at",
+                    direction=models.Direction.DESC
+                )
             )
 
             # Keep only the lowest chunk_index per doc_id (first chunk of each article)
@@ -352,6 +366,7 @@ class QdrantAdapter(VectorStorePort):
                     seen_docs[doc_id] = (point, chunk_index)
 
             deduped = [v[0] for v in seen_docs.values()]
+            # Results are already sorted by Qdrant, but re-sort to ensure consistency after dedup
             deduped.sort(
                 key=lambda p: (p.payload or {}).get("published_at") or "",
                 reverse=True,
@@ -359,5 +374,33 @@ class QdrantAdapter(VectorStorePort):
             return {"articles": deduped[:limit], "next_offset": next_page_offset}
 
         except Exception as e:
+            # If order_by fails (older Qdrant version), retry without it
+            if "order_by" in str(e).lower():
+                logger.warning(f"Qdrant order_by not supported, falling back to client-side sort: {e}")
+                try:
+                    results, next_page_offset = self.client.scroll(
+                        collection_name=settings.QDRANT_COLLECTION,
+                        scroll_filter=filter_obj,
+                        limit=limit * 8,
+                        offset=offset,
+                        with_payload=True,
+                        with_vectors=False,
+                    )
+                    seen_docs: dict = {}
+                    for point in results:
+                        payload = point.payload or {}
+                        doc_id = payload.get("doc_id", point.id)
+                        chunk_index = payload.get("chunk_index", 0)
+                        if doc_id not in seen_docs or chunk_index < seen_docs[doc_id][1]:
+                            seen_docs[doc_id] = (point, chunk_index)
+                    deduped = [v[0] for v in seen_docs.values()]
+                    deduped.sort(
+                        key=lambda p: (p.payload or {}).get("published_at") or "",
+                        reverse=True,
+                    )
+                    return {"articles": deduped[:limit], "next_offset": next_page_offset}
+                except Exception as e2:
+                    logger.error(f"Error browsing Qdrant (fallback): {e2}")
+                    return {"articles": [], "next_offset": None}
             logger.error(f"Error browsing Qdrant: {e}")
             return {"articles": [], "next_offset": None}