Upload 3 files

README (1).md

@@ -0,0 +1,71 @@
+---
+title: Trend Longevity Analyser
+emoji: 📊
+colorFrom: blue
+colorTo: indigo
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: true
+---
+
+# 📊 Trend Longevity Analyser
+
+A **RAG-powered trend intelligence tool** that classifies whether any topic is *Early, Rising, at Peak, Declining, or Fading* — using live news data.
+
+## How It Works
+
+This tool implements a full 6-step RAG (Retrieval-Augmented Generation) pipeline:
+
+| Step | What Happens |
+|------|-------------|
+| **1. Fetch** | NewsAPI pulls up to 50 recent articles on your topic |
+| **2. Chunk** | LangChain splits articles into overlapping 400-character chunks |
+| **3. Embed** | `all-MiniLM-L6-v2` encodes each chunk into a 384-dim vector |
+| **4. Store** | ChromaDB holds all vectors in an in-memory collection |
+| **5. Retrieve** | Semantic search returns the 10 most relevant chunks |
+| **6. Generate** | Claude analyses the retrieved context and returns a structured trend signal |
+
+## Tech Stack
+
+- **Retrieval:** [ChromaDB](https://www.trychroma.com) (vector store) + [Sentence Transformers](https://sbert.net) (embeddings)
+- **Orchestration:** [LangChain](https://langchain.com) text splitting
+- **News Data:** [NewsAPI](https://newsapi.org) (free tier)
+- **Generation:** [Google Gemini Flash](https://aistudio.google.com) (free tier)
+- **UI:** [Gradio](https://gradio.app)
+
+## Setup
+
+### Running Locally
+
+```bash
+git clone https://huggingface.co/spaces/lization/trend-longevity-analyser
+cd trend-longevity-analyser
+pip install -r requirements.txt
+export NEWSAPI_KEY=your_key_here
+export ANTHROPIC_API_KEY=your_key_here
+python app.py
+```
+
+### HF Space Secrets
+
+Set `NEWSAPI_KEY` and `GEMINI_API_KEY` as Space Secrets under **Settings → Variables and Secrets**. If not set, users can enter keys directly in the UI.
+
+## Get Your Free API Keys
+
+- **NewsAPI:** [newsapi.org/register](https://newsapi.org/register) — free tier, 100 requests/day, last 30 days of articles
+- **Google Gemini:** [aistudio.google.com](https://aistudio.google.com) — free tier, 1,500 requests/day, no credit card needed
+
+## Why RAG (Not Just a Prompt)?
+
+Instead of passing all 50 articles to Claude (expensive, noisy, hits context limits), the RAG approach:
+
+1. Embeds every chunk as a vector
+2. Retrieves only the **10 most semantically relevant chunks** via cosine similarity
+3. Passes those to Claude for analysis
+
+This gives more focused, accurate, and cost-efficient results — and is directly analogous to production social listening systems used in enterprise contexts.
+
+---
+
+Built by [Sammie Wong](https://linkedin.com/in/)

app (1).py

@@ -0,0 +1,403 @@
+"""
+Trend Longevity Analyser
+========================
+A RAG-powered tool that classifies whether a topic/trend is Early, Rising,
+at Peak, Declining, or Fading — based on live news data.
+
+RAG Pipeline (6 steps):
+  1. FETCH    → NewsAPI pulls up to 50 recent articles on the topic
+  2. CHUNK    → LangChain splits each article into overlapping 400-char chunks
+  3. EMBED    → Sentence Transformers encodes every chunk as a dense vector
+  4. STORE    → ChromaDB holds all vectors in an in-memory collection
+  5. RETRIEVE → Semantic search returns the 10 most relevant chunks
+  6. GENERATE → Gemini Flash analyses the retrieved context and returns a structured signal
+
+Built by: Sammie Wong
+"""
+
+import os
+import json
+import uuid
+import gradio as gr
+import google.generativeai as genai
+import chromadb
+from chromadb.utils import embedding_functions
+from newsapi import NewsApiClient
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from datetime import datetime, timedelta
+
+
+# ─── STEP 1: FETCH ────────────────────────────────────────────────────────────
+
+def fetch_articles(topic: str, days_back: int, newsapi_key: str) -> list[dict]:
+    """
+    Pull recent news articles from NewsAPI for the given topic.
+    Free tier: up to 100 requests/day, articles from the last 30 days.
+    """
+    client = NewsApiClient(api_key=newsapi_key)
+    from_date = (datetime.now() - timedelta(days=days_back)).strftime('%Y-%m-%d')
+
+    response = client.get_everything(
+        q=f'"{topic}"',       # Exact phrase match for cleaner signal
+        language='en',
+        sort_by='publishedAt',
+        from_param=from_date,
+        page_size=50          # NewsAPI free tier maximum
+    )
+    return response.get('articles', [])
+
+
+# ─── STEP 2: CHUNK ────────────────────────────────────────────────────────────
+
+def chunk_articles(articles: list[dict]) -> tuple[list[str], list[dict]]:
+    """
+    Split each article into overlapping chunks.
+
+    Why chunk? LLMs have context limits and RAG works better with focused
+    pieces of text than entire articles. Overlap (40 chars) prevents
+    losing meaning at chunk boundaries.
+    """
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=400,   # ~80 words — enough context per chunk
+        chunk_overlap=40  # Overlap prevents boundary information loss
+    )
+
+    all_chunks, all_metadata = [], []
+
+    for article in articles:
+        # Combine title + description + content for the richest signal
+        full_text = " ".join(filter(None, [
+            article.get('title', ''),
+            article.get('description', ''),
+            article.get('content', '')
+        ]))
+
+        for chunk in splitter.split_text(full_text):
+            all_chunks.append(chunk)
+            all_metadata.append({
+                'source':       article['source']['name'],
+                'published_at': article['publishedAt'][:10],
+                'title':        (article.get('title') or '')[:100]
+            })
+
+    return all_chunks, all_metadata
+
+
+# ─── STEPS 3 & 4: EMBED + STORE ───────────────────────────────────────────────
+
+def build_vector_store(chunks: list[str], metadatas: list[dict]):
+    """
+    Encode every chunk into a 384-dimensional embedding vector and store
+    in an in-memory ChromaDB collection.
+
+    Model: all-MiniLM-L6-v2 — fast, accurate, no GPU needed.
+    Storage: EphemeralClient (in-memory) means no disk writes — perfect for
+    a serverless HF Space where each request is stateless.
+    """
+    embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
+        model_name="all-MiniLM-L6-v2"
+    )
+
+    try:
+        db = chromadb.EphemeralClient()  # ChromaDB >= 0.4.x
+    except AttributeError:
+        db = chromadb.Client()           # Fallback for older versions
+
+    collection = db.create_collection(
+        name=f"trend_{uuid.uuid4().hex[:8]}",
+        embedding_function=embedding_fn
+    )
+
+    # Insert in batches of 100 to avoid memory spikes
+    batch_size = 100
+    for i in range(0, len(chunks), batch_size):
+        batch_end = i + batch_size
+        collection.add(
+            documents=chunks[i:batch_end],
+            metadatas=metadatas[i:batch_end],
+            ids=[f"c{i + j}" for j in range(len(chunks[i:batch_end]))]
+        )
+
+    return collection
+
+
+# ─── STEP 5: RETRIEVE ─────────────────────────────────────────────────────────
+
+def retrieve_context(collection, topic: str, n_results: int = 10) -> tuple[list[str], list[dict]]:
+    """
+    Run a semantic similarity search to retrieve the most relevant chunks.
+
+    The query is phrased to surface trend-signal language — not just
+    topic mentions. ChromaDB uses cosine similarity on the embeddings.
+    """
+    query = f"trend momentum growth decline viral popularity media coverage {topic}"
+
+    results = collection.query(
+        query_texts=[query],
+        n_results=min(n_results, collection.count())
+    )
+    return results['documents'][0], results['metadatas'][0]
+
+
+# ─── STEP 6: GENERATE ─────────────────────────────────────────────────────────
+
+def analyse_with_gemini(
+    topic: str,
+    retrieved_docs: list[str],
+    retrieved_meta: list[dict],
+    total_articles: int,
+    days_back: int,
+    gemini_key: str
+) -> dict:
+    """
+    Pass the retrieved chunks (NOT all articles) to Gemini Flash for analysis.
+
+    This is the core RAG advantage: the model only sees the most semantically
+    relevant evidence, which produces more focused and accurate analysis
+    than dumping all 50 articles into the prompt.
+
+    response_mime_type="application/json" tells Gemini to return clean JSON
+    directly — no markdown fences, no preamble, no parsing headaches.
+    """
+    context = "\n\n".join([
+        f"[{m['source']} · {m['published_at']}]\n{doc}"
+        for doc, m in zip(retrieved_docs, retrieved_meta)
+    ])
+
+    prompt = f"""You are a senior trend analyst at a social listening company (like Pulsar, Brandwatch, or Sprinklr).
+
+You have been given the {len(retrieved_docs)} most semantically relevant news excerpts about "{topic}", 
+retrieved via RAG from a corpus of {total_articles} articles published in the last {days_back} days.
+
+RETRIEVED CONTEXT:
+{context}
+
+Based on this evidence, classify the trend and return a JSON object with exactly these fields:
+{{
+    "phase": "Early|Rising|Peak|Declining|Fading",
+    "confidence": <integer 0-100>,
+    "momentum_score": <integer 0-100>,
+    "summary": "<2-3 sentence narrative of the trend's current state and why>",
+    "key_signals": [
+        "<specific evidence signal from the articles>",
+        "<specific evidence signal from the articles>",
+        "<specific evidence signal from the articles>",
+        "<specific evidence signal from the articles>"
+    ],
+    "prediction_30d": "<one concrete sentence: what will likely happen to this trend in 30 days>",
+    "media_spread": "Niche|Specialist|Mainstream|Viral",
+    "top_themes": ["<theme 1>", "<theme 2>", "<theme 3>"]
+}}
+
+Phase definitions:
+- Early:     Emerging signal, limited coverage, mostly specialist/niche sources
+- Rising:    Volume growing, broadening coverage, sentiment intensifying
+- Peak:      Maximum velocity, mainstream saturation, brand/celebrity involvement
+- Declining: Volume dropping, novelty fading, sentiment normalising
+- Fading:    Minimal coverage, topic becoming dated, resolved, or replaced"""
+
+    genai.configure(api_key=gemini_key)
+    model = genai.GenerativeModel(
+        model_name="gemini-2.0-flash",
+        generation_config=genai.GenerationConfig(
+            response_mime_type="application/json",  # Forces clean JSON output
+            max_output_tokens=900,
+        )
+    )
+    response = model.generate_content(prompt)
+    return json.loads(response.text)
+
+
+# ─── PIPELINE ORCHESTRATOR ────────────────────────────────────────────────────
+
+def run_analysis(topic: str, days_back: int, newsapi_key_input: str, gemini_key_input: str):
+    """
+    Runs the full 6-step RAG pipeline and returns formatted Gradio outputs.
+    Returns 6 values matching the 6 gr.Markdown output components.
+    """
+    EMPTY = ("", "", "", "", "", "")
+
+    if not topic.strip():
+        return ("⚠️ Please enter a topic.", *EMPTY[1:])
+
+    # Resolve API keys: UI input → environment variable → error
+    news_key   = newsapi_key_input.strip()  or os.environ.get("NEWSAPI_KEY", "")
+    gemini_key = gemini_key_input.strip()   or os.environ.get("GEMINI_API_KEY", "")
+
+    if not news_key:
+        return ("⚠️ NewsAPI key is required. Get a free key at newsapi.org", *EMPTY[1:])
+    if not gemini_key:
+        return ("⚠️ Gemini API key is required. Get a free key at aistudio.google.com", *EMPTY[1:])
+
+    try:
+        # ── Step 1: Fetch ──────────────────────────────────────────────────
+        articles = fetch_articles(topic, int(days_back), news_key)
+        if not articles:
+            return (
+                f"⚠️ No articles found for **'{topic}'** in the last {days_back} days.\n\n"
+                "Try a broader topic, shorter name, or longer date range.",
+                *EMPTY[1:]
+            )
+
+        # ── Steps 2–4: Chunk → Embed → Store ─────��────────────────────────
+        chunks, metadatas = chunk_articles(articles)
+        collection = build_vector_store(chunks, metadatas)
+
+        # ── Step 5: Retrieve ───────────────────────────────────────────────
+        retrieved_docs, retrieved_meta = retrieve_context(collection, topic)
+
+        # ── Step 6: Generate ───────────────────────────────────────────────
+        result = analyse_with_gemini(
+            topic, retrieved_docs, retrieved_meta,
+            len(articles), int(days_back), gemini_key
+        )
+
+        # ── Format outputs ─────────────────────────────────────────────────
+        phase_icons = {
+            "Early": "🌱", "Rising": "📈", "Peak": "🔥",
+            "Declining": "📉", "Fading": "🌫️"
+        }
+        phase_colors = {
+            "Early": "#22c55e", "Rising": "#3b82f6", "Peak": "#f97316",
+            "Declining": "#ef4444", "Fading": "#94a3b8"
+        }
+        phase     = result.get("phase", "Unknown")
+        icon      = phase_icons.get(phase, "❓")
+        color     = phase_colors.get(phase, "#6b7280")
+
+        phase_md = f"## {icon} {phase.upper()}"
+
+        scores_md = f"""### 📊 Metrics
+| | |
+|---|---|
+| **Confidence** | `{result.get('confidence', '—')}%` |
+| **Momentum Score** | `{result.get('momentum_score', '—')} / 100` |
+| **Media Spread** | `{result.get('media_spread', '—')}` |
+| **Articles Fetched** | `{len(articles)}` |
+| **Chunks in Vector Store** | `{len(chunks)}` |
+| **Chunks Retrieved via RAG** | `{len(retrieved_docs)}` |"""
+
+        summary_md = f"### 📝 Narrative\n{result.get('summary', '')}"
+
+        signals_md = "### 🔍 Key Signals\n" + "\n".join(
+            [f"- {s}" for s in result.get('key_signals', [])]
+        ) + "\n\n**Top Themes:** " + "  ".join(
+            [f"`{t}`" for t in result.get('top_themes', [])]
+        )
+
+        prediction_md = f"### 🔮 30-Day Prediction\n_{result.get('prediction_30d', '')}_"
+
+        sources_md = "### 📰 Articles Used in RAG Retrieval\n" + "\n".join([
+            f"- **{m['source']}** ({m['published_at']}): _{m['title']}_"
+            for m in retrieved_meta[:6]
+        ])
+
+        return phase_md, scores_md, summary_md, signals_md, prediction_md, sources_md
+
+    except json.JSONDecodeError:
+        return ("⚠️ Could not parse analysis response. Please try again.", *EMPTY[1:])
+    except Exception as e:
+        return (f"⚠️ Error: {str(e)}", *EMPTY[1:])
+
+
+# ─── GRADIO UI ────────────────────────────────────────────────────────────────
+
+CSS = """
+#title-block { text-align: center; padding: 8px 0 4px 0; }
+#title-block h1 { font-size: 2rem; font-weight: 800; margin-bottom: 2px; }
+#title-block p  { color: #64748b; font-size: 0.95rem; }
+.phase-box      { text-align: center; font-size: 1.8rem; font-weight: 800;
+                  padding: 18px; background: #f8fafc; border-radius: 12px;
+                  border: 2px solid #e2e8f0; min-height: 80px; }
+.metric-card    { background: #f8fafc; border-radius: 10px; padding: 4px 8px;
+                  border-left: 3px solid #3b82f6; }
+footer { display: none !important; }
+"""
+
+HOWTO = """
+**Step 1 — Fetch:** NewsAPI retrieves up to 50 articles matching your topic from the selected date range.
+
+**Step 2 — Chunk:** LangChain's `RecursiveCharacterTextSplitter` breaks each article into overlapping 400-character chunks (~80 words). Overlap prevents information loss at chunk boundaries.
+
+**Step 3 — Embed:** Each chunk is encoded into a 384-dimensional dense vector using `all-MiniLM-L6-v2` (Sentence Transformers) — optimised for semantic similarity, runs without a GPU.
+
+**Step 4 — Store:** All vectors are loaded into a ChromaDB `EphemeralClient` collection (fully in-memory — no disk writes, stateless per request).
+
+**Step 5 — Retrieve:** A trend-signal query is run against the vector store. ChromaDB uses cosine similarity to return the 10 most semantically relevant chunks from across all articles.
+
+**Step 6 — Generate:** Gemini Flash receives *only* the retrieved chunks as context — not all 50 articles. This is the core RAG advantage: focused, grounded, efficient analysis with a minimal prompt. `response_mime_type="application/json"` guarantees clean structured output.
+"""
+
+with gr.Blocks(theme=gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="slate",
+    font=[gr.themes.GoogleFont("DM Sans"), "ui-sans-serif", "sans-serif"]
+), css=CSS, title="Trend Longevity Analyser") as demo:
+
+    with gr.Column(elem_id="title-block"):
+        gr.Markdown("""
+# 📊 Trend Longevity Analyser
+**RAG-powered trend intelligence** · NewsAPI + ChromaDB + Sentence Transformers + Gemini Flash
+""")
+
+    gr.Markdown("---")
+
+    # ── Inputs ────────────────────────────────────────────────────────────────
+    with gr.Accordion("🔑 API Keys", open=False):
+        gr.Markdown(
+            "_Keys entered here are used only for your request and never stored. "
+            "If you're hosting this Space privately, set `NEWSAPI_KEY` and "
+            "`GEMINI_API_KEY` as Secrets instead._"
+        )
+        with gr.Row():
+            newsapi_input = gr.Textbox(label="NewsAPI Key",        placeholder="Get free key at newsapi.org",        type="password")
+            gemini_input  = gr.Textbox(label="Google Gemini API Key", placeholder="Get free key at aistudio.google.com", type="password")
+
+    with gr.Row():
+        with gr.Column(scale=4):
+            topic_input = gr.Textbox(
+                label="Topic / Trend",
+                placeholder="e.g.  'Gen Z workplace burnout'  ·  'green hydrogen'  ·  'AI companions'",
+                lines=1
+            )
+        with gr.Column(scale=1):
+            days_input = gr.Slider(label="Days Back", minimum=7, maximum=30, value=30, step=7,
+                                   info="Free NewsAPI tier = 30 days max")
+
+    analyse_btn = gr.Button("🔍  Analyse Trend", variant="primary", size="lg")
+
+    gr.Markdown("---")
+
+    # ── Outputs ───────────────────────────────────────────────────────────────
+    phase_output = gr.Markdown(elem_classes=["phase-box"])
+
+    with gr.Row():
+        with gr.Column():
+            scores_output     = gr.Markdown(elem_classes=["metric-card"])
+            signals_output    = gr.Markdown()
+        with gr.Column():
+            summary_output    = gr.Markdown()
+            prediction_output = gr.Markdown()
+
+    sources_output = gr.Markdown()
+
+    with gr.Accordion("🧠  How the RAG Pipeline Works", open=False):
+        gr.Markdown(HOWTO)
+
+    gr.Markdown(
+        "_Built by [Sammie Wong](https://linkedin.com/in/) · "
+        "Source: [GitHub](https://github.com/) · "
+        "Powered by [NewsAPI](https://newsapi.org) + [ChromaDB](https://www.trychroma.com) + "
+        "[Gemini Flash](https://aistudio.google.com)_",
+    )
+
+    # ── Wire up ───────────────────────────────────────────────────────────────
+    analyse_btn.click(
+        fn=run_analysis,
+        inputs=[topic_input, days_input, newsapi_input, gemini_input],
+        outputs=[phase_output, scores_output, summary_output,
+                 signals_output, prediction_output, sources_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements (1).txt

@@ -0,0 +1,7 @@
+gradio>=4.40.0
+google-generativeai>=0.8.0
+newsapi-python>=0.2.7
+langchain>=0.2.0
+langchain-text-splitters>=0.2.0
+chromadb>=0.5.0
+sentence-transformers>=3.0.0