{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# Quick Start\n",
                "\n",
                ":::{note}\n",
                "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",
                "\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": null,
            "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()\"\"\",\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 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",
                        "--------------------------------------------------------------------------------\n",
                        "Executor:\n",
                        "Traceback (most recent call last):\n",
                        "  File \"/workspace/tmp_code_f562e5e3c313207b9ec10ca87094085f.python\", line 1, in <module>\n",
                        "    import pandas as pd\n",
                        "ModuleNotFoundError: No module named 'pandas'\n",
                        "\n",
                        "\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",
                        "--------------------------------------------------------------------------------\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",
                        "--------------------------------------------------------------------------------\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",
                        "--------------------------------------------------------------------------------\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",
                        "--------------------------------------------------------------------------------\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",
                        "--------------------------------------------------------------------------------\n",
                        "Executor:\n",
                        "[*********************100%***********************]  2 of 2 completed\n",
                        "\n",
                        "\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"
                    ]
                }
            ],
            "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",
                "\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": 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": [
                            "<IPython.core.display.Image object>"
                        ]
                    },
                    "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"
            ]
        },
        {
            "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": "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
}