diff --git a/python/docs/src/core-concepts/overview.md b/python/docs/src/core-concepts/overview.md index d61612ec2..408207417 100644 --- a/python/docs/src/core-concepts/overview.md +++ b/python/docs/src/core-concepts/overview.md @@ -116,7 +116,7 @@ implementation of the contracts determines how agents handle messages. The behavior contract is sometimes referred to as the message protocol. It is the developer's responsibility to implement the behavior contract. Multi-agent patterns are design patterns that emerge from behavior contracts -(see [Multi-Agent Design Patterns](../getting-started/multi-agent-design-patterns.ipynb)). +(see [Multi-Agent Design Patterns](../getting-started/multi-agent-design-patterns.md)). ### An Example Application diff --git a/python/docs/src/getting-started/group-chat.ipynb b/python/docs/src/getting-started/group-chat.ipynb new file mode 100644 index 000000000..dd2208c2a --- /dev/null +++ b/python/docs/src/getting-started/group-chat.ipynb @@ -0,0 +1,399 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Group Chat\n", + "\n", + "Group chat is a design pattern where a group of agents share a common thread\n", + "of messages: they all subscribe and publish to the same thread. Each participant\n", + "agent is specialized for a particular task, such as writer, illustrator, and editor\n", + "in a collaborative writing task.\n", + "\n", + "The order\n", + "of converation is maintained by a Group Chat Manager agent, which selects\n", + "the next agent to speak. The exact algorithm for selecting the next agent\n", + "can vary based on your application requirements. Typicall, a round-robin\n", + "algorithm or a selection by an LLM model is used.\n", + "\n", + "Group chat is useful for dynamically decomposing a complex task into smaller ones \n", + "that can be handled by specialized agents with well-defined roles.\n", + "\n", + "In this example, we implement a simple group chat system with a round-robin\n", + "Group Chat Manager to create content for a children's story book. \n", + "We use three specialized agents: a writer, an illustrator, and an editor." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Message Protocol\n", + "\n", + "The message protocol for the group chat system is simple: user publishes\n", + "a `GroupChatMessage` message to all participants.\n", + "The group chat manager sends out a `RequestToSpeak` message to the next agent\n", + "in the round-robin order, and the agent publishes `GroupChatMessage` messages,\n", + "which are consumed by all participants.\n", + "Once a conclusion is reached, in this case, the editor approves the draft,\n", + "the group chat manager stops sending `RequestToSpeak` message, and\n", + "the group chat ends." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from dataclasses import dataclass\n", + "\n", + "from agnext.components import Image\n", + "from agnext.components.models import LLMMessage\n", + "\n", + "\n", + "@dataclass\n", + "class GroupChatMessage:\n", + " body: LLMMessage\n", + "\n", + "\n", + "@dataclass\n", + "class RequestToSpeak:\n", + " pass" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Agents\n", + "\n", + "Let's first define the agents that only uses LLM models to generate text.\n", + "The `WriterAgent` is responsible for writing a draft and create a description\n", + "for the illustration.\n", + "The `EditorAgent` is responsible for approving the draft which includes\n", + "both the text written by the `WriterAgent` and the illustration\n", + "created by the `IllustratorAgent`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from typing import List\n", + "\n", + "from agnext.components import DefaultTopicId, RoutedAgent, message_handler\n", + "from agnext.components.models import AssistantMessage, ChatCompletionClient, LLMMessage, SystemMessage, UserMessage\n", + "from agnext.core import MessageContext\n", + "\n", + "\n", + "class WriterAgent(RoutedAgent):\n", + " def __init__(\n", + " self,\n", + " model_client: ChatCompletionClient,\n", + " ) -> None:\n", + " super().__init__(\"A writer\")\n", + " self._model_client = model_client\n", + " self._chat_history: List[LLMMessage] = [\n", + " SystemMessage(\n", + " \"You are a writer. Write a draft with a paragraph description of an illustration, starting the description paragraph with 'ILLUSTRATION'.\"\n", + " )\n", + " ]\n", + "\n", + " @message_handler\n", + " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", + " self._chat_history.append(message.body)\n", + "\n", + " @message_handler\n", + " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:\n", + " completion = await self._model_client.create(self._chat_history)\n", + " assert isinstance(completion.content, str)\n", + " self._chat_history.append(AssistantMessage(content=completion.content, source=\"Writer\"))\n", + " print(f\"\\n{'-'*80}\\nWriter:\\n{completion.content}\")\n", + " await self.publish_message(\n", + " GroupChatMessage(body=UserMessage(content=completion.content, source=\"Writer\")), DefaultTopicId()\n", + " )\n", + "\n", + "\n", + "class EditorAgent(RoutedAgent):\n", + " def __init__(\n", + " self,\n", + " model_client: ChatCompletionClient,\n", + " ) -> None:\n", + " super().__init__(\"An editor\")\n", + " self._model_client = model_client\n", + " self._chat_history: List[LLMMessage] = [\n", + " SystemMessage(\"You are an editor. Reply with 'APPROVE' to approve the draft\")\n", + " ]\n", + "\n", + " @message_handler\n", + " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", + " self._chat_history.append(message.body)\n", + "\n", + " @message_handler\n", + " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:\n", + " completion = await self._model_client.create(self._chat_history)\n", + " assert isinstance(completion.content, str)\n", + " self._chat_history.append(AssistantMessage(content=completion.content, source=\"Editor\"))\n", + " print(f\"\\n{'-'*80}\\nEditor:\\n{completion.content}\")\n", + " await self.publish_message(\n", + " GroupChatMessage(body=UserMessage(content=completion.content, source=\"Editor\")), DefaultTopicId()\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's define the `IllustratorAgent` which uses a DALL-E model to generate\n", + "an illustration based on the description provided by the `WriterAgent`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "\n", + "import openai\n", + "from IPython.display import display\n", + "\n", + "\n", + "class IllustratorAgent(RoutedAgent):\n", + " def __init__(self, image_client: openai.AsyncClient) -> None:\n", + " super().__init__(\"An illustrator\")\n", + " self._image_client = image_client\n", + " self._chat_history: List[LLMMessage] = []\n", + "\n", + " @message_handler\n", + " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", + " self._chat_history.append(message.body)\n", + "\n", + " @message_handler\n", + " async def handle_request_to_speak(self, message: RequestToSpeak, ctx: MessageContext) -> None:\n", + " # Generate an image using dall-e-2\n", + " last_message_text = self._chat_history[-1].content\n", + " assert isinstance(last_message_text, str)\n", + " match = re.search(r\"ILLUSTRATION(.+)\\n\", last_message_text, re.DOTALL)\n", + " print(f\"\\n{'-'*80}\\nIllustrator:\\n\")\n", + " if match is None:\n", + " print(\"No description found\")\n", + " await self.publish_message(\n", + " GroupChatMessage(UserMessage(content=\"No description found\", source=\"Illustrator\")), DefaultTopicId()\n", + " )\n", + " return\n", + " description = match.group(1)[:500]\n", + " print(description.strip())\n", + " response = await self._image_client.images.generate(\n", + " prompt=description.strip(), model=\"dall-e-2\", response_format=\"b64_json\", size=\"256x256\"\n", + " )\n", + " image = Image.from_base64(response.data[0].b64_json) # type: ignore\n", + " display(image.image) # type: ignore\n", + " await self.publish_message(\n", + " GroupChatMessage(UserMessage(content=[image], source=\"Illustrator\")), DefaultTopicId()\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lastly, we define the `GroupChatManager` agent which manages the group chat\n", + "and selects the next agent to speak in a round-robin fashion.\n", + "The group chat manager checks if the editor has approved the draft by \n", + "looking for the \"APPORVED\" keyword in the message. If the editor has approved\n", + "the draft, the group chat manager stops selecting the next speaker, and the group chat ends." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from agnext.core import AgentId\n", + "\n", + "\n", + "class GroupChatManager(RoutedAgent):\n", + " def __init__(self, participants: List[AgentId]) -> None:\n", + " super().__init__(\"Group chat manager\")\n", + " self._num_rounds = 0\n", + " self._participants = participants\n", + " self._chat_history: List[GroupChatMessage] = []\n", + "\n", + " @message_handler\n", + " async def handle_message(self, message: GroupChatMessage, ctx: MessageContext) -> None:\n", + " self._chat_history.append(message)\n", + " assert isinstance(message.body, UserMessage)\n", + " if message.body.source == \"Editor\" and \"APPROVE\" in message.body.content:\n", + " return\n", + " speaker = self._participants[self._num_rounds % len(self._participants)]\n", + " self._num_rounds += 1\n", + " await self.send_message(RequestToSpeak(), speaker)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Running the Group Chat\n", + "\n", + "To run the group chat, we create an {py:class}`~agnext.application.SingleThreadedAgentRuntime`\n", + "and register the agents' factories and subscriptions.\n", + "We then start the runtime and publish a `GroupChatMessage` to start the group chat." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------------\n", + "Writer:\n", + "**ILLUSTRATION:**\n", + "The illustration vividly captures the majestic essence of a dragon, its scales shimmering like a thousand emeralds under the moonlight. The dragon stands atop a rugged cliff, wings unfurled and casting a shadow over the ancient forest below. Its eyes, glowing with an otherworldly light, exude wisdom and power. Tendrils of smoke curl from its nostrils, blending into the mist that envelops the scene. The night sky is dotted with twinkling stars, and a full moon bathes the landscape in a silvery glow, accentuating the dragon's formidable presence. Below, the forest teems with life, unaware of the guardian watching over them from the heights above.\n", + "\n", + "**POEM:**\n", + "\n", + "In moonlit night, a dragon soared so high,\n", + "Emerald scales 'neath a starlit sky.\n", + "Upon a cliff, where whispers of ancients dwell,\n", + "Its eyes of wisdom, tales untold, foretell.\n", + "\n", + "Wings unfurled, they whisper through the night,\n", + "A guardian fierce, of forests bathed in light.\n", + "Smoke tendrils dance, coiling in the mist,\n", + "A silent sentinel, in nature's tryst.\n", + "\n", + "Stars above in silent hush adorn,\n", + "The ageless dragon, by time unshorn.\n", + "With power ancient and heart so deep,\n", + "In moonlit realms, eternal vigil keep.\n", + "\n", + "--------------------------------------------------------------------------------\n", + "Illustrator:\n", + "\n", + ":**\n", + "The illustration vividly captures the majestic essence of a dragon, its scales shimmering like a thousand emeralds under the moonlight. The dragon stands atop a rugged cliff, wings unfurled and casting a shadow over the ancient forest below. Its eyes, glowing with an otherworldly light, exude wisdom and power. Tendrils of smoke curl from its nostrils, blending into the mist that envelops the scene. The night sky is dotted with twinkling stars, and a full moon bathes the landscape in a silver\n" + ] + }, + { + "data": { + "image/jpeg": "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", + "image/png": "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", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------------\n", + "Editor:\n", + "APPROVE\n" + ] + } + ], + "source": [ + "from agnext.application import SingleThreadedAgentRuntime\n", + "from agnext.components import DefaultSubscription\n", + "from agnext.components.models import OpenAIChatCompletionClient\n", + "from agnext.core import AgentId\n", + "\n", + "runtime = SingleThreadedAgentRuntime()\n", + "\n", + "editor_type = await runtime.register(\n", + " \"editor\",\n", + " lambda: EditorAgent(\n", + " OpenAIChatCompletionClient(\n", + " model=\"gpt-4o\",\n", + " # api_key=\"YOUR_API_KEY\",\n", + " )\n", + " ),\n", + " subscriptions=lambda: [DefaultSubscription()],\n", + ")\n", + "writer_type = await runtime.register(\n", + " \"writer\",\n", + " lambda: WriterAgent(\n", + " OpenAIChatCompletionClient(\n", + " model=\"gpt-4o\",\n", + " # api_key=\"YOUR_API_KEY\",\n", + " )\n", + " ),\n", + " subscriptions=lambda: [DefaultSubscription()],\n", + ")\n", + "illustrator_type = await runtime.register(\n", + " \"illustrator\",\n", + " lambda: IllustratorAgent(\n", + " image_client=openai.AsyncClient(\n", + " # api_key=\"YOUR_API_KEY\",\n", + " )\n", + " ),\n", + " subscriptions=lambda: [DefaultSubscription()],\n", + ")\n", + "await runtime.register(\n", + " \"group_chat_manager\",\n", + " lambda: GroupChatManager(\n", + " participants=[\n", + " AgentId(writer_type, \"default\"),\n", + " AgentId(illustrator_type, \"default\"),\n", + " AgentId(editor_type, \"default\"),\n", + " ],\n", + " ),\n", + " subscriptions=lambda: [DefaultSubscription()],\n", + ")\n", + "\n", + "runtime.start()\n", + "await runtime.publish_message(\n", + " GroupChatMessage(UserMessage(content=\"Please write a short poem about a dragon with illustration.\", source=\"User\")),\n", + " DefaultTopicId(),\n", + ")\n", + "await runtime.stop_when_idle()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the output, you can see the writer, illustrator, and editor agents\n", + "taking turns to speak and collaborate to generate a poem with an illustration." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "agnext", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/docs/src/getting-started/multi-agent-design-patterns.md b/python/docs/src/getting-started/multi-agent-design-patterns.md new file mode 100644 index 000000000..3e9242f70 --- /dev/null +++ b/python/docs/src/getting-started/multi-agent-design-patterns.md @@ -0,0 +1,18 @@ +# Multi-Agent Design Patterns + +Agents can work together in a variety of ways to solve problems. +Research works like [AutoGen](https://aka.ms/autogen-paper), +[MetaGPT](https://arxiv.org/abs/2308.00352) +and [ChatDev](https://arxiv.org/abs/2307.07924) have shown +multi-agent systems out-performing single agent systems at complex tasks +like software development. + +A multi-agent design pattern is a structure that emerges from message protocols: +it describes how agents interact with each other to solve problems. +For example, the [tool-equiped agent](./tools.ipynb#tool-equipped-agent) in +the previous section employs a design pattern called ReAct, +which involves an agent interacting with tools. + +You can implement any multi-agent design pattern using AGNext agents. +In the next two sections, we will discuss two common design patterns: +group chat for task decomposition, and reflection for robustness. \ No newline at end of file diff --git a/python/docs/src/getting-started/multi-agent-design-patterns.ipynb b/python/docs/src/getting-started/reflection.ipynb similarity index 97% rename from python/docs/src/getting-started/multi-agent-design-patterns.ipynb rename to python/docs/src/getting-started/reflection.ipynb index 14799b12e..a427a8421 100644 --- a/python/docs/src/getting-started/multi-agent-design-patterns.ipynb +++ b/python/docs/src/getting-started/reflection.ipynb @@ -4,30 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Multi-Agent Design Patterns\n", - "\n", - "Agents can work together in a variety of ways to solve problems.\n", - "Research works like [AutoGen](https://aka.ms/autogen-paper),\n", - "[MetaGPT](https://arxiv.org/abs/2308.00352)\n", - "and [ChatDev](https://arxiv.org/abs/2307.07924) have shown\n", - "multi-agent systems out-performing single agent systems at complex tasks\n", - "like software development.\n", - "\n", - "A multi-agent design pattern is a structure that emerges from message protocols:\n", - "it describes how agents interact with each other to solve problems.\n", - "For example, the [tool-equiped agent](./tools.ipynb#tool-equipped-agent) in\n", - "the previous section employs a design pattern called ReAct,\n", - "which involves an agent interacting with tools.\n", - "\n", - "You can implement any multi-agent design pattern using AGNext agents.\n", - "In this section, we use the reflection pattern as an example." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Reflection\n", + "# Reflection\n", "\n", "Reflection is a design pattern where an LLM generation is followed by a reflection,\n", "which in itself is another LLM generation conditioned on the output of the first one.\n", @@ -50,7 +27,7 @@ "will generate a code snippet, and the reviewer agent will generate a critique\n", "of the code snippet.\n", "\n", - "### Message Protocol\n", + "## Message Protocol\n", "\n", "Before we define the agents, we need to first define the message protocol for the agents." ] @@ -107,7 +84,7 @@ "\n", "![coder-reviewer data flow](coder-reviewer-data-flow.svg)\n", "\n", - "### Agents\n", + "## Agents\n", "\n", "Now, let's define the agents for the reflection design pattern." ] @@ -376,7 +353,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Logging\n", + "## Logging\n", "\n", "Turn on logging to see the messages exchanged between the agents." ] @@ -397,7 +374,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Running the Design Pattern\n", + "## Running the Design Pattern\n", "\n", "Let's test the design pattern with a coding task." ] diff --git a/python/docs/src/getting-started/tools.ipynb b/python/docs/src/getting-started/tools.ipynb index 4aa35c23f..a24d26b1c 100644 --- a/python/docs/src/getting-started/tools.ipynb +++ b/python/docs/src/getting-started/tools.ipynb @@ -1,324 +1,320 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Tools\n", - "\n", - "Tools are code that can be executed by an agent to perform actions. A tool\n", - "can be a simple function such as a calculator, or an API call to a third-party service\n", - "such as stock price lookup and weather forecast.\n", - "In the context of AI agents, tools are designed to be executed by agents in\n", - "response to model-generated function calls.\n", - "\n", - "AGNext provides the {py:mod}`agnext.components.tools` module with a suite of built-in\n", - "tools and utilities for creating and running custom tools." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Built-in Tools\n", - "\n", - "One of the built-in tools is the {py:class}`agnext.components.tools.PythonCodeExecutionTool`,\n", - "which allows agents to execute Python code snippets.\n", - "\n", - "Here is how you create the tool and use it." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "from agnext.components.code_executor import LocalCommandLineCodeExecutor\n", - "from agnext.components.tools import PythonCodeExecutionTool\n", - "from agnext.core import CancellationToken\n", - "\n", - "# Create the tool.\n", - "code_executor = LocalCommandLineCodeExecutor()\n", - "code_execution_tool = PythonCodeExecutionTool(code_executor)\n", - "cancellation_token = CancellationToken()\n", - "\n", - "# Use the tool directly without an agent.\n", - "code = \"print('Hello, world!')\"\n", - "result = await code_execution_tool.run_json({\"code\": code}, cancellation_token)\n", - "print(code_execution_tool.return_value_as_string(result))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The {py:class}`~agnext.components.code_executor.LocalCommandLineCodeExecutor`\n", - "class is a built-in code executor that runs Python code snippets in a subprocess\n", - "in the local command line environment.\n", - "The {py:class}`~agnext.components.tools.PythonCodeExecutionTool` class wraps the code executor\n", - "and provides a simple interface to execute Python code snippets.\n", - "\n", - "Other built-in tools will be added in the future." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Custom Function Tools\n", - "\n", - "A tool can also be a simple Python function that performs a specific action.\n", - "To create a custom function tool, you just need to create a Python function\n", - "and use the {py:class}`agnext.components.tools.FunctionTool` class to wrap it.\n", - "\n", - "For example, a simple tool to obtain the stock price of a company might look like this:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "138.75280591295171\n" - ] - } - ], - "source": [ - "import random\n", - "\n", - "from agnext.components.tools import FunctionTool\n", - "from agnext.core import CancellationToken\n", - "from typing_extensions import Annotated\n", - "\n", - "\n", - "async def get_stock_price(ticker: str, date: Annotated[str, \"Date in YYYY/MM/DD\"]) -> float:\n", - " # Returns a random stock price for demonstration purposes.\n", - " return random.uniform(10, 200)\n", - "\n", - "\n", - "# Create a function tool.\n", - "stock_price_tool = FunctionTool(get_stock_price, description=\"Get the stock price.\")\n", - "\n", - "# Run the tool.\n", - "cancellation_token = CancellationToken()\n", - "result = await stock_price_tool.run_json({\"ticker\": \"AAPL\", \"date\": \"2021/01/01\"}, cancellation_token)\n", - "\n", - "# Print the result.\n", - "print(stock_price_tool.return_value_as_string(result))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Tool-Equipped Agent\n", - "\n", - "To use tools with an agent, you can use {py:class}`agnext.components.tool_agent.ToolAgent`,\n", - "by using it in a composition pattern.\n", - "Here is an example tool-use agent that uses {py:class}`~agnext.components.tool_agent.ToolAgent`\n", - "as an inner agent for executing tools." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "import asyncio\n", - "from dataclasses import dataclass\n", - "from typing import List\n", - "\n", - "from agnext.application import SingleThreadedAgentRuntime\n", - "from agnext.components import FunctionCall, RoutedAgent, message_handler\n", - "from agnext.components.models import (\n", - " AssistantMessage,\n", - " ChatCompletionClient,\n", - " FunctionExecutionResult,\n", - " FunctionExecutionResultMessage,\n", - " LLMMessage,\n", - " OpenAIChatCompletionClient,\n", - " SystemMessage,\n", - " UserMessage,\n", - ")\n", - "from agnext.components.tool_agent import ToolAgent, ToolException\n", - "from agnext.components.tools import FunctionTool, Tool, ToolSchema\n", - "from agnext.core import AgentId, AgentInstantiationContext, MessageContext\n", - "\n", - "\n", - "@dataclass\n", - "class Message:\n", - " content: str\n", - "\n", - "\n", - "class ToolUseAgent(RoutedAgent):\n", - " def __init__(self, model_client: ChatCompletionClient, tool_schema: List[ToolSchema], tool_agent: AgentId) -> None:\n", - " super().__init__(\"An agent with tools\")\n", - " self._system_messages: List[LLMMessage] = [SystemMessage(\"You are a helpful AI assistant.\")]\n", - " self._model_client = model_client\n", - " self._tool_schema = tool_schema\n", - " self._tool_agent = tool_agent\n", - "\n", - " @message_handler\n", - " async def handle_user_message(self, message: Message, ctx: MessageContext) -> Message:\n", - " # Create a session of messages.\n", - " session: List[LLMMessage] = [UserMessage(content=message.content, source=\"user\")]\n", - " # Get a response from the model.\n", - " response = await self._model_client.create(\n", - " self._system_messages + session, tools=self._tool_schema, cancellation_token=cancellation_token\n", - " )\n", - " # Add the response to the session.\n", - " session.append(AssistantMessage(content=response.content, source=\"assistant\"))\n", - "\n", - " # Keep iterating until the model stops generating tool calls.\n", - " while isinstance(response.content, list) and all(isinstance(item, FunctionCall) for item in response.content):\n", - " # Execute functions called by the model by sending messages to itself.\n", - " results: List[FunctionExecutionResult | BaseException] = await asyncio.gather(\n", - " *[self.send_message(call, self._tool_agent) for call in response.content],\n", - " return_exceptions=True,\n", - " )\n", - " # Combine the results into a single response and handle exceptions.\n", - " function_results: List[FunctionExecutionResult] = []\n", - " for result in results:\n", - " if isinstance(result, FunctionExecutionResult):\n", - " function_results.append(result)\n", - " elif isinstance(result, ToolException):\n", - " function_results.append(FunctionExecutionResult(content=f\"Error: {result}\", call_id=result.call_id))\n", - " elif isinstance(result, BaseException):\n", - " raise result # Unexpected exception.\n", - " session.append(FunctionExecutionResultMessage(content=function_results))\n", - " # Query the model again with the new response.\n", - " response = await self._model_client.create(\n", - " self._system_messages + session, tools=self._tool_schema, cancellation_token=cancellation_token\n", - " )\n", - " session.append(AssistantMessage(content=response.content, source=self.metadata[\"type\"]))\n", - "\n", - " # Return the final response.\n", - " assert isinstance(response.content, str)\n", - " return Message(content=response.content)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The `ToolUseAgent` class is a bit involved, however,\n", - "the core idea can be described using a simple control flow graph:\n", - "\n", - "![ToolUseAgent control flow graph](tool-use-agent-cfg.svg)\n", - "\n", - "The `ToolUseAgent`'s `handle_user_message` handler handles messages from the user,\n", - "and determines whether the model has generated a tool call.\n", - "If the model has generated tool calls, then the handler sends a function call\n", - "message to the {py:class}`~agnext.components.tool_agent.ToolAgent` agent\n", - "to execute the tools,\n", - "and then queries the model again with the results of the tool calls.\n", - "This process continues until the model stops generating tool calls,\n", - "at which point the final response is returned to the user.\n", - "\n", - "By having the tool execution logic in a separate agent,\n", - "we expose the model-tool interactions to the agent runtime as messages, so the tool executions\n", - "can be observed externally and intercepted if necessary.\n", - "\n", - "To run the agent, we need to create a runtime and register the agent." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Create a runtime.\n", - "runtime = SingleThreadedAgentRuntime()\n", - "# Create the tools.\n", - "tools: List[Tool] = [FunctionTool(get_stock_price, description=\"Get the stock price.\")]\n", - "# Register the agents.\n", - "await runtime.register(\n", - " \"tool-executor-agent\",\n", - " lambda: ToolAgent(\n", - " description=\"Tool Executor Agent\",\n", - " tools=tools,\n", - " ),\n", - ")\n", - "await runtime.register(\n", - " \"tool-use-agent\",\n", - " lambda: ToolUseAgent(\n", - " OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", - " tool_schema=[tool.schema for tool in tools],\n", - " tool_agent=AgentId(\"tool-executor-agent\", AgentInstantiationContext.current_agent_id().key),\n", - " ),\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This example uses the {py:class}`agnext.components.models.OpenAIChatCompletionClient`,\n", - "for Azure OpenAI and other clients, see [Model Clients](./model-clients.ipynb).\n", - "Let's test the agent with a question about stock price." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The stock price of NVDA on June 1, 2024, is approximately $49.28.\n" - ] - } - ], - "source": [ - "# Start processing messages.\n", - "runtime.start()\n", - "# Send a direct message to the tool agent.\n", - "tool_use_agent = AgentId(\"tool-use-agent\", \"default\")\n", - "response = await runtime.send_message(Message(\"What is the stock price of NVDA on 2024/06/01?\"), tool_use_agent)\n", - "print(response.content)\n", - "# Stop processing messages.\n", - "await runtime.stop()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "See [samples](https://github.com/microsoft/agnext/tree/main/python/samples#tool-use-examples)\n", - "for more examples of using tools with agents, including how to use\n", - "broadcast communication model for tool execution, and how to intercept tool\n", - "execution for human-in-the-loop approval." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "agnext", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 2 + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tools\n", + "\n", + "Tools are code that can be executed by an agent to perform actions. A tool\n", + "can be a simple function such as a calculator, or an API call to a third-party service\n", + "such as stock price lookup and weather forecast.\n", + "In the context of AI agents, tools are designed to be executed by agents in\n", + "response to model-generated function calls.\n", + "\n", + "AGNext provides the {py:mod}`agnext.components.tools` module with a suite of built-in\n", + "tools and utilities for creating and running custom tools." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Built-in Tools\n", + "\n", + "One of the built-in tools is the {py:class}`agnext.components.tools.PythonCodeExecutionTool`,\n", + "which allows agents to execute Python code snippets.\n", + "\n", + "Here is how you create the tool and use it." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello, world!\n", + "\n" + ] + } + ], + "source": [ + "from agnext.components.code_executor import LocalCommandLineCodeExecutor\n", + "from agnext.components.tools import PythonCodeExecutionTool\n", + "from agnext.core import CancellationToken\n", + "\n", + "# Create the tool.\n", + "code_executor = LocalCommandLineCodeExecutor()\n", + "code_execution_tool = PythonCodeExecutionTool(code_executor)\n", + "cancellation_token = CancellationToken()\n", + "\n", + "# Use the tool directly without an agent.\n", + "code = \"print('Hello, world!')\"\n", + "result = await code_execution_tool.run_json({\"code\": code}, cancellation_token)\n", + "print(code_execution_tool.return_value_as_string(result))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The {py:class}`~agnext.components.code_executor.LocalCommandLineCodeExecutor`\n", + "class is a built-in code executor that runs Python code snippets in a subprocess\n", + "in the local command line environment.\n", + "The {py:class}`~agnext.components.tools.PythonCodeExecutionTool` class wraps the code executor\n", + "and provides a simple interface to execute Python code snippets.\n", + "\n", + "Other built-in tools will be added in the future." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Custom Function Tools\n", + "\n", + "A tool can also be a simple Python function that performs a specific action.\n", + "To create a custom function tool, you just need to create a Python function\n", + "and use the {py:class}`agnext.components.tools.FunctionTool` class to wrap it.\n", + "\n", + "For example, a simple tool to obtain the stock price of a company might look like this:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "194.71306528148511\n" + ] + } + ], + "source": [ + "import random\n", + "\n", + "from agnext.components.tools import FunctionTool\n", + "from agnext.core import CancellationToken\n", + "from typing_extensions import Annotated\n", + "\n", + "\n", + "async def get_stock_price(ticker: str, date: Annotated[str, \"Date in YYYY/MM/DD\"]) -> float:\n", + " # Returns a random stock price for demonstration purposes.\n", + " return random.uniform(10, 200)\n", + "\n", + "\n", + "# Create a function tool.\n", + "stock_price_tool = FunctionTool(get_stock_price, description=\"Get the stock price.\")\n", + "\n", + "# Run the tool.\n", + "cancellation_token = CancellationToken()\n", + "result = await stock_price_tool.run_json({\"ticker\": \"AAPL\", \"date\": \"2021/01/01\"}, cancellation_token)\n", + "\n", + "# Print the result.\n", + "print(stock_price_tool.return_value_as_string(result))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tool-Equipped Agent\n", + "\n", + "To use tools with an agent, you can use {py:class}`agnext.components.tool_agent.ToolAgent`,\n", + "by using it in a composition pattern.\n", + "Here is an example tool-use agent that uses {py:class}`~agnext.components.tool_agent.ToolAgent`\n", + "as an inner agent for executing tools." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from dataclasses import dataclass\n", + "from typing import List\n", + "\n", + "from agnext.application import SingleThreadedAgentRuntime\n", + "from agnext.components import RoutedAgent, message_handler\n", + "from agnext.components.models import (\n", + " ChatCompletionClient,\n", + " LLMMessage,\n", + " OpenAIChatCompletionClient,\n", + " SystemMessage,\n", + " UserMessage,\n", + ")\n", + "from agnext.components.tool_agent import ToolAgent, tool_agent_caller_loop\n", + "from agnext.components.tools import FunctionTool, Tool, ToolSchema\n", + "from agnext.core import AgentId, AgentInstantiationContext, MessageContext\n", + "\n", + "\n", + "@dataclass\n", + "class Message:\n", + " content: str\n", + "\n", + "\n", + "class ToolUseAgent(RoutedAgent):\n", + " def __init__(self, model_client: ChatCompletionClient, tool_schema: List[ToolSchema], tool_agent: AgentId) -> None:\n", + " super().__init__(\"An agent with tools\")\n", + " self._system_messages: List[LLMMessage] = [SystemMessage(\"You are a helpful AI assistant.\")]\n", + " self._model_client = model_client\n", + " self._tool_schema = tool_schema\n", + " self._tool_agent = tool_agent\n", + "\n", + " @message_handler\n", + " async def handle_user_message(self, message: Message, ctx: MessageContext) -> Message:\n", + " # Create a session of messages.\n", + " session: List[LLMMessage] = [UserMessage(content=message.content, source=\"user\")]\n", + " # Run the caller loop to handle tool calls.\n", + " messages = await tool_agent_caller_loop(\n", + " self,\n", + " tool_agent_id=self._tool_agent,\n", + " model_client=self._model_client,\n", + " input_messages=session,\n", + " tool_schema=self._tool_schema,\n", + " cancellation_token=ctx.cancellation_token,\n", + " )\n", + " # Return the final response.\n", + " assert isinstance(messages[-1].content, str)\n", + " return Message(content=messages[-1].content)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `ToolUseAgent` class uses a convenience function {py:meth}`agnext.components.tool_agent.tool_agent_caller_loop`, \n", + "to handle the interaction between the model and the tool agent.\n", + "The core idea can be described using a simple control flow graph:\n", + "\n", + "![ToolUseAgent control flow graph](tool-use-agent-cfg.svg)\n", + "\n", + "The `ToolUseAgent`'s `handle_user_message` handler handles messages from the user,\n", + "and determines whether the model has generated a tool call.\n", + "If the model has generated tool calls, then the handler sends a function call\n", + "message to the {py:class}`~agnext.components.tool_agent.ToolAgent` agent\n", + "to execute the tools,\n", + "and then queries the model again with the results of the tool calls.\n", + "This process continues until the model stops generating tool calls,\n", + "at which point the final response is returned to the user.\n", + "\n", + "By having the tool execution logic in a separate agent,\n", + "we expose the model-tool interactions to the agent runtime as messages, so the tool executions\n", + "can be observed externally and intercepted if necessary.\n", + "\n", + "To run the agent, we need to create a runtime and register the agent." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "AgentType(type='tool_use_agent')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create a runtime.\n", + "runtime = SingleThreadedAgentRuntime()\n", + "# Create the tools.\n", + "tools: List[Tool] = [FunctionTool(get_stock_price, description=\"Get the stock price.\")]\n", + "# Register the agents.\n", + "await runtime.register(\n", + " \"tool_executor_agent\",\n", + " lambda: ToolAgent(\n", + " description=\"Tool Executor Agent\",\n", + " tools=tools,\n", + " ),\n", + ")\n", + "await runtime.register(\n", + " \"tool_use_agent\",\n", + " lambda: ToolUseAgent(\n", + " OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", + " tool_schema=[tool.schema for tool in tools],\n", + " tool_agent=AgentId(\"tool_executor_agent\", AgentInstantiationContext.current_agent_id().key),\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This example uses the {py:class}`agnext.components.models.OpenAIChatCompletionClient`,\n", + "for Azure OpenAI and other clients, see [Model Clients](./model-clients.ipynb).\n", + "Let's test the agent with a question about stock price." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The stock price of NVIDIA (NVDA) on June 1, 2024, was approximately $148.86.\n" + ] + } + ], + "source": [ + "# Start processing messages.\n", + "runtime.start()\n", + "# Send a direct message to the tool agent.\n", + "tool_use_agent = AgentId(\"tool_use_agent\", \"default\")\n", + "response = await runtime.send_message(Message(\"What is the stock price of NVDA on 2024/06/01?\"), tool_use_agent)\n", + "print(response.content)\n", + "# Stop processing messages.\n", + "await runtime.stop()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "See [samples](https://github.com/microsoft/agnext/tree/main/python/samples#tool-use-examples)\n", + "for more examples of using tools with agents, including how to use\n", + "broadcast communication model for tool execution, and how to intercept tool\n", + "execution for human-in-the-loop approval." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "agnext", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 } diff --git a/python/docs/src/index.rst b/python/docs/src/index.rst index 0adb0dcfd..f25bd3cb8 100644 --- a/python/docs/src/index.rst +++ b/python/docs/src/index.rst @@ -30,6 +30,8 @@ To learn about the core concepts of AGNext, read the `overview List[LLMMessage]: + """Start a caller loop for a tool agent. This function sends messages to the tool agent + and the model client in an alternating fashion until the model client stops generating tool calls. + + Args: + tool_agent_id (AgentId): The Agent ID of the tool agent. + input_messages (List[LLMMessage]): The list of input messages. + model_client (ChatCompletionClient): The model client to use for the model API. + tool_schema (List[Tool | ToolSchema]): The list of tools that the model can use. + + Returns: + List[LLMMessage]: The list of output messages created in the caller loop. + """ + + generated_messages: List[LLMMessage] = [] + + # Get a response from the model. + response = await model_client.create(input_messages, tools=tool_schema, cancellation_token=cancellation_token) + # Add the response to the generated messages. + generated_messages.append(AssistantMessage(content=response.content, source=caller_source)) + + # Keep iterating until the model stops generating tool calls. + while isinstance(response.content, list) and all(isinstance(item, FunctionCall) for item in response.content): + # Execute functions called by the model by sending messages to tool agent. + results: List[FunctionExecutionResult | BaseException] = await asyncio.gather( + *[ + caller.send_message( + message=call, + recipient=tool_agent_id, + cancellation_token=cancellation_token, + ) + for call in response.content + ], + return_exceptions=True, + ) + # Combine the results into a single response and handle exceptions. + function_results: List[FunctionExecutionResult] = [] + for result in results: + if isinstance(result, FunctionExecutionResult): + function_results.append(result) + elif isinstance(result, ToolException): + function_results.append(FunctionExecutionResult(content=f"Error: {result}", call_id=result.call_id)) + elif isinstance(result, BaseException): + raise result # Unexpected exception. + generated_messages.append(FunctionExecutionResultMessage(content=function_results)) + # Query the model again with the new response. + response = await model_client.create( + input_messages + generated_messages, tools=tool_schema, cancellation_token=cancellation_token + ) + generated_messages.append(AssistantMessage(content=response.content, source=caller_source)) + + # Return the generated messages. + return generated_messages diff --git a/python/tests/test_tool_agent.py b/python/tests/test_tool_agent.py index 03e0a8ebb..7f7cc5089 100644 --- a/python/tests/test_tool_agent.py +++ b/python/tests/test_tool_agent.py @@ -1,19 +1,34 @@ import asyncio import json +from typing import Any, AsyncGenerator, List import pytest +from openai.resources.chat.completions import AsyncCompletions +from openai.types.chat.chat_completion import ChatCompletion, Choice +from openai.types.chat.chat_completion_chunk import ChatCompletionChunk +from openai.types.chat.chat_completion_message import ChatCompletionMessage +from openai.types.chat.chat_completion_message_tool_call import ChatCompletionMessageToolCall, Function +from openai.types.completion_usage import CompletionUsage + from agnext.application import SingleThreadedAgentRuntime from agnext.components import FunctionCall -from agnext.components.models import FunctionExecutionResult from agnext.components.tool_agent import ( InvalidToolArgumentsException, ToolAgent, ToolExecutionException, ToolNotFoundException, + tool_agent_caller_loop, +) +from agnext.components.tools import FunctionTool, Tool +from agnext.core import CancellationToken, AgentId +from agnext.components.models import ( + AssistantMessage, + FunctionExecutionResult, + FunctionExecutionResultMessage, + OpenAIChatCompletionClient, + UserMessage, ) from agnext.components.tools import FunctionTool -from agnext.core import CancellationToken -from agnext.core import AgentId def _pass_function(input: str) -> str: @@ -29,6 +44,60 @@ async def _async_sleep_function(input: str) -> str: return "pass" +class _MockChatCompletion: + def __init__(self, model: str = "gpt-4o") -> None: + self._saved_chat_completions: List[ChatCompletion] = [ + ChatCompletion( + id="id1", + choices=[ + Choice( + finish_reason="tool_calls", + index=0, + message=ChatCompletionMessage( + content=None, + tool_calls=[ + ChatCompletionMessageToolCall( + id="1", + type="function", + function=Function( + name="pass", + arguments=json.dumps({"input": "pass"}), + ), + ) + ], + role="assistant", + ), + ) + ], + created=0, + model=model, + object="chat.completion", + usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0), + ), + ChatCompletion( + id="id2", + choices=[ + Choice( + finish_reason="stop", index=0, message=ChatCompletionMessage(content="Hello", role="assistant") + ) + ], + created=0, + model=model, + object="chat.completion", + usage=CompletionUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0), + ), + ] + self._curr_index = 0 + + async def mock_create( + self, *args: Any, **kwargs: Any + ) -> ChatCompletion | AsyncGenerator[ChatCompletionChunk, None]: + await asyncio.sleep(0.1) + completion = self._saved_chat_completions[self._curr_index] + self._curr_index += 1 + return completion + + @pytest.mark.asyncio async def test_tool_agent() -> None: runtime = SingleThreadedAgentRuntime() @@ -74,3 +143,33 @@ async def test_tool_agent() -> None: await result_future await runtime.stop() + + +@pytest.mark.asyncio +async def test_caller_loop(monkeypatch: pytest.MonkeyPatch) -> None: + mock = _MockChatCompletion(model="gpt-4o-2024-05-13") + monkeypatch.setattr(AsyncCompletions, "create", mock.mock_create) + client = OpenAIChatCompletionClient(model="gpt-4o-2024-05-13", api_key="api_key") + tools : List[Tool] = [FunctionTool(_pass_function, name="pass", description="Pass function")] + runtime = SingleThreadedAgentRuntime() + await runtime.register( + "tool_agent", + lambda: ToolAgent( + description="Tool agent", + tools=tools, + ), + ) + agent = AgentId("tool_agent", "default") + runtime.start() + messages = await tool_agent_caller_loop( + runtime, + agent, + client, + [UserMessage(content="Hello", source="user")], + tool_schema=tools + ) + assert len(messages) == 3 + assert isinstance(messages[0], AssistantMessage) + assert isinstance(messages[1], FunctionExecutionResultMessage) + assert isinstance(messages[2], AssistantMessage) + await runtime.stop()