Delete app.py

app.py

@@ -1,399 +0,0 @@
-"""
-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 → Claude analyses the retrieved context and returns a structured signal
-
-Built by: Sammie Wong
-"""
-
-import os
-import json
-import uuid
-import gradio as gr
-import anthropic
-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_claude(
-    topic: str,
-    retrieved_docs: list[str],
-    retrieved_meta: list[dict],
-    total_articles: int,
-    days_back: int,
-    anthropic_key: str
-) -> dict:
-    """
-    Pass the retrieved chunks (NOT all articles) to Claude for analysis.
-
-    This is the core RAG advantage: Claude only sees the most semantically
-    relevant evidence, which produces more focused and accurate analysis
-    than dumping all 50 articles into the prompt.
-    """
-    # Build context block from retrieved chunks
-    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 ONLY valid JSON (no markdown, no explanation):
-{{
-    "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"""
-
-    client = anthropic.Anthropic(api_key=anthropic_key)
-    message = client.messages.create(
-        model="claude-sonnet-4-20250514",
-        max_tokens=900,
-        messages=[{"role": "user", "content": prompt}]
-    )
-
-    return json.loads(message.content[0].text)
-
-
-# ─── PIPELINE ORCHESTRATOR ────────────────────────────────────────────────────
-
-def run_analysis(topic: str, days_back: int, newsapi_key_input: str, anthropic_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", "")
-    claude_key = anthropic_key_input.strip() or os.environ.get("ANTHROPIC_API_KEY", "")
-
-    if not news_key:
-        return ("⚠️ NewsAPI key is required. Get a free key at newsapi.org", *EMPTY[1:])
-    if not claude_key:
-        return ("⚠️ Anthropic API key is required.", *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_claude(
-            topic, retrieved_docs, retrieved_meta,
-            len(articles), int(days_back), claude_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:** Claude 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.
-"""
-
-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 + Claude
-""")
-
-    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 "
-            "`ANTHROPIC_API_KEY` as Secrets instead._"
-        )
-        with gr.Row():
-            newsapi_input    = gr.Textbox(label="NewsAPI Key",     placeholder="Get free key at newsapi.org", type="password")
-            anthropic_input  = gr.Textbox(label="Anthropic API Key", placeholder="sk-ant-...",                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) + "
-        "[Claude](https://anthropic.com)_",
-    )
-
-    # ── Wire up ───────────────────────────────────────────────────────────────
-    analyse_btn.click(
-        fn=run_analysis,
-        inputs=[topic_input, days_input, newsapi_input, anthropic_input],
-        outputs=[phase_output, scores_output, summary_output,
-                 signals_output, prediction_output, sources_output]
-    )
-
-if __name__ == "__main__":
-    demo.launch()