diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/code-execution-groupchat.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/code-execution-groupchat.ipynb new file mode 100644 index 000000000..6daa85207 --- /dev/null +++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/code-execution-groupchat.ipynb @@ -0,0 +1,333 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Code Execution\n", + "\n", + "In this section we explore creating custom agents to handle code generation and execution. These tasks can be handled using the provided Agent implementations found here {py:meth}`~autogen_agentchat.agents.AssistantAgent`, {py:meth}`~autogen_agentchat.agents.CodeExecutorAgent`; but this guide will show you how to implement custom, lightweight agents that can replace their functionality. This simple example implements two agents that create a plot of Tesla's and Nvidia's stock returns.\n", + "\n", + "We first define the agent classes and their respective procedures for \n", + "handling messages.\n", + "We create two agent classes: `Assistant` and `Executor`. The `Assistant`\n", + "agent writes code and the `Executor` agent executes the code.\n", + "We also create a `Message` data class, which defines the messages that are passed between\n", + "the agents.\n", + "\n", + "```{attention}\n", + "Code generated in this example is run within a [Docker](https://www.docker.com/) container. Please ensure Docker is [installed](https://docs.docker.com/get-started/get-docker/) and running prior to running the example. Local code execution is available ({py:class}`~autogen_ext.code_executors.local.LocalCommandLineCodeExecutor`) but is not recommended due to the risk of running LLM generated code in your local environment.\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "from dataclasses import dataclass\n", + "from typing import List\n", + "\n", + "from autogen_core import DefaultTopicId, MessageContext, RoutedAgent, default_subscription, message_handler\n", + "from autogen_core.code_executor import CodeBlock, CodeExecutor\n", + "from autogen_core.models import (\n", + " AssistantMessage,\n", + " ChatCompletionClient,\n", + " LLMMessage,\n", + " SystemMessage,\n", + " UserMessage,\n", + ")\n", + "\n", + "\n", + "@dataclass\n", + "class Message:\n", + " content: str\n", + "\n", + "\n", + "@default_subscription\n", + "class Assistant(RoutedAgent):\n", + " def __init__(self, model_client: ChatCompletionClient) -> None:\n", + " super().__init__(\"An assistant agent.\")\n", + " self._model_client = model_client\n", + " self._chat_history: List[LLMMessage] = [\n", + " SystemMessage(\n", + " content=\"\"\"Write Python script in markdown block, and it will be executed.\n", + "Always save figures to file in the current directory. Do not use plt.show(). All code required to complete this task must be contained within a single response.\"\"\",\n", + " )\n", + " ]\n", + "\n", + " @message_handler\n", + " async def handle_message(self, message: Message, ctx: MessageContext) -> None:\n", + " self._chat_history.append(UserMessage(content=message.content, source=\"user\"))\n", + " result = await self._model_client.create(self._chat_history)\n", + " print(f\"\\n{'-'*80}\\nAssistant:\\n{result.content}\")\n", + " self._chat_history.append(AssistantMessage(content=result.content, source=\"assistant\")) # type: ignore\n", + " await self.publish_message(Message(content=result.content), DefaultTopicId()) # type: ignore\n", + "\n", + "\n", + "def extract_markdown_code_blocks(markdown_text: str) -> List[CodeBlock]:\n", + " pattern = re.compile(r\"```(?:\\s*([\\w\\+\\-]+))?\\n([\\s\\S]*?)```\")\n", + " matches = pattern.findall(markdown_text)\n", + " code_blocks: List[CodeBlock] = []\n", + " for match in matches:\n", + " language = match[0].strip() if match[0] else \"\"\n", + " code_content = match[1]\n", + " code_blocks.append(CodeBlock(code=code_content, language=language))\n", + " return code_blocks\n", + "\n", + "\n", + "@default_subscription\n", + "class Executor(RoutedAgent):\n", + " def __init__(self, code_executor: CodeExecutor) -> None:\n", + " super().__init__(\"An executor agent.\")\n", + " self._code_executor = code_executor\n", + "\n", + " @message_handler\n", + " async def handle_message(self, message: Message, ctx: MessageContext) -> None:\n", + " code_blocks = extract_markdown_code_blocks(message.content)\n", + " if code_blocks:\n", + " result = await self._code_executor.execute_code_blocks(\n", + " code_blocks, cancellation_token=ctx.cancellation_token\n", + " )\n", + " print(f\"\\n{'-'*80}\\nExecutor:\\n{result.output}\")\n", + " await self.publish_message(Message(content=result.output), DefaultTopicId())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You might have already noticed, the agents' logic, whether it is using model or code executor,\n", + "is completely decoupled from\n", + "how messages are delivered. This is the core idea: the framework provides\n", + "a communication infrastructure, and the agents are responsible for their own\n", + "logic. We call the communication infrastructure an **Agent Runtime**.\n", + "\n", + "Agent runtime is a key concept of this framework. Besides delivering messages,\n", + "it also manages agents' lifecycle. \n", + "So the creation of agents are handled by the runtime.\n", + "\n", + "The following code shows how to register and run the agents using \n", + "{py:class}`~autogen_core.SingleThreadedAgentRuntime`,\n", + "a local embedded agent runtime implementation.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------------\n", + "Assistant:\n", + "```python\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import yfinance as yf\n", + "\n", + "# Define the ticker symbols for NVIDIA and Tesla\n", + "tickers = ['NVDA', 'TSLA']\n", + "\n", + "# Download the stock data from Yahoo Finance starting from 2024-01-01\n", + "start_date = '2024-01-01'\n", + "end_date = pd.to_datetime('today').strftime('%Y-%m-%d')\n", + "\n", + "# Download the adjusted closing prices\n", + "stock_data = yf.download(tickers, start=start_date, end=end_date)['Adj Close']\n", + "\n", + "# Calculate the daily returns\n", + "returns = stock_data.pct_change().dropna()\n", + "\n", + "# Plot the cumulative returns for each stock\n", + "cumulative_returns = (1 + returns).cumprod()\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(cumulative_returns.index, cumulative_returns['NVDA'], label='NVIDIA', color='green')\n", + "plt.plot(cumulative_returns.index, cumulative_returns['TSLA'], label='Tesla', color='red')\n", + "plt.title('NVIDIA vs Tesla Stock Returns YTD (2024)')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Cumulative Return')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "\n", + "# Save the plot to a file\n", + "plt.savefig('nvidia_vs_tesla_ytd_returns.png')\n", + "```\n", + "\n", + "--------------------------------------------------------------------------------\n", + "Executor:\n", + "Traceback (most recent call last):\n", + " File \"/workspace/tmp_code_fd7395dcad4fbb74d40c981411db604e78e1a17783ca1fab3aaec34ff2c3fdf0.python\", line 1, in \n", + " import pandas as pd\n", + "ModuleNotFoundError: No module named 'pandas'\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "Assistant:\n", + "It seems like the necessary libraries are not available in your environment. However, since I can't install packages or check the environment directly from here, you'll need to make sure that the appropriate packages are installed in your working environment. Once the modules are available, the script provided will execute properly.\n", + "\n", + "Here's how you can install the required packages using pip (make sure to run these commands in your terminal or command prompt):\n", + "\n", + "```bash\n", + "pip install pandas matplotlib yfinance\n", + "```\n", + "\n", + "Let me provide you the script again for reference:\n", + "\n", + "```python\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import yfinance as yf\n", + "\n", + "# Define the ticker symbols for NVIDIA and Tesla\n", + "tickers = ['NVDA', 'TSLA']\n", + "\n", + "# Download the stock data from Yahoo Finance starting from 2024-01-01\n", + "start_date = '2024-01-01'\n", + "end_date = pd.to_datetime('today').strftime('%Y-%m-%d')\n", + "\n", + "# Download the adjusted closing prices\n", + "stock_data = yf.download(tickers, start=start_date, end=end_date)['Adj Close']\n", + "\n", + "# Calculate the daily returns\n", + "returns = stock_data.pct_change().dropna()\n", + "\n", + "# Plot the cumulative returns for each stock\n", + "cumulative_returns = (1 + returns).cumprod()\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(cumulative_returns.index, cumulative_returns['NVDA'], label='NVIDIA', color='green')\n", + "plt.plot(cumulative_returns.index, cumulative_returns['TSLA'], label='Tesla', color='red')\n", + "plt.title('NVIDIA vs Tesla Stock Returns YTD (2024)')\n", + "plt.xlabel('Date')\n", + "plt.ylabel('Cumulative Return')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "\n", + "# Save the plot to a file\n", + "plt.savefig('nvidia_vs_tesla_ytd_returns.png')\n", + "```\n", + "\n", + "Make sure to install the packages in the environment where you run this script. Feel free to ask if you have further questions or issues!\n", + "\n", + "--------------------------------------------------------------------------------\n", + "Executor:\n", + "[*********************100%***********************] 2 of 2 completed\n", + "\n", + "\n", + "--------------------------------------------------------------------------------\n", + "Assistant:\n", + "It looks like the data fetching process completed successfully. You should now have a plot saved as `nvidia_vs_tesla_ytd_returns.png` in your current directory. If you have any additional questions or need further assistance, feel free to ask!\n" + ] + } + ], + "source": [ + "import tempfile\n", + "\n", + "from autogen_core import SingleThreadedAgentRuntime\n", + "from autogen_ext.code_executors.docker import DockerCommandLineCodeExecutor\n", + "from autogen_ext.models.openai import OpenAIChatCompletionClient\n", + "\n", + "work_dir = tempfile.mkdtemp()\n", + "\n", + "# Create an local embedded runtime.\n", + "runtime = SingleThreadedAgentRuntime()\n", + "\n", + "async with DockerCommandLineCodeExecutor(work_dir=work_dir) as executor: # type: ignore[syntax]\n", + " # Register the assistant and executor agents by providing\n", + " # their agent types, the factory functions for creating instance and subscriptions.\n", + " await Assistant.register(\n", + " runtime,\n", + " \"assistant\",\n", + " lambda: Assistant(\n", + " OpenAIChatCompletionClient(\n", + " model=\"gpt-4o\",\n", + " # api_key=\"YOUR_API_KEY\"\n", + " )\n", + " ),\n", + " )\n", + " await Executor.register(runtime, \"executor\", lambda: Executor(executor))\n", + "\n", + " # Start the runtime and publish a message to the assistant.\n", + " runtime.start()\n", + " await runtime.publish_message(\n", + " Message(\"Create a plot of NVIDA vs TSLA stock returns YTD from 2024-01-01.\"), DefaultTopicId()\n", + " )\n", + " await runtime.stop_when_idle()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From the agent's output, we can see the plot of Tesla's and Nvidia's stock returns\n", + "has been created." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from IPython.display import Image\n", + "\n", + "Image(filename=f\"{work_dir}/nvidia_vs_tesla_ytd_returns.png\") # type: ignore" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "AutoGen also supports a distributed agent runtime, which can host agents running on\n", + "different processes or machines, with different identities, languages and dependencies.\n", + "\n", + "To learn how to use agent runtime, communication, message handling, and subscription, please continue\n", + "reading the sections following this quick start." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/index.md b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/index.md index e1dada414..7528ed8e4 100644 --- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/index.md +++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/design-patterns/index.md @@ -27,4 +27,5 @@ handoffs mixture-of-agents multi-agent-debate reflection +code-execution-groupchat ``` diff --git a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb index 232547db1..fde686bad 100644 --- a/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb +++ b/python/packages/autogen-core/docs/src/user-guide/core-user-guide/quickstart.ipynb @@ -10,94 +10,57 @@ "See [here](pkg-info-autogen-core) for installation instructions.\n", ":::\n", "\n", - "Before diving into the core APIs, let's start with a simple example of two\n", - "agents creating a plot of Tesla's and Nvidia's stock returns.\n", + "Before diving into the core APIs, let's start with a simple example of two agents that count down from 10 to 1.\n", "\n", "We first define the agent classes and their respective procedures for \n", "handling messages.\n", - "We create two agent classes: `Assistant` and `Executor`. The `Assistant`\n", - "agent writes code and the `Executor` agent executes the code.\n", - "We also create a `Message` data class, which defines the messages that are passed between\n", - "the agents.\n", - "\n", - "```{attention}\n", - "Code generated in this example is run within a [Docker](https://www.docker.com/) container. Please ensure Docker is [installed](https://docs.docker.com/get-started/get-docker/) and running prior to running the example. Local code execution is available ({py:class}`~autogen_ext.code_executors.local.LocalCommandLineCodeExecutor`) but is not recommended due to the risk of running LLM generated code in your local environment.\n", - "```" + "We create two agent classes: `Modifier` and `Checker`. The `Modifier` agent modifies a number that is given and the `Check` agent checks the value against a condition.\n", + "We also create a `Message` data class, which defines the messages that are passed between the agents." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ - "import re\n", "from dataclasses import dataclass\n", - "from typing import List\n", + "from typing import Callable\n", "\n", "from autogen_core import DefaultTopicId, MessageContext, RoutedAgent, default_subscription, message_handler\n", - "from autogen_core.code_executor import CodeBlock, CodeExecutor\n", - "from autogen_core.models import (\n", - " AssistantMessage,\n", - " ChatCompletionClient,\n", - " LLMMessage,\n", - " SystemMessage,\n", - " UserMessage,\n", - ")\n", "\n", "\n", "@dataclass\n", "class Message:\n", - " content: str\n", + " content: int\n", "\n", "\n", "@default_subscription\n", - "class Assistant(RoutedAgent):\n", - " def __init__(self, model_client: ChatCompletionClient) -> None:\n", - " super().__init__(\"An assistant agent.\")\n", - " self._model_client = model_client\n", - " self._chat_history: List[LLMMessage] = [\n", - " SystemMessage(\n", - " content=\"\"\"Write Python script in markdown block, and it will be executed.\n", - "Always save figures to file in the current directory. Do not use plt.show(). All code required to complete this task must be contained within a single response.\"\"\",\n", - " )\n", - " ]\n", + "class Modifier(RoutedAgent):\n", + " def __init__(self, modify_val: Callable[[int], int]) -> None:\n", + " super().__init__(\"A modifier agent.\")\n", + " self._modify_val = modify_val\n", "\n", " @message_handler\n", " async def handle_message(self, message: Message, ctx: MessageContext) -> None:\n", - " self._chat_history.append(UserMessage(content=message.content, source=\"user\"))\n", - " result = await self._model_client.create(self._chat_history)\n", - " print(f\"\\n{'-'*80}\\nAssistant:\\n{result.content}\")\n", - " self._chat_history.append(AssistantMessage(content=result.content, source=\"assistant\")) # type: ignore\n", - " await self.publish_message(Message(content=result.content), DefaultTopicId()) # type: ignore\n", - "\n", - "\n", - "def extract_markdown_code_blocks(markdown_text: str) -> List[CodeBlock]:\n", - " pattern = re.compile(r\"```(?:\\s*([\\w\\+\\-]+))?\\n([\\s\\S]*?)```\")\n", - " matches = pattern.findall(markdown_text)\n", - " code_blocks: List[CodeBlock] = []\n", - " for match in matches:\n", - " language = match[0].strip() if match[0] else \"\"\n", - " code_content = match[1]\n", - " code_blocks.append(CodeBlock(code=code_content, language=language))\n", - " return code_blocks\n", + " val = self._modify_val(message.content)\n", + " print(f\"{'-'*80}\\nModifier:\\nModified {message.content} to {val}\")\n", + " await self.publish_message(Message(content=val), DefaultTopicId()) # type: ignore\n", "\n", "\n", "@default_subscription\n", - "class Executor(RoutedAgent):\n", - " def __init__(self, code_executor: CodeExecutor) -> None:\n", - " super().__init__(\"An executor agent.\")\n", - " self._code_executor = code_executor\n", + "class Checker(RoutedAgent):\n", + " def __init__(self, run_until: Callable[[int], bool]) -> None:\n", + " super().__init__(\"A checker agent.\")\n", + " self._run_until = run_until\n", "\n", " @message_handler\n", " async def handle_message(self, message: Message, ctx: MessageContext) -> None:\n", - " code_blocks = extract_markdown_code_blocks(message.content)\n", - " if code_blocks:\n", - " result = await self._code_executor.execute_code_blocks(\n", - " code_blocks, cancellation_token=ctx.cancellation_token\n", - " )\n", - " print(f\"\\n{'-'*80}\\nExecutor:\\n{result.output}\")\n", - " await self.publish_message(Message(content=result.output), DefaultTopicId())" + " if not self._run_until(message.content):\n", + " print(f\"{'-'*80}\\nChecker:\\n{message.content} passed the check, continue.\")\n", + " await self.publish_message(Message(content=message.content), DefaultTopicId())\n", + " else:\n", + " print(f\"{'-'*80}\\nChecker:\\n{message.content} failed the check, stopping.\")" ] }, { @@ -121,275 +84,106 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", "--------------------------------------------------------------------------------\n", - "Assistant:\n", - "```python\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import yfinance as yf\n", - "\n", - "# Define the stock tickers\n", - "ticker_symbols = ['NVDA', 'TSLA']\n", - "\n", - "# Download the stock data from Yahoo Finance starting from 2024-01-01\n", - "start_date = '2024-01-01'\n", - "stock_data = yf.download(ticker_symbols, start=start_date)['Adj Close']\n", - "\n", - "# Calculate daily returns\n", - "returns = stock_data.pct_change().dropna()\n", - "\n", - "# Plot the stock returns\n", - "plt.figure(figsize=(10, 6))\n", - "for ticker in ticker_symbols:\n", - " returns[ticker].cumsum().plot(label=ticker)\n", - "\n", - "plt.title('NVIDIA vs TSLA Stock Returns YTD from 2024-01-01')\n", - "plt.xlabel('Date')\n", - "plt.ylabel('Cumulative Returns')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "\n", - "# Save the plot to a file\n", - "plt.savefig('nvidia_vs_tsla_stock_returns_ytd_2024.png')\n", - "```\n", - "\n", + "Checker:\n", + "10 passed the check, continue.\n", "--------------------------------------------------------------------------------\n", - "Executor:\n", - "Traceback (most recent call last):\n", - " File \"/workspace/tmp_code_f562e5e3c313207b9ec10ca87094085f.python\", line 1, in \n", - " import pandas as pd\n", - "ModuleNotFoundError: No module named 'pandas'\n", - "\n", - "\n", + "Modifier:\n", + "Modified 10 to 9\n", "--------------------------------------------------------------------------------\n", - "Assistant:\n", - "It looks like some required modules are not installed. Let me proceed by installing the necessary libraries before running the script.\n", - "\n", - "```python\n", - "!pip install pandas matplotlib yfinance\n", - "```\n", - "\n", + "Checker:\n", + "9 passed the check, continue.\n", "--------------------------------------------------------------------------------\n", - "Executor:\n", - " File \"/workspace/tmp_code_78ffa711e7b0ff8738fdeec82404018c.python\", line 1\n", - " !pip install -qqq pandas matplotlib yfinance\n", - " ^\n", - "SyntaxError: invalid syntax\n", - "\n", - "\n", + "Modifier:\n", + "Modified 9 to 8\n", "--------------------------------------------------------------------------------\n", - "Assistant:\n", - "It appears that I'm unable to run installation commands within the code execution environment. However, you can install the necessary libraries using the following commands in your local environment:\n", - "\n", - "```sh\n", - "pip install pandas matplotlib yfinance\n", - "```\n", - "\n", - "After installing the libraries, you can then run the previous plotting script. Here is the combined process:\n", - "\n", - "1. First, install the required libraries (run this in your terminal or command prompt):\n", - " ```sh\n", - " pip install pandas matplotlib yfinance\n", - " ```\n", - "\n", - "2. Now, you can run the script to generate the plot:\n", - " ```python\n", - " import pandas as pd\n", - " import matplotlib.pyplot as plt\n", - " import yfinance as yf\n", - "\n", - " # Define the stock tickers\n", - " ticker_symbols = ['NVDA', 'TSLA']\n", - "\n", - " # Download the stock data from Yahoo Finance starting from 2024-01-01\n", - " start_date = '2024-01-01'\n", - " stock_data = yf.download(ticker_symbols, start=start_date)['Adj Close']\n", - "\n", - " # Calculate daily returns\n", - " returns = stock_data.pct_change().dropna()\n", - "\n", - " # Plot the stock returns\n", - " plt.figure(figsize=(10, 6))\n", - " for ticker in ticker_symbols:\n", - " returns[ticker].cumsum().plot(label=ticker)\n", - "\n", - " plt.title('NVIDIA vs TSLA Stock Returns YTD from 2024-01-01')\n", - " plt.xlabel('Date')\n", - " plt.ylabel('Cumulative Returns')\n", - " plt.legend()\n", - " plt.grid(True)\n", - "\n", - " # Save the plot to a file\n", - " plt.savefig('nvidia_vs_tsla_stock_returns_ytd_2024.png')\n", - " ```\n", - "\n", - "This should generate and save the desired plot in your current directory as `nvidia_vs_tsla_stock_returns_ytd_2024.png`.\n", - "\n", + "Checker:\n", + "8 passed the check, continue.\n", "--------------------------------------------------------------------------------\n", - "Executor:\n", - "Requirement already satisfied: pandas in /usr/local/lib/python3.12/site-packages (2.2.2)\n", - "Requirement already satisfied: matplotlib in /usr/local/lib/python3.12/site-packages (3.9.2)\n", - "Requirement already satisfied: yfinance in /usr/local/lib/python3.12/site-packages (0.2.43)\n", - "Requirement already satisfied: numpy>=1.26.0 in /usr/local/lib/python3.12/site-packages (from pandas) (2.1.1)\n", - "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.12/site-packages (from pandas) (2.9.0.post0)\n", - "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.12/site-packages (from pandas) (2024.2)\n", - "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.12/site-packages (from pandas) (2024.1)\n", - "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.12/site-packages (from matplotlib) (1.3.0)\n", - "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.12/site-packages (from matplotlib) (0.12.1)\n", - "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.12/site-packages (from matplotlib) (4.53.1)\n", - "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.12/site-packages (from matplotlib) (1.4.7)\n", - "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.12/site-packages (from matplotlib) (24.1)\n", - "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.12/site-packages (from matplotlib) (10.4.0)\n", - "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.12/site-packages (from matplotlib) (3.1.4)\n", - "Requirement already satisfied: requests>=2.31 in /usr/local/lib/python3.12/site-packages (from yfinance) (2.32.3)\n", - "Requirement already satisfied: multitasking>=0.0.7 in /usr/local/lib/python3.12/site-packages (from yfinance) (0.0.11)\n", - "Requirement already satisfied: lxml>=4.9.1 in /usr/local/lib/python3.12/site-packages (from yfinance) (5.3.0)\n", - "Requirement already satisfied: platformdirs>=2.0.0 in /usr/local/lib/python3.12/site-packages (from yfinance) (4.3.6)\n", - "Requirement already satisfied: frozendict>=2.3.4 in /usr/local/lib/python3.12/site-packages (from yfinance) (2.4.4)\n", - "Requirement already satisfied: peewee>=3.16.2 in /usr/local/lib/python3.12/site-packages (from yfinance) (3.17.6)\n", - "Requirement already satisfied: beautifulsoup4>=4.11.1 in /usr/local/lib/python3.12/site-packages (from yfinance) (4.12.3)\n", - "Requirement already satisfied: html5lib>=1.1 in /usr/local/lib/python3.12/site-packages (from yfinance) (1.1)\n", - "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.12/site-packages (from beautifulsoup4>=4.11.1->yfinance) (2.6)\n", - "Requirement already satisfied: six>=1.9 in /usr/local/lib/python3.12/site-packages (from html5lib>=1.1->yfinance) (1.16.0)\n", - "Requirement already satisfied: webencodings in /usr/local/lib/python3.12/site-packages (from html5lib>=1.1->yfinance) (0.5.1)\n", - "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.12/site-packages (from requests>=2.31->yfinance) (3.3.2)\n", - "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.12/site-packages (from requests>=2.31->yfinance) (3.10)\n", - "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.12/site-packages (from requests>=2.31->yfinance) (2.2.3)\n", - "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.12/site-packages (from requests>=2.31->yfinance) (2024.8.30)\n", - "WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager, possibly rendering your system unusable.It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv. Use the --root-user-action option if you know what you are doing and want to suppress this warning.\n", - " File \"/workspace/tmp_code_d094fa6242b4268e4812bf9902aa1374.python\", line 1\n", - " import pandas as pd\n", - "IndentationError: unexpected indent\n", - "\n", - "\n", + "Modifier:\n", + "Modified 8 to 7\n", "--------------------------------------------------------------------------------\n", - "Assistant:\n", - "Thank you for the confirmation. As the required packages are installed, let's proceed with the script to plot the NVIDIA vs TSLA stock returns YTD starting from 2024-01-01.\n", - "\n", - "Here's the updated script:\n", - "\n", - "```python\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import yfinance as yf\n", - "\n", - "# Define the stock tickers\n", - "ticker_symbols = ['NVDA', 'TSLA']\n", - "\n", - "# Download the stock data from Yahoo Finance starting from 2024-01-01\n", - "start_date = '2024-01-01'\n", - "stock_data = yf.download(ticker_symbols, start=start_date)['Adj Close']\n", - "\n", - "# Calculate daily returns\n", - "returns = stock_data.pct_change().dropna()\n", - "\n", - "# Plot the stock returns\n", - "plt.figure(figsize=(10, 6))\n", - "for ticker in ticker_symbols:\n", - " returns[ticker].cumsum().plot(label=ticker)\n", - "\n", - "plt.title('NVIDIA vs TSLA Stock Returns YTD from 2024-01-01')\n", - "plt.xlabel('Date')\n", - "plt.ylabel('Cumulative Returns')\n", - "plt.legend()\n", - "plt.grid(True)\n", - "\n", - "# Save the plot to a file\n", - "plt.savefig('nvidia_vs_tsla_stock_returns_ytd_2024.png')\n", - "```\n", - "\n", + "Checker:\n", + "7 passed the check, continue.\n", "--------------------------------------------------------------------------------\n", - "Executor:\n", - "[*********************100%***********************] 2 of 2 completed\n", - "\n", - "\n", + "Modifier:\n", + "Modified 7 to 6\n", "--------------------------------------------------------------------------------\n", - "Assistant:\n", - "It looks like the stock data was successfully downloaded, and the plot has been generated and saved as `nvidia_vs_tsla_stock_returns_ytd_2024.png` in the current directory.\n", - "\n", - "If you have any further questions or need additional assistance, feel free to ask!\n" + "Checker:\n", + "6 passed the check, continue.\n", + "--------------------------------------------------------------------------------\n", + "Modifier:\n", + "Modified 6 to 5\n", + "--------------------------------------------------------------------------------\n", + "Checker:\n", + "5 passed the check, continue.\n", + "--------------------------------------------------------------------------------\n", + "Modifier:\n", + "Modified 5 to 4\n", + "--------------------------------------------------------------------------------\n", + "Checker:\n", + "4 passed the check, continue.\n", + "--------------------------------------------------------------------------------\n", + "Modifier:\n", + "Modified 4 to 3\n", + "--------------------------------------------------------------------------------\n", + "Checker:\n", + "3 passed the check, continue.\n", + "--------------------------------------------------------------------------------\n", + "Modifier:\n", + "Modified 3 to 2\n", + "--------------------------------------------------------------------------------\n", + "Checker:\n", + "2 passed the check, continue.\n", + "--------------------------------------------------------------------------------\n", + "Modifier:\n", + "Modified 2 to 1\n", + "--------------------------------------------------------------------------------\n", + "Checker:\n", + "1 failed the check, stopping.\n" ] } ], "source": [ - "import tempfile\n", - "\n", - "from autogen_core import SingleThreadedAgentRuntime\n", - "from autogen_ext.code_executors import DockerCommandLineCodeExecutor\n", - "from autogen_ext.models.openai import OpenAIChatCompletionClient\n", - "\n", - "work_dir = tempfile.mkdtemp()\n", + "from autogen_core import AgentId, SingleThreadedAgentRuntime\n", "\n", "# Create an local embedded runtime.\n", "runtime = SingleThreadedAgentRuntime()\n", "\n", - "async with DockerCommandLineCodeExecutor(work_dir=work_dir) as executor: # type: ignore[syntax]\n", - " # Register the assistant and executor agents by providing\n", - " # their agent types, the factory functions for creating instance and subscriptions.\n", - " await Assistant.register(\n", - " runtime,\n", - " \"assistant\",\n", - " lambda: Assistant(\n", - " OpenAIChatCompletionClient(\n", - " model=\"gpt-4o\",\n", - " # api_key=\"YOUR_API_KEY\"\n", - " )\n", - " ),\n", - " )\n", - " await Executor.register(runtime, \"executor\", lambda: Executor(executor))\n", + "# Register the modifier and checker agents by providing\n", + "# their agent types, the factory functions for creating instance and subscriptions.\n", + "await Modifier.register(\n", + " runtime,\n", + " \"modifier\",\n", + " # Modify the value by subtracting 1\n", + " lambda: Modifier(modify_val=lambda x: x - 1),\n", + ")\n", "\n", - " # Start the runtime and publish a message to the assistant.\n", - " runtime.start()\n", - " await runtime.publish_message(\n", - " Message(\"Create a plot of NVIDA vs TSLA stock returns YTD from 2024-01-01.\"), DefaultTopicId()\n", - " )\n", - " await runtime.stop_when_idle()" + "await Checker.register(\n", + " runtime,\n", + " \"checker\",\n", + " # Run until the value is less than or equal to 1\n", + " lambda: Checker(run_until=lambda x: x <= 1),\n", + ")\n", + "\n", + "# Start the runtime and send a direct message to the checker.\n", + "runtime.start()\n", + "await runtime.send_message(Message(10), AgentId(\"checker\", \"default\"))\n", + "await runtime.stop_when_idle()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "From the agent's output, we can see the plot of Tesla's and Nvidia's stock returns\n", - "has been created." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "/var/folders/cs/b9_18p1s2rd56_s2jl65rxwc0000gn/T/tmp_9c2ylon\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from IPython.display import Image\n", - "\n", - "Image(filename=f\"{work_dir}/NVIDIA_vs_TSLA_Stock_Returns_YTD_2024.png\") # type: ignore" + "From the agent's output, we can see the value was successfully decremented from 10 to 1 as the modifier and checker conditions dictate." ] }, { @@ -406,7 +200,7 @@ ], "metadata": { "kernelspec": { - "display_name": "agnext", + "display_name": ".venv", "language": "python", "name": "python3" }, @@ -420,7 +214,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.9" + "version": "3.12.7" } }, "nbformat": 4,