Upload 12 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+artifacts/movie_faiss.index filter=lfs diff=lfs merge=lfs -text

ReviewSentiment.py

@@ -0,0 +1,263 @@
+import torch
+import torch.nn as nn
+import numpy as np
+import re
+
+# =========================== Device ===========================
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Model running on: {DEVICE}")
+
+# =========================== Tokenizer ===========================
+def simple_tokenize(text):
+    return text.split()
+
+# =========================== Model ===========================
+class GoEmotionsLSTM(nn.Module):
+    def __init__(self, vocab_size, embed_dim=200, hidden_dim=256, num_classes=28, num_layers=2):
+        super().__init__()
+
+        self.embeddings = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
+
+        self.lstm = nn.LSTM(
+            input_size=embed_dim,
+            hidden_size=hidden_dim,
+            num_layers=num_layers,
+            batch_first=True,
+            dropout=0.2,
+            bidirectional=True
+        )
+
+        self.fc = nn.Linear(hidden_dim * 2, num_classes)
+        self.dropout = nn.Dropout(0.2)
+
+    def forward(self, x):
+        x = self.embeddings(x)
+        _, (h, _) = self.lstm(x)
+
+        h_forward = h[-2]
+        h_backward = h[-1]
+        h_cat = torch.cat((h_forward, h_backward), dim=1)
+
+        h_cat = self.dropout(h_cat)
+        out = self.fc(h_cat)
+        return out
+
+# =========================== Load Model (ONCE) ===========================
+def load_goemotion_model(path="artifacts/goemotions_bilstm_checkpoint.pth"):
+    checkpoint = torch.load(path, map_location=DEVICE)
+
+    vocab = checkpoint["vocab"]
+    max_len = checkpoint["max_len"]
+
+    model = GoEmotionsLSTM(vocab_size=len(vocab))
+    model.load_state_dict(checkpoint["model_state"])
+    model.to(DEVICE)
+    model.eval()
+
+    return model, vocab, max_len
+
+# Load once at startup
+MODEL, VOCAB, MAX_LEN = load_goemotion_model()
+
+# =========================== Emotion Map ===========================
+EMOTION_MAP = [
+    "admiration","amusement","anger","annoyance","approval","caring","confusion",
+    "curiosity","desire","disappointment","disapproval","disgust","embarrassment",
+    "excitement","fear","gratitude","grief","joy","love","nervousness","optimism",
+    "pride","realization","relief","remorse","sadness","surprise","neutral"
+]
+
+# =========================== Sentiment Groups ===========================
+POSITIVE_EMOTIONS = {
+    "admiration", "amusement", "approval", "caring", "desire", "excitement",
+    "gratitude", "joy", "love", "optimism", "pride", "relief"
+}
+
+NEGATIVE_EMOTIONS = {
+    "anger", "annoyance", "disappointment", "disapproval", "disgust",
+    "embarrassment", "fear", "grief", "nervousness", "remorse", "sadness"
+}
+
+NEUTRAL_EMOTIONS = {
+    "confusion", "curiosity", "realization", "surprise", "neutral"
+}
+
+# =========================== Preprocessing ===========================
+_CLEAN_RE = re.compile(r'[^a-z0-9\s]+')
+
+def clean_text(text: str) -> str:
+    text = text.lower()
+    text = _CLEAN_RE.sub(" ", text)
+    return " ".join(text.split())
+
+# =========================== Core Prediction ===========================
+@torch.inference_mode()
+def predict_sentiment(text: str):
+    text = clean_text(text)
+    tokens = simple_tokenize(text)
+
+    seq = [VOCAB.get(tok, 1) for tok in tokens]  # 1 = <UNK>
+
+    if len(seq) < MAX_LEN:
+        seq.extend([VOCAB["<PAD>"]] * (MAX_LEN - len(seq)))
+    else:
+        seq = seq[:MAX_LEN]
+
+    x = torch.tensor(seq, dtype=torch.long, device=DEVICE).unsqueeze(0)
+
+    logits = MODEL(x)
+    probs = torch.sigmoid(logits)[0].cpu().numpy()
+
+    # Aggregate probabilities
+    pos_score = 0.0
+    neg_score = 0.0
+    neu_score = 0.0
+
+    for i, p in enumerate(probs):
+        emotion = EMOTION_MAP[i]
+        if emotion in POSITIVE_EMOTIONS:
+            pos_score += p
+        elif emotion in NEGATIVE_EMOTIONS:
+            neg_score += p
+        elif emotion in NEUTRAL_EMOTIONS:
+            neu_score += p
+
+    scores = {
+        "positive": pos_score,
+        "negative": neg_score,
+        "neutral": neu_score
+    }
+
+    sentiment = max(scores, key=scores.get)
+    confidence = float(scores[sentiment] / (pos_score + neg_score + neu_score + 1e-8))
+
+    return {
+        "sentiment": sentiment,
+        "confidence": round(confidence, 4)
+    }
+
+# =========================== Public Function ===========================
+def find_sentiment(text: str):
+    return predict_sentiment(text)
+
+# =========================== Analyze Sentiment ===========================
+
+def analyze_reviews_sentiment(reviews: list[str]):
+    """
+    reviews: list of review strings
+    returns: percentage distribution
+    """
+
+    total = len(reviews)
+
+    if total == 0:
+        return {
+            "positive": 0.0,
+            "negative": 0.0,
+            "neutral": 0.0
+        }
+
+    counts = {
+        "positive": 0,
+        "negative": 0,
+        "neutral": 0
+    }
+
+    for review in reviews:
+        result = find_sentiment(review)
+        counts[result["sentiment"]] += 1
+
+    percentages = {
+        "positive": round((counts["positive"] / total) * 100, 2),
+        "negative": round((counts["negative"] / total) * 100, 2),
+        "neutral": round((counts["neutral"] / total) * 100, 2)
+    }
+
+    return percentages
+
+
+"""TEST_REVIEWS_50 = [
+    # Positive (1–18)
+    "Absolutely loved this movie, the story and acting were brilliant.",
+    "One of the best films I have seen this year, totally worth it.",
+    "The cinematography was stunning and the soundtrack was perfect.",
+    "I really enjoyed every minute of it, great experience.",
+    "An amazing performance by the lead actor, truly outstanding.",
+    "This movie exceeded my expectations in every way.",
+    "Beautiful storytelling and emotional depth, loved it.",
+    "The direction and screenplay were top-notch.",
+    "A शानदार movie, very entertaining and engaging.",
+    "I was smiling the whole time, such a feel-good film.",
+    "The action sequences were incredible and well choreographed.",
+    "A masterpiece, will definitely watch it again.",
+    "The chemistry between the actors was amazing.",
+    "Really inspiring and motivational movie.",
+    "This film made my day, absolutely fantastic.",
+    "Loved the humor and the emotional moments.",
+    "A very satisfying and enjoyable watch.",
+    "Brilliant execution and great visuals.",
+
+    # Negative (19–36)
+    "This movie was a complete waste of time.",
+    "I did not like it at all, very boring and slow.",
+    "The plot made no sense and the acting was bad.",
+    "Terrible screenplay and weak performances.",
+    "I was very disappointed with this film.",
+    "The movie felt too long and dragged a lot.",
+    "Poor direction and horrible editing.",
+    "Not worth the hype, very average experience.",
+    "The story was predictable and dull.",
+    "I regret watching this movie.",
+    "Bad acting and cringe dialogues.",
+    "This film was really annoying to watch.",
+    "Nothing interesting happened in the entire movie.",
+    "The worst movie I have seen in a long time.",
+    "Very weak script and poor execution.",
+    "It was painful to sit through this movie.",
+    "Extremely disappointing and underwhelming.",
+    "The movie failed to impress in any aspect.",
+
+    # Neutral (37–50)
+    "The movie was okay, nothing special.",
+    "It was an average film with decent acting.",
+    "The story was simple and straightforward.",
+    "Some parts were good, some parts were boring.",
+    "It was a one-time watch kind of movie.",
+    "The film was neither good nor bad.",
+    "Decent movie, could have been better.",
+    "The acting was fine and the story was okay.",
+    "Nothing extraordinary, just a regular film.",
+    "It was watchable but not memorable.",
+    "An average experience overall.",
+    "The movie did its job, nothing more.",
+    "It was fine for a weekend watch.",
+    "Neither impressive nor terrible."
+]
+
+def test_50_reviews_sentiment():
+    print("=" * 80)
+    print("TESTING SENTIMENT DISTRIBUTION ON 50 MOVIE REVIEWS")
+    print("=" * 80)
+
+    # Individual predictions (optional but good for debugging)
+    for idx, review in enumerate(TEST_REVIEWS_50, start=1):
+        result = find_sentiment(review)
+        print(f"{idx:02d}. {review}")
+        print(f"    → Sentiment: {result['sentiment'].upper():8} | Confidence: {result['confidence']}")
+        print("-" * 80)
+
+    print("\nAGGREGATED RESULT")
+    print("=" * 80)
+
+    distribution = analyze_reviews_sentiment(TEST_REVIEWS_50)
+
+    print(f"Positive : {distribution['positive']}%")
+    print(f"Negative : {distribution['negative']}%")
+    print(f"Neutral  : {distribution['neutral']}%")
+    print("=" * 80)
+
+
+# Run test
+if __name__ == "__main__":
+    test_50_reviews_sentiment()
+"""

app.py

@@ -0,0 +1,194 @@
+import os
+import requests
+import pandas as pd
+from fastapi import FastAPI, HTTPException, Query
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from typing import Literal, List, Optional
+from fastapi.middleware.cors import CORSMiddleware
+
+# --- Import your existing custom modules ---
+from summarise_bot import summarise_movie as workflow
+from prediction_helper import recommend 
+from utils import (get_movie_id, get_movie_details, get_movie_reviews, TTS)
+from ReviewSentiment import analyze_reviews_sentiment
+
+# =============================
+# CONFIGURATION
+# =============================
+TMDB_API_KEY = "4ca4d3c95de0c88528c2682781127d55"
+TMDB_BASE_URL = "https://api.themoviedb.org/3"
+TMDB_IMAGE_BASE = "https://image.tmdb.org/t/p/w500"
+
+app = FastAPI(title='Movie Recommendation System', version='2.1')
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# =============================
+# DATA LOADING
+# =============================
+try:
+    # Ensure this matches your actual CSV filename
+    movies_df = pd.read_csv('artifacts/cleaned_movie.csv') 
+    ALL_MOVIE_TITLES = movies_df['title'].dropna().unique().tolist()
+    print(f"✅ Loaded {len(ALL_MOVIE_TITLES)} movies for local search.")
+except Exception as e:
+    print(f"⚠️ Warning: Could not load local movie list. ({e})")
+    ALL_MOVIE_TITLES = []
+
+# =============================
+# MODELS
+# =============================
+class RecomendationInput(BaseModel):
+    movie_title: str
+    engine: Literal["embedding", "tfidf", "hybrid"] = "embedding"
+    top_k: int = 5
+
+class MovieInfo(BaseModel):
+    title: str
+    overview: str
+    release_date: str
+    runtime: int | None
+    rating: float
+    vote_count: int
+    genres: list[str]
+    poster: str | None
+    backdrop: str | None
+
+class MovieReviews(BaseModel):
+    title : str
+    num_reviews : int = 50
+
+class WorkflowInput(BaseModel):
+    title: str
+    overview: str
+
+# =============================
+# HELPERS
+# =============================
+def fetch_tmdb(endpoint: str, params: dict = {}):
+    params['api_key'] = TMDB_API_KEY
+    url = f"{TMDB_BASE_URL}{endpoint}"
+    response = requests.get(url, params=params)
+    return response.json() if response.status_code == 200 else None
+
+def format_tmdb_movies(results: list):
+    formatted = []
+    for m in results:
+        formatted.append({
+            "title": m.get("title"),
+            "poster": f"{TMDB_IMAGE_BASE}{m.get('poster_path')}" if m.get('poster_path') else None,
+            "rating": m.get("vote_average"),
+            "release_date": m.get("release_date", "N/A"),
+            "id": m.get("id"),
+            "vote_count": m.get("vote_count")
+        })
+    return formatted
+
+# =============================
+# ENDPOINTS
+# =============================
+
+@app.get('/')
+def status():
+    return {'message': 'API is live', 'movies_loaded': len(ALL_MOVIE_TITLES)}
+
+# --- TRENDING & POPULAR ---
+
+@app.get('/movies/trending')
+def get_trending(time_window: str = "week"):
+    data = fetch_tmdb(f"/trending/movie/{time_window}")
+    if not data: return []
+    return format_tmdb_movies(data.get("results", []))
+
+@app.get('/movies/popular')
+def get_popular():
+    data = fetch_tmdb("/movie/popular")
+    if not data: return []
+    return format_tmdb_movies(data.get("results", []))
+
+# --- SEARCH ---
+
+@app.get('/movies/search')
+def search_movies(query: str = Query(..., min_length=2)):
+    # Search local DB for autocomplete so recommendations always work
+    q = query.lower()
+    matches = [t for t in ALL_MOVIE_TITLES if q in t.lower()][:10]
+    return {"results": matches}
+
+# --- CORE FEATURES ---
+
+@app.post('/recomendation')
+def recomendation(input_data : RecomendationInput):
+    # If movie not in local dataset, return 404 so Frontend handles it gracefully
+    if input_data.movie_title not in ALL_MOVIE_TITLES:
+        raise HTTPException(status_code=404, detail="Movie not found in local dataset")
+
+    try:
+        results = recommend(movie_title=input_data.movie_title, engine=input_data.engine, top_k=input_data.top_k)
+        return {"results": results.to_dict(orient='records')}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get('/movie-info/{title}', response_model=MovieInfo)
+def movie_info(title: str):
+    try:
+        # Uses TMDB API via utils, works for ANY movie
+        movie_id = get_movie_id(title)
+        if not movie_id:
+             raise HTTPException(status_code=404, detail="Movie not found on TMDB")
+        return get_movie_details(movie_id=movie_id)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/movie-reviews-sentiment")
+def movie_reviews_sentiment(input_data: MovieReviews):
+    try:
+        movie_id = get_movie_id(movie_title=input_data.title)
+        reviews_data = get_movie_reviews(movie_id=movie_id, max_reviews=input_data.num_reviews)
+
+        if not reviews_data:
+            # Return specific error for frontend to handle
+            raise HTTPException(status_code=404, detail="No reviews found")
+
+        review_texts = [r["content"] for r in reviews_data if r.get("content")]
+        sentiment_distribution = analyze_reviews_sentiment(review_texts)
+
+        return {
+            "movie": input_data.title,
+            "total_reviews_analyzed": len(review_texts),
+            "sentiment_distribution": sentiment_distribution
+        }
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get('/TTS/{text}')
+async def generate_tts(text: str):
+    try:
+        if not text.strip():
+            raise HTTPException(status_code=400, detail="Text is empty")
+
+        # The updated utils.TTS now returns a safe TEMP path
+        audio_path = await TTS(text=text)
+
+        if not os.path.exists(audio_path):
+            raise HTTPException(status_code=500, detail="Audio generation failed")
+
+        return FileResponse(audio_path, media_type="audio/mpeg", filename="summary_audio.mp3")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post('/summarize-movie')
+def summarize_movie(input_data: WorkflowInput):
+    try:
+        return workflow(title=input_data.title, overview=input_data.overview)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

artifacts/goemotions_bilstm_checkpoint.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2061697f00e13a048b56bfd5b8ce721ba5cdd91143ce5a1d4e1e6a272ff7944d
+size 16386991

artifacts/movie_embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d4b5489815b1c9fc85cce13f25bdc158e74efa1636d1bb7e61bd01a328a14b4
+size 21759104

artifacts/movie_faiss.index

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53103535da1e4cc8cfbc2d3ff7a5beaee18c95a9218300e9c1f9a6bda125a57b
+size 21759021

artifacts/tfidf_matrix.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9a8389e8e7db42e72cc65e7ec30200775f44881ec53325cfdd1a108449970e4
+size 5540299

artifacts/tfidf_vectorizer.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bac055cb4eacfa2fd32b6c72c248afbfd4062a5772069543cdf3b63d328066c
+size 328902

prediction_helper.py

@@ -0,0 +1,148 @@
+import numpy as np
+import pandas as pd
+import faiss
+import pickle
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+import warnings
+warnings.filterwarnings("ignore", module="sklearn")
+
+df = pd.read_csv("artifacts/cleaned_movie.csv")
+
+# --------------------- loading models -------------------------
+print("LOADING THE MODELS...")
+
+embeddings = np.load("artifacts/movie_embeddings.npy")
+print("Embeddings shape:", embeddings.shape)
+
+index = faiss.read_index("artifacts/movie_faiss.index")
+print("FAISS index loaded. Total vectors:", index.ntotal)
+
+with open("artifacts/tfidf_vectorizer.pkl", "rb") as f:
+    tfidf_vectorizer = pickle.load(f)
+print("tfidf_vectorizer loaded.")
+
+with open("artifacts/tfidf_matrix.pkl", "rb") as f:
+    tfidf_matrix = pickle.load(f)
+print("tfidf_matrix loaded")
+
+model = SentenceTransformer("all-MiniLM-L6-v2")
+print("SentenceTransformer loaded.")
+
+print("ALL MODELS LOADED SUCCESFULLY.")
+
+
+#------------------------------ loading engines ---------------------------
+def recommend_movies(movie_title, df, model, index, top_k=10):
+    try:
+        if movie_title not in df['title'].values:
+            return f"Movie '{movie_title}' not found in dataset."
+        idx = df[df['title'] == movie_title].index[0]
+        query_text = df.loc[idx, 'tags']
+        query_embedding = model.encode([query_text])
+        query_embedding = query_embedding / np.linalg.norm(query_embedding, axis=1, keepdims=True)
+        scores, indices = index.search(query_embedding, top_k + 1)
+        sim_scores = scores[0][1:]
+        sim_indices = indices[0][1:]
+
+        results = df.iloc[sim_indices].copy()
+        results["embedding_score"] = sim_scores
+
+        return results[['title', 'embedding_score']]
+    except Exception as e:
+        raise Exception(f"Error while recomending movies [embeddings] : {e}")
+
+def recommend_movies_tfidf(movie_title, df, tfidf_matrix, top_k=5):
+    try:
+        if movie_title not in df['title'].values:
+            return f"Movie '{movie_title}' not found in dataset."
+
+        idx = df[df['title'] == movie_title].index[0]
+
+        cosine_sim = cosine_similarity(tfidf_matrix[idx], tfidf_matrix).flatten()
+
+        sim_indices = cosine_sim.argsort()[::-1][1:top_k+1]
+
+        results = df.iloc[sim_indices].copy()
+        results["tfidf_score"] = cosine_sim[sim_indices]
+
+        return results[['title', 'tfidf_score']]
+    except Exception as e:
+        raise Exception(f"Error while recomending movies [tfidf] : {e}")
+    
+
+def recommend_movies_hybrid(movie_title, df, model, index, tfidf_matrix, top_k=10, alpha=0.6):
+    try:
+        """
+        alpha = weight for embedding score
+        (1 - alpha) = weight for tf-idf score
+        """
+
+        if movie_title not in df['title'].values:
+            return f"Movie '{movie_title}' not found in dataset."
+
+        idx = df[df['title'] == movie_title].index[0]
+        query_text = df.loc[idx, 'tags']
+
+        # -------- Embedding Search --------
+        query_embedding = model.encode([query_text])
+        query_embedding = query_embedding / np.linalg.norm(query_embedding, axis=1, keepdims=True)
+
+        emb_scores, emb_indices = index.search(query_embedding, 50)
+        emb_scores = emb_scores[0]
+        emb_indices = emb_indices[0]
+
+        emb_df = pd.DataFrame({
+            "index": emb_indices,
+            "embedding_score": emb_scores
+        })
+
+        # -------- TF-IDF Search --------
+        cosine_sim = cosine_similarity(tfidf_matrix[idx], tfidf_matrix).flatten()
+        tfidf_indices = cosine_sim.argsort()[::-1][:50]
+        tfidf_scores = cosine_sim[tfidf_indices]
+
+        tfidf_df = pd.DataFrame({
+            "index": tfidf_indices,
+            "tfidf_score": tfidf_scores
+        })
+
+        # -------- Merge Both --------
+        merged = pd.merge(emb_df, tfidf_df, on="index", how="outer").fillna(0)
+
+        # -------- Normalize Scores --------
+        merged["embedding_score"] = merged["embedding_score"] / merged["embedding_score"].max()
+        merged["tfidf_score"] = merged["tfidf_score"] / merged["tfidf_score"].max()
+
+        # -------- Weighted Fusion --------
+        merged["hybrid_score"] = alpha * merged["embedding_score"] + (1 - alpha) * merged["tfidf_score"]
+
+        # -------- Final Ranking --------
+        merged = merged.sort_values(by="hybrid_score", ascending=False)
+
+        top_indices = merged["index"].head(top_k).values
+        results = df.iloc[top_indices].copy()
+        results["hybrid_score"] = merged["hybrid_score"].head(top_k).values
+
+        return results[['title', 'hybrid_score']]
+    except Exception as e:
+        raise Exception(f"Error while recomending movies [hybrid] : {e}")
+
+def recommend(movie_title, engine="embedding", top_k=5):
+    if engine == "embedding":
+        return recommend_movies(movie_title, df, model, index, top_k)
+
+    elif engine == "tfidf":
+        return recommend_movies_tfidf(movie_title, df, tfidf_matrix, top_k)
+
+    elif engine == "hybrid":
+        return recommend_movies_hybrid(movie_title, df, model, index, tfidf_matrix, top_k)
+
+    else:
+        return "Invalid engine. Choose: 'embedding', 'tfidf', or 'hybrid'."
+
+
+# ----------------------------- testing ---------------------------------------
+"""print(recommend("Toy Story", engine="embedding", top_k=5))
+print(recommend("Toy Story", engine="tfidf", top_k=5))
+print(recommend("Toy Story", engine="hybrid", top_k=5))"""

requirements.txt

@@ -0,0 +1,14 @@
+pandas
+sentence-transformers
+nltk
+numpy
+faiss-cpu
+scikit-learn
+fastapi
+edge_tts
+langchain
+langgraph
+langchain-community
+langchain-openai
+uvicorn
+langchain-groq

summarise_bot.py

@@ -0,0 +1,385 @@
+# =========================
+# IMPORTS
+# =========================
+from langgraph.graph import StateGraph, START, END
+from typing import TypedDict
+from langchain_core.messages import HumanMessage
+from langchain_openai import ChatOpenAI
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_core.tools import tool
+import json
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+# =========================
+# TAVILY TOOL
+# =========================
+@tool
+def tavily_search(query: str) -> dict:
+    """
+    Perform a real-time web search using Tavily.
+    """
+    try:
+        search = TavilySearchResults(max_results=2)
+        results = search.run(query)
+        return {"query": query, "results": results}
+    except Exception as e:
+        return {"error": str(e)}
+    
+
+# =========================
+# LLM
+# =========================
+llm = ChatOpenAI(
+    model="gpt-4.1-nano",
+    temperature=0.4,
+    streaming=True
+)
+
+
+# =========================
+# STATE
+# =========================
+class MovieState(TypedDict, total=False):
+    title: str
+    overview: str
+    web_context: str
+    key_plot_points: str
+    iconic_moments: str
+    themes: str
+    interesting_facts: str
+    songs: str
+    trailer: str
+    summary: str
+
+
+# =========================
+# NODE: FETCH WEB CONTEXT
+# =========================
+def fetch_web_context(state: MovieState):
+    title = state["title"]
+
+    query = f"""
+    Find reliable and up-to-date information about the movie "{title}".
+
+    Focus on:
+    - Official trailers (studio or verified YouTube channels)
+    - Soundtrack / songs (Spotify, Apple Music, IMDb soundtrack)
+    - Verified trivia or interesting facts
+    - Release details and reception (optional)
+
+    Prefer sources like:
+    - IMDb
+    - Wikipedia
+    - Official studio websites
+    - Verified YouTube channels
+    - Major entertainment publications
+
+    Avoid:
+    - Fan theories
+    - Reviews without factual info
+    - Opinion-heavy blogs
+    """
+
+    web = tavily_search.run(query)
+
+    return {
+        "web_context": str(web)
+    }
+
+# =========================
+# HELPER PROMPT RUNNER
+# =========================
+def run_llm(prompt: str) -> str:
+    return llm.invoke(prompt).content
+
+
+# =========================
+# ANALYSIS NODES
+# =========================
+def find_key_points(state: MovieState):
+    prompt = f"""
+You are a professional movie analyst.
+
+Movie title: {state['title']}
+
+Overview:
+{state['overview']}
+
+Verified web context (may include reviews, trivia, or plot confirmations):
+{state['web_context']}
+
+Task:
+Extract the MOST IMPORTANT plot points that define the story.
+
+Guidelines:
+- Focus on STORY EVENTS, not themes or opinions
+- Keep it chronological
+- Avoid unnecessary details or long explanations
+- Do NOT invent scenes not supported by the overview or web context
+
+Output format (strict):
+- Bullet list
+- 5–7 plot points max
+- Each point: 1 concise sentence
+"""
+    return {"key_plot_points": run_llm(prompt)}
+
+
+def find_iconic_moments(state: MovieState):
+    prompt = f"""
+You are a film analyst identifying ICONIC moments.
+
+Movie title: {state['title']}
+
+Overview:
+{state['overview']}
+
+Verified web context (reviews, trivia, cultural references):
+{state['web_context']}
+
+Task:
+Identify the most ICONIC moments from the movie.
+
+Definition of iconic:
+- Scenes that audiences remember most
+- Moments often referenced in reviews, memes, or pop culture
+- Visually, emotionally, or narratively standout scenes
+
+Guidelines:
+- Do NOT summarize the full plot
+- Avoid repeating basic plot points
+- Focus on memorable SCENES or MOMENTS
+- Base choices on common recognition (not personal opinion)
+
+Output format (strict):
+- Numbered list
+- 4–6 iconic moments
+- Each item:
+  • Scene title (short)
+  • One-sentence explanation of why it’s iconic
+"""
+    return {"iconic_moments": run_llm(prompt)}
+
+def find_themes(state: MovieState):
+    prompt = f"""
+You are a movie analyst focusing on THEMES.
+
+Movie title: {state['title']}
+
+Overview:
+{state['overview']}
+
+Verified web context (critical analysis, reviews, commentary):
+{state['web_context']}
+
+Task:
+Identify the CORE THEMES explored in the movie.
+
+Guidelines:
+- Themes should be CONCEPTS (not plot points or morals)
+- Avoid vague words like "life" or "journey" unless specific
+- Base themes on story events and critical interpretation
+- Do NOT over-explain
+
+Output format (strict):
+- Bullet list
+- 3–5 themes only
+- Each theme format:
+  **Theme name** – one concise explanatory sentence
+"""
+    return {"themes": run_llm(prompt)}
+
+def find_interesting_facts(state: MovieState):
+    prompt = f"""
+You are a movie researcher collecting VERIFIED trivia.
+
+Movie title: {state['title']}
+
+Overview:
+{state['overview']}
+
+Verified web context (interviews, trivia, production notes, reviews):
+{state['web_context']}
+
+Task:
+Extract interesting and lesser-known facts about the movie.
+
+Guidelines:
+- Facts must be BASED on the web context or widely known sources
+- Avoid speculation or unverified claims
+- Focus on production, casting, behind-the-scenes, or reception
+- Do NOT repeat plot points
+
+Output format (strict):
+- Bullet list
+- 4–6 facts
+- Each fact:
+  • One concise sentence
+  • Clearly factual (no opinions)
+"""
+    return {"interesting_facts": run_llm(prompt)}
+
+def find_songs(state: MovieState):
+    prompt = f"""
+You are extracting OFFICIAL soundtrack information.
+
+Movie title: {state['title']}
+
+Verified web context (soundtrack listings, music platforms, official sources):
+{state['web_context']}
+
+Task:
+Identify the official soundtrack songs associated with this movie.
+
+Rules:
+- Include ONLY officially released songs (not background score unless famous)
+- Prefer reliable sources (Spotify, YouTube, Apple Music, IMDb soundtrack)
+- Do NOT guess or invent songs
+- Do NOT add explanations or extra text
+
+Output format (STRICT — follow exactly):
+- One song per line
+- Each line format:
+  [song name, official link]
+
+If no reliable song information is found:
+- Return an empty list: []
+"""
+    return {"songs": run_llm(prompt)}
+
+
+def find_trailer(state: MovieState):
+    prompt = f"""
+You are retrieving OFFICIAL movie trailer information.
+
+Movie title: {state['title']}
+
+Verified web context (official YouTube channels, studio pages, IMDb, Wikipedia):
+{state['web_context']}
+
+Task:
+Find official trailer links for this movie.
+
+Rules:
+- ONLY official trailers (no fan edits, reactions, reviews)
+- Prefer studio or verified YouTube channels
+- Do NOT invent or approximate links
+- Do NOT include commentary or descriptions
+
+Output format (STRICT — follow exactly):
+- One trailer per line
+- Each line format:
+  [trailer name, official link]
+
+If no official trailer is found:
+- Return an empty list: []
+"""
+    return {"trailer": run_llm(prompt)}
+
+
+# =========================
+# FINAL SUMMARY
+# =========================
+def generate_summary(state: MovieState):
+    prompt = f"""
+You are generating a FINAL movie summary for a frontend application.
+
+Movie title: {state['title']}
+
+Use ONLY the information provided below.
+Do NOT add new facts.
+Do NOT use markdown.
+Do NOT include extra text.
+
+INPUT DATA
+---------
+
+KEY PLOT POINTS:
+{state['key_plot_points']}
+
+ICONIC MOMENTS:
+{state['iconic_moments']}
+
+THEMES:
+{state['themes']}
+
+INTERESTING FACTS:
+{state['interesting_facts']}
+
+SONGS:
+{state['songs']}
+
+TRAILERS:
+{state['trailer']}
+
+---------
+
+TASK:
+Return a VALID JSON object that follows this schema EXACTLY.
+
+JSON SCHEMA (STRICT):
+{{
+  "overview": "2–3 sentence high-level movie overview",
+  "key_moments": ["moment 1", "moment 2", "moment 3"],
+  "themes": ["theme 1", "theme 2"],
+  "notable_facts": ["fact 1", "fact 2"],
+  "soundtrack_highlights": ["song name 1", "song name 2"],
+  "official_trailer": "trailer name"
+}}
+"""
+    return {"summary": run_llm(prompt)}
+
+
+
+# =========================
+# GRAPH
+# =========================
+graph = StateGraph(MovieState)
+
+graph.add_node("fetch_web_context", fetch_web_context)
+graph.add_node("find_key_points", find_key_points)
+graph.add_node("find_iconic_moments", find_iconic_moments)
+graph.add_node("find_themes", find_themes)
+graph.add_node("find_interesting_facts", find_interesting_facts)
+graph.add_node("find_songs", find_songs)
+graph.add_node("find_trailer", find_trailer)
+graph.add_node("generate_summary", generate_summary)
+
+graph.add_edge(START, "fetch_web_context")
+
+graph.add_edge("fetch_web_context", "find_key_points")
+graph.add_edge("fetch_web_context", "find_iconic_moments")
+graph.add_edge("fetch_web_context", "find_themes")
+graph.add_edge("fetch_web_context", "find_interesting_facts")
+graph.add_edge("fetch_web_context", "find_songs")
+graph.add_edge("fetch_web_context", "find_trailer")
+
+graph.add_edge("find_key_points", "generate_summary")
+graph.add_edge("find_iconic_moments", "generate_summary")
+graph.add_edge("find_themes", "generate_summary")
+graph.add_edge("find_interesting_facts", "generate_summary")
+graph.add_edge("find_songs", "generate_summary")
+graph.add_edge("find_trailer", "generate_summary")
+
+graph.add_edge("generate_summary", END)
+
+workflow = graph.compile()
+
+def summarise_movie(title: str, overview: str):
+    result = workflow.invoke({
+        "title": title,
+        "overview": overview
+    })
+
+    raw_summary = result["summary"]
+
+    try:
+        return json.loads(raw_summary)
+    except json.JSONDecodeError:
+        raise ValueError("LLM returned invalid JSON")
+
+
+#print(summarise_movie("Jumanji", "Four teenagers are sucked into a magical video game..."))

utils.py

@@ -0,0 +1,98 @@
+from dotenv import load_dotenv
+import os
+import edge_tts
+import tempfile
+from uuid import uuid4
+import requests
+load_dotenv()
+
+
+API_KEY = os.getenv("TMDB_API_KEY")
+BASE_URL = "https://api.themoviedb.org/3"
+IMAGE_BASE = "https://image.tmdb.org/t/p/w500"
+
+#--------------------------------- get movie id ----------------------------
+def get_movie_id(movie_title):
+    url = f"{BASE_URL}/search/movie"
+    params = {
+        "api_key": API_KEY,
+        "query": movie_title
+    }
+
+    r = requests.get(url, params=params)
+    data = r.json()
+
+    if "results" in data and len(data["results"]) > 0:
+        return data["results"][0]["id"]
+    return None
+
+#--------------------------------- get movie reviews ----------------------------
+def get_movie_reviews(movie_id, max_reviews=100):
+    url = f"{BASE_URL}/movie/{movie_id}/reviews"
+    params = {
+        "api_key": API_KEY,
+        "language": "en-US"
+    }
+
+    response = requests.get(url, params=params)
+
+    if response.status_code != 200:
+        print("TMDB Error:", response.status_code, response.text)
+        return []
+
+    data = response.json()
+
+    reviews = []
+
+    for review in data.get("results", [])[:max_reviews]:
+        reviews.append({
+            "author": review.get("author"),
+            "content": review.get("content"),
+            "rating": review.get("author_details", {}).get("rating"),
+            "created_at": review.get("created_at")
+        })
+
+    return reviews
+
+#--------------------------------- get full movie details ----------------------------
+def get_movie_details(movie_id):
+    url = f"{BASE_URL}/movie/{movie_id}"
+    params = {"api_key": API_KEY}
+
+    r = requests.get(url, params=params)
+    data = r.json()
+
+    details = {
+        "title": data.get("title"),
+        "overview": data.get("overview"),
+        "release_date": data.get("release_date"),
+        "runtime": data.get("runtime"),
+        "rating": data.get("vote_average"),
+        "vote_count": data.get("vote_count"),
+        "genres": [g["name"] for g in data.get("genres", [])],
+        "poster": IMAGE_BASE + data["poster_path"] if data.get("poster_path") else None,
+        "backdrop": IMAGE_BASE + data["backdrop_path"] if data.get("backdrop_path") else None
+    }
+
+    return details
+
+#----------------------------------------- TTS ----------------------------------------------
+async def TTS(text: str) -> str:
+    """
+    Saves audio to a SYSTEM TEMP folder so VS Code doesn't refresh.
+    """
+    if not text:
+        return ""
+    
+    # 1. Create a temp file path (e.g., C:\Users\AppData\Local\Temp\tmp123.mp3)
+    # delete=False ensures the file stays so we can send it to frontend
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3")
+    temp_path = temp_file.name
+    temp_file.close() # Close handle so TTS engine can write to it
+
+    # 2. Generate Audio
+    # Assuming you are using edge-tts; if using gTTS, adjust accordingly
+    communicate = edge_tts.Communicate(text, "en-US-AriaNeural")
+    await communicate.save(temp_path)
+
+    return temp_path