Update app.py

app.py

@@ -1,122 +1,116 @@
+# app.py
 import os
 import logging
 import asyncio
-import nest_asyncio
-from datetime import datetime
-import uuid
-import aiohttp
-import gradio as gr
-
-from langfuse.llama_index import LlamaIndexInstrumentor
-from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
-from llama_index.tools.weather import OpenWeatherMapToolSpec
-from llama_index.tools.playwright import PlaywrightToolSpec
-from llama_index.core.tools import FunctionTool
-from llama_index.core.agent.workflow import AgentWorkflow
-from llama_index.core.workflow import Context
-from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
 from llama_index.core.memory import ChatMemoryBuffer
 from llama_index.readers.web import RssReader
 
-# Configure logging
-logging.getLogger("langfuse").setLevel(logging.WARNING)
+import subprocess
+subprocess.run(["playwright", "install"])
 
-# Initialize Langfuse instrumentor
+# allow nested loops in Spaces
+nest_asyncio.apply()
+
+# --- Llangfuse ---
 instrumentor = LlamaIndexInstrumentor(
     public_key=os.environ.get("LANGFUSE_PUBLIC_KEY"),
     secret_key=os.environ.get("LANGFUSE_SECRET_KEY"),
-    host=os.environ.get("LANGFUSE_HOST"),
 )
 instrumentor.start()
 
-# Environment variables
-hf_token = os.environ.get("HF_TOKEN")
-openweather_api_key = os.environ.get("OPENWEATHER_API_KEY")
-serper_api_key = os.environ.get("SERPER_API_KEY")
+# --- Secrets via env vars ---
+HF_TOKEN            = os.getenv("HF_TOKEN")
+# OPENAI_API_KEY      = os.getenv("OPENAI_API_KEY")
+OPENWEATHERMAP_KEY  = os.getenv("OPENWEATHERMAP_API_KEY")
+SERPER_API_KEY      = os.getenv("SERPER_API_KEY")
 
-# Initialize LLM and conversation memory
+# --- LLMs ---
 llm = HuggingFaceInferenceAPI(
     model_name="Qwen/Qwen2.5-Coder-32B-Instruct",
-    token=hf_token,
+    token=HF_TOKEN, 
     task="conversational"
 )
-memory = ChatMemoryBuffer.from_defaults(token_limit=4096)
+
+memory = ChatMemoryBuffer.from_defaults(token_limit=8192)
 today_str = datetime.now().strftime("%B %d, %Y")
 ANON_USER_ID = os.environ.get("ANON_USER_ID", uuid.uuid4().hex)
 
-# Define tools
-# DuckDuckGo web search
-duckduckgo_tool = FunctionTool.from_defaults(
-    DuckDuckGoSearchToolSpec().duckduckgo_full_search
-)
-
-# Weather tools
+# # OpenAI for pure function-calling
+# openai_llm = OpenAI(
+#     model="gpt-4o",
+#     api_key=OPENAI_API_KEY,
+#     temperature=0.0,
+#     streaming=False,
+# )
+
+# --- Tools Setup ---
+# DuckDuckGo
+duck_spec = DuckDuckGoSearchToolSpec()
+search_tool = FunctionTool.from_defaults(duck_spec.duckduckgo_full_search)
+
+# Weather
+openweather_api_key=OPENWEATHERMAP_KEY
+weather_tool_spec = OpenWeatherMapToolSpec(key=openweather_api_key)
+weather_tool_spec = OpenWeatherMapToolSpec(key=openweather_api_key)
 weather_tool = FunctionTool.from_defaults(
-    OpenWeatherMapToolSpec(key=openweather_api_key).weather_at_location,
+    weather_tool_spec.weather_at_location,
     name="current_weather",
-    description="Get the current weather for a city/country."
+    description="Get the current weather at a specific location (city, country)."
 )
 forecast_tool = FunctionTool.from_defaults(
-    OpenWeatherMapToolSpec(key=openweather_api_key).forecast_tommorrow_at_location,
+    weather_tool_spec.forecast_tommorrow_at_location,
     name="weather_forecast",
-    description="Get tomorrow's weather forecast for a city/country."
+    description="Get tomorrow's weather forecast for a specific location (city, country)."
 )
 
-# Playwright tools setup
-nest_asyncio.apply()
-browser = asyncio.get_event_loop().run_until_complete(
-    PlaywrightToolSpec.create_async_playwright_browser(
-        headless=True,
-        args=["--no-sandbox", "--disable-setuid-sandbox"]
-    )
-)
+# Playwright (synchronous start)
+async def _start_browser():
+    return await PlaywrightToolSpec.create_async_playwright_browser(headless=True)
+browser = asyncio.get_event_loop().run_until_complete(_start_browser())
+
+
+
+
 playwright_tool_spec = PlaywrightToolSpec.from_async_browser(browser)
 
 navigate_tool = FunctionTool.from_defaults(
     playwright_tool_spec.navigate_to,
     name="web_navigate",
-    description="Navigate to a URL."
+    description="Navigate to a specific URL."
 )
 extract_text_tool = FunctionTool.from_defaults(
     playwright_tool_spec.extract_text,
     name="web_extract_text",
-    description="Extract text from the current page."
+    description="Extract all text from the current page."
 )
 extract_links_tool = FunctionTool.from_defaults(
     playwright_tool_spec.extract_hyperlinks,
     name="web_extract_links",
-    description="Extract hyperlinks from the current page."
+    description="Extract all hyperlinks from the current page."
 )
 
-# Google News RSS tool
+# Google News RSS
 def fetch_google_news_rss():
-    reader = RssReader(html_to_text=True)
-    docs = reader.load_data(["https://news.google.com/rss"])
-    return [
-        {"title": doc.metadata.get("title", "").strip(), "url": doc.metadata.get("link", "")} for doc in docs
-    ]
+    docs = RssReader(html_to_text=True).load_data(["https://news.google.com/rss"])
+    return [{"title":d.metadata.get("title",""), "url":d.metadata.get("link","")} for d in docs]
+
+
+
 
 google_rss_tool = FunctionTool.from_defaults(
-    fetch_google_news_rss,
+    fn=fetch_google_news_rss,
     name="fetch_google_news_rss",
-    description="Get latest headlines and URLs from Google News RSS feed."
+    description="Fetch latest headlines and URLs from Google News RSS."
 )
 
-# Serper news API tool
+# Serper
 async def fetch_serper_news(query: str):
     if not serper_api_key:
         raise ValueError("Missing SERPER_API_KEY environment variable")
-    url = f"https://google.serper.dev/news?q={query}&tbs=qdr%3Ad"
-    headers = {"X-API-KEY": serper_api_key, "Content-Type": "application/json"}
-    async with aiohttp.ClientSession() as session:
-        async with session.get(url, headers=headers) as resp:
-            resp.raise_for_status()
-            return await resp.json()
-
 serper_news_tool = FunctionTool.from_defaults(
     fetch_serper_news,
     name="fetch_news_from_serper",
-    description="Fetch news articles on a topic via Serper API."
+    description="Fetch news articles on a given topic via the Serper API."
 )
 
 # Create the agent workflow
@@ -125,45 +119,14 @@ tools = [
     navigate_tool,
     extract_text_tool,
     extract_links_tool,
-    weather_tool,
-    forecast_tool,
-    google_rss_tool,
-    serper_news_tool,
-]
-web_agent = AgentWorkflow.from_tools_or_functions(tools, llm=llm)
-ctx = Context(web_agent)
-
-# Async helper to run agent queries
-def run_query_sync(query: str):
-    """Helper to run async agent.run in sync context."""
-    return asyncio.get_event_loop().run_until_complete(
-        web_agent.run(query, ctx=ctx)
-    )
-
-async def run_query(query: str):
-    trace_id = f"agent-run-{uuid.uuid4().hex}"
-    try:
-        with instrumentor.observe(
-            trace_id=trace_id,
-            session_id="web-agent-session",
-            user_id=ANON_USER_ID,
-        ):
-            return await web_agent.run(query, ctx=ctx)
-    finally:
-        instrumentor.flush()
 
 # Gradio interface function
 async def gradio_query(user_input, chat_history=None):
-    history = chat_history or []
+    chat_history = chat_history or []
     result = await run_query(user_input)
-    # Ensure text-only content and strip any role prefix
-    resp_text = str(result.response)
-    if resp_text.lower().startswith("assistant:"):
-        resp_text = resp_text.split(":", 1)[1].strip()
-    # Append OpenAI-style message dicts
-    history.append({"role": "user", "content": user_input})
-    history.append({"role": "assistant", "content": resp_text})
-    return history, history
+    response = result.response
+    chat_history.append((user_input, response))
+    return chat_history, chat_history
 
 # Build and launch Gradio app
 grb = gr.Blocks()
@@ -175,11 +138,10 @@ with grb:
         "🙌 Got ideas or improvements? PRs welcome!  \n\n"
         "👉 _Try asking “What’s the weather in Montreal?” or “What’s in the news today?”_"
     )
-    chatbot = gr.Chatbot(type="messages")  # use openai-style messages
+    chatbot = gr.Chatbot()  # conversation UI
     txt = gr.Textbox(placeholder="Ask me anything...", show_label=False)
     txt.submit(gradio_query, [txt, chatbot], [chatbot, chatbot])
     gr.Button("Send").click(gradio_query, [txt, chatbot], [chatbot, chatbot])
 
 if __name__ == "__main__":
-    # share=True if you want a public Space link
-    grb.launch()
+    grb.launch()