chatbot update

chatbot.py

@@ -0,0 +1,232 @@
+# app.py
+import os
+import re
+import json
+import time
+from datetime import datetime
+from typing import List, Dict
+
+from flask import Flask, request, jsonify
+from dotenv import load_dotenv
+import requests
+
+# ----------------------------
+# Optional providers (OpenAI v1 / Cohere)
+# ----------------------------
+OPENAI_CLIENT = None
+try:
+    from openai import OpenAI
+    OPENAI_CLIENT = "available"
+except Exception:
+    OPENAI_CLIENT = None
+
+try:
+    import cohere
+except Exception:
+    cohere = None
+
+load_dotenv()
+app = Flask(__name__)
+
+# ----------------------------
+# Config
+# ----------------------------
+LLM_PROVIDER = os.getenv("LLM_PROVIDER", "openai").lower().strip()
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+COHERE_API_KEY = os.getenv("COHERE_API_KEY")
+SERPAPI_API_KEY = os.getenv("SERPAPI_API_KEY")
+SEARCH_TOPK = int(os.getenv("SEARCH_TOPK", "5"))
+TIMEZONE = "Asia/Kolkata"
+
+if LLM_PROVIDER == "openai" and not OPENAI_API_KEY:
+    print("[WARN] OPENAI_API_KEY not set; general answers will fail.")
+if LLM_PROVIDER == "cohere" and not COHERE_API_KEY:
+    print("[WARN] COHERE_API_KEY not set; general answers will fail.")
+if not SERPAPI_API_KEY:
+    print("[WARN] SERPAPI_API_KEY not set; 'latest' queries will not work.")
+
+# Initialize OpenAI client (v1+)
+openai_client = None
+if LLM_PROVIDER == "openai" and OPENAI_CLIENT and OPENAI_API_KEY:
+    openai_client = OpenAI(api_key=OPENAI_API_KEY)
+
+# ----------------------------
+# Utilities
+# ----------------------------
+
+# Common “latest/live” triggers
+LATEST_TRIGGERS = [
+    r"\btoday\b", r"\bnow\b", r"\blatest\b", r"\bupdate\b", r"\brecent\b",
+    r"\bbreaking\b", r"\blive\b", r"\bthis\s+hour\b", r"\bthis\s+minute\b",
+    r"\bcurrent\b", r"\bas of\b", r"\btoday'?s\b", r"\bprice\s+today\b"
+]
+LATEST_PATTERN = re.compile("|".join(LATEST_TRIGGERS), re.IGNORECASE)
+
+# Simple aliases for finance names/tickers (extend as needed)
+ALIASES = {
+    "tcs": "Tata Consultancy Services",
+    "ril": "Reliance Industries",
+    "infy": "Infosys",
+    "hdfc bank": "HDFC Bank",
+    "icici": "ICICI Bank",
+}
+
+def normalize_entities(text: str) -> str:
+    t = text
+    for k, v in ALIASES.items():
+        t = re.sub(rf"\b{k}\b", v, t, flags=re.IGNORECASE)
+    return t
+
+def needs_live_context(query: str) -> bool:
+    """Heuristic to detect time-sensitive queries."""
+    if not query:
+        return False
+    q = query.lower()
+
+    if LATEST_PATTERN.search(q):
+        return True
+
+    # Domain shortcuts
+    domain_triggers = [
+        "who won", "match result", "score now", "stock price", "share price",
+        "usd inr rate", "exchange rate", "weather", "today's weather",
+        "news on", "headline", "earnings today", "ipo today",
+        "live price", "current price", "price right now"
+    ]
+    if any(t in q for t in domain_triggers):
+        return True
+
+    # Finance shortcut: “price of <entity>”
+    if re.search(r"\bprice of\b", q) and not re.search(r"\byesterday|last close|history\b", q):
+        return True
+
+    return False
+
+def pick_is_news(query: str) -> bool:
+    """Treat as news if clear news terms appear."""
+    q = query.lower()
+    news_terms = ["news", "headline", "breaking", "election", "budget", "earthquake", "merger", "acquisition", "ceo resigns"]
+    return any(t in q for t in news_terms)
+
+def serpapi_search(query: str, is_news: bool = False, num: int = SEARCH_TOPK) -> List[Dict[str, str]]:
+    """Fetch top search or news results from SerpAPI."""
+    if not SERPAPI_API_KEY:
+        return []
+
+    params = {
+        "api_key": SERPAPI_API_KEY,
+        "q": query,
+    }
+
+    if is_news:
+        url = "https://serpapi.com/search.json"
+        params.update({"engine": "google_news", "num": min(num, 10), "hl": "en", "gl": "in"})
+    else:
+        url = "https://serpapi.com/search.json"
+        params.update({"engine": "google", "num": min(num, 10), "hl": "en", "gl": "in"})
+
+    r = requests.get(url, params=params, timeout=20)
+    r.raise_for_status()
+    data = r.json()
+
+    results: List[Dict[str, str]] = []
+    if is_news:
+        for item in (data.get("news_results") or [])[:num]:
+            results.append({
+                "title": item.get("title") or "",
+                "snippet": item.get("snippet") or item.get("description") or "",
+                "link": item.get("link") or "",
+                "source": (item.get("source") or {}).get("name") or item.get("source") or ""
+            })
+    else:
+        for item in (data.get("organic_results") or [])[:num]:
+            results.append({
+                "title": item.get("title") or "",
+                "snippet": item.get("snippet") or "",
+                "link": item.get("link") or "",
+                "source": item.get("source") or ""
+            })
+    return results
+
+def build_citation_block(hits: List[Dict[str, str]]) -> str:
+    """Compact citations for the LLM and the response."""
+    lines = []
+    for i, h in enumerate(hits, start=1):
+        title = (h.get("title") or "").strip()
+        link = (h.get("link") or "").strip()
+        source = (h.get("source") or "").strip()
+        snippet = (h.get("snippet") or "").strip()
+        lines.append(f"[{i}] {title} — {source}\n{snippet}\n{link}")
+    return "\n\n".join(lines)
+
+# ----------------------------
+# LLM Calls
+# ----------------------------
+
+BASE_SYSTEM_PROMPT = (
+    "You are a helpful and precise assistant. Use simple, neutral English. "
+    "When sources are provided, synthesize them, highlight clear facts, and include a short 'Sources' list as [1], [2], etc. "
+    "If information is uncertain or evolving, state that clearly."
+)
+
+def call_openai(system_prompt: str, user_prompt: str) -> str:
+    """OpenAI Python SDK ≥ 1.0.0."""
+    if not openai_client:
+        raise RuntimeError("OpenAI is not configured.")
+    resp = openai_client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user",  "content": user_prompt}
+        ],
+        temperature=0.2,
+        max_tokens=900,
+    )
+    return (resp.choices[0].message.content or "").strip()
+
+def call_cohere(system_prompt: str, user_prompt: str) -> str:
+    """Cohere chat (adjust model if needed)."""
+    if not cohere or not COHERE_API_KEY:
+        raise RuntimeError("Cohere is not configured.")
+    client = cohere.Client(api_key=COHERE_API_KEY)
+    resp = client.chat(
+        model="command-r-plus",
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user",  "content": user_prompt}
+        ],
+        temperature=0.2,
+        max_tokens=900,
+    )
+    text = getattr(resp, "text", None) or (getattr(resp, "output_text", None))
+    if not text and hasattr(resp, "message") and hasattr(resp.message, "content"):
+        parts = resp.message.content
+        text = "".join(getattr(p, "text", "") for p in parts)
+    return (text or "").strip()
+
+def call_llm(system_prompt: str, user_prompt: str) -> str:
+    if LLM_PROVIDER == "openai":
+        return call_openai(system_prompt, user_prompt)
+    elif LLM_PROVIDER == "cohere":
+        return call_cohere(system_prompt, user_prompt)
+    else:
+        raise RuntimeError("Unsupported LLM_PROVIDER")
+
+def compose_live_user_prompt(query: str, hits: List[Dict[str, str]]) -> str:
+    citation_block = build_citation_block(hits)
+    today = datetime.now().strftime("%B %d, %Y")
+    return (
+        f"User question (time-sensitive): {query}\n"
+        f"Date today: {today}\n\n"
+        f"You have these top search results. Answer using only what these sources support. "
+        f"Be concise and include a 'Sources' section with numbered citations pointing to the links.\n\n"
+        f"{citation_block}\n\n"
+        f"Now write the answer:"
+    )
+
+def compose_general_user_prompt(query: str) -> str:
+    today = datetime.now().strftime("%B %d, %Y")
+    return (
+        f"User question: {query}\n"
+        f"(Answer in simple, neutral English. If facts might have changed after {today}, mention that briefly.)"
+    )

pytrade.py

@@ -15,6 +15,18 @@ import json
 import os
 import time
 import requests
+from typing import List, Dict
+from chatbot import (
+        normalize_entities,
+        needs_live_context,
+        pick_is_news,
+        serpapi_search,
+        compose_live_user_prompt,
+        compose_general_user_prompt,
+        call_llm,
+        BASE_SYSTEM_PROMPT,
+        SEARCH_TOPK
+    )
 
 app = Flask(__name__)
 
@@ -109,6 +121,61 @@ def analyze_all():
     except Exception as e:
         return jsonify({"error": str(e)}), 500
 
+
+
+@app.route("/chat", methods=["POST"])
+def chat():
+    """
+    Request JSON:
+      { "message": "your question" }
+      or
+      { "question": "your question" }
+
+    Response JSON:
+      {
+        "answer": "...",
+        "live": true/false,
+        "sources": [{title, link, source, snippet}]
+      }
+    """
+    data = request.get_json(force=True, silent=True) or {}
+    message = (data.get("message") or data.get("question") or "").strip()
+
+    if not message:
+        return jsonify({"error": "message or question is required"}), 400
+
+    # Normalize common aliases (e.g., TCS -> Tata Consultancy Services)
+    message = normalize_entities(message)
+
+    # Decide if this needs live context
+    live = needs_live_context(message)
+
+    hits: List[Dict[str, str]] = []
+    if live:
+        is_news = pick_is_news(message)
+        try:
+            hits = serpapi_search(message, is_news=is_news, num=SEARCH_TOPK)
+        except Exception:
+            hits = []
+            live = False
+
+    try:
+        if live and hits:
+            user_prompt = compose_live_user_prompt(message, hits)
+            answer = call_llm(BASE_SYSTEM_PROMPT, user_prompt)
+            return jsonify({"answer": answer, "live": True, "sources": hits})
+        else:
+            user_prompt = compose_general_user_prompt(message)
+            answer = call_llm(BASE_SYSTEM_PROMPT, user_prompt)
+            return jsonify({"answer": answer, "live": False, "sources": []})
+    except Exception as e:
+        return jsonify({
+            "error": "LLM call failed",
+            "details": str(e),
+            "live": live,
+            "sources": hits
+        }), 500
+
 if __name__ == "__main__":
     # Default to 5000 locally; on Hugging Face Spaces the platform injects PORT.
     port = int(os.environ.get("PORT", "5000"))

requirements.txt

@@ -15,3 +15,10 @@ lxml_html_clean
 nltk
 rapidfuzz
 gunicorn
+torch
+dotenv
+gunicorn
+torch
+python-dotenv
+openai>=1.0.0
+