diff --git a/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/company-research.ipynb b/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/company-research.ipynb new file mode 100644 index 000000000000..b6692c4ca7f5 --- /dev/null +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/company-research.ipynb @@ -0,0 +1,478 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Company Research \n", + "\n", + "\n", + "Conducting company research, or competitive analysis, is a critical part of any business strategy. In this notebook, we will demonstrate how to create a team of agents to address this task. While there are many ways to translate a task into an agentic implementation, we will explore a sequential approach. We will create agents corresponding to steps in the research process and give them tools to perform their tasks.\n", + "\n", + "- **Search Agent**: Searches the web for information about a company. Will have access to a search engine API tool to retrieve search results.\n", + "- **Stock Analysis Agent**: Retrieves the company's stock information from a financial data API, computes basic statistics (current price, 52-week high, 52-week low, etc.), and generates a plot of the stock price year-to-date, saving it to a file. Will have access to a financial data API tool to retrieve stock information.\n", + "- **Report Agent**: Generates a report based on the information collected by the search and stock analysis agents. \n", + "\n", + "First, let's import the necessary modules." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from autogen_agentchat.agents import CodingAssistantAgent,ToolUseAssistantAgent\n", + "from autogen_agentchat.teams.group_chat import RoundRobinGroupChat\n", + "from autogen_core.components.models import OpenAIChatCompletionClient \n", + "from autogen_core.components.tools import FunctionTool" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining Tools \n", + "\n", + "Next, we will define the tools that the agents will use to perform their tasks. We will create a `google_search` that uses the Google Search API to search the web for information about a company. We will also create a `analyze_stock` function that uses the `yfinance` library to retrieve stock information for a company. \n", + "\n", + "Finally, we will wrap these functions into a `FunctionTool` class that will allow us to use them as tools in our agents. \n", + "\n", + "Note: The `google_search` function requires an API key to work. You can create a `.env` file in the same directory as this notebook and add your API key as \n", + "\n", + "```\n", + "GOOGLE_SEARCH_ENGINE_ID =xxx\n", + "GOOGLE_API_KEY=xxx \n", + "``` \n", + "\n", + "Also install required libraries \n", + "\n", + "```\n", + "pip install yfinance matplotlib pytz numpy pandas python-dotenv requests bs4\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "#!pip install yfinance matplotlib pytz numpy pandas python-dotenv requests bs4\n", + "\n", + "def google_search(query: str, num_results: int = 2, max_chars: int = 500) -> list:\n", + " import os\n", + " import requests\n", + " from dotenv import load_dotenv\n", + " from bs4 import BeautifulSoup\n", + " import time\n", + "\n", + " load_dotenv()\n", + "\n", + " api_key = os.getenv('GOOGLE_API_KEY')\n", + " search_engine_id = os.getenv('GOOGLE_SEARCH_ENGINE_ID')\n", + " \n", + " if not api_key or not search_engine_id:\n", + " raise ValueError(\"API key or Search Engine ID not found in environment variables\")\n", + "\n", + " url = \"https://www.googleapis.com/customsearch/v1\"\n", + " params = {\n", + " 'key': api_key,\n", + " 'cx': search_engine_id,\n", + " 'q': query,\n", + " 'num': num_results\n", + " }\n", + "\n", + " response = requests.get(url, params=params)\n", + " \n", + " if response.status_code != 200:\n", + " print(response.json())\n", + " raise Exception(f\"Error in API request: {response.status_code}\")\n", + "\n", + " results = response.json().get('items', [])\n", + " \n", + " def get_page_content(url):\n", + " try:\n", + " response = requests.get(url, timeout=10)\n", + " soup = BeautifulSoup(response.content, 'html.parser')\n", + " text = soup.get_text(separator=' ', strip=True)\n", + " words = text.split()\n", + " content = ''\n", + " for word in words:\n", + " if len(content) + len(word) + 1 > max_chars:\n", + " break\n", + " content += ' ' + word\n", + " return content.strip()\n", + " except Exception as e:\n", + " print(f\"Error fetching {url}: {str(e)}\")\n", + " return \"\"\n", + "\n", + " enriched_results = []\n", + " for item in results:\n", + " body = get_page_content(item['link'])\n", + " enriched_results.append({\n", + " 'title': item['title'],\n", + " 'link': item['link'],\n", + " 'snippet': item['snippet'],\n", + " 'body': body\n", + " })\n", + " time.sleep(1) # Be respectful to the servers\n", + "\n", + " return enriched_results\n", + "\n", + " \n", + "def analyze_stock(ticker: str) -> dict:\n", + " import yfinance as yf\n", + " import matplotlib.pyplot as plt\n", + " from datetime import datetime, timedelta\n", + " import numpy as np\n", + " from pytz import timezone\n", + " import pandas as pd\n", + " import os\n", + "\n", + " stock = yf.Ticker(ticker)\n", + " \n", + " # Get historical data (1 year of data to ensure we have enough for 200-day MA)\n", + " end_date = datetime.now(timezone('UTC'))\n", + " start_date = end_date - timedelta(days=365)\n", + " hist = stock.history(start=start_date, end=end_date)\n", + " \n", + " # Ensure we have data\n", + " if hist.empty:\n", + " return {\"error\": \"No historical data available for the specified ticker.\"}\n", + " \n", + " # Compute basic statistics and additional metrics\n", + " current_price = stock.info.get('currentPrice', hist['Close'].iloc[-1])\n", + " year_high = stock.info.get('fiftyTwoWeekHigh', hist['High'].max())\n", + " year_low = stock.info.get('fiftyTwoWeekLow', hist['Low'].min())\n", + " \n", + " # Calculate 50-day and 200-day moving averages\n", + " ma_50 = hist['Close'].rolling(window=50).mean().iloc[-1]\n", + " ma_200 = hist['Close'].rolling(window=200).mean().iloc[-1]\n", + " \n", + " # Calculate YTD price change and percent change\n", + " ytd_start = datetime(end_date.year, 1, 1, tzinfo=timezone('UTC'))\n", + " ytd_data = hist.loc[ytd_start:]\n", + " if not ytd_data.empty:\n", + " price_change = ytd_data['Close'].iloc[-1] - ytd_data['Close'].iloc[0]\n", + " percent_change = (price_change / ytd_data['Close'].iloc[0]) * 100\n", + " else:\n", + " price_change = percent_change = np.nan\n", + " \n", + " # Determine trend\n", + " if pd.notna(ma_50) and pd.notna(ma_200):\n", + " if ma_50 > ma_200:\n", + " trend = \"Upward\"\n", + " elif ma_50 < ma_200:\n", + " trend = \"Downward\"\n", + " else:\n", + " trend = \"Neutral\"\n", + " else:\n", + " trend = \"Insufficient data for trend analysis\"\n", + " \n", + " # Calculate volatility (standard deviation of daily returns)\n", + " daily_returns = hist['Close'].pct_change().dropna()\n", + " volatility = daily_returns.std() * np.sqrt(252) # Annualized volatility\n", + " \n", + " # Create result dictionary\n", + " result = {\n", + " \"ticker\": ticker,\n", + " \"current_price\": current_price,\n", + " \"52_week_high\": year_high,\n", + " \"52_week_low\": year_low,\n", + " \"50_day_ma\": ma_50,\n", + " \"200_day_ma\": ma_200,\n", + " \"ytd_price_change\": price_change,\n", + " \"ytd_percent_change\": percent_change,\n", + " \"trend\": trend,\n", + " \"volatility\": volatility\n", + " }\n", + " \n", + " # Convert numpy types to Python native types for better JSON serialization\n", + " for key, value in result.items():\n", + " if isinstance(value, np.generic):\n", + " result[key] = value.item()\n", + " \n", + " # Generate plot\n", + " plt.figure(figsize=(12, 6))\n", + " plt.plot(hist.index, hist['Close'], label='Close Price')\n", + " plt.plot(hist.index, hist['Close'].rolling(window=50).mean(), label='50-day MA')\n", + " plt.plot(hist.index, hist['Close'].rolling(window=200).mean(), label='200-day MA')\n", + " plt.title(f\"{ticker} Stock Price (Past Year)\")\n", + " plt.xlabel(\"Date\")\n", + " plt.ylabel(\"Price ($)\")\n", + " plt.legend()\n", + " plt.grid(True)\n", + " \n", + " # Save plot to file\n", + " os.makedirs(\"coding\", exist_ok=True)\n", + " plot_file_path = f\"coding/{ticker}_stockprice.png\"\n", + " plt.savefig(plot_file_path)\n", + " print(f\"Plot saved as {plot_file_path}\")\n", + " result[\"plot_file_path\"] = plot_file_path\n", + " \n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "google_search_tool = FunctionTool(google_search, description=\"Search Google for information, returns results with a snippet and body content\")\n", + "stock_analysis_tool = FunctionTool(analyze_stock, description=\"Analyze stock data and generate a plot\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining Agents\n", + "\n", + "Next, we will define the agents that will perform the tasks. We will create a `search_agent` that searches the web for information about a company, a `stock_analysis_agent` that retrieves stock information for a company, and a `report_agent` that generates a report based on the information collected by the other agents. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "search_agent = ToolUseAssistantAgent( name=\"Google_Search_Agent\",\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", + " registered_tools=[google_search_tool],\n", + " description=\"Search Google for information, returns top 2 results with a snippet and body content\",\n", + " system_message = \"You are a helpful AI assistant. Solve tasks using your tools.\",\n", + ")\n", + "\n", + "stock_analysis_agent = ToolUseAssistantAgent( name=\"Stock_Analysis_Agent\",\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", + " registered_tools=[stock_analysis_tool],\n", + " description=\"Analyze stock data and generate a plot\",\n", + " system_message = \"You are a helpful AI assistant. Solve tasks using your tools.\",\n", + ") \n", + "\n", + "report_agent = CodingAssistantAgent( name=\"Report_Agent\",\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", + " description=\"Generate a report based on the search and stock analysis results\",\n", + " system_message=\"You are a helpful assistant that can generate a comprehensive report on a given topic based on search and stock analysis results provided. When you done with generating the report, reply with TERMINATE.\"\n", + ")\n", + "\n", + "team = RoundRobinGroupChat([search_agent, stock_analysis_agent, report_agent])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:02:03.043352]:\u001b[0m\n", + "\n", + "Write a financial report on American airlines\n", + "From: user\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:02:05.010849], Google_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_3SnRoIqxoibAgf574n9z5Vpg', arguments='{\"query\":\"American Airlines financial report\",\"num_results\":5}', name='google_search')]\n", + "From: Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:02:12.172388], tool_agent_for_Google_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionExecutionResult(content=\"[{'title': 'Financial AAL | American Airlines', 'link': 'https://americanairlines.gcs-web.com/financial-results/financial-aal', 'snippet': 'Investor Relations; Financial Results; Financial Results. Quarterly Menu. AAL · AMR · LCC. Financial AAL. 2024. Q2. Earnings Release.', 'body': 'Financial AAL | American Airlines Skip to main navigation Main Menu Investor Relations Toolkit Presentations & Investor Updates Financial Results SEC Filings Annual Shareholders Meeting Proxy Materials & Virtual Shareholder Meeting AGM – QA Written Responses Stock Info Events Equity Distribution Analysts FAQs Merger Information Contact Us Corporate Information About Us Leadership Bios Fact Sheets Where We Fly Our Planes News Corporate Governance Plan Travel American Airlines AAdvantage'}, {'title': 'American Airlines reports fourth-quarter and full-year 2023 financial ...', 'link': 'https://news.aa.com/news/news-details/2024/American-Airlines-reports-fourth-quarter-and-full-year-2023-financial-results-CORP-FI-01/default.aspx', 'snippet': 'Jan 25, 2024 ... American Airlines Group Inc. (NASDAQ: AAL) today reported its fourth-quarter and full-year 2023 financial results, including: Record\\\\xa0...', 'body': 'Just a moment... Enable JavaScript and cookies to continue'}, {'title': 'American Airlines Reports Second-Quarter 2024 Financial Results ...', 'link': 'https://americanairlines.gcs-web.com/news-releases/news-release-details/american-airlines-reports-second-quarter-2024-financial-results', 'snippet': 'Jul 25, 2024 ... American produced record quarterly revenue of $14.3 billion in the second quarter, an increase of 2% year over year.', 'body': 'American Airlines Reports Second-Quarter 2024 Financial Results | American Airlines Skip to main navigation Main Menu Investor Relations Toolkit Presentations & Investor Updates Financial Results SEC Filings Annual Shareholders Meeting Proxy Materials & Virtual Shareholder Meeting AGM – QA Written Responses Stock Info Events Equity Distribution Analysts FAQs Merger Information Contact Us Corporate Information About Us Leadership Bios Fact Sheets Where We Fly Our Planes News Corporate Governance'}, {'title': 'American Airlines reports first-quarter 2024 financial results ...', 'link': 'https://news.aa.com/news/news-details/2024/American-Airlines-reports-first-quarter-2024-financial-results-CORP-FI-04/default.aspx', 'snippet': 'Apr 25, 2024 ... American Airlines Group Inc. (NASDAQ: AAL) today reported its first-quarter 2024 financial results, including: Record first-quarter revenue\\\\xa0...', 'body': 'Just a moment... Enable JavaScript and cookies to continue'}, {'title': 'American Airlines Group - AnnualReports.com', 'link': 'https://www.annualreports.com/Company/american-airlines-group', 'snippet': 'American Airlines Group reports have an aggregate usefulness score of 4.7 based on 179 reviews. American Airlines Group. Most Recent Annual Report. American\\\\xa0...', 'body': 'American Airlines Group - AnnualReports.com Menu BROWSE BY Exchanges Industry Other Filters BROWSE BY Exchanges Industry Other Filters 0 American Airlines Group Ticker AAL Exchange NASDAQ More Industry Air Services, Other More Sector Industrial Goods More 10,000+ Employees Based in Dallas-Fort Worth, Texas American Airlines offers customers 6,800 daily flights to more than 365 destinations in 61 countries from its hubs in Charlotte, Chicago, Dallas-Fort Worth, Los Angeles, Miami, New York,'}]\", call_id='call_3SnRoIqxoibAgf574n9z5Vpg')]\n", + "From: tool_agent_for_Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:02:21.539163], Google_Search_Agent:\u001b[0m\n", + "\n", + "### American Airlines Financial Report\n", + "\n", + "#### Overview\n", + "American Airlines Group Inc. (NASDAQ: AAL) is one of the largest airlines in the world, providing service to over 365 destinations in 61 countries. The company is headquartered in Fort Worth, Texas, and operates approximately 6,800 daily flights. \n", + "\n", + "#### Recent Financial Performance\n", + "\n", + "1. **Fourth Quarter and Full Year 2023 Financial Results** \n", + " - Reported on January 25, 2024\n", + " - **Key Highlights:**\n", + " - The company achieved record revenues in the fourth quarter.\n", + " - Year-over-year comparisons showed significant improvements across various financial metrics.\n", + " - **Source:** [American Airlines News Release](https://news.aa.com/news/news-details/2024/American-Airlines-reports-fourth-quarter-and-full-year-2023-financial-results-CORP-FI-01/default.aspx)\n", + "\n", + "2. **Second Quarter 2024 Financial Results** \n", + " - Reported on July 25, 2024\n", + " - **Key Highlights:**\n", + " - Achieved a record quarterly revenue of $14.3 billion, marking a 2% increase year-over-year.\n", + " - **Source:** [American Airlines Q2 2024 Results](https://americanairlines.gcs-web.com/news-releases/news-release-details/american-airlines-reports-second-quarter-2024-financial-results)\n", + "\n", + "3. **First Quarter 2024 Financial Results**\n", + " - Reported on April 25, 2024\n", + " - **Key Highlights:**\n", + " - Set a record for first-quarter revenue, reflecting a rebound in travel demand.\n", + " - **Source:** [American Airlines Q1 2024 Results](https://news.aa.com/news/news-details/2024/American-Airlines-reports-first-quarter-2024-financial-results-CORP-FI-04/default.aspx)\n", + "\n", + "#### Summary of Financial Insights\n", + "American Airlines has demonstrated a consistent upward trajectory in revenue generation, particularly in the wake of global recovery trends following the pandemic. The financial results indicate a strong recovery in passenger demand, attributed to strategic operational enhancements and expanded route offerings.\n", + "\n", + "#### Key Takeaways\n", + "- American Airlines continues to recover well, marking significant revenue growth across all quarters reported in 2023 and early 2024.\n", + "- Future strategies and expansions could build upon the current momentum, potentially leading to even higher revenue streams.\n", + "\n", + "For a comprehensive view of American Airlines’ financial results, investors and interested parties can refer to their [Investor Relations page](https://americanairlines.gcs-web.com/financial-results/financial-aal) for further details on financial reports and filings.\n", + "From: Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:02:22.296396], Stock_Analysis_Agent:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_Ds837ykHHUjBtpIPeqSwVKqE', arguments='{\"ticker\":\"AAL\"}', name='analyze_stock')]\n", + "From: Stock_Analysis_AgentPlot saved as coding/AAL_stockprice.png\n", + "\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:02:32.457106], tool_agent_for_Stock_Analysis_Agent:\u001b[0m\n", + "\n", + "[FunctionExecutionResult(content=\"{'ticker': 'AAL', 'current_price': 11.985, '52_week_high': 16.15, '52_week_low': 9.07, '50_day_ma': 10.543800048828125, '200_day_ma': 12.718999948501587, 'ytd_price_change': -1.9099998474121094, 'ytd_percent_change': -14.21130883218106, 'trend': 'Downward', 'volatility': 0.4104421021721457, 'plot_file_path': 'coding/AAL_stockprice.png'}\", call_id='call_Ds837ykHHUjBtpIPeqSwVKqE')]\n", + "From: tool_agent_for_Stock_Analysis_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:02:40.412837], Stock_Analysis_Agent:\u001b[0m\n", + "\n", + "### American Airlines Financial Report\n", + "\n", + "#### Overview\n", + "American Airlines Group Inc. (NASDAQ: AAL) is a leading airline provider, serving over 365 destinations across 61 countries. Headquartered in Fort Worth, Texas, the airline operates around 6,800 daily flights.\n", + "\n", + "#### Recent Financial Performance\n", + "\n", + "1. **Fourth Quarter and Full Year 2023 Financial Results** \n", + " - Reported: January 25, 2024\n", + " - **Highlights:**\n", + " - Achieved record revenues for the quarter.\n", + " - Significant year-over-year improvements across financial metrics.\n", + "\n", + "2. **Second Quarter 2024 Financial Results** \n", + " - Reported: July 25, 2024\n", + " - **Highlights:**\n", + " - Record quarterly revenue of $14.3 billion, up 2% year-over-year.\n", + "\n", + "3. **First Quarter 2024 Financial Results**\n", + " - Reported: April 25, 2024\n", + " - **Highlights:**\n", + " - Record first-quarter revenue reflects a strong recovery in travel demand.\n", + "\n", + "#### Summary of Financial Insights\n", + "American Airlines has shown a strong upward trend in revenue generation, especially with the revival of passenger travel demand following the pandemic. Enhanced operational strategies and expanded route offerings have contributed to this recovery.\n", + "\n", + "#### Key Stock Metrics\n", + "- **Current Price:** $11.99\n", + "- **52-Week High:** $16.15\n", + "- **52-Week Low:** $9.07\n", + "- **50-Day Moving Average:** $10.54\n", + "- **200-Day Moving Average:** $12.72\n", + "- **Year-to-Date Price Change:** -$1.91\n", + "- **Year-to-Date Percent Change:** -14.21%\n", + "- **Volatility:** 41.04%\n", + "- **Trend:** Downward\n", + "\n", + "![Stock Price Trend](coding/AAL_stockprice.png)\n", + "\n", + "#### Key Takeaways\n", + "- American Airlines continues to recover post-pandemic, with noteworthy revenue growth across all reported quarters in 2023 and early 2024.\n", + "- The current financial metrics indicate areas for strategic enhancements, aiming for increased revenue.\n", + "\n", + "Investors and stakeholders can find more details on American Airlines’ financial results on their [Investor Relations page](https://americanairlines.gcs-web.com/financial-results/financial-aal).\n", + "From: Stock_Analysis_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:02:49.475519], Report_Agent:\u001b[0m\n", + "\n", + "### American Airlines Financial Report\n", + "\n", + "#### Overview\n", + "American Airlines Group Inc. (NASDAQ: AAL) is one of the largest airlines globally, offering service to over 365 destinations in 61 countries. The airline operates around 6,800 daily flights and is headquartered in Fort Worth, Texas.\n", + "\n", + "#### Recent Financial Performance\n", + "\n", + "1. **Fourth Quarter and Full Year 2023 Financial Results** \n", + " - **Date Reported:** January 25, 2024\n", + " - **Highlights:**\n", + " - Achieved record revenues for the quarter, symbolizing robust travel demand recovery.\n", + " - Strong improvements year-over-year in operating income and net earnings.\n", + "\n", + "2. **Second Quarter 2024 Financial Results** \n", + " - **Date Reported:** July 25, 2024\n", + " - **Highlights:**\n", + " - Reported a record quarterly revenue of $14.3 billion, reflecting a 2% increase from the previous year.\n", + " - Continued focus on operational efficiency and customer service enhancements.\n", + "\n", + "3. **First Quarter 2024 Financial Results**\n", + " - **Date Reported:** April 25, 2024\n", + " - **Highlights:**\n", + " - Set a record for first-quarter revenue, showing a strong rebound in passenger travel demand as restrictions eased.\n", + "\n", + "#### Summary of Financial Insights\n", + "The financial results from American Airlines indicate a sustained recovery trajectory, highlighting significant revenue growth fueled by the resurgence in passenger travel. Operational improvements and expanded routes have played a crucial role in this rebound.\n", + "\n", + "#### Key Stock Metrics\n", + "- **Current Price:** $11.99\n", + "- **52-Week High:** $16.15\n", + "- **52-Week Low:** $9.07\n", + "- **50-Day Moving Average:** $10.54\n", + "- **200-Day Moving Average:** $12.72\n", + "- **Year-to-Date Price Change:** -$1.91\n", + "- **Year-to-Date Percent Change:** -14.21%\n", + "- **Volatility:** 41.04%\n", + "- **Stock Trend:** Downward\n", + "\n", + "![Stock Price Trend](coding/AAL_stockprice.png)\n", + "\n", + "#### Key Takeaways\n", + "- American Airlines is benefiting from a solid recovery post-pandemic with notable revenue growth across all quarters in 2023 and early 2024.\n", + "- The company is positioned for potential growth through strategic operational enhancements and a focus on expanding its service network.\n", + "\n", + "For further details on American Airlines’ financial results and other updates, investors may visit their [Investor Relations page](https://americanairlines.gcs-web.com/financial-results/financial-aal).\n", + "\n", + "TERMINATE\n", + "From: Report_AgentTeamRunResult(messages=[TextMessage(source='user', content='Write a financial report on American airlines'), TextMessage(source='Google_Search_Agent', content='### American Airlines Financial Report\\n\\n#### Overview\\nAmerican Airlines Group Inc. (NASDAQ: AAL) is one of the largest airlines in the world, providing service to over 365 destinations in 61 countries. The company is headquartered in Fort Worth, Texas, and operates approximately 6,800 daily flights. \\n\\n#### Recent Financial Performance\\n\\n1. **Fourth Quarter and Full Year 2023 Financial Results** \\n - Reported on January 25, 2024\\n - **Key Highlights:**\\n - The company achieved record revenues in the fourth quarter.\\n - Year-over-year comparisons showed significant improvements across various financial metrics.\\n - **Source:** [American Airlines News Release](https://news.aa.com/news/news-details/2024/American-Airlines-reports-fourth-quarter-and-full-year-2023-financial-results-CORP-FI-01/default.aspx)\\n\\n2. **Second Quarter 2024 Financial Results** \\n - Reported on July 25, 2024\\n - **Key Highlights:**\\n - Achieved a record quarterly revenue of $14.3 billion, marking a 2% increase year-over-year.\\n - **Source:** [American Airlines Q2 2024 Results](https://americanairlines.gcs-web.com/news-releases/news-release-details/american-airlines-reports-second-quarter-2024-financial-results)\\n\\n3. **First Quarter 2024 Financial Results**\\n - Reported on April 25, 2024\\n - **Key Highlights:**\\n - Set a record for first-quarter revenue, reflecting a rebound in travel demand.\\n - **Source:** [American Airlines Q1 2024 Results](https://news.aa.com/news/news-details/2024/American-Airlines-reports-first-quarter-2024-financial-results-CORP-FI-04/default.aspx)\\n\\n#### Summary of Financial Insights\\nAmerican Airlines has demonstrated a consistent upward trajectory in revenue generation, particularly in the wake of global recovery trends following the pandemic. The financial results indicate a strong recovery in passenger demand, attributed to strategic operational enhancements and expanded route offerings.\\n\\n#### Key Takeaways\\n- American Airlines continues to recover well, marking significant revenue growth across all quarters reported in 2023 and early 2024.\\n- Future strategies and expansions could build upon the current momentum, potentially leading to even higher revenue streams.\\n\\nFor a comprehensive view of American Airlines’ financial results, investors and interested parties can refer to their [Investor Relations page](https://americanairlines.gcs-web.com/financial-results/financial-aal) for further details on financial reports and filings.'), TextMessage(source='Stock_Analysis_Agent', content='### American Airlines Financial Report\\n\\n#### Overview\\nAmerican Airlines Group Inc. (NASDAQ: AAL) is a leading airline provider, serving over 365 destinations across 61 countries. Headquartered in Fort Worth, Texas, the airline operates around 6,800 daily flights.\\n\\n#### Recent Financial Performance\\n\\n1. **Fourth Quarter and Full Year 2023 Financial Results** \\n - Reported: January 25, 2024\\n - **Highlights:**\\n - Achieved record revenues for the quarter.\\n - Significant year-over-year improvements across financial metrics.\\n\\n2. **Second Quarter 2024 Financial Results** \\n - Reported: July 25, 2024\\n - **Highlights:**\\n - Record quarterly revenue of $14.3 billion, up 2% year-over-year.\\n\\n3. **First Quarter 2024 Financial Results**\\n - Reported: April 25, 2024\\n - **Highlights:**\\n - Record first-quarter revenue reflects a strong recovery in travel demand.\\n\\n#### Summary of Financial Insights\\nAmerican Airlines has shown a strong upward trend in revenue generation, especially with the revival of passenger travel demand following the pandemic. Enhanced operational strategies and expanded route offerings have contributed to this recovery.\\n\\n#### Key Stock Metrics\\n- **Current Price:** $11.99\\n- **52-Week High:** $16.15\\n- **52-Week Low:** $9.07\\n- **50-Day Moving Average:** $10.54\\n- **200-Day Moving Average:** $12.72\\n- **Year-to-Date Price Change:** -$1.91\\n- **Year-to-Date Percent Change:** -14.21%\\n- **Volatility:** 41.04%\\n- **Trend:** Downward\\n\\n![Stock Price Trend](coding/AAL_stockprice.png)\\n\\n#### Key Takeaways\\n- American Airlines continues to recover post-pandemic, with noteworthy revenue growth across all reported quarters in 2023 and early 2024.\\n- The current financial metrics indicate areas for strategic enhancements, aiming for increased revenue.\\n\\nInvestors and stakeholders can find more details on American Airlines’ financial results on their [Investor Relations page](https://americanairlines.gcs-web.com/financial-results/financial-aal).'), StopMessage(source='Report_Agent', content='### American Airlines Financial Report\\n\\n#### Overview\\nAmerican Airlines Group Inc. (NASDAQ: AAL) is one of the largest airlines globally, offering service to over 365 destinations in 61 countries. The airline operates around 6,800 daily flights and is headquartered in Fort Worth, Texas.\\n\\n#### Recent Financial Performance\\n\\n1. **Fourth Quarter and Full Year 2023 Financial Results** \\n - **Date Reported:** January 25, 2024\\n - **Highlights:**\\n - Achieved record revenues for the quarter, symbolizing robust travel demand recovery.\\n - Strong improvements year-over-year in operating income and net earnings.\\n\\n2. **Second Quarter 2024 Financial Results** \\n - **Date Reported:** July 25, 2024\\n - **Highlights:**\\n - Reported a record quarterly revenue of $14.3 billion, reflecting a 2% increase from the previous year.\\n - Continued focus on operational efficiency and customer service enhancements.\\n\\n3. **First Quarter 2024 Financial Results**\\n - **Date Reported:** April 25, 2024\\n - **Highlights:**\\n - Set a record for first-quarter revenue, showing a strong rebound in passenger travel demand as restrictions eased.\\n\\n#### Summary of Financial Insights\\nThe financial results from American Airlines indicate a sustained recovery trajectory, highlighting significant revenue growth fueled by the resurgence in passenger travel. Operational improvements and expanded routes have played a crucial role in this rebound.\\n\\n#### Key Stock Metrics\\n- **Current Price:** $11.99\\n- **52-Week High:** $16.15\\n- **52-Week Low:** $9.07\\n- **50-Day Moving Average:** $10.54\\n- **200-Day Moving Average:** $12.72\\n- **Year-to-Date Price Change:** -$1.91\\n- **Year-to-Date Percent Change:** -14.21%\\n- **Volatility:** 41.04%\\n- **Stock Trend:** Downward\\n\\n![Stock Price Trend](coding/AAL_stockprice.png)\\n\\n#### Key Takeaways\\n- American Airlines is benefiting from a solid recovery post-pandemic with notable revenue growth across all quarters in 2023 and early 2024.\\n- The company is positioned for potential growth through strategic operational enhancements and a focus on expanding its service network.\\n\\nFor further details on American Airlines’ financial results and other updates, investors may visit their [Investor Relations page](https://americanairlines.gcs-web.com/financial-results/financial-aal).\\n\\nTERMINATE')])\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "result = await team.run(\"Write a financial report on American airlines\")\n", + "print(result)" + ] + } + ], + "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/packages/autogen-core/docs/src/agentchat-user-guide/examples/index.md b/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/index.md new file mode 100644 index 000000000000..eddcceee3ffa --- /dev/null +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/index.md @@ -0,0 +1,54 @@ +--- +myst: + html_meta: + "description lang=en": | + Examples built using AgentChat, a high-level api for AutoGen +--- + +# Examples + +A list of examples to help you get started with AgentChat. + +:::::{grid} 2 2 2 3 + +::::{grid-item-card} Travel Planning +:img-top: ../../images/code.svg +:img-alt: travel planning example +:link: ./travel-planning.html + +^^^ +Generating a travel plan using multiple agents. + +:::: + +::::{grid-item-card} Company Research +:img-top: ../../images/code.svg +:img-alt: company research example +:link: ./company-research.html + +^^^ +Generating a company research report using multiple agents with tools. + +:::: + +::::{grid-item-card} Literature Review +:img-top: ../../images/code.svg +:img-alt: literature review example +:link: ./literature-review.html + +^^^ +Generating a literature review using agents with tools. + +:::: + +::::: + +```{toctree} +:maxdepth: 1 +:hidden: + +travel-planning +company-research +literature-review + +``` diff --git a/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/literature-review.ipynb b/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/literature-review.ipynb new file mode 100644 index 000000000000..0d70cafbc64e --- /dev/null +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/literature-review.ipynb @@ -0,0 +1,350 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Literature Review\n", + "\n", + "A common task while exploring a new topic is to conduct a literature review. In this example we will explore how a multi-agent team can be configured to conduct a _simple_ literature review.\n", + "\n", + "- **Arxiv Search Agent**: Use the Arxiv API to search for papers related to a given topic and return results.\n", + "- **Google Search Agent**: Use the Google Search api to find papers related to a given topic and return results.\n", + "- **Report Agent**: Generate a report based on the information collected by the search and stock analysis agents.\n", + "\n", + "\n", + "First, let us import the necessary modules. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from autogen_agentchat.agents import CodingAssistantAgent, ToolUseAssistantAgent\n", + "from autogen_agentchat.teams.group_chat import RoundRobinGroupChat\n", + "from autogen_core.components.models import OpenAIChatCompletionClient\n", + "from autogen_core.components.tools import FunctionTool" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining Tools \n", + "\n", + "Next, we will define the tools that the agents will use to perform their tasks. In this case we will define a simple function `search_arxiv` that will use the `arxiv` library to search for papers related to a given topic. \n", + "\n", + "Finally, we will wrap the functions into a `FunctionTool` class that will allow us to use it as a tool in the agents. \n", + "\n", + "Note: You will need to set the appropriate environment variables for tools as needed.\n", + "\n", + "Also install required libraries: \n", + "\n", + "```bash\n", + "!pip install arxiv\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def google_search(query: str, num_results: int = 2, max_chars: int = 500) -> list:\n", + " import os\n", + " import requests\n", + " from dotenv import load_dotenv\n", + " from bs4 import BeautifulSoup\n", + " import time\n", + "\n", + " load_dotenv()\n", + "\n", + " api_key = os.getenv('GOOGLE_API_KEY')\n", + " search_engine_id = os.getenv('GOOGLE_SEARCH_ENGINE_ID')\n", + " \n", + " if not api_key or not search_engine_id:\n", + " raise ValueError(\"API key or Search Engine ID not found in environment variables\")\n", + "\n", + " url = \"https://www.googleapis.com/customsearch/v1\"\n", + " params = {\n", + " 'key': api_key,\n", + " 'cx': search_engine_id,\n", + " 'q': query,\n", + " 'num': num_results\n", + " }\n", + "\n", + " response = requests.get(url, params=params)\n", + " \n", + " if response.status_code != 200:\n", + " print(response.json())\n", + " raise Exception(f\"Error in API request: {response.status_code}\")\n", + "\n", + " results = response.json().get('items', [])\n", + " \n", + " def get_page_content(url):\n", + " try:\n", + " response = requests.get(url, timeout=10)\n", + " soup = BeautifulSoup(response.content, 'html.parser')\n", + " text = soup.get_text(separator=' ', strip=True)\n", + " words = text.split()\n", + " content = ''\n", + " for word in words:\n", + " if len(content) + len(word) + 1 > max_chars:\n", + " break\n", + " content += ' ' + word\n", + " return content.strip()\n", + " except Exception as e:\n", + " print(f\"Error fetching {url}: {str(e)}\")\n", + " return \"\"\n", + "\n", + " enriched_results = []\n", + " for item in results:\n", + " body = get_page_content(item['link'])\n", + " enriched_results.append({\n", + " 'title': item['title'],\n", + " 'link': item['link'],\n", + " 'snippet': item['snippet'],\n", + " 'body': body\n", + " })\n", + " time.sleep(1) # Be respectful to the servers\n", + "\n", + " return enriched_results\n", + "\n", + "def arxiv_search(query: str, max_results: int = 2) -> list:\n", + " \"\"\"\n", + " Search Arxiv for papers and return the results including abstracts.\n", + " \"\"\"\n", + " import arxiv \n", + " client = arxiv.Client()\n", + " search = arxiv.Search(\n", + " query=query,\n", + " max_results=max_results,\n", + " sort_by=arxiv.SortCriterion.Relevance\n", + " )\n", + " \n", + " results = []\n", + " for paper in client.results(search):\n", + " results.append({\n", + " 'title': paper.title,\n", + " 'authors': [author.name for author in paper.authors],\n", + " 'published': paper.published.strftime('%Y-%m-%d'),\n", + " 'abstract': paper.summary,\n", + " 'pdf_url': paper.pdf_url,\n", + " })\n", + " \n", + " # # Write results to a file\n", + " # with open('arxiv_search_results.json', 'w') as f:\n", + " # json.dump(results, f, indent=2)\n", + " \n", + " return results" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "google_search_tool = FunctionTool(google_search, description=\"Search Google for information, returns results with a snippet and body content\")\n", + "arxiv_search_tool = FunctionTool(arxiv_search, description=\"Search Arxiv for papers related to a given topic, including abstracts\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Defining Agents \n", + "\n", + "Next, we will define the agents that will perform the tasks. " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:21:08.443314]:\u001b[0m\n", + "\n", + "Write a literature review on no code tools for building multi agent ai systems\n", + "From: user\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:21:09.295153], Google_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_hw2vekTxYJgfPynNxomuQQhU', arguments='{\"query\":\"no code tools for building multi agent AI systems\",\"num_results\":5}', name='google_search')]\n", + "From: Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:21:16.023771], tool_agent_for_Google_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionExecutionResult(content='[{\\'title\\': \\'AutoGen Studio: A No-Code Developer Tool for Building and ...\\', \\'link\\': \\'https://arxiv.org/abs/2408.15247\\', \\'snippet\\': \\'Aug 9, 2024 ... Abstract:Multi-agent systems, where multiple agents (generative AI models + tools) collaborate, are emerging as an effective pattern for\\\\xa0...\\', \\'body\\': \\'[2408.15247] AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems Skip to main content We gratefully acknowledge support from the Simons Foundation, member institutions , and all contributors. Donate > cs > arXiv:2408.15247 Help | Advanced Search All fields Title Author Abstract Comments Journal reference ACM classification MSC classification Report number arXiv identifier DOI ORCID arXiv author ID Help pages Full text Search open search GO open navigation\\'}, {\\'title\\': \\'AutoGen Studio: A No-Code Developer Tool for Building and ...\\', \\'link\\': \\'https://www.microsoft.com/en-us/research/publication/autogen-studio-a-no-code-developer-tool-for-building-and-debugging-multi-agent-systems/\\', \\'snippet\\': \\'Aug 2, 2024 ... Multi-agent systems, where multiple agents (generative AI models + tools) collaborate, are emerging as an effective pattern for solving\\\\xa0...\\', \\'body\\': \\'Your request has been blocked. This could be due to several reasons. Skip to main content Microsoft Microsoft 365 Teams Copilot Windows Surface Xbox Deals Small Business Support More All Microsoft Office Windows Surface Xbox Deals Support Software Windows Apps OneDrive Outlook Skype OneNote Microsoft Teams Microsoft Edge PCs & Devices Computers Shop Xbox Accessories VR & mixed reality Phones Entertainment Xbox Game Pass Ultimate Xbox Live Gold Xbox games PC games Windows digital games Movies &\\'}, {\\'title\\': \\'Insights and Learnings from Building a Complex Multi-Agent System ...\\', \\'link\\': \\'https://www.reddit.com/r/LangChain/comments/1byz3lr/insights_and_learnings_from_building_a_complex/\\', \\'snippet\\': \"Apr 8, 2024 ... I\\'m a business owner and a tech guy with a background in math, coding, and ML. Since early 2023, I\\'ve fallen in love with the LLM world. So, I\\\\xa0...\", \\'body\\': \"You\\'ve been blocked by network security. To continue, log in to your Reddit account or use your developer token If you think you\\'ve been blocked by mistake, file a ticket below and we\\'ll look into it. Log in File a ticket\"}, {\\'title\\': \\'Multi Agents System (MAS) Builder - Build your AI Workforce\\', \\'link\\': \\'https://relevanceai.com/multi-agents\\', \\'snippet\\': \\'Mar 10, 2024 ... Easily build a multi-agent system. AI workers working collaboratively. No coding required.\\', \\'body\\': \\'Multi Agents System (MAS) Builder - Build your AI Workforce Recruit Bosh, the AI BDR Agent, and book meetings on autopilot. Recruit Bosh, the AI BDR Agent, and book meetings on autopilot. Register Learn more Product AI Agents Agent Teams AI Tools Integrations API Function Sales Marketing Customer Support Research Operations Agents Bosh the Sales Agent Inbound - AI SDR Outbound - AI BDR Lima the Lifecycle Agent Resources Blog Customers Documentation\\\\u200b Javascript SDK Python SDK\\\\u200b Templates Building\\'}, {\\'title\\': \\'Crew AI\\', \\'link\\': \\'https://www.crewai.com/\\', \\'snippet\\': \"Start by using CrewAI\\'s framework or UI Studio to build your multi-agent automations—whether coding from scratch or leveraging our no-code tools and templates.\", \\'body\\': \\'Crew AI Get the Inside Scoop First! Join Our Exclusive Waitlist Home Enterprise Open Source Login Start Enterprise Trial crewAI © Copyright 2024 Log in Start Enterprise Trial The Leading Multi-Agent Platform The Leading Multi-Agent Platform Streamline workflows across industries with powerful AI agents. Build and deploy automated workflows using any LLM and cloud platform. Start Free Trial I Want A Demo 100,000,000+ 75,000,000 50,000,000 25,000,000 10,000,000 7,500,000 5,000,000 2,500,000\\'}]', call_id='call_hw2vekTxYJgfPynNxomuQQhU')]\n", + "From: tool_agent_for_Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:21:28.301664], Google_Search_Agent:\u001b[0m\n", + "\n", + "### Literature Review on No-Code Tools for Building Multi-Agent AI Systems\n", + "\n", + "The field of artificial intelligence is rapidly evolving, particularly with the emergence of multi-agent systems (MAS), where multiple intelligent agents collaborate to solve complex problems. The advent of no-code tools has significantly democratized access to these technologies, enabling non-technical users to construct and deploy multi-agent systems without extensive programming knowledge. This review synthesizes recent findings and developments in no-code tools suitable for building MAS.\n", + "\n", + "1. **AutoGen Studio**: Recent advancements have shown that tools like AutoGen Studio are at the forefront of the no-code revolution in multi-agent system development. According to a study published on arXiv, AutoGen Studio serves as a no-code developer tool that allows users to build and debug multi-agent systems efficiently. The framework is designed to facilitate collaboration between various generative AI models and tools, making it a promising resource for developers looking to implement complex behaviors without deep technical skills. (Source: [arXiv](https://arxiv.org/abs/2408.15247))\n", + "\n", + "2. **Multi Agents System (MAS) Builder**: Another notable example is the Multi Agents System (MAS) Builder, a platform that enables users to create AI teams effortlessly. This tool allows entrepreneurs and businesses to recruit AI agents for tasks such as sales and customer support, optimizing operations without the need for coding. The user-friendly interface streamlines the process, showcasing the potential of no-code solutions in practical business applications. (Source: [RelevanceAI](https://relevanceai.com/multi-agents))\n", + "\n", + "3. **Crew AI Platform**: Crew AI offers an intuitive framework for users to automate workflows across various industries using multi-agent systems. The no-code tools provided by Crew AI facilitate the development of automations while allowing users to explore coding from scratch or leverage pre-existing templates. This flexibility is critical for organizations aiming to optimize efficiency and improve decision-making processes through AI. The platform emphasizes ease of use and accessibility for a broad audience. (Source: [Crew AI](https://www.crewai.com/))\n", + "\n", + "4. **Community Insights**: Experiences shared by users in forums, such as those from Reddit, reveal valuable insights into the practicalities and challenges of using no-code tools for building multi-agent systems. Users, both from technical and non-technical backgrounds, have reported successes and setbacks, providing a grassroots perspective that could guide newcomers in their journey with no-code platforms. \n", + "\n", + "5. **Emerging Trends**: The rise of no-code tools aligns with industry trends towards automation and AI integration in everyday business processes. These tools not only reduce the barrier to entry for users unacquainted with traditional programming languages but also encourage innovation by allowing users to focus on logical design and system architecture rather than syntax and debugging.\n", + "\n", + "In conclusion, no-code tools for building multi-agent AI systems are gaining traction and transforming the landscape of AI development. With platforms like AutoGen Studio, MAS Builder, and Crew AI, a wide range of users can engage in the development of sophisticated AI systems without needing extensive technical expertise. Future studies could further explore the effectiveness, limitations, and user satisfaction associated with these tools to develop a deeper understanding of their impact on the AI ecosystem.\n", + "From: Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:21:29.259392], Arxiv_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_sEyPLYy5AYq3PJZyNmGOWKUr', arguments='{\"query\":\"no code tools for building multi agent AI systems\",\"max_results\":5}', name='arxiv_search')]\n", + "From: Arxiv_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:21:34.471756], tool_agent_for_Arxiv_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionExecutionResult(content='[{\\'title\\': \\'AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems\\', \\'authors\\': [\\'Victor Dibia\\', \\'Jingya Chen\\', \\'Gagan Bansal\\', \\'Suff Syed\\', \\'Adam Fourney\\', \\'Erkang Zhu\\', \\'Chi Wang\\', \\'Saleema Amershi\\'], \\'published\\': \\'2024-08-09\\', \\'abstract\\': \\'Multi-agent systems, where multiple agents (generative AI models + tools)\\\\ncollaborate, are emerging as an effective pattern for solving long-running,\\\\ncomplex tasks in numerous domains. However, specifying their parameters (such\\\\nas models, tools, and orchestration mechanisms etc,.) and debugging them\\\\nremains challenging for most developers. To address this challenge, we present\\\\nAUTOGEN STUDIO, a no-code developer tool for rapidly prototyping, debugging,\\\\nand evaluating multi-agent workflows built upon the AUTOGEN framework. AUTOGEN\\\\nSTUDIO offers a web interface and a Python API for representing LLM-enabled\\\\nagents using a declarative (JSON-based) specification. It provides an intuitive\\\\ndrag-and-drop UI for agent workflow specification, interactive evaluation and\\\\ndebugging of workflows, and a gallery of reusable agent components. We\\\\nhighlight four design principles for no-code multi-agent developer tools and\\\\ncontribute an open-source implementation at\\\\nhttps://github.com/microsoft/autogen/tree/main/samples/apps/autogen-studio\\', \\'pdf_url\\': \\'http://arxiv.org/pdf/2408.15247v1\\'}, {\\'title\\': \\'HAICOSYSTEM: An Ecosystem for Sandboxing Safety Risks in Human-AI Interactions\\', \\'authors\\': [\\'Xuhui Zhou\\', \\'Hyunwoo Kim\\', \\'Faeze Brahman\\', \\'Liwei Jiang\\', \\'Hao Zhu\\', \\'Ximing Lu\\', \\'Frank Xu\\', \\'Bill Yuchen Lin\\', \\'Yejin Choi\\', \\'Niloofar Mireshghallah\\', \\'Ronan Le Bras\\', \\'Maarten Sap\\'], \\'published\\': \\'2024-09-24\\', \\'abstract\\': \"AI agents are increasingly autonomous in their interactions with human users\\\\nand tools, leading to increased interactional safety risks. We present\\\\nHAICOSYSTEM, a framework examining AI agent safety within diverse and complex\\\\nsocial interactions. HAICOSYSTEM features a modular sandbox environment that\\\\nsimulates multi-turn interactions between human users and AI agents, where the\\\\nAI agents are equipped with a variety of tools (e.g., patient management\\\\nplatforms) to navigate diverse scenarios (e.g., a user attempting to access\\\\nother patients\\' profiles). To examine the safety of AI agents in these\\\\ninteractions, we develop a comprehensive multi-dimensional evaluation framework\\\\nthat uses metrics covering operational, content-related, societal, and legal\\\\nrisks. Through running 1840 simulations based on 92 scenarios across seven\\\\ndomains (e.g., healthcare, finance, education), we demonstrate that HAICOSYSTEM\\\\ncan emulate realistic user-AI interactions and complex tool use by AI agents.\\\\nOur experiments show that state-of-the-art LLMs, both proprietary and\\\\nopen-sourced, exhibit safety risks in over 50\\\\\\\\% cases, with models generally\\\\nshowing higher risks when interacting with simulated malicious users. Our\\\\nfindings highlight the ongoing challenge of building agents that can safely\\\\nnavigate complex interactions, particularly when faced with malicious users. To\\\\nfoster the AI agent safety ecosystem, we release a code platform that allows\\\\npractitioners to create custom scenarios, simulate interactions, and evaluate\\\\nthe safety and performance of their agents.\", \\'pdf_url\\': \\'http://arxiv.org/pdf/2409.16427v2\\'}, {\\'title\\': \\'AutoML-Agent: A Multi-Agent LLM Framework for Full-Pipeline AutoML\\', \\'authors\\': [\\'Patara Trirat\\', \\'Wonyong Jeong\\', \\'Sung Ju Hwang\\'], \\'published\\': \\'2024-10-03\\', \\'abstract\\': \"Automated machine learning (AutoML) accelerates AI development by automating\\\\ntasks in the development pipeline, such as optimal model search and\\\\nhyperparameter tuning. Existing AutoML systems often require technical\\\\nexpertise to set up complex tools, which is in general time-consuming and\\\\nrequires a large amount of human effort. Therefore, recent works have started\\\\nexploiting large language models (LLM) to lessen such burden and increase the\\\\nusability of AutoML frameworks via a natural language interface, allowing\\\\nnon-expert users to build their data-driven solutions. These methods, however,\\\\nare usually designed only for a particular process in the AI development\\\\npipeline and do not efficiently use the inherent capacity of the LLMs. This\\\\npaper proposes AutoML-Agent, a novel multi-agent framework tailored for\\\\nfull-pipeline AutoML, i.e., from data retrieval to model deployment.\\\\nAutoML-Agent takes user\\'s task descriptions, facilitates collaboration between\\\\nspecialized LLM agents, and delivers deployment-ready models. Unlike existing\\\\nwork, instead of devising a single plan, we introduce a retrieval-augmented\\\\nplanning strategy to enhance exploration to search for more optimal plans. We\\\\nalso decompose each plan into sub-tasks (e.g., data preprocessing and neural\\\\nnetwork design) each of which is solved by a specialized agent we build via\\\\nprompting executing in parallel, making the search process more efficient.\\\\nMoreover, we propose a multi-stage verification to verify executed results and\\\\nguide the code generation LLM in implementing successful solutions. Extensive\\\\nexperiments on seven downstream tasks using fourteen datasets show that\\\\nAutoML-Agent achieves a higher success rate in automating the full AutoML\\\\nprocess, yielding systems with good performance throughout the diverse domains.\", \\'pdf_url\\': \\'http://arxiv.org/pdf/2410.02958v1\\'}, {\\'title\\': \\'Enhancing Trust in LLM-Based AI Automation Agents: New Considerations and Future Challenges\\', \\'authors\\': [\\'Sivan Schwartz\\', \\'Avi Yaeli\\', \\'Segev Shlomov\\'], \\'published\\': \\'2023-08-10\\', \\'abstract\\': \\'Trust in AI agents has been extensively studied in the literature, resulting\\\\nin significant advancements in our understanding of this field. However, the\\\\nrapid advancements in Large Language Models (LLMs) and the emergence of\\\\nLLM-based AI agent frameworks pose new challenges and opportunities for further\\\\nresearch. In the field of process automation, a new generation of AI-based\\\\nagents has emerged, enabling the execution of complex tasks. At the same time,\\\\nthe process of building automation has become more accessible to business users\\\\nvia user-friendly no-code tools and training mechanisms. This paper explores\\\\nthese new challenges and opportunities, analyzes the main aspects of trust in\\\\nAI agents discussed in existing literature, and identifies specific\\\\nconsiderations and challenges relevant to this new generation of automation\\\\nagents. We also evaluate how nascent products in this category address these\\\\nconsiderations. Finally, we highlight several challenges that the research\\\\ncommunity should address in this evolving landscape.\\', \\'pdf_url\\': \\'http://arxiv.org/pdf/2308.05391v1\\'}, {\\'title\\': \\'AI2Apps: A Visual IDE for Building LLM-based AI Agent Applications\\', \\'authors\\': [\\'Xin Pang\\', \\'Zhucong Li\\', \\'Jiaxiang Chen\\', \\'Yuan Cheng\\', \\'Yinghui Xu\\', \\'Yuan Qi\\'], \\'published\\': \\'2024-04-07\\', \\'abstract\\': \\'We introduce AI2Apps, a Visual Integrated Development Environment (Visual\\\\nIDE) with full-cycle capabilities that accelerates developers to build\\\\ndeployable LLM-based AI agent Applications. This Visual IDE prioritizes both\\\\nthe Integrity of its development tools and the Visuality of its components,\\\\nensuring a smooth and efficient building experience.On one hand, AI2Apps\\\\nintegrates a comprehensive development toolkit ranging from a prototyping\\\\ncanvas and AI-assisted code editor to agent debugger, management system, and\\\\ndeployment tools all within a web-based graphical user interface. On the other\\\\nhand, AI2Apps visualizes reusable front-end and back-end code as intuitive\\\\ndrag-and-drop components. Furthermore, a plugin system named AI2Apps Extension\\\\n(AAE) is designed for Extensibility, showcasing how a new plugin with 20\\\\ncomponents enables web agent to mimic human-like browsing behavior. Our case\\\\nstudy demonstrates substantial efficiency improvements, with AI2Apps reducing\\\\ntoken consumption and API calls when debugging a specific sophisticated\\\\nmultimodal agent by approximately 90% and 80%, respectively. The AI2Apps,\\\\nincluding an online demo, open-source code, and a screencast video, is now\\\\npublicly accessible.\\', \\'pdf_url\\': \\'http://arxiv.org/pdf/2404.04902v1\\'}]', call_id='call_sEyPLYy5AYq3PJZyNmGOWKUr')]\n", + "From: tool_agent_for_Arxiv_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:21:49.246052], Arxiv_Search_Agent:\u001b[0m\n", + "\n", + "### Literature Review on No-Code Tools for Building Multi-Agent AI Systems\n", + "\n", + "The development of multi-agent systems (MAS) is enhanced by the emergence of no-code tools that allow users without programming expertise to create sophisticated applications. This literature review presents recent advancements and tools that facilitate the creation and management of multi-agent AI systems, highlighting their significance and functionality.\n", + "\n", + "1. **AutoGen Studio**: Victor Dibia et al. (2024) introduce AutoGen Studio, a no-code developer tool aimed at simplifying the construction of multi-agent workflows. It features a web interface that allows users to create and debug agent configurations using a drag-and-drop interface, backed by a declarative JSON-based specification. The framework enables users to represent interactions between various AI models and tools seamlessly. The authors emphasize its potential for rapid prototyping and debugging, which is critical for developers engaging with complex systems (Dibia et al., 2024). [Read more](http://arxiv.org/pdf/2408.15247v1)\n", + "\n", + "2. **HAICOSYSTEM**: Zhou et al. (2024) present HAICOSYSTEM, a sandbox environment designed to explore safety risks in human-AI interactions with autonomous agents. This framework allows for comprehensive evaluation of AI agents through simulated multi-turn interactions. The research highlights the importance of safety evaluations within MAS, particularly in complex social interactions where agents might face various operational risks. This tool underscores the necessity for organizations to understand the safety implications of deploying AI systems (Zhou et al., 2024). [Read more](http://arxiv.org/pdf/2409.16427v2)\n", + "\n", + "3. **AutoML-Agent**: Trirat et al. (2024) propose AutoML-Agent, a multi-agent framework that focuses on automating the complete machine learning pipeline from data retrieval to model deployment. By facilitating cooperation among specialized LLM agents through a natural language interface, AutoML-Agent minimizes the technical barriers traditionally associated with AutoML. The framework enhances user experience in building data-driven solutions without requiring deep technical knowledge, reflecting the capabilities of no-code solutions in enhancing AI accessibility (Trirat et al., 2024). [Read more](http://arxiv.org/pdf/2410.02958v1)\n", + "\n", + "4. **Trust in AI Automation Agents**: Schwartz et al. (2023) discuss the trust challenges faced by LLM-based automation agents in their paper. As the use of no-code tools expands, ensuring user trust in these systems becomes increasingly important. Their analysis highlights how newer products address the complexities of trust within automation frameworks and outlines ongoing challenges that developers and researchers must consider to foster reliable interactions with AI systems (Schwartz et al., 2023). [Read more](http://arxiv.org/pdf/2308.05391v1)\n", + "\n", + "5. **AI2Apps**: Pang et al. (2024) introduce AI2Apps, a Visual Integrated Development Environment (IDE) designed to expedite the development of LLM-based AI agent applications. AI2Apps offers a comprehensive suite of development tools, including a prototyping canvas and a drag-and-drop interface for integrating both frontend and backend components. The case study presented demonstrates significant efficiencies in reducing resource consumption during the debugging phase of agent development, which is incredibly useful for non-technical users aiming to build robust applications (Pang et al., 2024). [Read more](http://arxiv.org/pdf/2404.04902v1)\n", + "\n", + "### Conclusion\n", + "\n", + "The proliferation of no-code tools for multi-agent AI systems offers a transformative potential for users across various sectors. With tools like AutoGen Studio and AI2Apps, non-expert users can engage in developing and deploying complex multi-agent workflows. Furthermore, considerations around safety and trust are critical as these systems become more integrated into business and societal functions. Future studies should focus on user experiences, tool effectiveness, and broader implications of deploying no-code solutions in AI development.\n", + "From: Arxiv_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T10:22:08.923914], Report_Agent:\u001b[0m\n", + "\n", + "### Literature Review on No-Code Tools for Building Multi-Agent AI Systems\n", + "\n", + "The evolution of artificial intelligence (AI) has led to a growing focus on multi-agent systems (MAS), which utilize multiple autonomous agents to perform complex tasks collaboratively. The emergence of no-code tools has transformed how these systems are designed and deployed, enabling individuals with minimal technical expertise to create sophisticated applications. This literature review synthesizes recent research and tools that facilitate the development of MAS through no-code solutions, emphasizing their significance and functionality.\n", + "\n", + "1. **AutoGen Studio**: Dibia et al. (2024) introduced AutoGen Studio, a no-code platform designed to streamline the development of multi-agent workflows. This tool provides a web-based interface that employs a drag-and-drop mechanism for users to create and debug agent configurations, supported by a declarative JSON specification. The authors accentuate the tool's capabilities for rapid prototyping and debugging, which is particularly vital for users navigating complex systems (Dibia et al., 2024). The ability to represent interactions among various AI models intuitively makes AutoGen Studio a valuable asset in the no-code ecosystem. [Read more](http://arxiv.org/pdf/2408.15247v1)\n", + "\n", + "2. **HAICOSYSTEM**: Zhou et al. (2024) developed HAICOSYSTEM, a sandbox environment that explores safety risks in autonomous agents interacting with humans. The framework allows for extensive evaluation of AI agents within simulated multi-turn dialogues. Their research highlights the critical need for safety evaluations in MAS, particularly in nuanced social interactions where agents might encounter operational challenges. This focus on safety underscores the significance of understanding the implications of deploying AI systems in real-world scenarios (Zhou et al., 2024). [Read more](http://arxiv.org/pdf/2409.16427v2)\n", + "\n", + "3. **AutoML-Agent**: In their work, Trirat et al. (2024) proposed AutoML-Agent, a multi-agent framework designed to automate the entire machine learning pipeline, from data acquisition to model deployment. By leveraging a natural language interface, this tool encourages collaboration among specialized agents, thereby reducing the technical barriers commonly associated with AutoML. The authors emphasize that AutoML-Agent epitomizes how no-code solutions can enhance user accessibility, allowing users to construct data-driven applications without needing extensive technical knowledge (Trirat et al., 2024). [Read more](http://arxiv.org/pdf/2410.02958v1)\n", + "\n", + "4. **Trust in AI Automation Agents**: Schwartz et al. (2023) address the trust issues inherent in using LLM-based automation agents within no-code frameworks. Their findings highlight how trust remains a complex challenge as no-code tools become more prevalent. The authors discuss strategies to address these challenges and improve user interactions with automated systems, emphasizing the need for ongoing research to ensure reliability and user confidence in AI-based solutions (Schwartz et al., 2023). [Read more](http://arxiv.org/pdf/2308.05391v1)\n", + "\n", + "5. **AI2Apps**: Pang et al. (2024) introduce AI2Apps, a Visual Integrated Development Environment (IDE) that aims to accelerate the creation of applications incorporating LLM-based AI agents. AI2Apps features an array of development tools, including a prototyping canvas and a user-friendly drag-and-drop interface for seamlessly integrating frontend and backend components. Their case study illustrates the significant efficiency gains during the debugging phase, particularly appealing to non-technical users striving to create robust applications (Pang et al., 2024). [Read more](http://arxiv.org/pdf/2404.04902v1)\n", + "\n", + "### Conclusion\n", + "\n", + "The proliferation of no-code tools for building multi-agent AI systems represents a significant shift in the accessibility and usability of AI technologies. Platforms like AutoGen Studio and AI2Apps empower users across various sectors to engage in the development and implementation of complex multi-agent systems without requiring extensive programming knowledge. However, the implications of safety and trust in these systems must be thoroughly understood as they become increasingly integrated into both business practices and everyday life. Future research should continue to investigate user experiences, the effectiveness of these tools, and the broader social implications of deploying no-code solutions in the AI landscape.\n", + "\n", + "### References\n", + "\n", + "- Dibia, V., et al. (2024). AutoGen Studio: A No-Code Developer Tool for Multi-Agent Workflows. arXiv. [Link](http://arxiv.org/pdf/2408.15247v1)\n", + "\n", + "- Zhou, et al. (2024). HAICOSYSTEM: Exploring Safety Risks in Human-AI Interaction with Autonomous Agents. arXiv. [Link](http://arxiv.org/pdf/2409.16427v2)\n", + "\n", + "- Trirat, E., et al. (2024). AutoML-Agent: An Automated Multi-Agent Framework for Machine Learning Pipelines. arXiv. [Link](http://arxiv.org/pdf/2410.02958v1)\n", + "\n", + "- Schwartz, E., et al. (2023). Trust in AI Automation Agents: Challenges and Solutions. arXiv. [Link](http://arxiv.org/pdf/2308.05391v1)\n", + "\n", + "- Pang, S., et al. (2024). AI2Apps: A Visual Development Environment for LLM-based AI Agent Applications. arXiv. [Link](http://arxiv.org/pdf/2404.04902v1)\n", + "\n", + "TERMINATE\n", + "From: Report_Agent" + ] + }, + { + "data": { + "text/plain": [ + "TeamRunResult(messages=[TextMessage(source='user', content='Write a literature review on no code tools for building multi agent ai systems'), TextMessage(source='Google_Search_Agent', content='### Literature Review on No-Code Tools for Building Multi-Agent AI Systems\\n\\nThe field of artificial intelligence is rapidly evolving, particularly with the emergence of multi-agent systems (MAS), where multiple intelligent agents collaborate to solve complex problems. The advent of no-code tools has significantly democratized access to these technologies, enabling non-technical users to construct and deploy multi-agent systems without extensive programming knowledge. This review synthesizes recent findings and developments in no-code tools suitable for building MAS.\\n\\n1. **AutoGen Studio**: Recent advancements have shown that tools like AutoGen Studio are at the forefront of the no-code revolution in multi-agent system development. According to a study published on arXiv, AutoGen Studio serves as a no-code developer tool that allows users to build and debug multi-agent systems efficiently. The framework is designed to facilitate collaboration between various generative AI models and tools, making it a promising resource for developers looking to implement complex behaviors without deep technical skills. (Source: [arXiv](https://arxiv.org/abs/2408.15247))\\n\\n2. **Multi Agents System (MAS) Builder**: Another notable example is the Multi Agents System (MAS) Builder, a platform that enables users to create AI teams effortlessly. This tool allows entrepreneurs and businesses to recruit AI agents for tasks such as sales and customer support, optimizing operations without the need for coding. The user-friendly interface streamlines the process, showcasing the potential of no-code solutions in practical business applications. (Source: [RelevanceAI](https://relevanceai.com/multi-agents))\\n\\n3. **Crew AI Platform**: Crew AI offers an intuitive framework for users to automate workflows across various industries using multi-agent systems. The no-code tools provided by Crew AI facilitate the development of automations while allowing users to explore coding from scratch or leverage pre-existing templates. This flexibility is critical for organizations aiming to optimize efficiency and improve decision-making processes through AI. The platform emphasizes ease of use and accessibility for a broad audience. (Source: [Crew AI](https://www.crewai.com/))\\n\\n4. **Community Insights**: Experiences shared by users in forums, such as those from Reddit, reveal valuable insights into the practicalities and challenges of using no-code tools for building multi-agent systems. Users, both from technical and non-technical backgrounds, have reported successes and setbacks, providing a grassroots perspective that could guide newcomers in their journey with no-code platforms. \\n\\n5. **Emerging Trends**: The rise of no-code tools aligns with industry trends towards automation and AI integration in everyday business processes. These tools not only reduce the barrier to entry for users unacquainted with traditional programming languages but also encourage innovation by allowing users to focus on logical design and system architecture rather than syntax and debugging.\\n\\nIn conclusion, no-code tools for building multi-agent AI systems are gaining traction and transforming the landscape of AI development. With platforms like AutoGen Studio, MAS Builder, and Crew AI, a wide range of users can engage in the development of sophisticated AI systems without needing extensive technical expertise. Future studies could further explore the effectiveness, limitations, and user satisfaction associated with these tools to develop a deeper understanding of their impact on the AI ecosystem.'), TextMessage(source='Arxiv_Search_Agent', content='### Literature Review on No-Code Tools for Building Multi-Agent AI Systems\\n\\nThe development of multi-agent systems (MAS) is enhanced by the emergence of no-code tools that allow users without programming expertise to create sophisticated applications. This literature review presents recent advancements and tools that facilitate the creation and management of multi-agent AI systems, highlighting their significance and functionality.\\n\\n1. **AutoGen Studio**: Victor Dibia et al. (2024) introduce AutoGen Studio, a no-code developer tool aimed at simplifying the construction of multi-agent workflows. It features a web interface that allows users to create and debug agent configurations using a drag-and-drop interface, backed by a declarative JSON-based specification. The framework enables users to represent interactions between various AI models and tools seamlessly. The authors emphasize its potential for rapid prototyping and debugging, which is critical for developers engaging with complex systems (Dibia et al., 2024). [Read more](http://arxiv.org/pdf/2408.15247v1)\\n\\n2. **HAICOSYSTEM**: Zhou et al. (2024) present HAICOSYSTEM, a sandbox environment designed to explore safety risks in human-AI interactions with autonomous agents. This framework allows for comprehensive evaluation of AI agents through simulated multi-turn interactions. The research highlights the importance of safety evaluations within MAS, particularly in complex social interactions where agents might face various operational risks. This tool underscores the necessity for organizations to understand the safety implications of deploying AI systems (Zhou et al., 2024). [Read more](http://arxiv.org/pdf/2409.16427v2)\\n\\n3. **AutoML-Agent**: Trirat et al. (2024) propose AutoML-Agent, a multi-agent framework that focuses on automating the complete machine learning pipeline from data retrieval to model deployment. By facilitating cooperation among specialized LLM agents through a natural language interface, AutoML-Agent minimizes the technical barriers traditionally associated with AutoML. The framework enhances user experience in building data-driven solutions without requiring deep technical knowledge, reflecting the capabilities of no-code solutions in enhancing AI accessibility (Trirat et al., 2024). [Read more](http://arxiv.org/pdf/2410.02958v1)\\n\\n4. **Trust in AI Automation Agents**: Schwartz et al. (2023) discuss the trust challenges faced by LLM-based automation agents in their paper. As the use of no-code tools expands, ensuring user trust in these systems becomes increasingly important. Their analysis highlights how newer products address the complexities of trust within automation frameworks and outlines ongoing challenges that developers and researchers must consider to foster reliable interactions with AI systems (Schwartz et al., 2023). [Read more](http://arxiv.org/pdf/2308.05391v1)\\n\\n5. **AI2Apps**: Pang et al. (2024) introduce AI2Apps, a Visual Integrated Development Environment (IDE) designed to expedite the development of LLM-based AI agent applications. AI2Apps offers a comprehensive suite of development tools, including a prototyping canvas and a drag-and-drop interface for integrating both frontend and backend components. The case study presented demonstrates significant efficiencies in reducing resource consumption during the debugging phase of agent development, which is incredibly useful for non-technical users aiming to build robust applications (Pang et al., 2024). [Read more](http://arxiv.org/pdf/2404.04902v1)\\n\\n### Conclusion\\n\\nThe proliferation of no-code tools for multi-agent AI systems offers a transformative potential for users across various sectors. With tools like AutoGen Studio and AI2Apps, non-expert users can engage in developing and deploying complex multi-agent workflows. Furthermore, considerations around safety and trust are critical as these systems become more integrated into business and societal functions. Future studies should focus on user experiences, tool effectiveness, and broader implications of deploying no-code solutions in AI development.'), StopMessage(source='Report_Agent', content=\"### Literature Review on No-Code Tools for Building Multi-Agent AI Systems\\n\\nThe evolution of artificial intelligence (AI) has led to a growing focus on multi-agent systems (MAS), which utilize multiple autonomous agents to perform complex tasks collaboratively. The emergence of no-code tools has transformed how these systems are designed and deployed, enabling individuals with minimal technical expertise to create sophisticated applications. This literature review synthesizes recent research and tools that facilitate the development of MAS through no-code solutions, emphasizing their significance and functionality.\\n\\n1. **AutoGen Studio**: Dibia et al. (2024) introduced AutoGen Studio, a no-code platform designed to streamline the development of multi-agent workflows. This tool provides a web-based interface that employs a drag-and-drop mechanism for users to create and debug agent configurations, supported by a declarative JSON specification. The authors accentuate the tool's capabilities for rapid prototyping and debugging, which is particularly vital for users navigating complex systems (Dibia et al., 2024). The ability to represent interactions among various AI models intuitively makes AutoGen Studio a valuable asset in the no-code ecosystem. [Read more](http://arxiv.org/pdf/2408.15247v1)\\n\\n2. **HAICOSYSTEM**: Zhou et al. (2024) developed HAICOSYSTEM, a sandbox environment that explores safety risks in autonomous agents interacting with humans. The framework allows for extensive evaluation of AI agents within simulated multi-turn dialogues. Their research highlights the critical need for safety evaluations in MAS, particularly in nuanced social interactions where agents might encounter operational challenges. This focus on safety underscores the significance of understanding the implications of deploying AI systems in real-world scenarios (Zhou et al., 2024). [Read more](http://arxiv.org/pdf/2409.16427v2)\\n\\n3. **AutoML-Agent**: In their work, Trirat et al. (2024) proposed AutoML-Agent, a multi-agent framework designed to automate the entire machine learning pipeline, from data acquisition to model deployment. By leveraging a natural language interface, this tool encourages collaboration among specialized agents, thereby reducing the technical barriers commonly associated with AutoML. The authors emphasize that AutoML-Agent epitomizes how no-code solutions can enhance user accessibility, allowing users to construct data-driven applications without needing extensive technical knowledge (Trirat et al., 2024). [Read more](http://arxiv.org/pdf/2410.02958v1)\\n\\n4. **Trust in AI Automation Agents**: Schwartz et al. (2023) address the trust issues inherent in using LLM-based automation agents within no-code frameworks. Their findings highlight how trust remains a complex challenge as no-code tools become more prevalent. The authors discuss strategies to address these challenges and improve user interactions with automated systems, emphasizing the need for ongoing research to ensure reliability and user confidence in AI-based solutions (Schwartz et al., 2023). [Read more](http://arxiv.org/pdf/2308.05391v1)\\n\\n5. **AI2Apps**: Pang et al. (2024) introduce AI2Apps, a Visual Integrated Development Environment (IDE) that aims to accelerate the creation of applications incorporating LLM-based AI agents. AI2Apps features an array of development tools, including a prototyping canvas and a user-friendly drag-and-drop interface for seamlessly integrating frontend and backend components. Their case study illustrates the significant efficiency gains during the debugging phase, particularly appealing to non-technical users striving to create robust applications (Pang et al., 2024). [Read more](http://arxiv.org/pdf/2404.04902v1)\\n\\n### Conclusion\\n\\nThe proliferation of no-code tools for building multi-agent AI systems represents a significant shift in the accessibility and usability of AI technologies. Platforms like AutoGen Studio and AI2Apps empower users across various sectors to engage in the development and implementation of complex multi-agent systems without requiring extensive programming knowledge. However, the implications of safety and trust in these systems must be thoroughly understood as they become increasingly integrated into both business practices and everyday life. Future research should continue to investigate user experiences, the effectiveness of these tools, and the broader social implications of deploying no-code solutions in the AI landscape.\\n\\n### References\\n\\n- Dibia, V., et al. (2024). AutoGen Studio: A No-Code Developer Tool for Multi-Agent Workflows. arXiv. [Link](http://arxiv.org/pdf/2408.15247v1)\\n\\n- Zhou, et al. (2024). HAICOSYSTEM: Exploring Safety Risks in Human-AI Interaction with Autonomous Agents. arXiv. [Link](http://arxiv.org/pdf/2409.16427v2)\\n\\n- Trirat, E., et al. (2024). AutoML-Agent: An Automated Multi-Agent Framework for Machine Learning Pipelines. arXiv. [Link](http://arxiv.org/pdf/2410.02958v1)\\n\\n- Schwartz, E., et al. (2023). Trust in AI Automation Agents: Challenges and Solutions. arXiv. [Link](http://arxiv.org/pdf/2308.05391v1)\\n\\n- Pang, S., et al. (2024). AI2Apps: A Visual Development Environment for LLM-based AI Agent Applications. arXiv. [Link](http://arxiv.org/pdf/2404.04902v1)\\n\\nTERMINATE\")])" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "google_search_agent = ToolUseAssistantAgent(\n", + " name=\"Google_Search_Agent\",\n", + " registered_tools=[google_search_tool],\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", + " description=\"An agent that can search Google for information, returns results with a snippet and body content\", \n", + " system_message = \"You are a helpful AI assistant. Solve tasks using your tools.\",\n", + ")\n", + "\n", + "arxiv_search_agent = ToolUseAssistantAgent(\n", + " name=\"Arxiv_Search_Agent\",\n", + " registered_tools=[ arxiv_search_tool],\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", + " description=\"An agent that can search Arxiv for papers related to a given topic, including abstracts\", \n", + " system_message = \"You are a helpful AI assistant. Solve tasks using your tools. Specifically, you can take into consideration the user's request and craft a search query that is most likely to return relevant academi papers.\",\n", + ")\n", + "\n", + "\n", + "report_agent = CodingAssistantAgent( \n", + " name=\"Report_Agent\",\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", + " description=\"Generate a report based on a given topic\", \n", + " system_message = \"You are a helpful assistant. Your task is to synthesize data extracted into a high quality literature review including CORRECT references. You MUST write a final report that is formatted as a literature review with CORRECT references. Your response should end with the word 'TERMINATE'\",\n", + ")\n", + "\n", + "team = RoundRobinGroupChat( \n", + " participants=[google_search_agent, arxiv_search_agent, report_agent]\n", + ")\n", + "\n", + "result = await team.run(task=\"Write a literature review on no code tools for building multi agent ai systems\")\n", + "result" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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/packages/autogen-core/docs/src/agentchat-user-guide/guides/tool_use.ipynb b/python/packages/autogen-core/docs/src/agentchat-user-guide/guides/tool_use.ipynb index 1a5f3fd77b24..73ebeaa37abd 100644 --- a/python/packages/autogen-core/docs/src/agentchat-user-guide/guides/tool_use.ipynb +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/guides/tool_use.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -67,31 +67,24 @@ "text": [ "\n", "--------------------------------------------------------------------------- \n", - "\u001b[91m[2024-10-04T17:59:55.737430]:\u001b[0m\n", + "\u001b[91m[2024-10-08T09:50:13.202461]:\u001b[0m\n", "\n", "What's the weather in New York?\n", - "From: user" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", + "From: user\n", "--------------------------------------------------------------------------- \n", - "\u001b[91m[2024-10-04T17:59:56.310787], Weather_Assistant:\u001b[0m\n", + "\u001b[91m[2024-10-08T09:50:14.090696], Weather_Assistant:\u001b[0m\n", "\n", - "[FunctionCall(id='call_zxmdHPEQ1QMd2NwvYUSgxxDV', arguments='{\"city\":\"New York\"}', name='get_weather')]\n", + "[FunctionCall(id='call_wqkaIBdYjWklWG0GQkYz7FZ0', arguments='{\"city\":\"New York\"}', name='get_weather')]\n", "From: Weather_Assistant\n", "--------------------------------------------------------------------------- \n", - "\u001b[91m[2024-10-04T17:59:56.312084], tool_agent_for_Weather_Assistant:\u001b[0m\n", + "\u001b[91m[2024-10-08T09:50:14.092050], tool_agent_for_Weather_Assistant:\u001b[0m\n", "\n", - "[FunctionExecutionResult(content='Sunny', call_id='call_zxmdHPEQ1QMd2NwvYUSgxxDV')]\n", + "[FunctionExecutionResult(content='The weather in New York is 72 degrees and Sunny.', call_id='call_wqkaIBdYjWklWG0GQkYz7FZ0')]\n", "From: tool_agent_for_Weather_Assistant\n", "--------------------------------------------------------------------------- \n", - "\u001b[91m[2024-10-04T17:59:56.767874], Weather_Assistant:\u001b[0m\n", + "\u001b[91m[2024-10-08T09:50:14.714470], Weather_Assistant:\u001b[0m\n", "\n", - "The weather in New York is sunny. \n", + "The weather in New York is 72 degrees and sunny. \n", "\n", "TERMINATE\n", "From: Weather_Assistant" @@ -121,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -139,27 +132,63 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "--------------------------------------------------------------------------------\n", - "user:\n", - "Who was the first president of the United States?\n", - "--------------------------------------------------------------------------------\n", - "WikiPedia_Assistant:\n", - "[FunctionCall(id='call_CZA1pVGETEdvJv34aZ4dN7PF', arguments='{\"query\":\"first president of the United States\"}', name='wikipedia')]\n", - "--------------------------------------------------------------------------------\n", - "tool_agent:\n", - "[FunctionExecutionResult(content='Page: George Washington\\nSummary: George Washington (February 22, 1732 – December 14, 1799) was an Am', call_id='call_CZA1pVGETEdvJv34aZ4dN7PF')]\n", - "--------------------------------------------------------------------------------\n", - "WikiPedia_Assistant:\n", - "The first president of the United States was George Washington, who served from April 30, 1789, to March 4, 1797. \n", - "\n", - "TERMINATE\n" + "\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:51:36.869317]:\u001b[0m\n", + "\n", + "Who is the receipient of the 2023 Nobel Prize in Physics?\n", + "From: user" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:51:37.856066], WikiPedia_Assistant:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_bdLqS1msbHCy5IMGYaata5vs', arguments='{\"query\":\"2023 Nobel Prize in Physics\"}', name='wikipedia')]\n", + "From: WikiPedia_Assistant\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:51:38.518288], tool_agent_for_WikiPedia_Assistant:\u001b[0m\n", + "\n", + "[FunctionExecutionResult(content='Page: Nobel Prize in Physics\\nSummary: The Nobel Prize in Physics (Swedish: Nobelpriset i fysik) is a', call_id='call_bdLqS1msbHCy5IMGYaata5vs')]\n", + "From: tool_agent_for_WikiPedia_Assistant\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:51:39.070911], WikiPedia_Assistant:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_BFXGGeuBbOQ1LPb4f0NiNva2', arguments='{\"query\":\"2023 Nobel Prize in Physics recipients\"}', name='wikipedia')]\n", + "From: WikiPedia_Assistant\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:51:39.727147], tool_agent_for_WikiPedia_Assistant:\u001b[0m\n", + "\n", + "[FunctionExecutionResult(content='Page: Nobel Prize in Physics\\nSummary: The Nobel Prize in Physics (Swedish: Nobelpriset i fysik) is a', call_id='call_BFXGGeuBbOQ1LPb4f0NiNva2')]\n", + "From: tool_agent_for_WikiPedia_Assistant\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:51:40.746467], WikiPedia_Assistant:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_iH2gkY5A2LiQTiy2eh86XpP5', arguments='{\"query\": \"2023 Nobel Prize in Physics winners\"}', name='wikipedia'), FunctionCall(id='call_rJXgJQiAKoD7yrymNJCsQA9N', arguments='{\"query\": \"Nobel Prize in Physics\"}', name='wikipedia')]\n", + "From: WikiPedia_Assistant\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:51:41.469348], tool_agent_for_WikiPedia_Assistant:\u001b[0m\n", + "\n", + "[FunctionExecutionResult(content='Page: Nobel Prize in Physics\\nSummary: The Nobel Prize in Physics (Swedish: Nobelpriset i fysik) is a', call_id='call_iH2gkY5A2LiQTiy2eh86XpP5'), FunctionExecutionResult(content='Page: Nobel Prize in Physics\\nSummary: The Nobel Prize in Physics (Swedish: Nobelpriset i fysik) is a', call_id='call_rJXgJQiAKoD7yrymNJCsQA9N')]\n", + "From: tool_agent_for_WikiPedia_Assistant\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:51:42.576718], WikiPedia_Assistant:\u001b[0m\n", + "\n", + "I couldn't find specific information about the recipients of the 2023 Nobel Prize in Physics. You might want to check a reliable news source or the official Nobel Prize website for the most accurate and up-to-date details. \n", + "\n", + "TERMINATE\n", + "From: WikiPedia_Assistant" ] } ], @@ -167,9 +196,9 @@ "wikipedia_assistant = ToolUseAssistantAgent(\n", " \"WikiPedia_Assistant\",\n", " model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", - " tool_schema=[langchain_wikipedia_tool.schema],\n", + " registered_tools=[langchain_wikipedia_tool],\n", ")\n", - "team = RoundRobinGroupChat([wikipedia_assistant], tools=[langchain_wikipedia_tool])\n", + "team = RoundRobinGroupChat([wikipedia_assistant])\n", "result = await team.run(\"Who was the first president of the United States?\")\n", "\n", "# print(result)" @@ -185,7 +214,7 @@ ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "agnext", "language": "python", "name": "python3" }, @@ -199,7 +228,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.6" + "version": "3.11.9" } }, "nbformat": 4, diff --git a/python/packages/autogen-core/docs/src/agentchat-user-guide/index.md b/python/packages/autogen-core/docs/src/agentchat-user-guide/index.md index ef16896c41b6..c297288d520e 100644 --- a/python/packages/autogen-core/docs/src/agentchat-user-guide/index.md +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/index.md @@ -3,14 +3,20 @@ myst: html_meta: "description lang=en": | User Guide for AgentChat, a high-level api for AutoGen + User Guide for AgentChat, a high-level api for AutoGen --- # AgentChat -AgentChat is a high-level package for building multi-agent applications built on top of the `autogen-core` package. For beginner users, AgentChat is the recommended starting point. For advanced users, `autogen-core` provides more flexibility and control over the underlying components. +AgentChat is a high-level package for building multi-agent applications built on top of the [ `autogen-core`](../core-user-guide/index.md) package. For beginner users, AgentChat is the recommended starting point. For advanced users, [ `autogen-core`](../core-user-guide/index.md) provides more flexibility and control over the underlying components. AgentChat aims to provide intuitive defaults, such as **Agents** with preset behaviors and **Teams** with predefined communication protocols, to simplify building multi-agent applications. +```{tip} +If you are interested in implementing complex agent interaction behaviours, defining custom messaging protocols, or orchestration mechanisms, consider using the [ `autogen-core`](../core-user-guide/index.md) package. + +``` + ## Agents Agents provide presets for how an agent might respond to received messages. The following Agents are currently supported: @@ -27,18 +33,18 @@ Teams define how groups of agents communicate to address tasks. The following Te ```{toctree} :caption: Getting Started -:maxdepth: 1 +:maxdepth: 2 :hidden: quickstart guides/tool_use -guides/examples + ``` ```{toctree} :caption: Examples -:maxdepth: 1 +:maxdepth: 3 :hidden: -examples/travel-planning +examples/index ``` diff --git a/python/packages/autogen-core/docs/src/agentchat-user-guide/quickstart.md b/python/packages/autogen-core/docs/src/agentchat-user-guide/quickstart.md index 7b8b55b8ccf4..973100a51200 100644 --- a/python/packages/autogen-core/docs/src/agentchat-user-guide/quickstart.md +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/quickstart.md @@ -1,13 +1,13 @@ --- myst: -html_meta: -"description lang=en": | -Quick Start Guide for AgentChat: Migrating from AutoGen 0.2x to 0.4x. + html_meta: + "description lang=en": | + Quick Start Guide for AgentChat: Migrating from AutoGen 0.2x to 0.4x. --- # Quick Start -AgentChat API, introduced in AutoGen 0.4x, offers a similar level of abstraction as the default Agent classes in AutoGen 0.2x. This guide demonstrates how to migrate basic examples from AutoGen 0.2x to AgentChat in AutoGen 0.4x. +AgentChat API, introduced in AutoGen 0.4x, offers a similar level of abstraction as the default Agent classes in AutoGen 0.2x. ## Installation @@ -22,62 +22,23 @@ pip install autogen-agentchat==0.4.0dev0 For further installation instructions, please refer to the [package information](pkg-info-autogen-agentchat). ::: -## Migrating from AutoGen 0.2x to 0.4x +## Creating a Simple Agent Team -The following example illustrates creating a simple agent team with two agents and compares how this is done in AutoGen 0.2x and 0.4x. +The following example illustrates creating a simple agent team with two agents that interact to solve a task. -1. An `AssistantAgent` (0.2x) / `CodingAssistantAgent` (0.4x) that generates responses using an LLM model. -2. A `UserProxyAgent` (0.2x) / `CodeExecutorAgent` (0.4x) that executes code snippets and returns the output. +1. `CodingAssistantAgent` that generates responses using an LLM model. 2.`CodeExecutorAgent` that executes code snippets and returns the output. The task is to "Create a plot of NVIDIA and TESLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'." -``````{tab-set} - -`````{tab-item} AgentChat (v0.4x) -```python -from autogen_agentchat.agents import CodeExecutorAgent, CodingAssistantAgent -from autogen_agentchat.teams.group_chat import RoundRobinGroupChat -from autogen_core.components.code_executor import DockerCommandLineCodeExecutor -from autogen_core.components.models import OpenAIChatCompletionClient - -async with DockerCommandLineCodeExecutor(work_dir="coding") as code_executor: - code_executor_agent = CodeExecutorAgent("code_executor", code_executor=code_executor) - coding_assistant_agent = CodingAssistantAgent( - "coding_assistant", model_client=OpenAIChatCompletionClient(model="gpt-4") - ) - group_chat = RoundRobinGroupChat([coding_assistant_agent, code_executor_agent]) - result = await group_chat.run( - task="Create a plot of NVIDIA and TESLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'." - ) - print(result) -``` -````` - -`````{tab-item} v0.2x -```python -from autogen import AssistantAgent, UserProxyAgent, config_list_from_json - -config_list = config_list_from_json(env_or_file="OAI_CONFIG_LIST") -assistant = AssistantAgent("assistant", llm_config={"config_list": config_list}) -code_executor_agent = UserProxyAgent( - "code_executor_agent", - code_execution_config={"work_dir": "coding", "use_docker": True} -) -code_executor_agent.initiate_chat( - assistant, - message="Create a plot of NVIDIA and TESLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'." -) -``` -````` - -`````` +```{include} stocksnippet.md -AgentChat in v0.4x provides similar abstractions to the default agents in v0.2x: +``` -- `CodingAssistantAgent` (v0.4x) ~ `AssistantAgent` (v0.2x) -- `CodeExecutorAgent` (v0.4x) ~ `UserProxyAgent` with code execution (v0.2x) +```{tip} +AgentChat in v0.4x provides similar abstractions to the default agents in v0.2x. The `CodingAssistantAgent` and `CodeExecutorAgent` in v0.4x are equivalent to the `AssistantAgent` and `UserProxyAgent` with code execution in v0.2x. +``` -Key differences: +If you are exploring migrating your code from AutoGen 0.2x to 0.4x, the following are some key differences to consider: 1. In v0.4x, agent interactions are managed by `Teams` (e.g., `RoundRobinGroupChat`), replacing direct chat initiation. 2. v0.4x uses async/await syntax for improved performance and scalability. diff --git a/python/packages/autogen-core/docs/src/agentchat-user-guide/stocksnippet.md b/python/packages/autogen-core/docs/src/agentchat-user-guide/stocksnippet.md new file mode 100644 index 000000000000..9308cf14510b --- /dev/null +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/stocksnippet.md @@ -0,0 +1,40 @@ +``````{tab-set} + +`````{tab-item} AgentChat (v0.4x) +```python +from autogen_agentchat.agents import CodeExecutorAgent, CodingAssistantAgent +from autogen_agentchat.teams.group_chat import RoundRobinGroupChat +from autogen_core.components.code_executor import DockerCommandLineCodeExecutor +from autogen_core.components.models import OpenAIChatCompletionClient + +async with DockerCommandLineCodeExecutor(work_dir="coding") as code_executor: + code_executor_agent = CodeExecutorAgent("code_executor", code_executor=code_executor) + coding_assistant_agent = CodingAssistantAgent( + "coding_assistant", model_client=OpenAIChatCompletionClient(model="gpt-4") + ) + group_chat = RoundRobinGroupChat([coding_assistant_agent, code_executor_agent]) + result = await group_chat.run( + task="Create a plot of NVIDIA and TESLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'." + ) + print(result) +``` +````` + +`````{tab-item} v0.2x +```python +from autogen import AssistantAgent, UserProxyAgent, config_list_from_json + +config_list = config_list_from_json(env_or_file="OAI_CONFIG_LIST") +assistant = AssistantAgent("assistant", llm_config={"config_list": config_list}) +code_executor_agent = UserProxyAgent( + "code_executor_agent", + code_execution_config={"work_dir": "coding", "use_docker": True} +) +code_executor_agent.initiate_chat( + assistant, + message="Create a plot of NVIDIA and TESLA stock returns YTD from 2024-01-01 and save it to 'nvidia_tesla_2024_ytd.png'." +) +``` +````` + +`````` diff --git a/python/packages/autogen-core/docs/src/images/code.svg b/python/packages/autogen-core/docs/src/images/code.svg new file mode 100644 index 000000000000..ca0756489bf8 --- /dev/null +++ b/python/packages/autogen-core/docs/src/images/code.svg @@ -0,0 +1,21 @@ + + + + + + + + + + + + + + + + + + + + +