first version with search tool

app.py

@@ -1,8 +1,16 @@
 import os
-import gradio as gr
-import requests
-import inspect
-import pandas as pd
+from IPython.display import Image, display
+from typing import TypedDict, List, Dict, Any, Optional
+from langgraph.graph import StateGraph, START, END
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, AIMessage
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+#from langchain_community.tools import DuckDuckGoSearchRun
+from langgraph.prebuilt import ToolNode, tools_condition
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.utils.function_calling import convert_to_openai_tool
+from langchain.tools import Tool
+from serpapi import GoogleSearch
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -10,14 +18,142 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+
+SERPAPI_API_KEY = SERPAPI_TOKEN
+
+def serpapi_search(query: str) -> str:
+    print(f"Running SerpAPI search for: {query}")
+    params = {
+        "engine": "google",
+        "q": query,
+        "api_key": SERPAPI_API_KEY,
+        "num": 3,
+    }
+    search = GoogleSearch(params)
+    results = search.get_dict()
+    if "organic_results" in results:
+        snippets = [item.get("snippet", "") for item in results["organic_results"]]
+        return "\n".join(snippets)
+    return "No results found."
+
+serpapi_tool = Tool(
+    name="serpapi_search",
+    func=serpapi_search,
+    description="A tool that allows you to search the web using Google via SerpAPI. Input should be a search query."
+)
+
+# Initialize LLM
+model = ChatOpenAI( model="gpt-4o",temperature=0)
+vision_llm = ChatOpenAI(model="gpt-4o")
+
+#search_tool = DuckDuckGoSearchRun()
+tools = [serpapi_tool]
+
+llm_with_tools = model.bind_tools(tools, parallel_tool_calls=False)
+
+class AgentState(TypedDict):
+    question: Dict[str, Any]
+    messages: List[Any]
+    answer: Optional[str]
+    tool_calls: Optional[list]
+    tool_outputs: Optional[list]
+
+def assistant(state: AgentState):
+    print("\n--- ASSISTANT NODE ---")
+    print(f"State received: {state}")
+    question = state["question"]
+    print(f"Question dict: {question}")
+    #textual_description_of_tool = """
+    #search_tool: A tool that allows you to search the web using DuckDuckGo. It returns a list of search results based on the query provided.
+    #"""
+    textual_description_of_tool = """
+    serpapi_search: A tool that allows you to search the web using Google via SerpAPI. It returns a list of search results based on the query provided.
+    """
+    system_prompt = SystemMessage(
+        content=f"""
+        You are an expert assistant. Try to answer the question as accurately as possible.
+        You can use the following tools to help you:
+        {textual_description_of_tool}
+        """
+    )
+    user_prompt = HumanMessage(content=f"Question: {question.get('question', question)}")
+    messages = [system_prompt, user_prompt] + state.get("messages", [])
+    # If tool_outputs exist, add them as context
+    if state.get("tool_outputs"):
+        messages.append(HumanMessage(content=f"Tool results: {state['tool_outputs']}"))
+    print(f"Messages sent to LLM: {messages}")
+    response = llm_with_tools.invoke(messages)
+    print(f"Raw LLM response: {response}")
+    # If the LLM wants to call a tool, store tool_calls in state
+    tool_calls = getattr(response, "tool_calls", None)
+    if tool_calls:
+        print(f"Tool calls requested: {tool_calls}")
+        state["tool_calls"] = tool_calls
+        state["answer"] = ""  # Not final yet
+    else:
+        state["answer"] = response.content.strip()
+        print(f"Model response: {state['answer']}")
+        state.setdefault("messages", []).append(AIMessage(content=state["answer"]))
+    return state
+
+def tool_node(state: AgentState):
+    print("\n--- TOOL NODE ---")
+    print(f"State received: {state}")
+    outputs = []
+    for call in state.get("tool_calls", []):
+        print(f"Tool call: {call}")
+        args = call.get("args", {})
+        # Try to get 'query' or fallback to the first value
+        query = args.get("query")
+        if query is None and len(args) > 0:
+            query = list(args.values())[0]
+        print(f"Query to use: {query}")
+        if call["name"] == "serpapi_search":
+            try:
+                result = serpapi_search(query)
+            except Exception as e:
+                print(f"Error running SerpAPI search: {e}")
+                result = f"Error: {e}"
+            outputs.append(result)
+    state["tool_outputs"] = outputs
+    state["tool_calls"] = None  # Clear tool calls
+    return state
+
+#building the graph
+answering_graph = StateGraph(AgentState)
+
+# Add nodes
+answering_graph.add_node("assistant", assistant)
+#answering_graph.add_node("tools", ToolNode(tools))
+answering_graph.add_node("tools", tool_node)
+
+# Add edges
+answering_graph.add_edge(START, "assistant")
+answering_graph.add_conditional_edges(
+    "assistant",
+    lambda state: "tools" if state.get("tool_calls") else END
+)
+answering_graph.add_edge("tools", "assistant")
+
+# Compile the graph
+compiled_graph = answering_graph.compile()
+
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+
+        initial_state = {
+            "question": question,
+            "messages": [],
+            "answer": None
+        }
+
+        print(f"Initial state: {initial_state}")
+        answer = compiled_graph.invoke(initial_state)
+        print(f"Agent returning answer: {answer}")
+        return answer
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """

requirements.txt

@@ -1,2 +1,12 @@
+langchain
+langchain-openai
+langchain-huggingface
+langchain-community
+langgraph
+openai
+google-search-results
+serpapi
 gradio
-requests
+requests
+pandas
+ipython