correlation for review and insights

Co-authored-by: Copilot <copilot@github.com>

.gitignore

@@ -1,3 +1,5 @@
 .env
 env
-__pycache__
+__pycache__
+.vscode
+test*

main.py

@@ -1,5 +1,8 @@
 from fastapi import FastAPI, Depends, HTTPException, BackgroundTasks
+from pathlib import Path
+import os
 import requests
+from dotenv import load_dotenv
 from sqlalchemy.orm import Session
 from database import Base, engine,SessionLocal
 from models import User, Log, CtrReport
@@ -12,10 +15,113 @@ from utils import extract_points
 
 
 app = FastAPI()
+env_path = Path(__file__).resolve().parent / ".env"
+load_dotenv(env_path)
 
 Base.metadata.create_all(bind=engine)
 
 
+def get_representatives(
+    texts: list[str],
+    eps: float,
+    min_samples: int,
+    error_label: str
+) -> list[str]:
+    if not texts:
+        return []
+
+    try:
+        response = requests.post(
+            f"{API_BASE_URL}/get_representatives",
+            json={
+                "texts": texts,
+                "eps": eps,
+                "min_samples": min_samples
+            },
+            timeout=60
+        )
+    except requests.RequestException as exc:
+        raise HTTPException(
+            502,
+            f"{error_label} service failed: {exc}"
+        )
+
+    if response.status_code != 200:
+        raise HTTPException(
+            502,
+            f"{error_label} service error"
+        )
+
+    payload = response.json()
+
+    return payload.get("representatives", [])
+
+
+def requesty_chat(prompt: str) -> str:
+    api_key = os.getenv("REQUESTY_API_KEY")
+    if not api_key:
+        raise HTTPException(500, "Requesty API key not configured")
+
+    base_url = os.getenv(
+        "REQUESTY_API_URL",
+        "https://router.requesty.ai/v1"
+    ).rstrip("/")
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+    }
+
+    referer = os.getenv("REQUESTY_HTTP_REFERER")
+    title = os.getenv("REQUESTY_X_TITLE")
+    if referer:
+        headers["HTTP-Referer"] = referer
+    if title:
+        headers["X-Title"] = title
+
+    try:
+        response = requests.post(
+            f"{base_url}/chat/completions",
+            headers=headers,
+            json={
+                "model": "openai/gpt-4o",
+                "temperature": 0.2,
+                "max_tokens": 256,
+                "messages": [
+                    {
+                        "role": "system",
+                        "content": (
+                            "You find correlations between insights and reviews. "
+                            "Return 3-6 short numbered points, each under 20 words."
+                        )
+                    },
+                    {"role": "user", "content": prompt}
+                ]
+            },
+            timeout=60
+        )
+    except requests.RequestException as exc:
+        raise HTTPException(502, f"Requesty service failed: {exc}")
+
+    if response.status_code != 200:
+        detail = response.text.strip()
+        if detail:
+            raise HTTPException(
+                502,
+                f"Requesty service error: {detail}"
+            )
+        raise HTTPException(502, "Requesty service error")
+
+    payload = response.json()
+    choices = payload.get("choices", [])
+    if not choices:
+        raise HTTPException(502, "Requesty service returned no choices")
+
+    message = choices[0].get("message", {})
+    content = message.get("content", "")
+
+    return content.strip()
+
+
 @app.post("/auth/signup")
 def signup(data: SignupRequest, db: Session = Depends(get_db)):
     existing = db.query(User).filter(User.email == data.email).first()
@@ -283,6 +389,114 @@ def get_few_reviews(
     }
 
 
+@app.get("/correlated-review-insights")
+def correlated_review_insights(
+    restaurant_id: int,
+    eps: float = 0.41,
+    min_samples: int = 2,
+    db: Session = Depends(get_db)
+):
+
+    restaurant = (
+        db.query(Restaurant)
+        .filter(Restaurant.id == restaurant_id)
+        .first()
+    )
+
+    if not restaurant:
+        raise HTTPException(404, "Restaurant not found")
+
+    reviews = (
+        db.query(Review)
+        .filter(Review.restaurant_id == restaurant_id)
+        .all()
+    )
+
+    reports = (
+        db.query(CtrReport)
+        .order_by(CtrReport.id.desc())
+        .all()
+    )
+
+    if not reviews or not reports:
+        return {
+            "restaurant_id": restaurant.id,
+            "restaurant_name": restaurant.name,
+            "correlation_points": []
+        }
+
+    review_texts = [r.review for r in reviews]
+
+    all_points = []
+    for report in reports:
+        if not report.insights:
+            continue
+        all_points.extend(extract_points(report.insights))
+
+    unique_points = list(dict.fromkeys(all_points))
+
+    if not unique_points:
+        return {
+            "restaurant_id": restaurant.id,
+            "restaurant_name": restaurant.name,
+            "correlation_points": []
+        }
+
+    representative_reviews = get_representatives(
+        review_texts,
+        eps=eps,
+        min_samples=min_samples,
+        error_label="Representative review"
+    )
+
+    representative_insights = get_representatives(
+        unique_points,
+        eps=eps,
+        min_samples=min_samples,
+        error_label="Representative insight"
+    )
+
+    trimmed_reviews = representative_reviews[:25]
+    trimmed_insights = representative_insights[:25]
+
+    prompt = (
+        "Insights:\n"
+        + "\n".join(f"- {point}" for point in trimmed_insights)
+        + "\n\nReviews:\n"
+        + "\n".join(f"- {text}" for text in trimmed_reviews)
+        + "\n\nCorrelate them in short numbered points."
+    )
+
+    content = requesty_chat(prompt)
+
+    correlation_points = extract_points(content)
+
+    if not correlation_points:
+        correlation_points = [
+            line.strip("- ").strip()
+            for line in content.splitlines()
+            if line.strip()
+        ]
+
+    if not correlation_points and content:
+        correlation_points = [content]
+
+    cleaned_points = []
+    for point in correlation_points[:6]:
+        cleaned = point.strip()
+        if len(cleaned) > 200:
+            cleaned = cleaned[:197].rstrip() + "..."
+        cleaned_points.append(cleaned)
+
+    return {
+        "restaurant_id": restaurant.id,
+        "restaurant_name": restaurant.name,
+        "reviews_considered": len(trimmed_reviews),
+        "insights_considered": len(trimmed_insights),
+        "correlation_points": cleaned_points
+    }
+
+
 
 @app.get("/few-insights")
 def get_all_insights(