langgraph with openai + seperate llamaindex with subfolder

app.py

@@ -3,96 +3,16 @@ import gradio as gr
 import requests
 import pandas as pd
 
-from llama_index.core import PromptTemplate
-from llama_index.core.workflow import Context
-from llama_index.core.agent.workflow import ReActAgent, AgentStream, ToolCallResult
-from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI # customized to support different provider
-from llama_index.tools.wikipedia import WikipediaToolSpec
-from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
-from llama_index.tools.code_interpreter import CodeInterpreterToolSpec
-
-from config import HF_MODEL_NAME, HF_PROVIDER
-from prompt import custom_react_system_header_str
-from custom_tools import query_image_tool, automatic_speech_recognition_tool
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-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
-
-class LLamaIndexAgent:
-    def __init__(self,
-                 model_name="Qwen/Qwen2.5-Coder-32B-Instruct",
-                 provider="hf-inference",
-                 show_tools_desc=True,
-                 show_prompt=True):
-
-        # LLM definition
-        llm = HuggingFaceInferenceAPI(model_name=model_name,
-                                      provider=provider)
-        print(f"LLamaIndexAgent initialized with model \"{model_name}\"")
-
-        # tools definition
-        tool_spec_list = []
-        tool_spec_list += WikipediaToolSpec().to_tool_list()
-        tool_spec_list += DuckDuckGoSearchToolSpec().to_tool_list()
-        tool_spec_list += CodeInterpreterToolSpec().to_tool_list()
-        tool_spec_list += [query_image_tool, automatic_speech_recognition_tool]
-
-        # agent definition
-        self.agent = ReActAgent(llm=llm, tools=tool_spec_list)
-
-        # update default prompt with a custom one
-        custom_react_system_header = PromptTemplate(custom_react_system_header_str)
-        self.agent.update_prompts({"react_header": custom_react_system_header})
 
-        # context definition
-        self.ctx = Context(self.agent)
+# --- Choice of framework (either "langgraph" or "llamaindex") ---
+# FRAMEWORK = 'langgraph'
+FRAMEWORK = 'llamaindex'
 
-        if show_tools_desc:
-            for i, tool in enumerate(tool_spec_list):
-                print("\n" + "="*30 + f" Tool {i+1} " + "="*30)
-                print(tool.metadata.description)
-
-        if show_prompt:
-            prompt_dict = self.agent.get_prompts()
-            for k, v in prompt_dict.items():
-                print("\n" + "="*30 + f" Prompt: {k} " + "="*30)
-                print(v.template)
-
-    async def __call__(self, question: str) -> str:
-        print("\n\n"+"*"*50)
-        print(f"Agent received question: {question}")
-        print("*"*50)
-
-        handler = self.agent.run(question, ctx=self.ctx)
-        async for ev in handler.stream_events():
-            # if isinstance(ev, ToolCallResult):
-            #     print(f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}")
-            if isinstance(ev, AgentStream):
-                print(f"{ev.delta}", end="", flush=True)
-
-        response = await handler
-
-        # post-process the response (cast AgentOutput to str and keep only what's after "FINAL ANSWER:" for the exact match)
-        response = str(response)
-        try:
-            response = response.split("FINAL ANSWER:")[-1].strip()
-        except:
-            print('Could not split response on "FINAL ANSWER:"')
-        print("\n\n"+"-"*50)
-        print(f"Agent returning with answer: {response}")
-        return response
 
 async def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
@@ -115,9 +35,17 @@ async def run_and_submit_all(profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent (modify this part to create your agent)
     try:
-        # agent = BasicAgent()
-        agent = LLamaIndexAgent(model_name=HF_MODEL_NAME,
-                                provider=HF_PROVIDER)
+        if FRAMEWORK == 'langgraph':
+            from langgraph_dir.config import OPENAI_MODEL_NAME
+            from langgraph_dir.agent import LangGraphAgent
+            agent = LangGraphAgent(model_name=OPENAI_MODEL_NAME)
+        elif FRAMEWORK == 'llamaindex':
+            from llamaindex_dir.config import HF_MODEL_NAME, HF_PROVIDER
+            from llamaindex_dir.agent import LLamaIndexAgent
+            agent = LLamaIndexAgent(model_name=HF_MODEL_NAME, provider=HF_PROVIDER)
+        else:
+            raise AttributeError(
+                f"FRAMEWORK can either be 'langgraph' or 'llamaindex', received: '{FRAMEWORK}'")
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None

langgraph_dir/agent.py

@@ -0,0 +1,129 @@
+from typing import Literal
+
+from langchain_openai import ChatOpenAI
+from langgraph.graph import MessagesState
+from langchain_core.messages import SystemMessage, HumanMessage, ToolMessage
+from langgraph.graph import StateGraph, START, END
+
+from .prompt import system_prompt
+from .custom_tools import multiply, add, divide
+
+
+class LangGraphAgent:
+    def __init__(self,
+                 model_name="gpt-4.1-nano",
+                 show_tools_desc=True,
+                 show_prompt=True):
+
+        # =========== LLM definition ===========
+        llm = ChatOpenAI(model=model_name, temperature=0)
+        print(f"LangGraphAgent initialized with model \"{model_name}\"")
+
+        # =========== Augment the LLM with tools ===========
+        tools = [add, multiply, divide]
+        tools_by_name = {tool.name: tool for tool in tools}
+        llm_with_tools = llm.bind_tools(tools)
+
+        # tool_spec_list += WikipediaToolSpec().to_tool_list()
+        # tool_spec_list += DuckDuckGoSearchToolSpec().to_tool_list()
+        # tool_spec_list += CodeInterpreterToolSpec().to_tool_list()
+        # tool_spec_list += [query_image_tool, automatic_speech_recognition_tool]
+
+
+        # =========== Agent definition ===========
+
+        # Nodes
+        def llm_call(state: MessagesState):
+            """LLM decides whether to call a tool or not"""
+
+            return {
+                "messages": [
+                    llm_with_tools.invoke(
+                        [
+                            SystemMessage(
+                                content=system_prompt
+                            )
+                        ]
+                        + state["messages"]
+                    )
+                ]
+            }
+
+        def tool_node(state: dict):
+            """Performs the tool call"""
+
+            result = []
+            for tool_call in state["messages"][-1].tool_calls:
+                tool = tools_by_name[tool_call["name"]]
+                observation = tool.invoke(tool_call["args"])
+                result.append(ToolMessage(content=observation, tool_call_id=tool_call["id"]))
+            return {"messages": result}
+
+
+        # Conditional edge function to route to the tool node or end based upon whether the LLM made a tool call
+        def should_continue(state: MessagesState) -> Literal["environment", END]:
+            """Decide if we should continue the loop or stop based upon whether the LLM made a tool call"""
+
+            messages = state["messages"]
+            last_message = messages[-1]
+            # If the LLM makes a tool call, then perform an action
+            if last_message.tool_calls:
+                return "Action"
+            # Otherwise, we stop (reply to the user)
+            return END
+
+        # Build workflow
+        agent_builder = StateGraph(MessagesState)
+
+        # Add nodes
+        agent_builder.add_node("llm_call", llm_call)
+        agent_builder.add_node("environment", tool_node)
+
+        # Add edges to connect nodes
+        agent_builder.add_edge(START, "llm_call")
+        agent_builder.add_conditional_edges(
+            "llm_call",
+            should_continue,
+            {
+                # Name returned by should_continue : Name of next node to visit
+                "Action": "environment",
+                END: END,
+            },
+        )
+        agent_builder.add_edge("environment", "llm_call")
+
+        # Compile the agent
+        self.agent = agent_builder.compile()
+
+
+        # if show_tools_desc:
+        #     for i, tool in enumerate(tool_spec_list):
+        #         print("\n" + "="*30 + f" Tool {i+1} " + "="*30)
+        #         print(tool.metadata.description)
+
+        # if show_prompt:
+        #     prompt_dict = self.agent.get_prompts()
+        #     for k, v in prompt_dict.items():
+        #         print("\n" + "="*30 + f" Prompt: {k} " + "="*30)
+        #         print(v.template)
+
+    def __call__(self, question: str) -> str:
+        print("\n\n"+"*"*50)
+        print(f"Agent received question: {question}")
+        print("*"*50)
+
+        # Invoke
+        messages = [HumanMessage(content=question)]
+        messages = self.agent.invoke({"messages": messages})
+        for m in messages["messages"]:
+            m.pretty_print()
+
+        # post-process the response (keep only what's after "FINAL ANSWER:" for the exact match)
+        response = str(messages["messages"][-1].content)
+        try:
+            response = response.split("FINAL ANSWER:")[-1].strip()
+        except:
+            print('Could not split response on "FINAL ANSWER:"')
+        print("\n\n"+"-"*50)
+        print(f"Agent returning with answer: {response}")
+        return response

langgraph_dir/config.py

@@ -0,0 +1 @@
+OPENAI_MODEL_NAME = "gpt-4.1-nano"

langgraph_dir/custom_tools.py

@@ -0,0 +1,33 @@
+from langchain_core.tools import tool
+
+@tool
+def multiply(a: int, b: int) -> int:
+    """Multiply a and b.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a * b
+
+
+@tool
+def add(a: int, b: int) -> int:
+    """Adds a and b.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a + b
+
+
+@tool
+def divide(a: int, b: int) -> float:
+    """Divide a and b.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a / b

langgraph_dir/prompt.py

@@ -0,0 +1,9 @@
+# customized GAIA system prompt
+system_prompt = """\
+You are a general AI assistant with tools.
+I will ask you a question. Use your tools, and answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER]. \
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings.
+If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise.
+If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise.
+If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
+"""

llamaindex_dir/agent.py

@@ -0,0 +1,74 @@
+from llama_index.core import PromptTemplate
+from llama_index.core.workflow import Context
+from llama_index.core.agent.workflow import ReActAgent, AgentStream, ToolCallResult
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI # customized to support different provider
+from llama_index.tools.wikipedia import WikipediaToolSpec
+from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
+from llama_index.tools.code_interpreter import CodeInterpreterToolSpec
+
+from .prompt import custom_react_system_header_str
+from .custom_tools import query_image_tool, automatic_speech_recognition_tool
+
+class LLamaIndexAgent:
+    def __init__(self,
+                 model_name="Qwen/Qwen2.5-Coder-32B-Instruct",
+                 provider="hf-inference",
+                 show_tools_desc=True,
+                 show_prompt=True):
+
+        # LLM definition
+        llm = HuggingFaceInferenceAPI(model_name=model_name,
+                                      provider=provider)
+        print(f"LLamaIndexAgent initialized with model \"{model_name}\"")
+
+        # tools definition
+        tool_spec_list = []
+        tool_spec_list += WikipediaToolSpec().to_tool_list()
+        tool_spec_list += DuckDuckGoSearchToolSpec().to_tool_list()
+        tool_spec_list += CodeInterpreterToolSpec().to_tool_list()
+        tool_spec_list += [query_image_tool, automatic_speech_recognition_tool]
+
+        # agent definition
+        self.agent = ReActAgent(llm=llm, tools=tool_spec_list)
+
+        # update default prompt with a custom one
+        custom_react_system_header = PromptTemplate(custom_react_system_header_str)
+        self.agent.update_prompts({"react_header": custom_react_system_header})
+
+        # context definition
+        self.ctx = Context(self.agent)
+
+        if show_tools_desc:
+            for i, tool in enumerate(tool_spec_list):
+                print("\n" + "="*30 + f" Tool {i+1} " + "="*30)
+                print(tool.metadata.description)
+
+        if show_prompt:
+            prompt_dict = self.agent.get_prompts()
+            for k, v in prompt_dict.items():
+                print("\n" + "="*30 + f" Prompt: {k} " + "="*30)
+                print(v.template)
+
+    async def __call__(self, question: str) -> str:
+        print("\n\n"+"*"*50)
+        print(f"Agent received question: {question}")
+        print("*"*50)
+
+        handler = self.agent.run(question, ctx=self.ctx)
+        async for ev in handler.stream_events():
+            # if isinstance(ev, ToolCallResult):
+            #     print(f"\nCall {ev.tool_name} with {ev.tool_kwargs}\nReturned: {ev.tool_output}")
+            if isinstance(ev, AgentStream):
+                print(f"{ev.delta}", end="", flush=True)
+
+        response = await handler
+
+        # post-process the response (cast AgentOutput to str and keep only what's after "FINAL ANSWER:" for the exact match)
+        response = str(response)
+        try:
+            response = response.split("FINAL ANSWER:")[-1].strip()
+        except:
+            print('Could not split response on "FINAL ANSWER:"')
+        print("\n\n"+"-"*50)
+        print(f"Agent returning with answer: {response}")
+        return response

config.py → llamaindex_dir/config.py

@@ -5,4 +5,4 @@ HF_PROVIDER = "nebius"
 # HF_PROVIDER = "hf-inference"
 
 # HF_MODEL_NAME = "Qwen/Qwen3-32B"
-# HF_PROVIDER = "hf-inference"
+# HF_PROVIDER = "hf-inference"

custom_tools.py → llamaindex_dir/custom_tools.py

@@ -1,5 +1,3 @@
-# custom tools
-
 from huggingface_hub import InferenceClient
 from llama_index.core.tools import FunctionTool
 

requirements.txt

@@ -4,4 +4,7 @@ llama-index
 llama-index-llms-huggingface-api @ git+https://github.com/guillaumefrd/llama_index.git@add-provider-HF-API#subdirectory=llama-index-integrations/llms/llama-index-llms-huggingface-api
 llama_index.tools.wikipedia
 llama_index.tools.duckduckgo
-llama_index.tools.code_interpreter
+llama_index.tools.code_interpreter
+langchain
+langgraph
+langchain-openai