Spaces:
Running
Running
| import time | |
| from langchain_community.tools import DuckDuckGoSearchRun | |
| from cerebras.cloud.sdk import Cerebras | |
| from langchain_openai import ChatOpenAI | |
| import os | |
| import requests | |
| import asyncio | |
| import aiohttp | |
| import textwrap | |
| import re | |
| from datetime import datetime, timedelta | |
| from auth import save_chats | |
| from bs4 import BeautifulSoup | |
| from openai import OpenAI | |
| from duckduckgo_search import DDGS | |
| from PyPDF2 import PdfReader | |
| from docx import Document | |
| from urllib.parse import urlparse, quote | |
| from retry import retry # For retrying flaky operations | |
| from groq import Groq # For the second AI (Qwen-3-32B) | |
| # ================== PHILIPPINE LOCAL + MAX SEARCH + DEEP-THINK LENIENT FILTER ================== | |
| PHILIPPINE_LOCATIONS = [ | |
| "bacolod", "negros occidental", "negros", "iloilo", "cebu", "davao", "manila", "quezon", | |
| "makati", "pasig", "taguig", "cagayan de oro", "zamboanga", "general santos", "dumaguete", | |
| "tacloban", "ormoc", "dipolog", "pagadian", "roxas city", "kalibo", "antique", "capiz", | |
| "guimaras", "siquijor", "bohol", "leyte", "samar", "masbate" | |
| ] | |
| def is_philippine_local_query(query: str) -> bool: | |
| q = query.lower() | |
| return any(loc in q for loc in PHILIPPINE_LOCATIONS) | |
| def enhance_query(query: str) -> str: | |
| today_date = datetime.now().strftime("%B %d, %Y") | |
| q = query.lower().strip() | |
| if q in ["news today", "news", "today", "latest news", "headlines", "breaking news"]: | |
| return f"top world news headlines {today_date} breaking news" | |
| if is_philippine_local_query(query): | |
| return f"{query} Philippines latest news {today_date}" | |
| if any(w in q for w in ['today', 'latest', 'breaking', 'current', 'now']): | |
| return f"{query} latest {today_date}" | |
| return query | |
| def get_cutoff_days(query: str) -> int: | |
| """Smart cutoff: very strict for "today", lenient for deep sub-queries""" | |
| q = query.lower() | |
| if any(x in q for x in ["today", "breaking", "just now", "live", "happening now"]): | |
| return 3 | |
| if any(x in q for x in ["this week", "latest", "recent update", "current"]): | |
| return 10 | |
| if any(x in q for x in ["controversy", "alternative", "debate", "criticism", "scandal", "views"]): | |
| return 90 # Deep Think needs these | |
| if any(x in q for x in ["solution", "how to", "fix", "analysis", "details", "updates", "mainstream"]): | |
| return 45 | |
| if is_philippine_local_query(query) or "news" in q: | |
| return 12 | |
| return 35 | |
| def get_domain(url: str) -> str: | |
| try: | |
| return urlparse(url).netloc.lower().replace("www.", "").replace("m.", "") | |
| except: | |
| return "" | |
| def domain_score(url: str, is_ph: bool) -> int: | |
| dom = get_domain(url) | |
| RELIABLE_PH = {"inquirer.net", "rappler.com", "philstar.com", "gmanetwork.com", "abs-cbnnews.com", | |
| "manilatimes.net", "cnnphilippines.com", "mb.com.ph", "businessworld.com.ph", "pna.gov.ph"} | |
| RELIABLE_GLOBAL = {"reuters.com", "apnews.com", "bbc.com", "nytimes.com", "bloomberg.com", "theguardian.com", "aljazeera.com"} | |
| if dom in (RELIABLE_PH if is_ph else RELIABLE_GLOBAL): | |
| return 95 | |
| if dom.endswith(".ph") or "gov.ph" in dom: | |
| return 75 | |
| if any(g in dom for g in RELIABLE_GLOBAL): | |
| return 85 | |
| return 45 | |
| def parse_ddgs_date(date_str: str): | |
| if not date_str or date_str.lower() in ["recent", ""]: | |
| return datetime.now() | |
| date_str = date_str.lower() | |
| now = datetime.now() | |
| match = re.search(r"(\d+)\s*(hour|day|week|month|min)", date_str) | |
| if match: | |
| num = int(match.group(1)) | |
| unit = match.group(2) | |
| if "min" in unit or "hour" in unit: return now - timedelta(hours=max(1, num)) | |
| if "day" in unit: return now - timedelta(days=num) | |
| if "week" in unit: return now - timedelta(weeks=num) | |
| if "month" in unit: return now - timedelta(days=num * 30) | |
| try: | |
| return datetime.strptime(date_str[:10], "%Y-%m-%d") | |
| except: | |
| return now | |
| async def fetch_full_content_async(session, url: str): | |
| try: | |
| headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'} | |
| async with session.get(url, headers=headers, timeout=12) as response: | |
| if response.status != 200: | |
| return None | |
| text = await response.text() | |
| soup = BeautifulSoup(text, 'html.parser') | |
| for tag in soup(["script", "style", "nav", "footer", "header", "aside"]): | |
| tag.decompose() | |
| content = ' '.join(p.get_text(strip=True) for p in soup.find_all('p') if len(p.get_text(strip=True)) > 25) | |
| return content[:4800] if len(content) > 100 else None | |
| except Exception as e: | |
| return None | |
| # Retry on failures | |
| async def web_search_async(query, max_results=120): | |
| """MAX websites + 3-stage fallback = Grok-level deep search that NEVER returns empty""" | |
| try: | |
| enhanced = enhance_query(query) | |
| is_ph = is_philippine_local_query(query) | |
| cutoff_days = get_cutoff_days(query) | |
| # === DYNAMIC TODAY DATE (used in all fallbacks) === | |
| today_str = datetime.now().strftime("%B %d, %Y") | |
| with DDGS() as ddgs: | |
| raw = [] | |
| try: raw.extend(list(ddgs.news(keywords=enhanced, max_results=60, safesearch="off", region="ph-en" if is_ph else "wt-wt"))) | |
| except: pass | |
| try: raw.extend(list(ddgs.text(keywords=enhanced, max_results=80))) | |
| except: pass | |
| # Dedup + rank | |
| seen = set() | |
| unique = [r for r in raw if (url := r.get('url') or r.get('href','')) and url not in seen and url.startswith('http') and (seen.add(url) or True)] | |
| unique.sort(key=lambda r: (domain_score(r.get('url') or '', is_ph), parse_ddgs_date(r.get('date','')).timestamp()), reverse=True) | |
| # Async fetch full content (limit to top 20 to avoid overload) | |
| async with aiohttp.ClientSession() as session: | |
| tasks = [fetch_full_content_async(session, r.get('url') or r.get('href', '')) for r in unique[:20]] | |
| full_contents = await asyncio.gather(*tasks, return_exceptions=True) | |
| formatted = [] | |
| for idx, (r, full) in enumerate(zip(unique[:100], full_contents + [None] * (100 - len(full_contents)))): | |
| if isinstance(full, Exception): full = None | |
| url = r.get('url') or r.get('href', '') | |
| pub_date = parse_ddgs_date(r.get('date', '')) | |
| age_days = (datetime.now() - pub_date).days | |
| if age_days > cutoff_days + 15: continue | |
| if full and len(full) > 120: | |
| title = r.get('title', 'No title') | |
| snippet = r.get('body', '')[:800] | |
| age_str = "today" if age_days <= 1 else f"{age_days}d ago" | |
| entry = f"[{len(formatted)+1}] **{title}** ({age_str})\nSnippet: {snippet[:380]}...\n[URL: {url}]" | |
| formatted.append(entry) | |
| if len(formatted) >= 18: break | |
| # STAGE 2 & 3 FALLBACK — guarantees results | |
| if len(formatted) < 10: | |
| relaxed = cutoff_days * 3 | |
| for r in unique[30:160]: | |
| if any(r.get('url','') in e for e in formatted): continue | |
| pub_date = parse_ddgs_date(r.get('date', '')) | |
| if (datetime.now() - pub_date).days > relaxed: continue | |
| full = await fetch_full_content_async(session, r.get('url') or r.get('href','')) # Single async fetch for fallback | |
| if full: | |
| title = r.get('title', 'No title') | |
| snippet = r.get('body', '')[:800] | |
| entry = f"[{len(formatted)+1}] **{title}** ({(datetime.now()-pub_date).days}d ago - relaxed)\nSnippet: {snippet[:380]}...\n[URL: {r.get('url') or r.get('href','')}]" | |
| formatted.append(entry) | |
| if len(formatted) >= 16: break | |
| # === FIXED: Dynamic date fallback === | |
| return formatted or [f"Latest available data for \"{query}\" as of {today_str} (broad search used)."] | |
| except Exception as e: | |
| today_str = datetime.now().strftime("%B %d, %Y") # also dynamic in error case | |
| return [f"Search error: {str(e)[:120]}... Using latest available data as of {today_str}."] | |
| def web_search(query, max_results=120): | |
| """Sync wrapper for async web_search""" | |
| return asyncio.run(web_search_async(query, max_results)) | |
| def extract_file_text(file_paths): | |
| if not file_paths: | |
| return "" | |
| texts = [] | |
| for path in file_paths: | |
| try: | |
| if path.lower().endswith('.txt'): | |
| with open(path, 'r', encoding='utf-8') as f: | |
| texts.append(f"--- {os.path.basename(path)} ---\n{f.read()}") | |
| elif path.lower().endswith('.pdf'): | |
| reader = PdfReader(path) | |
| text = "\n".join(page.extract_text() or "" for page in reader.pages) | |
| texts.append(f"--- {os.path.basename(path)} ---\n{text}") | |
| elif path.lower().endswith('.docx'): | |
| doc = Document(path) | |
| text = "\n".join(para.text for para in doc.paragraphs) | |
| texts.append(f"--- {os.path.basename(path)} ---\n{text}") | |
| except Exception as e: | |
| texts.append(f"--- {os.path.basename(path)} ---\n[Error reading file: {str(e)}]") | |
| return "\n\n".join(texts)[:12000] | |
| def generate_queries(client, current_model, message, today_date): | |
| """Helper to generate smart queries for Deep Think""" | |
| try: | |
| plan_prompt = f"""Generate 3-6 complete, concise and correct keyword phrases (3-8 words max, NO operators, NO site except if asked, NO OR/AND) for deep live search on: "{quote(message)}". | |
| Include time words (today, 2026, latest, March 2026, etc.) where helpful. | |
| If a quiz is asked then be precise and straight to the point when answering. | |
| Make them varied: mainstream news, global news, background, controversy, updates, global/local, different angles. | |
| One phrase per line only. No numbers, no explanations except if asked.""" | |
| plan = client.chat.completions.create( | |
| model=current_model, | |
| messages=[{"role": "user", "content": plan_prompt}], | |
| max_tokens=250, temperature=0.4 | |
| ) | |
| return [line.strip() for line in plan.choices[0].message.content.splitlines() if line.strip()][:6] | |
| except Exception: | |
| base = message if len(message) < 60 else message[:55] | |
| return [ | |
| f"{base} latest news", | |
| f"{base} March 2026", | |
| f"{base} controversy", | |
| f"{base} updates today", | |
| f"{base} analysis", | |
| f"{base} mainstream", | |
| f"{base} world", | |
| f"{base} usa", | |
| f"{base} global" | |
| ] | |
| # Setup for the second AI model (Qwen-3-32B) | |
| client_qwen = Groq() # For using the Qwen-3-32B model | |
| def clean_response(text: str) -> str: | |
| """Strip leaked <think> blocks and extra newlines""" | |
| if not text: | |
| return "" | |
| text = re.sub(r'<think>.*?</think>', '', text, flags=re.DOTALL | re.IGNORECASE) | |
| text = re.sub(r'```(?:think|reasoning).*?```', '', text, flags=re.DOTALL | re.IGNORECASE) | |
| text = re.sub(r'\n{3,}', '\n\n', text) | |
| return text.strip() | |
| def format_sources(sources_list, max_sources=7): | |
| """Super clean, beautiful sources for both Philippine & global news""" | |
| if not sources_list: | |
| return "" | |
| formatted = [] | |
| for i, entry in enumerate(sources_list[:max_sources], 1): | |
| title = "Source" | |
| snippet = "" | |
| url = "#" | |
| if '**' in entry: | |
| title_match = re.search(r'\*\*(.+?)\*\*', entry) | |
| if title_match: | |
| title = title_match.group(1).strip() | |
| if 'Snippet:' in entry: | |
| snippet_part = entry.split('Snippet:')[1].split('\n')[0] | |
| snippet = snippet_part.strip()[:260] + "..." if len(snippet_part) > 260 else snippet_part.strip() | |
| url_match = re.search(r'\[URL:\s*(https?://[^\]]+)', entry) | |
| if url_match: | |
| url = url_match.group(1).strip() | |
| formatted.append(f"{i}. **{title}** \n {snippet}\n [Read full →]({url})") | |
| return "\n\n".join(formatted) | |
| def qwen_reasoning(message: str, search_context: str, chat_context: str = "") -> str: | |
| """Ultra-strict: 100% obeys chat instructions + only real data + specific""" | |
| system_instruction = "" | |
| if chat_context and str(chat_context).strip(): | |
| system_instruction = f"""[PERSISTENT CHAT INSTRUCTION — MUST OBEY 100% FOR THIS CHAT] | |
| {chat_context} | |
| → The ENTIRE answer must follow this instruction exactly (e.g. use only Filipino, be funny, be concise, etc.). | |
| → If it says "Use Filipino", reply 100% in Filipino. | |
| → If it says "be funny", add jokes in every response. | |
| """ | |
| prompt = textwrap.dedent(f"""\ | |
| {system_instruction}You are a precise news analyst. Use ONLY the real-time search data provided below. Do not add anything from your knowledge. | |
| Real-time search data: | |
| {search_context} | |
| User asked: "{message}" | |
| STRICT RULES: | |
| - Be extremely specific: name exact events, people, places, numbers, dates from the data only. | |
| - NEVER generalize, never say "details emerging", "potential", "focus areas", "stay tuned", or make up 2026 events. | |
| - If search data has no specific news, say exactly: "Walang major specific events sa latest searches para ngayon. Ito ang top general headlines mula sa data:" | |
| - Prioritize Philippine sources when query mentions Philippines. | |
| - Use clear markdown with bullets and bold facts. | |
| - Never output <think> or reasoning. | |
| Final answer:""") | |
| try: | |
| completion = client_qwen.chat.completions.create( | |
| model="qwen2-72b-instruct", | |
| messages=[{"role": "user", "content": prompt}], | |
| temperature=0.45, # even more factual | |
| max_tokens=2000, | |
| top_p=0.88, | |
| stream=False, | |
| ) | |
| return clean_response(completion.choices[0].message.content or "") | |
| except Exception: | |
| return "Limited verified updates available right now." | |
| # Cerebras Reviewer (strong reasoning model) | |
| cerebras_client = Cerebras( | |
| api_key=os.environ.get("CEREBRAS_API_KEY") | |
| ) | |
| # ================== MAIN CHAT STREAM (fixed and refined for all modes) ================== | |
| def chat_stream(message, history, current_model, logged_in_username, user_chats, current_chat_title, mode, auth_globals, file_paths=None, context=""): | |
| if file_paths and isinstance(file_paths, list) and len(file_paths) > 5: | |
| history.append({"role": "assistant", "content": "❌ Maximum 5 files allowed per message. Please remove some and try again."}) | |
| yield history | |
| return | |
| client = OpenAI(base_url="https://integrate.api.nvidia.com/v1", api_key=os.environ.get("API_KEY")) | |
| file_text = extract_file_text(file_paths) if file_paths else "" | |
| history = history or [] | |
| if not logged_in_username or not current_model or not current_chat_title: | |
| history.append({"role": "assistant", "content": "⚠️ Please login, load model, and select/create a chat first!"}) | |
| yield history | |
| return | |
| user_input = quote(message) | |
| if file_text: | |
| user_input += f"\n\n--- Attached files (up to 5) ---\n{file_text}" | |
| history.append({"role": "user", "content": user_input}) | |
| yield history | |
| history.append({"role": "assistant", "content": ""}) | |
| yield history | |
| today_date = datetime.now().strftime("%B %d, %Y") | |
| # === STRONG CONTEXT HANDLING (works in EVERY mode) === | |
| context_instruction = "" | |
| if context and str(context).strip(): | |
| ctx = str(context).strip() | |
| context_instruction = f"""[PERSISTENT CHAT INSTRUCTION — ALWAYS FOLLOW FOR THIS CHAT ONLY] | |
| {ctx} | |
| You MUST follow the above instruction naturally in EVERY response.""" | |
| system_context = [{"role": "system", "content": context_instruction}] if context_instruction else [] | |
| if mode == "💻 Coding Mode": | |
| # Gather persistent files | |
| coding_files_str = "" | |
| current_chat = next((chat for chat in (user_chats or []) if chat.get("title") == current_chat_title), None) | |
| if current_chat and current_chat.get("coding_files"): | |
| coding_files_str = "\n\n=== PERSISTENT PROJECT FILES ===\n" | |
| for fname, data in current_chat["coding_files"].items(): | |
| coding_files_str += f"\n--- {fname} ---\n{data['content']}\n" | |
| full_task = f"User request: {user_input}\n\nProject files:{coding_files_str}" | |
| # === STEP 1: RESEARCHER === | |
| history[-1]["content"] = "🔍 Researcher is searching StackOverflow, Reddit, GitHub..." | |
| yield history | |
| research_results = web_search(f"best solution {full_task} site:stackoverflow.com OR site:reddit.com/r/learnpython OR site:github.com", max_results=15) | |
| # === STEP 2: CODER === | |
| history[-1]["content"] += "\n🤖 Coder is writing the code..." | |
| yield history | |
| coder_prompt = f"""You are an expert senior software engineer. | |
| Project files: | |
| {coding_files_str} | |
| Research findings: | |
| {"\n\n".join(research_results[:8]) if research_results else "No external research available."} | |
| User request: {user_input} | |
| Write clean, well-commented, production-ready code.""" | |
| coder_response = client.chat.completions.create( | |
| model=current_model, | |
| messages=system_context + [{"role": "user", "content": coder_prompt}], | |
| temperature=0.3, | |
| max_tokens=4096, | |
| stream=False | |
| ).choices[0].message.content | |
| history[-1]["content"] += f"\n\n🤖 **Coder**:\n\n{coder_response}" | |
| yield history | |
| # === STEP 3: REVIEWER === | |
| history[-1]["content"] += "\n🧠 Cerebras Reviewer is doing deep analysis..." | |
| yield history | |
| reviewer_prompt = f"""You are an extremely strict senior code reviewer. | |
| Code to review: | |
| {coder_response[:3000]} | |
| User request: | |
| {user_input[:500]} | |
| Review strictly: | |
| - Bugs / logic errors | |
| - Security risks | |
| - Performance issues | |
| - Bad practices | |
| - Suggest fixes | |
| Then give the FINAL polished code. | |
| If good, say "✅ Looks solid" and return it unchanged.""" | |
| try: | |
| cerebras_response = cerebras_client.chat.completions.create( | |
| messages=system_context + [{"role": "user", "content": reviewer_prompt}], | |
| model="llama3.1-70b", | |
| stream=False, | |
| temperature=0.3, | |
| max_tokens=8192 | |
| ).choices[0].message.content or "✅ Reviewer found no major issues." | |
| except Exception as e: | |
| cerebras_response = f"Reviewer failed: {str(e)[:200]}\n\nOriginal code kept." | |
| history[-1]["content"] += f"\n\n🧠 **Cerebras Reviewer**:\n\n{cerebras_response}" | |
| yield history | |
| # Final output | |
| final_text = f"\n\n✅ **Final Polished Code**\n\n{cerebras_response}\n\n**Original version:**\n{coder_response}" | |
| history[-1]["content"] += final_text | |
| yield history | |
| elif mode == "Deep Think": | |
| history[-1]["content"] = "🧠 Deep Think mode active — searching and reasoning..." | |
| yield history | |
| # AI1 (NVIDIA): Generate queries | |
| queries = generate_queries(client, current_model, message, today_date) | |
| # Perform searches in parallel | |
| search_results = [] | |
| for q in queries: | |
| search_results.extend(web_search(q, max_results=20)) | |
| search_context = "\n\n".join(search_results[:15]) # Limit to top results | |
| history[-1]["content"] += f"\n\n🔍 Searches done on: {', '.join(queries)}" | |
| yield history | |
| # AI2 (Qwen via Groq): Initial reasoning | |
| initial_reasoning = qwen_reasoning(message, search_context, context) | |
| history[-1]["content"] += f"\n\n🤔 Initial Analysis:\n{initial_reasoning}" | |
| yield history | |
| # AI1 (Cerebras): Review and refine the reasoning | |
| review_prompt = f"""Review this initial analysis strictly for accuracy, completeness, and adherence to data: | |
| Initial Analysis: | |
| {initial_reasoning} | |
| Search Data: | |
| {search_context[:2000]} | |
| User Query: {message} | |
| Refine it: Add missing details, correct errors, ensure no hallucinations. Provide final polished response.""" | |
| try: | |
| refined_response = cerebras_client.chat.completions.create( | |
| messages=system_context + [{"role": "user", "content": review_prompt}], | |
| model="llama3.1-70b", | |
| stream=False, | |
| temperature=0.4, | |
| max_tokens=2000 | |
| ).choices[0].message.content | |
| except Exception as e: | |
| refined_response = f"Refinement failed: {str(e)[:200]}\n\nUsing initial reasoning." | |
| history[-1]["content"] += f"\n\n🧠 Refined Final Response:\n{refined_response}\n\nSources:\n{format_sources(search_results)}" | |
| yield history | |
| elif mode == "Fast Search": | |
| history[-1]["content"] = "⚡ Fast Search mode — quick web lookup..." | |
| yield history | |
| # Single AI (NVIDIA): Enhance query and search | |
| enhanced_query = enhance_query(message) | |
| search_results = web_search(enhanced_query, max_results=10) | |
| search_context = "\n\n".join(search_results) | |
| # Generate response using one AI | |
| prompt = f"""Summarize key facts from this search data for: "{message}" | |
| Data: | |
| {search_context} | |
| Be concise, use bullets.""" | |
| response = client.chat.completions.create( | |
| model=current_model, | |
| messages=system_context + [{"role": "user", "content": prompt}], | |
| temperature=0.5, | |
| max_tokens=1000, | |
| stream=False | |
| ).choices[0].message.content | |
| history[-1]["content"] += f"\n\n{response}\n\nSources:\n{format_sources(search_results, max_sources=5)}" | |
| yield history | |
| else: # Default Chat | |
| # Single AI (NVIDIA): Normal conversation | |
| full_prompt = "\n".join([msg["content"] for msg in history[-5:]]) # Last 5 messages for context | |
| response = client.chat.completions.create( | |
| model=current_model, | |
| messages=system_context + [{"role": "user", "content": full_prompt}], | |
| temperature=0.7, | |
| max_tokens=1500, | |
| stream=False | |
| ).choices[0].message.content | |
| history[-1]["content"] = response | |
| yield history | |
| # Auto-save (common for all modes) | |
| if logged_in_username and user_chats: | |
| for chat in user_chats: | |
| if chat["title"] == current_chat_title: | |
| chat["history"] = history | |
| break | |
| save_chats(logged_in_username, user_chats, auth_globals) |