resss

agent.py

@@ -1,269 +1,96 @@
 from typing import TypedDict, Annotated, List
 import operator
 import os
-import base64
-import requests
 from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+from langchain_core.messages import BaseMessage, HumanMessage
 from langgraph.graph import StateGraph, END, START
 from langgraph.prebuilt import ToolNode
-from langchain_core.tools import tool
-from langchain_community.document_loaders import YoutubeLoader, WikipediaLoader
-from langchain_community.tools import WikipediaQueryRun
-from langchain_community.utilities import WikipediaAPIWrapper
-from langchain_experimental.utilities import PythonREPL
-from langchain_chroma import Chroma
-from langchain_huggingface import HuggingFaceEmbeddings
-from langchain.tools import tool
-from langchain_community.tools import YouTubeSearchTool
-# Playwright Imports (Optional)
-try:
-    from langchain_community.agent_toolkits import PlaywrightBrowserToolkit
-    from langchain_community.tools.playwright.utils import create_sync_playwright_browser
-except ImportError:
-    PlaywrightBrowserToolkit = None
-    create_sync_playwright_browser = None
-
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_core.documents import Document
+from langchain_tavily import TavilySearch
+import google.auth
 from dotenv import load_dotenv
 
 load_dotenv()
 
-# Configure tracing
+
+# Set up Google credentials
 try:
-    if os.getenv("ARIZE_SPACE_ID") and os.getenv("ARIZE_API_KEY"):
-        from arize.otel import register
-        from openinference.instrumentation.google_genai import GoogleGenAIInstrumentor
-        from openinference.instrumentation.langchain import LangChainInstrumentor
-        
-        tracer_provider = register(
-            space_id=os.getenv("ARIZE_SPACE_ID"),
-            api_key=os.getenv("ARIZE_API_KEY"),
-            project_name=os.getenv("ARIZE_PROJECT_NAME", "langgraph-agent-test")
-        )
-        GoogleGenAIInstrumentor().instrument(tracer_provider=tracer_provider)
-        LangChainInstrumentor().instrument(tracer_provider=tracer_provider)
-        print("Tracing configured with Arize.")
-    else:
-        print("Arize tracing skipped: ARIZE_SPACE_ID or ARIZE_API_KEY not set.")
-except ImportError:
-    print("Tracing libraries not installed. Skipping tracing.")
-except Exception as e:
-    print(f"Error configuring tracing: {e}")
+    _, project_id = google.auth.default()
+    os.environ["GOOGLE_CLOUD_PROJECT"] = project_id
+    os.environ["GOOGLE_CLOUD_LOCATION"] = "global"
+    os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"
+except google.auth.exceptions.DefaultCredentialsError:
+    print("Google Cloud credentials not found. Please configure your credentials.")
+    # You might want to fall back to an API key or raise an exception here
+    # For this example, we'll proceed, but it will likely fail if not configured
+    pass
+
 
 # 1. Define the state
 class AgentState(TypedDict):
     messages: Annotated[List[BaseMessage], operator.add]
 
-# Helper to split and save documents to Chroma
-def save_to_chroma(docs):
-    if 'vector_store' in globals() and vector_store and docs:
-        try:
-            splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
-            splits = splitter.split_documents(docs)
-            if splits:
-                vector_store.add_documents(splits)
-        except Exception as e:
-            print(f"Error saving to Chroma: {e}")
-
 # 2. Define the tools
-@tool
-def get_youtube_transcript(url: str) -> str:
-    """Retrieves the transcript of a YouTube video given its URL."""
-    try:
-        loader = YoutubeLoader.from_youtube_url(url, add_video_info=True)
-        docs = loader.load()
-        if not docs:
-             return "No transcript found. Please search Google for the video title or ID."
-        
-        # Save to Chroma
-        save_to_chroma(docs)
-        
-        return "\n\n".join([f"Metadata: {d.metadata}\nContent: {d.page_content}" for d in docs])
-    except Exception as e:
-        return f"Error getting transcript: {e}. Please try searching Google for the video URL or ID."
-
-@tool
-def calculator(expression: str) -> str:
-    """Calculates a mathematical expression using Python. Example: '2 + 2', '34 * 5', 'import math; math.sqrt(2)'"""
-    try:
-        repl = PythonREPL()
-        if "print" not in expression:
-            expression = f"print({expression})"
-        return repl.run(expression)
-    except Exception as e:
-        return f"Error calculating: {e}"
-
-@tool
-def search_wikipedia(query: str) -> str:
-    """Search Wikipedia for a query. Useful for factual lists and biographies."""
-    try:
-        loader = WikipediaLoader(query=query, load_max_docs=3)
-        docs = loader.load()
-        # Save to Chroma
-        save_to_chroma(docs)
-        return "\n\n".join([d.page_content[:10000] for d in docs])
-    except Exception as e:
-        return f"Error searching Wikipedia: {e}"
-
-# ChromaDB RAG Tool
-vector_store = None
-try:
-    embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
-    vector_store = Chroma(
-        collection_name="agent_memory",
-        embedding_function=embeddings,
-        persist_directory="./chroma_db"
-    )
-except Exception as e:
-    print(f"Warning: ChromaDB initialization failed. RAG features disabled. Error: {e}")
-
-@tool
-def search_knowledge_base(query: str) -> str:
-    """Searches for relevant documents in the persistent knowledge base (memory of previous searches)."""
-    try:
-        retriever = vector_store.as_retriever()
-        docs = retriever.invoke(query)
-        if not docs:
-            return "No relevant information found."
-        return "\n".join([d.page_content for d in docs])
-    except Exception as e:
-        return f"Error searching knowledge base: {e}"
-
-@tool
-def browse_page(url: str) -> str:
-    """Browses a web page and extracts text using Playwright. Use this to read content from specific URLs."""
-    if not create_sync_playwright_browser:
-        return "Browsing unavailable (Playwright not installed)."
-    try:
-        browser = create_sync_playwright_browser(headless=True)
-        page = browser.new_page()
-        page.goto(url)
-        text = page.inner_text("body")
-        browser.close()
-        # Save to Chroma
-        if 'vector_store' in globals() and vector_store:
-             splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
-             docs = [Document(page_content=text, metadata={"source": url})]
-             splits = splitter.split_documents(docs)
-             vector_store.add_documents(splits)
-        return text[:10000]
-    except Exception as e:
-        return f"Error browsing: {e}"
-
-@tool
-def search_youtube_videos(query: str) -> str:
-    """Search for YouTube videos. Provide only the search keywords."""
-    try:
-        tool = YouTubeSearchTool()
-        return tool.run(f"{query}, 3")
-    except Exception as e:
-        return f"Error searching YouTube: {e}"
-
-# Combine Tools (Native Google Search is enabled via model param)
-# Removed rag_tool/knowledge_base as it was empty -> Adding it back now
-tools = [get_youtube_transcript, calculator, search_wikipedia, search_knowledge_base, search_youtube_videos, browse_page]
+tools = [TavilySearch(max_results=1)]
 tool_node = ToolNode(tools)
 
 # 3. Define the model
-LLM = "gemini-2.0-flash"
-model = ChatGoogleGenerativeAI(
-    model=LLM, 
-    temperature=0, 
-    max_retries=5,
-    google_search_retrieval=True
-)
+LLM = "gemini-1.5-flash"
+model = ChatGoogleGenerativeAI(model=LLM, temperature=0)
 model = model.bind_tools(tools)
 
 # 4. Define the agent node
 def should_continue(state):
     messages = state['messages']
     last_message = messages[-1]
+    # If there are no tool calls, then we finish
     if not last_message.tool_calls:
         return "end"
+    # Otherwise if there are tool calls, we continue
     else:
         return "continue"
 
 def call_model(state):
     messages = state['messages']
     response = model.invoke(messages)
+    # We return a list, because this will get added to the existing list
     return {"messages": [response]}
 
 # 5. Create the graph
 workflow = StateGraph(AgentState)
+
+# Define the two nodes we will cycle between
 workflow.add_node("agent", call_model)
 workflow.add_node("action", tool_node)
+
+# Set the entrypoint as `agent`
+# This means that this node is the first one called
 workflow.add_edge(START, "agent")
-workflow.add_conditional_edges("agent", should_continue, {"continue": "action", "end": END})
+
+# We now add a conditional edge
+workflow.add_conditional_edges(
+    "agent",
+    should_continue,
+    {
+        "continue": "action",
+        "end": END,
+    },
+)
+
+# We now add a normal edge from `tools` to `agent`.
+# This means that after `tools` is called, `agent` node is called next.
 workflow.add_edge("action", "agent")
+
+# Finally, we compile it!
+# This compiles it into a LangChain Runnable,
+# meaning you can use it as you would any other runnable
 app = workflow.compile()
 
+
 class LangGraphAgent:
     def __init__(self):
         self.app = app
 
-    def __call__(self, question: str, task_id: str = None) -> str:
-        messages = [
-            SystemMessage(content="""You are a helpful assistant with multimodal capabilities (Vision, Audio, PDF analysis).
-Step 1: ALWAYS START by performing a Google Search (or using Wikipedia/YouTube) to gather up-to-date information. Do not answer from memory.
-Step 2: If a URL is provided, search for the **EXACT URL** string on Google first to identify the video/page title. Do not add keywords yet. **DO NOT use the 'youtube_search' tool for this step; use Google Search.**
-Step 3: Once you have the title, search for that title to find descriptions or summaries.
-Step 4: Analyze the information found. If you cannot access a specific page or video directly (e.g. empty transcript), DO NOT GIVE UP. Use Google Search to find descriptions, summaries, or discussions from reliable sources.
-Step 5: If you identify relevant Wikipedia pages or YouTube videos, use the specific tools ('search_wikipedia', 'get_youtube_transcript') to ingest them into your Knowledge Base.
-Step 6: Reason to find the exact answer. Verify your findings by cross-referencing multiple sources if possible. You can use 'search_knowledge_base' to connect facts you have saved.
-Step 7: Output the final answer strictly in this format:
-FINAL ANSWER: [ANSWER]
-
-Do not include "FINAL ANSWER:" in the [ANSWER] part itself.
-Example:
-Thinking: ...
-FINAL ANSWER: 3
-
-If the question involves an image, video, or audio file provided in the context, analyze it to answer.
-"""),
-        ]
-        
-        content = []
-        content.append({"type": "text", "text": question})
-
-        if task_id:
-            image_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
-            try:
-                # Check headers first
-                response = requests.head(image_url, timeout=5)
-                mime_type = response.headers.get("Content-Type", "")
-                
-                # Allow images, audio, video, pdf
-                if response.status_code == 200 and any(t in mime_type for t in ["image/", "audio/", "video/", "application/pdf"]):
-                    # Fetch the file
-                    img_response = requests.get(image_url, timeout=10)
-                    if img_response.status_code == 200:
-                        file_data = base64.b64encode(img_response.content).decode("utf-8")
-                        content.append({
-                            "type": "image_url", # LangChain uses this key for multimodal data URI
-                            "image_url": {"url": f"data:{mime_type};base64,{file_data}"}
-                        })
-            except Exception as e:
-                print(f"Error checking/fetching file: {e}")
-
-        messages.append(HumanMessage(content=content))
-        
-        inputs = {"messages": messages}
+    def __call__(self, question: str) -> str:
+        inputs = {"messages": [HumanMessage(content=question)]}
         final_state = self.app.invoke(inputs)
-        result = final_state['messages'][-1].content
-        
-        def extract_text(content):
-            if isinstance(content, str):
-                return content
-            if isinstance(content, list):
-                return " ".join([extract_text(c) for c in content])
-            if isinstance(content, dict):
-                return content.get('text', str(content))
-            return str(content)
-
-        text_result = extract_text(result)
-        if "FINAL ANSWER:" in text_result:
-            return text_result.split("FINAL ANSWER:")[-1].strip()
-        return text_result
-
+        return final_state['messages'][-1].content

app.py

@@ -2,30 +2,16 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
-import time
-import subprocess
-import sys
 from dotenv import load_dotenv
 from agent import LangGraphAgent
 
 load_dotenv()
 
-def install_playwright():
-    try:
-        subprocess.run(["playwright", "--version"], check=True)
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        print("Installing Playwright browsers...")
-        try:
-            subprocess.run([sys.executable, "-m", "playwright", "install", "chromium"], check=True)
-            print("Playwright browsers installed.")
-        except Exception as e:
-            print(f"Failed to install Playwright browsers: {e}")
-
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-def run_and_submit_all(profile: gr.OAuthProfile | None, *args):
+def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the SimpleAgent on them, submits all answers,
     and displays the results.
@@ -89,18 +75,15 @@ def run_and_submit_all(profile: gr.OAuthProfile | None, *args):
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
-        time.sleep(2) # Rate limit to avoid 429 errors
         task_id = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text, task_id=task_id)
-            # Clean answer if agent included "FINAL ANSWER:"
-            clean_answer = submitted_answer.replace("FINAL ANSWER:", "").strip()
-            answers_payload.append({"task_id": task_id, "submitted_answer": clean_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer}) # Log original
+            submitted_answer = agent(question_text)
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer.strip()})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e:
              print(f"Error running agent on task {task_id}: {e}")
              results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
@@ -217,52 +200,7 @@ with gr.Blocks() as demo:
         outputs=[answer_textbox]
     )
 
-    def export_results(df):
-        if df is None or df.empty:
-            return None
-        file_path = "results.txt"
-        with open(file_path, "w", encoding="utf-8") as f:
-            for _, row in df.iterrows():
-                f.write(f"Task ID: {row.get('Task ID', 'N/A')}\n")
-                f.write(f"Question: {row.get('Question', 'N/A')}\n")
-                f.write(f"Answer: {row.get('Submitted Answer', 'N/A')}\n")
-                f.write("-" * 40 + "\n")
-        return file_path
-
-    gr.Markdown("---")
-    gr.Markdown("## Tools")
-    export_button = gr.Button("Export Results to Text")
-    file_output = gr.File(label="Download Results")
-
-    export_button.click(
-        fn=export_results,
-        inputs=[results_table],
-        outputs=[file_output]
-    )
-
-    with gr.Tab("Diagnostics"):
-        gr.Markdown("### Check Playwright")
-        pw_btn = gr.Button("Test Playwright")
-        pw_out = gr.Textbox(label="Result")
-        
-        def test_playwright_btn():
-            try:
-                from langchain_community.tools.playwright.utils import create_sync_playwright_browser
-                browser = create_sync_playwright_browser(headless=True)
-                page = browser.new_page()
-                page.goto("https://example.com")
-                t = page.title()
-                browser.close()
-                return f"Success! Title: {t}"
-            except ImportError:
-                return "Playwright not installed/importable."
-            except Exception as e:
-                return f"Playwright Failed: {e}"
-
-        pw_btn.click(test_playwright_btn, outputs=pw_out)
-
 if __name__ == "__main__":
-    install_playwright()
     print("\n" + "-"*30 + " App Starting " + "-"*30)
     # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")

requirements.txt

@@ -8,22 +8,4 @@ tavily-python
 langchain-google-genai
 google-auth
 langchain-tavily
-google-cloud-aiplatform
-youtube-transcript-api
-arize-otel
-openinference-instrumentation-google-genai
-openinference-instrumentation-langchain
-wikipedia
-langchain-experimental
-arxiv
-xmltodict
-chromadb
-langchain-chroma
-langchain-huggingface
-youtube-search
-sentence-transformers
-playwright
-lxml
-pytubefix
-pandas
-openpyxl
+google-cloud-aiplatform