added langgraph implementation

app.py

@@ -1,4 +1,5 @@
 import os
+import time
 import gradio as gr
 import asyncio
 import requests
@@ -11,21 +12,175 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
-from llama_index.core.tools import FunctionTool
-from llama_index.core.agent.workflow import AgentWorkflow
-from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
-from llama_index.tools.wikipedia import WikipediaToolSpec
+
+from typing import TypedDict, List, Dict, Any, Optional, Annotated
+from langgraph.graph import StateGraph, START, END
+from langchain_openai import ChatOpenAI
+# from langchain_huggingface.llms import HuggingFaceEndpoint
+from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage
+from langgraph.graph.message import add_messages
+from langchain_community.utilities import WikipediaAPIWrapper
+from langchain_community.tools import WikipediaQueryRun
+from langchain_community.document_loaders import YoutubeLoader, WebBaseLoader
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
+from langgraph.prebuilt import ToolNode, tools_condition
+from langchain.tools import tool
 
 # Initialize the Hugging Face model
-llm = HuggingFaceInferenceAPI(model_name="Qwen/Qwen2.5-Coder-32B-Instruct")
 
-# Initialize the DuckDuckGo search tool
-tool_spec = DuckDuckGoSearchToolSpec()
-search_tool = FunctionTool.from_defaults(tool_spec.duckduckgo_full_search)
-# Initialize the wikipedia  tool
-wiki_spec = WikipediaToolSpec()
-wiki_tools = wiki_spec.to_tool_list()
+llm = HuggingFaceEndpoint(
+    repo_id="Qwen/Qwen3-30B-A3B", # "Qwen/Qwen2.5-72B-Instruct",
+    provider="nebius", # "hf-inference",
+    max_new_tokens=8192,
+    do_sample=False,
+    # temperature=0.,
+)
+
+chat_model = ChatHuggingFace(llm=llm)
+
+# Define tools
+
+
+@tool
+def fetch_website(url:str) -> str:
+    """Fetch the content of a website.
+    Args:
+        url: The URL of the website to fetch.
+    Returns:
+        The title and content of the website.
+    """
+    loader = WebBaseLoader(url)
+    docs = loader.load()
+    return docs[0].page_content
+
+@tool
+def ask_wiki(query: str) -> str:
+    """Retrieve information from Wikipedia based on a user query.
+    Args:
+        query: A user query.
+    Returns:
+        A single string containing the retrieved article from Wikipedia.
+    """
+    if not query.strip():
+        return "Please provide a valid query."
+    try:
+        wiki_toolapi_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=1000)
+        wiki_tool = WikipediaQueryRun(api_wrapper=wiki_toolapi_wrapper)
+        result = wiki_tool.run(query)
+        return result
+    except Exception as e:
+        return f"Error retrieving information: {str(e)}"
+
+@tool
+def youtube_transcript(url: str) -> str:
+    """Retrieve transcript from Youtube based url.
+    Args:
+        url: input youtube url.
+    Returns:
+        A single string containing the transcript of the youtube videos.
+    """
+    max_attempts = 5  # Set a maximum number of attempts
+    attempts = 0
+    loader = YoutubeLoader.from_youtube_url(url, add_video_info=False)
+    while attempts < max_attempts:
+        try:
+            docs  = loader.load()
+            return docs[0].page_content
+        except Exception as e:
+            attempts += 1
+            print(f"Attempt {attempts} failed: {e}")
+            # Optionally add a delay before retrying
+            time.sleep(1) # Import the time module
+    return "Failed to retrieve transcript after multiple attempts."
+
+# @tool
+# def divide(a: int, b: int) -> float:
+#     """Divide a and b for occasional calculations.
+#     Args:
+#         a: integer
+#         b: integer
+#     Returns:
+#         A single float containing the result of the division.
+#     """
+#     return a / b
+
+# Equip llm with tools
+tools_list = [
+    fetch_website,
+    ask_wiki,
+    youtube_transcript,
+]
+
+llm_with_tools = chat_model.bind_tools(
+    tools_list, 
+    # parallel_tool_calls=False
+)
+
+# Define Agent Workflow
+
+class AgentState(TypedDict):
+    messages: Annotated[list[AnyMessage], add_messages]
+
+
+def assistant(state: AgentState):
+    # System message
+    textual_description_of_tool="""
+fetch_website(url: str) -> str:
+    Fetch the content of a website.
+    Args:
+        url: The URL of the website to fetch.
+    Returns:
+        The title and content of the website.
+
+ask_wiki(query: str) -> str:
+    Retreive information from Wikipedia based on a user query.
+    Args:
+        query: A user query.
+    Returns:
+        A single string containing the retrieved article from Wikipedia.
+
+youtube_transcript(url: str) -> str:
+    Args:
+        url: input youtube url.
+    Returns:
+        A single string containing the transcript of the youtube videos.
+"""
+    sys_msg = SystemMessage(
+        content=f"You are a helpful assistant at answering user questions. You can access provided tools:\n{textual_description_of_tool}\n"
+    )
+
+    return {
+        "messages": [llm_with_tools.invoke([sys_msg] + state["messages"])],
+    }
+
+# Build the StateGraph for the agent
+# The graph
+builder = StateGraph(AgentState)
+
+# Define nodes: these do the work
+builder.add_node("assistant", assistant)
+builder.add_node("tools", ToolNode(tools_list))
+
+# Define edges: these determine how the control flow moves
+builder.add_edge(START, "assistant")
+builder.add_conditional_edges(
+    "assistant",
+    # If the latest message requires a tool, route to tools
+    # Otherwise, provide a direct response
+    tools_condition,
+)
+builder.add_edge("tools", "assistant")
+agent_graph = builder.compile()
+
+messages = [
+    HumanMessage(
+        # content="Who is Barack Obama?"
+        # content="Divide 6790 by 5"
+        content=user_prompt
+    )
+]
+messages = agent_graph.invoke({"messages": messages}, config={"callbacks": [langfuse_handler]})
+
 
 class BasicAgent:
     def __init__(self):
@@ -35,13 +190,19 @@ class BasicAgent:
         # fixed_answer = "This is a default answer."
         # print(f"Agent returning fixed answer: {fixed_answer}")
         # Create agent with all the tools
-        agent = AgentWorkflow.from_tools_or_functions(
-            wiki_tools,
-            llm=llm
-        )
+        
         # Example query agent might receive
-        fixed_answer = await agent.run(question)
-        return fixed_answer
+        # fixed_answer = await agent.run(question)
+        messages = [
+            HumanMessage(
+                # content="Who is Barack Obama?"
+                # content="Divide 6790 by 5"
+                content=question
+            )
+        ]
+        response_text = messages['messages'][-1].content
+        return response_text.split('</think>')[-1]
+
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """