Updated for new agent tutorial

Author: seldo

1_basic_agent.py

@@ -1,24 +1,29 @@
 from dotenv import load_dotenv
 load_dotenv()
-from llama_index.core.agent import ReActAgent
+
 from llama_index.llms.openai import OpenAI
-from llama_index.core.tools import FunctionTool
+from llama_index.core.agent.workflow import AgentWorkflow
 
 def multiply(a: float, b: float) -> float:
     """Multiply two numbers and returns the product"""
     return a * b
 
-multiply_tool = FunctionTool.from_defaults(fn=multiply)
-
 def add(a: float, b: float) -> float:
     """Add two numbers and returns the sum"""
     return a + b
 
-add_tool = FunctionTool.from_defaults(fn=add)
+llm = OpenAI(model="gpt-4o-mini")
 
-llm = OpenAI(model="gpt-3.5-turbo",temperature=0)
-agent = ReActAgent.from_tools([multiply_tool, add_tool], llm=llm, verbose=True)
+workflow = AgentWorkflow.from_tools_or_functions(
+    [multiply, add],
+    llm=llm,
+    system_prompt="You are an agent that can perform basic mathematical operations using tools."
+)
 
-response = agent.chat("What is 20+(2*4)? Use a tool to calculate every step.")
+async def main():
+    response = await workflow.run(user_msg="What is 20+(2*4)?")
+    print(response)
 
-print(response)
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

2_local_agent.py

@@ -0,0 +1,33 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from llama_index.llms.openai import OpenAI
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.tools.yahoo_finance import YahooFinanceToolSpec
+
+def multiply(a: float, b: float) -> float:
+    """Multiply two numbers and returns the product"""
+    return a * b
+
+def add(a: float, b: float) -> float:
+    """Add two numbers and returns the sum"""
+    return a + b
+
+llm = OpenAI(model="gpt-4o-mini")
+
+finance_tools = YahooFinanceToolSpec().to_tool_list()
+finance_tools.extend([multiply, add])
+
+workflow = AgentWorkflow.from_tools_or_functions(
+    finance_tools,
+    llm=llm,
+    system_prompt="You are an agent that can perform basic mathematical operations using tools."
+)
+
+async def main():
+    response = await workflow.run(user_msg="What's the current stock price of NVIDIA?")
+    print(response)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

2_tools.py

@@ -0,0 +1,52 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from llama_index.llms.openai import OpenAI
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.tools.yahoo_finance import YahooFinanceToolSpec
+from llama_index.core.workflow import Context
+from llama_index.core.workflow import JsonPickleSerializer, JsonSerializer
+
+def multiply(a: float, b: float) -> float:
+    """Multiply two numbers and returns the product"""
+    return a * b
+
+def add(a: float, b: float) -> float:
+    """Add two numbers and returns the sum"""
+    return a + b
+
+llm = OpenAI(model="gpt-4o-mini")
+
+finance_tools = YahooFinanceToolSpec().to_tool_list()
+finance_tools.extend([multiply, add])
+
+workflow = AgentWorkflow.from_tools_or_functions(
+    finance_tools,
+    llm=llm,
+    system_prompt="You are an agent that can perform basic mathematical operations using tools."
+)
+
+# configure a context to work with our workflow
+ctx = Context(workflow)
+
+async def main():
+    response = await workflow.run(user_msg="Hi, my name is Laurie!",ctx=ctx)
+    print(response)
+
+    response2 = await workflow.run(user_msg="What's my name?",ctx=ctx)
+    print(response2)
+
+    # convert our Context to a dictionary object
+    ctx_dict = ctx.to_dict(serializer=JsonSerializer())
+
+    # create a new Context from the dictionary
+    restored_ctx = Context.from_dict(
+        workflow, ctx_dict, serializer=JsonSerializer()
+    )
+
+    response3 = await workflow.run(user_msg="What's my name?",ctx=restored_ctx)
+    print(response3)
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

3_rag_agent.py

@@ -0,0 +1,41 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from llama_index.llms.openai import OpenAI
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.tools.yahoo_finance import YahooFinanceToolSpec
+from llama_index.core.workflow import Context
+
+llm = OpenAI(model="gpt-4o-mini")
+
+async def set_name(ctx: Context, name: str) -> str:
+    state = await ctx.get("state")
+    state["name"] = name
+    await ctx.set("state", state)
+    return f"Name set to {name}"
+
+workflow = AgentWorkflow.from_tools_or_functions(
+    [set_name],
+    llm=llm,
+    system_prompt="You are a helpful assistant that can set a name.",
+    initial_state={"name": "unset"},
+)
+
+async def main():
+    ctx = Context(workflow)
+
+    # check if it knows a name before setting it
+    response = await workflow.run(user_msg="What's my name?", ctx=ctx)
+    print(str(response))
+
+    # set the name using a tool
+    response2 = await workflow.run(user_msg="My name is Laurie", ctx=ctx)
+    print(str(response2))
+
+    # retrieve the value from the state directly
+    state = await ctx.get("state")
+    print("Name as stored in state: ",state["name"])
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

3_state.py

@@ -0,0 +1,51 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from llama_index.llms.openai import OpenAI
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.core.workflow import Context
+from llama_index.tools.tavily_research import TavilyToolSpec
+import os
+from llama_index.core.agent.workflow import (
+    AgentInput,
+    AgentOutput,
+    ToolCall,
+    ToolCallResult,
+    AgentStream,
+)
+
+llm = OpenAI(model="gpt-4o-mini")
+
+tavily_tool = TavilyToolSpec( api_key=os.getenv("TAVILY_API_KEY") )
+
+workflow = AgentWorkflow.from_tools_or_functions(
+    tavily_tool.to_tool_list(),
+    llm=llm,
+    system_prompt="You're a helpful assistant that can search the web for information."
+)
+
+async def main():
+    handler = workflow.run(user_msg="What's the weather like in San Francisco?")
+
+    # handle streaming output
+    async for event in handler.stream_events():
+        if isinstance(event, AgentStream):
+            print(event.delta, end="", flush=True)
+        elif isinstance(event, AgentInput):
+            print("Agent input: ", event.input)  # the current input messages
+            print("Agent name:", event.current_agent_name)  # the current agent name
+        elif isinstance(event, AgentOutput):
+            print("Agent output: ", event.response)  # the current full response
+            print("Tool calls made: ", event.tool_calls)  # the selected tool calls, if any
+            print("Raw LLM response: ", event.raw)  # the raw llm api response
+        elif isinstance(event, ToolCallResult):
+            print("Tool called: ", event.tool_name)  # the tool name
+            print("Arguments to the tool: ", event.tool_kwargs)  # the tool kwargs
+            print("Tool output: ", event.tool_output)  # the tool output            
+
+    # print final output
+    print(str(await handler))
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())

3a_tools_and_state.py

@@ -0,0 +1,64 @@
+from dotenv import load_dotenv
+load_dotenv()
+
+from llama_index.llms.openai import OpenAI
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.core.workflow import Context
+from llama_index.core.workflow import (
+    InputRequiredEvent,
+    HumanResponseEvent,
+)
+
+llm = OpenAI(model="gpt-4o-mini")
+
+# a tool that performs a dangerous task
+async def dangerous_task(ctx: Context) -> str:
+    """A dangerous task that requires human confirmation."""
+
+    # emit an event to the external stream to be captured
+    ctx.write_event_to_stream(
+        InputRequiredEvent(
+            prefix="Are you sure you want to proceed? ",
+            user_name="Laurie",
+        )
+    )
+
+    # wait until we see a HumanResponseEvent
+    response = await ctx.wait_for_event(
+        HumanResponseEvent, requirements={"user_name": "Laurie"}
+    )
+
+    # act on the input from the event
+    if response.response.strip().lower() == "yes":
+        return "Dangerous task completed successfully."
+    else:
+        return "Dangerous task aborted."
+
+workflow = AgentWorkflow.from_tools_or_functions(
+    [dangerous_task],
+    llm=llm,
+    system_prompt="You are a helpful assistant that can perform dangerous tasks.",
+)
+async def main():
+    handler = workflow.run(user_msg="I want to proceed with the dangerous task.")
+
+    async for event in handler.stream_events():
+        # capture InputRequiredEvent
+        if isinstance(event, InputRequiredEvent):
+            # capture keyboard input
+            response = input(event.prefix)
+            # send our response back
+            handler.ctx.send_event(
+                HumanResponseEvent(
+                    response=response,
+                    user_name=event.user_name,
+                )
+            )
+
+    response = await handler
+    print(str(response))
+
+
+if __name__ == "__main__":
+    import asyncio
+    asyncio.run(main())