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..1e364983f784 --- /dev/null +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/company-research.ipynb @@ -0,0 +1,426 @@ +{ + "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", + "\n", + "def google_search(query: str, num_results: int = 2, max_chars: int = 500) -> list: # type: ignore[type-arg]\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 = {\"key\": str(api_key), \"cx\": str(search_engine_id), \"q\": str(query), \"num\": str(num_results)}\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: str) -> str:\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\"], \"link\": item[\"link\"], \"snippet\": item[\"snippet\"], \"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: # type: ignore[type-arg]\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 # type: ignore\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:] # type: ignore[misc]\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(\n", + " google_search, description=\"Search Google for information, returns results with a snippet and body content\"\n", + ")\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(\n", + " 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(\n", + " 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(\n", + " 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. 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-08T13:07:56.762630]:\u001b[0m\n", + "\n", + "Write a financial report on American airlines\n", + "From: user\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:07:57.840424], Google_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_Q72sGSLMyu2CLa7kVzZDHMpL', arguments='{\"query\":\"American Airlines financial report 2023\",\"num_results\":5}', name='google_search')]\n", + "From: Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:08:04.880251], tool_agent_for_Google_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionExecutionResult(content=\"[{'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': 'Financial AAL | American Airlines', 'link': 'https://americanairlines.gcs-web.com/financial-results/financial-aal', 'snippet': 'Financial Results. Investor Relations; Financial Results; Financial Results ... Transcript 196.4 KB. 2023. Q4. Earnings Release · Form 10-K · Transcript 190.6 KB\\\\xa0...', '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 Group - AnnualReports.com', 'link': 'https://www.annualreports.com/Company/american-airlines-group', 'snippet': 'Most Recent Annual Report · View 2023 Sustainability Report · Older/Archived Annual Reports · Rate This Report.', '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,'}, {'title': 'American Airlines reports fourth-quarter and full-year 2023 financial ...', 'link': 'https://americanairlines.gcs-web.com/news-releases/news-release-details/american-airlines-reports-fourth-quarter-and-full-year-2023', 'snippet': 'Jan 25, 2024 ... American produced record revenue of nearly $53 billion. In the fourth quarter, the company generated revenue of more than $13 billion and an operating margin\\\\xa0...', 'body': 'American Airlines reports fourth-quarter and full-year 2023 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'}, {'title': 'American Airlines reports fourth-quarter and full-year 2023 financial ...', 'link': 'https://finance.yahoo.com/news/american-airlines-reports-fourth-quarter-120000360.html', 'snippet': 'Jan 25, 2024 ... FORT WORTH, Texas, Jan. 25, 2024 (GLOBE NEWSWIRE) -- American Airlines Group Inc. (NASDAQ: AAL) today reported its fourth-quarter and\\\\xa0...', 'body': 'Yahoo Will be right back... Thank you for your patience. Our engineers are working quickly to resolve the issue.'}]\", call_id='call_Q72sGSLMyu2CLa7kVzZDHMpL')]\n", + "From: tool_agent_for_Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:08:06.643034], Google_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_7J6Eq4RA2aoxWJ71phUvkojN', arguments='{\"query\": \"American Airlines financial results 2023 full year\", \"num_results\": 2}', name='google_search'), FunctionCall(id='call_ixFuFFKDUDSdQSGLwWyxoIs6', arguments='{\"query\": \"American Airlines Q4 2023 earnings report\", \"num_results\": 2}', name='google_search')]\n", + "From: Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:08:09.736878], tool_agent_for_Google_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionExecutionResult(content=\"[{'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 fourth-quarter and full-year 2023 financial ...', 'link': 'https://americanairlines.gcs-web.com/news-releases/news-release-details/american-airlines-reports-fourth-quarter-and-full-year-2023', 'snippet': 'Jan 25, 2024 ... American produced record revenue of nearly $53 billion. In the fourth quarter, the company generated revenue of more than $13 billion and an operating margin\\\\xa0...', 'body': 'American Airlines reports fourth-quarter and full-year 2023 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'}]\", call_id='call_7J6Eq4RA2aoxWJ71phUvkojN'), FunctionExecutionResult(content='[{\\'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\\': \\'Investor Relations | American Airlines\\', \\'link\\': \\'http://americanairlines.gcs-web.com/\\', \\'snippet\\': \"The Investor Relations website contains information about American Airlines\\'s business for stockholders, potential investors, and financial analysts.\", \\'body\\': \\'Investor Relations | 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\\'}]', call_id='call_ixFuFFKDUDSdQSGLwWyxoIs6')]\n", + "From: tool_agent_for_Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:08:16.385923], Google_Search_Agent:\u001b[0m\n", + "\n", + "### Financial Report: American Airlines Group Inc. (2023)\n", + "\n", + "#### Overview\n", + "American Airlines Group Inc. (NASDAQ: AAL), one of the largest airlines in the world, released its financial results for the fourth quarter and full year of 2023 on January 25, 2024.\n", + "\n", + "#### Key Financial Highlights for Full Year 2023\n", + "- **Total Revenue**: American Airlines achieved record revenue of nearly **$53 billion** for the full year.\n", + "- **Operating Revenue**: In the fourth quarter, the airline generated more than **$13 billion** in revenue.\n", + "- **Operating Margin**: The operating margin improved significantly due to increased demand and operational efficiencies.\n", + "\n", + "#### Q4 Financial Results\n", + "- **Revenue in Q4**: The fourth quarter witnessed a robust revenue growth that reflects strong travel demand.\n", + "- **Performance Metrics**: Additional performance metrics include:\n", + " - Detailed information about passenger revenues, cargo revenues, and operational metrics such as capacity and load factors.\n", + " \n", + "#### Future Outlook\n", + "American Airlines is focusing on expanding its flight services and improving overall operational efficiency in 2024. The airline aims to capitalize on the continuing recovery in travel demand, which should positively impact future revenues and profitability.\n", + "\n", + "#### Corporate Strategy\n", + "The airline has emphasized the importance of sustainable practices and operational innovations in its corporate strategy to adapt to evolving market conditions.\n", + "\n", + "#### Links for More Information\n", + "- [American Airlines Q4 2023 Financial Results](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", + "- [Investor Relations Page](http://americanairlines.gcs-web.com/)\n", + "\n", + "This financial report provides a summary of American Airlines' financial performance and outlook as of 2023. For detailed insights, the complete financial statements and press releases should be consulted directly from the airline's investor relations resources.\n", + "From: Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:08:16.961784], Stock_Analysis_Agent:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_sXPgieP7Mih48h44NX3fCYIe', arguments='{\"ticker\":\"AAL\"}', name='analyze_stock')]\n", + "From: Stock_Analysis_AgentPlot saved as coding/AAL_stockprice.png\n", + "\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:08:21.371132], tool_agent_for_Stock_Analysis_Agent:\u001b[0m\n", + "\n", + "[FunctionExecutionResult(content=\"{'ticker': 'AAL', 'current_price': 11.92, '52_week_high': 16.15, '52_week_low': 9.07, '50_day_ma': 10.573600044250488, '200_day_ma': 12.708699951171875, 'ytd_price_change': -1.5199995040893555, 'ytd_percent_change': -11.30952047281244, 'trend': 'Downward', 'volatility': 0.4110122561680265, 'plot_file_path': 'coding/AAL_stockprice.png'}\", call_id='call_sXPgieP7Mih48h44NX3fCYIe')]\n", + "From: tool_agent_for_Stock_Analysis_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:08:28.314277], Stock_Analysis_Agent:\u001b[0m\n", + "\n", + "### Financial Report: American Airlines Group Inc. (2023)\n", + "\n", + "#### Overview\n", + "American Airlines Group Inc. (NASDAQ: AAL) is one of the largest airlines globally, with substantial operations in passenger and cargo transport. The company has recently released its financial results for the fourth quarter and the full year of 2023.\n", + "\n", + "#### Key Financial Highlights for Full Year 2023\n", + "- **Total Revenue**: American Airlines achieved record revenue of nearly **$53 billion** for the full year.\n", + "- **Operating Revenue**: The airline generated over **$13 billion** in revenue during the fourth quarter.\n", + "- **Operating Margin**: There was a significant improvement in the operating margin, driven by increased travel demand and operational efficiencies.\n", + "\n", + "#### Q4 Financial Results\n", + "- The fourth quarter showed robust revenue growth, reflecting strong demand for travel.\n", + "- Additional performance metrics included passenger revenues, cargo revenues, capacity, and load factors, showcasing the airline's recovery post-pandemic.\n", + "\n", + "#### Stock Performance Overview\n", + "- **Current Stock Price**: $11.92\n", + "- **52-Week High**: $16.15\n", + "- **52-Week Low**: $9.07\n", + "- **50-Day Moving Average**: $11.84\n", + "- **200-Day Moving Average**: $12.71\n", + "- **Year-to-Date Price Change**: -$1.52\n", + "- **Year-to-Date Percent Change**: -11.31%\n", + "- **Trend**: The stock is currently in a downward trend.\n", + "- **Volatility**: The stock has a volatility of 41.10%.\n", + "\n", + "![American Airlines Stock Price Trend](coding/AAL_stockprice.png)\n", + "\n", + "#### Future Outlook\n", + "American Airlines aims to expand its services and improve operational efficiency throughout 2024. The airline is poised to benefit from the continuing recovery in travel demand, which is expected to positively affect future revenues and profitability.\n", + "\n", + "#### Corporate Strategy\n", + "The airline has prioritized sustainability and innovation within its operational strategy to adapt to ever-changing market conditions.\n", + "\n", + "#### Links for More Information\n", + "- [American Airlines Q4 2023 Financial Results](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", + "- [Investor Relations Page](http://americanairlines.gcs-web.com/)\n", + "\n", + "This financial report provides a comprehensive overview of American Airlines' financial performance and stock analysis as of 2023. For more detailed insights, please refer to the airline's investor relations resources.\n", + "From: Stock_Analysis_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:08:28.703160], Report_Agent:\u001b[0m\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=\"### Financial Report: American Airlines Group Inc. (2023)\\n\\n#### Overview\\nAmerican Airlines Group Inc. (NASDAQ: AAL), one of the largest airlines in the world, released its financial results for the fourth quarter and full year of 2023 on January 25, 2024.\\n\\n#### Key Financial Highlights for Full Year 2023\\n- **Total Revenue**: American Airlines achieved record revenue of nearly **$53 billion** for the full year.\\n- **Operating Revenue**: In the fourth quarter, the airline generated more than **$13 billion** in revenue.\\n- **Operating Margin**: The operating margin improved significantly due to increased demand and operational efficiencies.\\n\\n#### Q4 Financial Results\\n- **Revenue in Q4**: The fourth quarter witnessed a robust revenue growth that reflects strong travel demand.\\n- **Performance Metrics**: Additional performance metrics include:\\n - Detailed information about passenger revenues, cargo revenues, and operational metrics such as capacity and load factors.\\n \\n#### Future Outlook\\nAmerican Airlines is focusing on expanding its flight services and improving overall operational efficiency in 2024. The airline aims to capitalize on the continuing recovery in travel demand, which should positively impact future revenues and profitability.\\n\\n#### Corporate Strategy\\nThe airline has emphasized the importance of sustainable practices and operational innovations in its corporate strategy to adapt to evolving market conditions.\\n\\n#### Links for More Information\\n- [American Airlines Q4 2023 Financial Results](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- [Investor Relations Page](http://americanairlines.gcs-web.com/)\\n\\nThis financial report provides a summary of American Airlines' financial performance and outlook as of 2023. For detailed insights, the complete financial statements and press releases should be consulted directly from the airline's investor relations resources.\"), TextMessage(source='Stock_Analysis_Agent', content=\"### Financial Report: American Airlines Group Inc. (2023)\\n\\n#### Overview\\nAmerican Airlines Group Inc. (NASDAQ: AAL) is one of the largest airlines globally, with substantial operations in passenger and cargo transport. The company has recently released its financial results for the fourth quarter and the full year of 2023.\\n\\n#### Key Financial Highlights for Full Year 2023\\n- **Total Revenue**: American Airlines achieved record revenue of nearly **$53 billion** for the full year.\\n- **Operating Revenue**: The airline generated over **$13 billion** in revenue during the fourth quarter.\\n- **Operating Margin**: There was a significant improvement in the operating margin, driven by increased travel demand and operational efficiencies.\\n\\n#### Q4 Financial Results\\n- The fourth quarter showed robust revenue growth, reflecting strong demand for travel.\\n- Additional performance metrics included passenger revenues, cargo revenues, capacity, and load factors, showcasing the airline's recovery post-pandemic.\\n\\n#### Stock Performance Overview\\n- **Current Stock Price**: $11.92\\n- **52-Week High**: $16.15\\n- **52-Week Low**: $9.07\\n- **50-Day Moving Average**: $11.84\\n- **200-Day Moving Average**: $12.71\\n- **Year-to-Date Price Change**: -$1.52\\n- **Year-to-Date Percent Change**: -11.31%\\n- **Trend**: The stock is currently in a downward trend.\\n- **Volatility**: The stock has a volatility of 41.10%.\\n\\n![American Airlines Stock Price Trend](coding/AAL_stockprice.png)\\n\\n#### Future Outlook\\nAmerican Airlines aims to expand its services and improve operational efficiency throughout 2024. The airline is poised to benefit from the continuing recovery in travel demand, which is expected to positively affect future revenues and profitability.\\n\\n#### Corporate Strategy\\nThe airline has prioritized sustainability and innovation within its operational strategy to adapt to ever-changing market conditions.\\n\\n#### Links for More Information\\n- [American Airlines Q4 2023 Financial Results](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- [Investor Relations Page](http://americanairlines.gcs-web.com/)\\n\\nThis financial report provides a comprehensive overview of American Airlines' financial performance and stock analysis as of 2023. For more detailed insights, please refer to the airline's investor relations resources.\"), StopMessage(source='Report_Agent', content='TERMINATE')])\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..7395cac25b91 --- /dev/null +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/literature-review.ipynb @@ -0,0 +1,357 @@ +{ + "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": [ + "def google_search(query: str, num_results: int = 2, max_chars: int = 500) -> list: # type: ignore[type-arg]\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 = {\"key\": api_key, \"cx\": search_engine_id, \"q\": query, \"num\": num_results}\n", + "\n", + " response = requests.get(url, params=params) # type: ignore[arg-type]\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: str) -> str:\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\"], \"link\": item[\"link\"], \"snippet\": item[\"snippet\"], \"body\": body}\n", + " )\n", + " time.sleep(1) # Be respectful to the servers\n", + "\n", + " return enriched_results\n", + "\n", + "\n", + "def arxiv_search(query: str, max_results: int = 2) -> list: # type: ignore[type-arg]\n", + " \"\"\"\n", + " Search Arxiv for papers and return the results including abstracts.\n", + " \"\"\"\n", + " import arxiv\n", + "\n", + " client = arxiv.Client()\n", + " search = arxiv.Search(query=query, max_results=max_results, sort_by=arxiv.SortCriterion.Relevance)\n", + "\n", + " results = []\n", + " for paper in client.results(search):\n", + " results.append(\n", + " {\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", + "\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(\n", + " google_search, description=\"Search Google for information, returns results with a snippet and body content\"\n", + ")\n", + "arxiv_search_tool = FunctionTool(\n", + " arxiv_search, description=\"Search Arxiv for papers related to a given topic, including abstracts\"\n", + ")" + ] + }, + { + "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-08T13:16:31.834796]:\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-08T13:16:32.601078], Google_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_uJyuIbKg0XGXTqozjBMUCQqX', arguments='{\"query\":\"no code tools for building multi agent AI systems\",\"num_results\":5,\"max_chars\":1000}', name='google_search')]\n", + "From: Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:16:39.878814], 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 menu quick links Login Help Pages About Computer Science > Software Engineering arXiv:2408.15247 (cs) [Submitted on 9 Aug 2024] 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 View a PDF of the paper titled AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems, by Victor Dibia and 7 other authors View\\'}, {\\'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 & TV Business Microsoft Azure Microsoft Dynamics 365 Microsoft 365 Microsoft Industry Data platform Microsoft Advertising Licensing Shop Business Developer & IT .NET Visual Studio Windows Server Windows Dev Center Docs Other Microsoft Rewards Free downloads & security Education Store locations Gift cards View Sitemap Search Search Microsoft.com Cancel Your current User-Agent string appears to be from an automated process, if this is incorrect, please click this link: United States English\\'}, {\\'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 the AI Workforce What is the AI Workforce? Enterprise Pricing Login Sign Up Product AI Agents Agent Teams AI Tools Custom Actions for GPTs API By Function Sales Marketing Customer Support Research Operations Agents Bosh the Sales Agent Inbound - AI SDR Outbound - AI SDR Resources Blog Documentation Workflows Javascript SDK Python SDK Templates Building the AI Workforce Enterprise Pricing Log in Sign up AI Agent Teams Build a Multi Agent System Create your own AI team that work collaboratively\\'}, {\\'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 1,000,000 750,000 500,000 250,000 100,000 75,000 50,000 25,000 10,000 5,000 2,500 1,000 500 250 100 50 10 0 Multi-Agent Crews run using CrewAI Trusted By Industry Leaders The Complete Platform for Multi-Agent Automation 1. Build Quickly 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. 2. Deploy Confidently Move the crews you built to production with powerful tools for different deployment\\'}]', call_id='call_uJyuIbKg0XGXTqozjBMUCQqX')]\n", + "From: tool_agent_for_Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:16:49.739108], Google_Search_Agent:\u001b[0m\n", + "\n", + "### Literature Review on No-Code Tools for Building Multi-Agent AI Systems\n", + "\n", + "The advent of no-code and low-code platforms has revolutionized the development of software applications, including multi-agent AI systems. These tools enable users, regardless of their technical background, to create sophisticated systems through visual interfaces and pre-built components. This literature review explores the current landscape of no-code tools specifically designed for building multi-agent AI systems, examining their capabilities, features, and potential use cases.\n", + "\n", + "#### 1. **AutoGen Studio**\n", + "One of the prominent tools in this domain is **AutoGen Studio**, which provides a no-code environment for designing and debugging multi-agent systems. According to a recent paper published in **arXiv**, this tool focuses on facilitating collaboration among different agents, including generative AI models and associated tools. It emphasizes usability, allowing developers to build complex systems without extensive programming knowledge (Dibia et al., 2024).\n", + "\n", + "#### 2. **Multi Agents System (MAS) Builder**\n", + "Another notable platform is the **Multi Agents System (MAS) Builder** by **Relevance AI**. This tool allows users to construct AI worker systems that can operate collaboratively without requiring any coding skills. The platform highlights features such as the ability to create and deploy AI teams optimized for tasks like sales and customer support, showcasing the practical applications of no-code tools in business environments (Relevance AI, 2024).\n", + "\n", + "#### 3. **Crew AI**\n", + "**Crew AI** offers a comprehensive framework for automating workflows through multi-agent systems. It includes a UI Studio that facilitates the creation of automations without programming. Users can leverage pre-configured templates and build agents that execute tasks across various domains. This flexibility makes it suitable for industries seeking to enhance operational efficiency through automated systems (Crew AI, 2024).\n", + "\n", + "#### 4. **Insights and Community Experiences**\n", + "Additionally, community discussions and insights shared on platforms like **Reddit** provide anecdotal evidence of the effectiveness and user experiences when employing no-code tools for multi-agent systems. Users share their journeys in building complex systems, highlighting both successes and challenges faced during development (April 2024).\n", + "\n", + "### Conclusion\n", + "The evolution of no-code tools has significantly lowered the barrier to entry for developing multi-agent AI systems. Platforms such as AutoGen Studio, MAS Builder, and Crew AI exemplify the potential for creating sophisticated systems without traditional coding requirements. As these tools continue to grow in capability and user adoption, they promise to democratize AI development and enable a wider range of professionals to leverage AI technologies in their work.\n", + "\n", + "### References\n", + "1. Dibia, V., Chen, J., Bansal, G., Syed, S., Fourney, A., Zhu, E., Wang, C., & Amershi, S. (2024). AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems. arXiv.\n", + "2. Relevance AI. (2024). Multi Agents System (MAS) Builder - Build your AI Workforce. Retrieved from [Relevance AI](https://relevanceai.com/multi-agents).\n", + "3. Crew AI. (2024). The Leading Multi-Agent Platform. Retrieved from [Crew AI](https://www.crewai.com/).\n", + "4. Insights from Community Discussions. Reddit. (April 2024). \n", + "\n", + "This review highlights the emerging trends and significant tools in the no-code multi-agent AI space, indicating a shift toward more accessible AI system development.\n", + "From: Google_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:16:50.542039], Arxiv_Search_Agent:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_HnNhdJzH3xCbiofbbcoqzFDP', arguments='{\"query\":\"no code tools multi agent AI systems\",\"max_results\":5}', name='arxiv_search')]\n", + "From: Arxiv_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:16:52.486634], 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\\': \\'Collaboration of AI Agents via Cooperative Multi-Agent Deep Reinforcement Learning\\', \\'authors\\': [\\'Niranjan Balachandar\\', \\'Justin Dieter\\', \\'Govardana Sachithanandam Ramachandran\\'], \\'published\\': \\'2019-06-30\\', \\'abstract\\': \\'There are many AI tasks involving multiple interacting agents where agents\\\\nshould learn to cooperate and collaborate to effectively perform the task. Here\\\\nwe develop and evaluate various multi-agent protocols to train agents to\\\\ncollaborate with teammates in grid soccer. We train and evaluate our\\\\nmulti-agent methods against a team operating with a smart hand-coded policy. As\\\\na baseline, we train agents concurrently and independently, with no\\\\ncommunication. Our collaborative protocols were parameter sharing, coordinated\\\\nlearning with communication, and counterfactual policy gradients. Against the\\\\nhand-coded team, the team trained with parameter sharing and the team trained\\\\nwith coordinated learning performed the best, scoring on 89.5% and 94.5% of\\\\nepisodes respectively when playing against the hand-coded team. Against the\\\\nparameter sharing team, with adversarial training the coordinated learning team\\\\nscored on 75% of the episodes, indicating it is the most adaptable of our\\\\nmethods. The insights gained from our work can be applied to other domains\\\\nwhere multi-agent collaboration could be beneficial.\\', \\'pdf_url\\': \\'http://arxiv.org/pdf/1907.00327v1\\'}, {\\'title\\': \\'Levels of AI Agents: from Rules to Large Language Models\\', \\'authors\\': [\\'Yu Huang\\'], \\'published\\': \\'2024-03-06\\', \\'abstract\\': \\'AI agents are defined as artificial entities to perceive the environment,\\\\nmake decisions and take actions. Inspired by the 6 levels of autonomous driving\\\\nby Society of Automotive Engineers, the AI agents are also categorized based on\\\\nutilities and strongness, as the following levels: L0, no AI, with tools taking\\\\ninto account perception plus actions; L1, using rule-based AI; L2, making\\\\nrule-based AI replaced by IL/RL-based AI, with additional reasoning & decision\\\\nmaking; L3, applying LLM-based AI instead of IL/RL-based AI, additionally\\\\nsetting up memory & reflection; L4, based on L3, facilitating autonomous\\\\nlearning & generalization; L5, based on L4, appending personality of emotion\\\\nand character and collaborative behavior with multi-agents.\\', \\'pdf_url\\': \\'http://arxiv.org/pdf/2405.06643v1\\'}, {\\'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\\': \\'The Partially Observable Asynchronous Multi-Agent Cooperation Challenge\\', \\'authors\\': [\\'Meng Yao\\', \\'Qiyue Yin\\', \\'Jun Yang\\', \\'Tongtong Yu\\', \\'Shengqi Shen\\', \\'Junge Zhang\\', \\'Bin Liang\\', \\'Kaiqi Huang\\'], \\'published\\': \\'2021-12-07\\', \\'abstract\\': \\'Multi-agent reinforcement learning (MARL) has received increasing attention\\\\nfor its applications in various domains. Researchers have paid much attention\\\\non its partially observable and cooperative settings for meeting real-world\\\\nrequirements. For testing performance of different algorithms, standardized\\\\nenvironments are designed such as the StarCraft Multi-Agent Challenge, which is\\\\none of the most successful MARL benchmarks. To our best knowledge, most of\\\\ncurrent environments are synchronous, where agents execute actions in the same\\\\npace. However, heterogeneous agents usually have their own action spaces and\\\\nthere is no guarantee for actions from different agents to have the same\\\\nexecuted cycle, which leads to asynchronous multi-agent cooperation. Inspired\\\\nfrom the Wargame, a confrontation game between two armies abstracted from real\\\\nworld environment, we propose the first Partially Observable Asynchronous\\\\nmulti-agent Cooperation challenge (POAC) for the MARL community. Specifically,\\\\nPOAC supports two teams of heterogeneous agents to fight with each other, where\\\\nan agent selects actions based on its own observations and cooperates\\\\nasynchronously with its allies. Moreover, POAC is a light weight, flexible and\\\\neasy to use environment, which can be configured by users to meet different\\\\nexperimental requirements such as self-play model, human-AI model and so on.\\\\nAlong with our benchmark, we offer six game scenarios of varying difficulties\\\\nwith the built-in rule-based AI as opponents. Finally, since most MARL\\\\nalgorithms are designed for synchronous agents, we revise several\\\\nrepresentatives to meet the asynchronous setting, and the relatively poor\\\\nexperimental results validate the challenge of POAC. Source code is released in\\\\n\\\\\\\\url{http://turingai.ia.ac.cn/data\\\\\\\\_center/show}.\\', \\'pdf_url\\': \\'http://arxiv.org/pdf/2112.03809v1\\'}]', call_id='call_HnNhdJzH3xCbiofbbcoqzFDP')]\n", + "From: tool_agent_for_Arxiv_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:17:12.845506], 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 AI systems has been significantly enhanced by the emergence of no-code tools, allowing a broader range of users to engage in the creation and management of complex AI applications without extensive programming knowledge. This literature review synthesizes current research on no-code tools tailored for building multi-agent AI systems, discussing their functionalities, design, and implications.\n", + "\n", + "#### 1. AutoGen Studio\n", + "**AutoGen Studio** is a cutting-edge no-code developer tool specifically designed for building and debugging multi-agent systems. Dibia et al. (2024) highlight that this platform simplifies the development process through a web interface that supports drag-and-drop functionalities for creating agent workflows. With a Python API and a JSON-based specification for representing agents, AutoGen Studio allows users to prototype and evaluate workflows effortlessly. This tool not only enhances usability but also fosters collaboration among various generative AI models and tools. The authors emphasize four core design principles that inform the development of no-code tools, aiming to streamline the creation of multi-agent systems (Dibia et al., 2024). [Read the paper here](http://arxiv.org/pdf/2408.15247v1).\n", + "\n", + "#### 2. Levels of AI Agents\n", + "In a conceptual exploration, Huang (2024) classifies AI agents into levels based on their capabilities, ranging from rule-based systems (L1) to advanced large language models (LLMs) (L3). This classification is crucial for understanding the potential complexity and collaboration among agents in multi-agent frameworks. These levels imply varying degrees of autonomy and decision-making, which can impact the design of no-code tools intended for multi-agent systems. The consideration of these levels is vital for developing platforms that allow effective integration and collaboration between diverse agent types (Huang, 2024). [Read the paper here](http://arxiv.org/pdf/2405.06643v1).\n", + "\n", + "#### 3. HAICOSYSTEM\n", + "**HAICOSYSTEM** presents a novel framework that examines safety risks in human-AI interactions, focusing on multi-agent systems' operational complexities. Zhou et al. (2024) discuss a modular sandbox environment that simulates interactions between AI agents and human users across various scenarios. The framework allows practitioners to evaluate and ensure the safety and performance of agents, emphasizing a crucial aspect that no-code tools must address—handling operational risks in real-time interactions. This research underscores the need for built-in safety and evaluation features within no-code platforms for multi-agent systems (Zhou et al., 2024). [Read the paper here](http://arxiv.org/pdf/2409.16427v2).\n", + "\n", + "#### 4. Collaboration Protocols in AI Agents\n", + "Balachandar et al. (2019) focus on the collaborative protocols that enable multiple agents to work together effectively in a competitive setting like grid soccer. Their work discusses various strategies for cooperation and highlights the importance of communication among agents. This foundational understanding of multi-agent interaction can influence the design and implementation of no-code tools by offering insights into how agents can collaborate seamlessly without the need for extensive programming (Balachandar et al., 2019). [Read the paper here](http://arxiv.org/pdf/1907.00327v1).\n", + "\n", + "#### 5. Asynchronous Multi-Agent Cooperation\n", + "In a more technical aspect, Yao et al. (2021) introduce the **Partially Observable Asynchronous Multi-Agent Cooperation (POAC)** challenge to evaluate multi-agent reinforcement learning (MARL) algorithms in asynchronous environments. This environment design shifts the focus from synchronous operations, which are common in many existing no-code tools, to more realistic settings reflecting real-world complexities. The flexibility and adaptability required for asynchronous operations highlight critical design considerations for the next generation of no-code development tools (Yao et al., 2021). [Read the paper here](http://arxiv.org/pdf/2112.03809v1).\n", + "\n", + "### Conclusion\n", + "No-code tools for building multi-agent AI systems are rapidly evolving, offering unprecedented access to AI development for users without programming expertise. Tools like AutoGen Studio provide essential frameworks for agent collaboration, while safety frameworks like HAICOSYSTEM remind developers of the necessity of operational integrity. Insights from collaboration protocols and asynchronous environments further inform the development and refinement of these tools. As the landscape grows, these no-code platforms will likely play a pivotal role in democratizing the development of sophisticated multi-agent systems across various domains.\n", + "\n", + "### References\n", + "1. Dibia, V., Chen, J., Bansal, G., Syed, S., Fourney, A., Zhu, E., Wang, C., & Amershi, S. (2024). AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems. arXiv.\n", + "2. Huang, Y. (2024). Levels of AI Agents: from Rules to Large Language Models. arXiv.\n", + "3. Zhou, X., Kim, H., Brahman, F., Jiang, L., Zhu, H., Lu, X., Xu, F., Lin, B. Y., Choi, Y., Mireshghallah, N., Bras, R. L., & Sap, M. (2024). HAICOSYSTEM: An Ecosystem for Sandboxing Safety Risks in Human-AI Interactions. arXiv.\n", + "4. Balachandar, N., Dieter, J., & Ramachandran, G. S. (2019). Collaboration of AI Agents via Cooperative Multi-Agent Deep Reinforcement Learning. arXiv.\n", + "5. Yao, M., Yin, Q., Yang, J., Yu, T., Shen, S., Zhang, J., Liang, B., & Huang, K. (2021). The Partially Observable Asynchronous Multi-Agent Cooperation Challenge. arXiv.\n", + "From: Arxiv_Search_Agent\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T13:17:36.794418], Report_Agent:\u001b[0m\n", + "\n", + "### Literature Review on No-Code Tools for Building Multi-Agent AI Systems\n", + "\n", + "The emergence of no-code tools signals a significant shift in the development landscape of multi-agent AI systems, enabling users with minimal programming knowledge to design and implement complex AI applications. This literature review synthesizes current research and practical insights on no-code tools crafted for establishing multi-agent AI systems, emphasizing their features, capabilities, and applications.\n", + "\n", + "#### 1. AutoGen Studio\n", + "**AutoGen Studio** serves as a pioneering no-code platform tailored for the design and debugging of multi-agent systems. Dibia et al. (2024) highlight that this tool utilizes a web-based interface that enables users to construct workflows through intuitive drag-and-drop functionalities. The flexibility offered by a Python API, along with a JSON-based framework for representing agents, streamlines the prototyping and evaluation processes. Such features foster collaboration among various generative AI models and enhance usability, ultimately addressing the diverse needs of non-technical users in constructing multi-agent environments (Dibia et al., 2024). [Read the paper here](http://arxiv.org/pdf/2408.15247v1).\n", + "\n", + "#### 2. Levels of AI Agents\n", + "Huang (2024) introduces a conceptual framework categorizing AI agents by their capabilities. This classification ranges from simple rule-based systems to advanced large language models, underscoring the varying complexities in multi-agent interactions. Understanding these levels aids in informing the design of no-code tools to support effective collaboration among agents of differing capabilities. By integrating awareness of these agent levels, developers can enhance how no-code platforms facilitate interactions within multi-agent systems (Huang, 2024). [Read the paper here](http://arxiv.org/pdf/2405.06643v1).\n", + "\n", + "#### 3. HAICOSYSTEM\n", + "The **HAICOSYSTEM** framework examines the safety considerations inherent in human-AI interactions, especially concerning multi-agent contexts. Zhou et al. (2024) propose a modular sandbox environment that simulates various operational scenarios, allowing practitioners to assess and ensure safety while interacting with agents. This research emphasizes the necessity of incorporating safety evaluation features into no-code platforms for multi-agent systems, ensuring that these tools not only enhance usability but also promote reliable and secure interactions (Zhou et al., 2024). [Read the paper here](http://arxiv.org/pdf/2409.16427v2).\n", + "\n", + "#### 4. Collaboration Protocols in AI Agents\n", + "The investigation by Balachandar et al. (2019) into collaborative protocols among AI agents reveals fundamental strategies that can enhance cooperative behavior in multi-agent systems. Their insights are invaluable for informing the design of no-code platforms, highlighting the importance of effective communication and cooperation among agents. By embedding these collaborative features into no-code tools, developers can facilitate more seamless integration and interaction among agents, which is essential for complex multi-agent tasks (Balachandar et al., 2019). [Read the paper here](http://arxiv.org/pdf/1907.00327v1).\n", + "\n", + "#### 5. Asynchronous Multi-Agent Cooperation\n", + "Yao et al. (2021) present the **Partially Observable Asynchronous Multi-Agent Cooperation (POAC)** challenge, which evaluates the performance of multi-agent reinforcement learning algorithms in asynchronous environments. This design paradigm shifts focus from synchronous operations, commonly found in traditional no-code tools, toward interfaces that reflect realistic interactions. The implications of asynchronous cooperation underscore critical design considerations for developing future no-code tools, emphasizing the need for flexibility and adaptability in systems that work under real-world constraints (Yao et al., 2021). [Read the paper here](http://arxiv.org/pdf/2112.03809v1).\n", + "\n", + "### Conclusion\n", + "No-code tools for developing multi-agent AI systems are rapidly advancing, providing unprecedented opportunities for users without programming skills to engage in complex AI development. Platforms like AutoGen Studio are at the forefront of these innovations, facilitating collaboration and simplifying design processes. Concurrent research on AI agent levels, safety frameworks, collaboration protocols, and asynchronous cooperation further enhances the understanding of requirements for effective no-code tool design. As these tools proliferate, they are poised to democratize access to multi-agent system development across diverse sectors.\n", + "\n", + "### References\n", + "1. Dibia, V., Chen, J., Bansal, G., Syed, S., Fourney, A., Zhu, E., Wang, C., & Amershi, S. (2024). AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems. arXiv. [Available here](http://arxiv.org/pdf/2408.15247v1).\n", + "2. Huang, Y. (2024). Levels of AI Agents: from Rules to Large Language Models. arXiv. [Available here](http://arxiv.org/pdf/2405.06643v1).\n", + "3. Zhou, X., Kim, H., Brahman, F., Jiang, L., Zhu, H., Lu, X., Xu, F., Lin, B. Y., Choi, Y., Mireshghallah, N., Bras, R. L., & Sap, M. (2024). HAICOSYSTEM: An Ecosystem for Sandboxing Safety Risks in Human-AI Interactions. arXiv. [Available here](http://arxiv.org/pdf/2409.16427v2).\n", + "4. Balachandar, N., Dieter, J., & Ramachandran, G. S. (2019). Collaboration of AI Agents via Cooperative Multi-Agent Deep Reinforcement Learning. arXiv. [Available here](http://arxiv.org/pdf/1907.00327v1).\n", + "5. Yao, M., Yin, Q., Yang, J., Yu, T., Shen, S., Zhang, J., Liang, B., & Huang, K. (2021). The Partially Observable Asynchronous Multi-Agent Cooperation Challenge. arXiv. [Available here](http://arxiv.org/pdf/2112.03809v1).\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 advent of no-code and low-code platforms has revolutionized the development of software applications, including multi-agent AI systems. These tools enable users, regardless of their technical background, to create sophisticated systems through visual interfaces and pre-built components. This literature review explores the current landscape of no-code tools specifically designed for building multi-agent AI systems, examining their capabilities, features, and potential use cases.\\n\\n#### 1. **AutoGen Studio**\\nOne of the prominent tools in this domain is **AutoGen Studio**, which provides a no-code environment for designing and debugging multi-agent systems. According to a recent paper published in **arXiv**, this tool focuses on facilitating collaboration among different agents, including generative AI models and associated tools. It emphasizes usability, allowing developers to build complex systems without extensive programming knowledge (Dibia et al., 2024).\\n\\n#### 2. **Multi Agents System (MAS) Builder**\\nAnother notable platform is the **Multi Agents System (MAS) Builder** by **Relevance AI**. This tool allows users to construct AI worker systems that can operate collaboratively without requiring any coding skills. The platform highlights features such as the ability to create and deploy AI teams optimized for tasks like sales and customer support, showcasing the practical applications of no-code tools in business environments (Relevance AI, 2024).\\n\\n#### 3. **Crew AI**\\n**Crew AI** offers a comprehensive framework for automating workflows through multi-agent systems. It includes a UI Studio that facilitates the creation of automations without programming. Users can leverage pre-configured templates and build agents that execute tasks across various domains. This flexibility makes it suitable for industries seeking to enhance operational efficiency through automated systems (Crew AI, 2024).\\n\\n#### 4. **Insights and Community Experiences**\\nAdditionally, community discussions and insights shared on platforms like **Reddit** provide anecdotal evidence of the effectiveness and user experiences when employing no-code tools for multi-agent systems. Users share their journeys in building complex systems, highlighting both successes and challenges faced during development (April 2024).\\n\\n### Conclusion\\nThe evolution of no-code tools has significantly lowered the barrier to entry for developing multi-agent AI systems. Platforms such as AutoGen Studio, MAS Builder, and Crew AI exemplify the potential for creating sophisticated systems without traditional coding requirements. As these tools continue to grow in capability and user adoption, they promise to democratize AI development and enable a wider range of professionals to leverage AI technologies in their work.\\n\\n### References\\n1. Dibia, V., Chen, J., Bansal, G., Syed, S., Fourney, A., Zhu, E., Wang, C., & Amershi, S. (2024). AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems. arXiv.\\n2. Relevance AI. (2024). Multi Agents System (MAS) Builder - Build your AI Workforce. Retrieved from [Relevance AI](https://relevanceai.com/multi-agents).\\n3. Crew AI. (2024). The Leading Multi-Agent Platform. Retrieved from [Crew AI](https://www.crewai.com/).\\n4. Insights from Community Discussions. Reddit. (April 2024). \\n\\nThis review highlights the emerging trends and significant tools in the no-code multi-agent AI space, indicating a shift toward more accessible AI system development.'), TextMessage(source='Arxiv_Search_Agent', content=\"### Literature Review on No-Code Tools for Building Multi-Agent AI Systems\\n\\nThe development of multi-agent AI systems has been significantly enhanced by the emergence of no-code tools, allowing a broader range of users to engage in the creation and management of complex AI applications without extensive programming knowledge. This literature review synthesizes current research on no-code tools tailored for building multi-agent AI systems, discussing their functionalities, design, and implications.\\n\\n#### 1. AutoGen Studio\\n**AutoGen Studio** is a cutting-edge no-code developer tool specifically designed for building and debugging multi-agent systems. Dibia et al. (2024) highlight that this platform simplifies the development process through a web interface that supports drag-and-drop functionalities for creating agent workflows. With a Python API and a JSON-based specification for representing agents, AutoGen Studio allows users to prototype and evaluate workflows effortlessly. This tool not only enhances usability but also fosters collaboration among various generative AI models and tools. The authors emphasize four core design principles that inform the development of no-code tools, aiming to streamline the creation of multi-agent systems (Dibia et al., 2024). [Read the paper here](http://arxiv.org/pdf/2408.15247v1).\\n\\n#### 2. Levels of AI Agents\\nIn a conceptual exploration, Huang (2024) classifies AI agents into levels based on their capabilities, ranging from rule-based systems (L1) to advanced large language models (LLMs) (L3). This classification is crucial for understanding the potential complexity and collaboration among agents in multi-agent frameworks. These levels imply varying degrees of autonomy and decision-making, which can impact the design of no-code tools intended for multi-agent systems. The consideration of these levels is vital for developing platforms that allow effective integration and collaboration between diverse agent types (Huang, 2024). [Read the paper here](http://arxiv.org/pdf/2405.06643v1).\\n\\n#### 3. HAICOSYSTEM\\n**HAICOSYSTEM** presents a novel framework that examines safety risks in human-AI interactions, focusing on multi-agent systems' operational complexities. Zhou et al. (2024) discuss a modular sandbox environment that simulates interactions between AI agents and human users across various scenarios. The framework allows practitioners to evaluate and ensure the safety and performance of agents, emphasizing a crucial aspect that no-code tools must address—handling operational risks in real-time interactions. This research underscores the need for built-in safety and evaluation features within no-code platforms for multi-agent systems (Zhou et al., 2024). [Read the paper here](http://arxiv.org/pdf/2409.16427v2).\\n\\n#### 4. Collaboration Protocols in AI Agents\\nBalachandar et al. (2019) focus on the collaborative protocols that enable multiple agents to work together effectively in a competitive setting like grid soccer. Their work discusses various strategies for cooperation and highlights the importance of communication among agents. This foundational understanding of multi-agent interaction can influence the design and implementation of no-code tools by offering insights into how agents can collaborate seamlessly without the need for extensive programming (Balachandar et al., 2019). [Read the paper here](http://arxiv.org/pdf/1907.00327v1).\\n\\n#### 5. Asynchronous Multi-Agent Cooperation\\nIn a more technical aspect, Yao et al. (2021) introduce the **Partially Observable Asynchronous Multi-Agent Cooperation (POAC)** challenge to evaluate multi-agent reinforcement learning (MARL) algorithms in asynchronous environments. This environment design shifts the focus from synchronous operations, which are common in many existing no-code tools, to more realistic settings reflecting real-world complexities. The flexibility and adaptability required for asynchronous operations highlight critical design considerations for the next generation of no-code development tools (Yao et al., 2021). [Read the paper here](http://arxiv.org/pdf/2112.03809v1).\\n\\n### Conclusion\\nNo-code tools for building multi-agent AI systems are rapidly evolving, offering unprecedented access to AI development for users without programming expertise. Tools like AutoGen Studio provide essential frameworks for agent collaboration, while safety frameworks like HAICOSYSTEM remind developers of the necessity of operational integrity. Insights from collaboration protocols and asynchronous environments further inform the development and refinement of these tools. As the landscape grows, these no-code platforms will likely play a pivotal role in democratizing the development of sophisticated multi-agent systems across various domains.\\n\\n### References\\n1. Dibia, V., Chen, J., Bansal, G., Syed, S., Fourney, A., Zhu, E., Wang, C., & Amershi, S. (2024). AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems. arXiv.\\n2. Huang, Y. (2024). Levels of AI Agents: from Rules to Large Language Models. arXiv.\\n3. Zhou, X., Kim, H., Brahman, F., Jiang, L., Zhu, H., Lu, X., Xu, F., Lin, B. Y., Choi, Y., Mireshghallah, N., Bras, R. L., & Sap, M. (2024). HAICOSYSTEM: An Ecosystem for Sandboxing Safety Risks in Human-AI Interactions. arXiv.\\n4. Balachandar, N., Dieter, J., & Ramachandran, G. S. (2019). Collaboration of AI Agents via Cooperative Multi-Agent Deep Reinforcement Learning. arXiv.\\n5. Yao, M., Yin, Q., Yang, J., Yu, T., Shen, S., Zhang, J., Liang, B., & Huang, K. (2021). The Partially Observable Asynchronous Multi-Agent Cooperation Challenge. arXiv.\"), StopMessage(source='Report_Agent', content='### Literature Review on No-Code Tools for Building Multi-Agent AI Systems\\n\\nThe emergence of no-code tools signals a significant shift in the development landscape of multi-agent AI systems, enabling users with minimal programming knowledge to design and implement complex AI applications. This literature review synthesizes current research and practical insights on no-code tools crafted for establishing multi-agent AI systems, emphasizing their features, capabilities, and applications.\\n\\n#### 1. AutoGen Studio\\n**AutoGen Studio** serves as a pioneering no-code platform tailored for the design and debugging of multi-agent systems. Dibia et al. (2024) highlight that this tool utilizes a web-based interface that enables users to construct workflows through intuitive drag-and-drop functionalities. The flexibility offered by a Python API, along with a JSON-based framework for representing agents, streamlines the prototyping and evaluation processes. Such features foster collaboration among various generative AI models and enhance usability, ultimately addressing the diverse needs of non-technical users in constructing multi-agent environments (Dibia et al., 2024). [Read the paper here](http://arxiv.org/pdf/2408.15247v1).\\n\\n#### 2. Levels of AI Agents\\nHuang (2024) introduces a conceptual framework categorizing AI agents by their capabilities. This classification ranges from simple rule-based systems to advanced large language models, underscoring the varying complexities in multi-agent interactions. Understanding these levels aids in informing the design of no-code tools to support effective collaboration among agents of differing capabilities. By integrating awareness of these agent levels, developers can enhance how no-code platforms facilitate interactions within multi-agent systems (Huang, 2024). [Read the paper here](http://arxiv.org/pdf/2405.06643v1).\\n\\n#### 3. HAICOSYSTEM\\nThe **HAICOSYSTEM** framework examines the safety considerations inherent in human-AI interactions, especially concerning multi-agent contexts. Zhou et al. (2024) propose a modular sandbox environment that simulates various operational scenarios, allowing practitioners to assess and ensure safety while interacting with agents. This research emphasizes the necessity of incorporating safety evaluation features into no-code platforms for multi-agent systems, ensuring that these tools not only enhance usability but also promote reliable and secure interactions (Zhou et al., 2024). [Read the paper here](http://arxiv.org/pdf/2409.16427v2).\\n\\n#### 4. Collaboration Protocols in AI Agents\\nThe investigation by Balachandar et al. (2019) into collaborative protocols among AI agents reveals fundamental strategies that can enhance cooperative behavior in multi-agent systems. Their insights are invaluable for informing the design of no-code platforms, highlighting the importance of effective communication and cooperation among agents. By embedding these collaborative features into no-code tools, developers can facilitate more seamless integration and interaction among agents, which is essential for complex multi-agent tasks (Balachandar et al., 2019). [Read the paper here](http://arxiv.org/pdf/1907.00327v1).\\n\\n#### 5. Asynchronous Multi-Agent Cooperation\\nYao et al. (2021) present the **Partially Observable Asynchronous Multi-Agent Cooperation (POAC)** challenge, which evaluates the performance of multi-agent reinforcement learning algorithms in asynchronous environments. This design paradigm shifts focus from synchronous operations, commonly found in traditional no-code tools, toward interfaces that reflect realistic interactions. The implications of asynchronous cooperation underscore critical design considerations for developing future no-code tools, emphasizing the need for flexibility and adaptability in systems that work under real-world constraints (Yao et al., 2021). [Read the paper here](http://arxiv.org/pdf/2112.03809v1).\\n\\n### Conclusion\\nNo-code tools for developing multi-agent AI systems are rapidly advancing, providing unprecedented opportunities for users without programming skills to engage in complex AI development. Platforms like AutoGen Studio are at the forefront of these innovations, facilitating collaboration and simplifying design processes. Concurrent research on AI agent levels, safety frameworks, collaboration protocols, and asynchronous cooperation further enhances the understanding of requirements for effective no-code tool design. As these tools proliferate, they are poised to democratize access to multi-agent system development across diverse sectors.\\n\\n### References\\n1. Dibia, V., Chen, J., Bansal, G., Syed, S., Fourney, A., Zhu, E., Wang, C., & Amershi, S. (2024). AutoGen Studio: A No-Code Developer Tool for Building and Debugging Multi-Agent Systems. arXiv. [Available here](http://arxiv.org/pdf/2408.15247v1).\\n2. Huang, Y. (2024). Levels of AI Agents: from Rules to Large Language Models. arXiv. [Available here](http://arxiv.org/pdf/2405.06643v1).\\n3. Zhou, X., Kim, H., Brahman, F., Jiang, L., Zhu, H., Lu, X., Xu, F., Lin, B. Y., Choi, Y., Mireshghallah, N., Bras, R. L., & Sap, M. (2024). HAICOSYSTEM: An Ecosystem for Sandboxing Safety Risks in Human-AI Interactions. arXiv. [Available here](http://arxiv.org/pdf/2409.16427v2).\\n4. Balachandar, N., Dieter, J., & Ramachandran, G. S. (2019). Collaboration of AI Agents via Cooperative Multi-Agent Deep Reinforcement Learning. arXiv. [Available here](http://arxiv.org/pdf/1907.00327v1).\\n5. Yao, M., Yin, Q., Yang, J., Yu, T., Shen, S., Zhang, J., Liang, B., & Huang, K. (2021). The Partially Observable Asynchronous Multi-Agent Cooperation Challenge. arXiv. [Available here](http://arxiv.org/pdf/2112.03809v1).\\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(participants=[google_search_agent, arxiv_search_agent, report_agent])\n", + "\n", + "result = await team.run(task=\"Write a literature review on no code tools for building multi agent ai systems\")\n", + "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/travel-planning.ipynb b/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/travel-planning.ipynb new file mode 100644 index 000000000000..3ff954b25565 --- /dev/null +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/examples/travel-planning.ipynb @@ -0,0 +1,223 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Travel Planning \n", + "\n", + "In this example, we'll walk through the process of creating a sophisticated travel planning system using AgentChat. Our travel planner will utilize multiple AI agents, each with a specific role, to collaboratively create a comprehensive travel itinerary. \n", + "\n", + "First, let us import the necessary modules." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from autogen_agentchat.agents import CodingAssistantAgent\n", + "from autogen_agentchat.teams.group_chat import RoundRobinGroupChat\n", + "from autogen_core.components.models import OpenAIChatCompletionClient" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining Agents \n", + "\n", + "In the next section we will define the agents that will be used in the travel planning team." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "planner_agent = CodingAssistantAgent(\n", + " \"planner_agent\",\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4\"),\n", + " description=\"A helpful assistant that can plan trips.\",\n", + " system_message=\"You are a helpful assistant that can suggest a travel plan for a user based on their request.\",\n", + ")\n", + "\n", + "local_agent = CodingAssistantAgent(\n", + " \"local_agent\",\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4\"),\n", + " description=\"A local assistant that can suggest local activities or places to visit.\",\n", + " system_message=\"You are a helpful assistant that can suggest authentic and interesting local activities or places to visit for a user and can utilize any context information provided.\",\n", + ")\n", + "\n", + "language_agent = CodingAssistantAgent(\n", + " \"language_agent\",\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4\"),\n", + " description=\"A helpful assistant that can provide language tips for a given destination.\",\n", + " system_message=\"You are a helpful assistant that can review travel plans, providing feedback on important/critical tips about how best to address language or communication challenges for the given destination. If the plan already includes language tips, you can mention that the plan is satisfactory, with rationale.\",\n", + ")\n", + "\n", + "travel_summary_agent = CodingAssistantAgent(\n", + " \"travel_summary_agent\",\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4\"),\n", + " description=\"A helpful assistant that can summarize the travel plan.\",\n", + " system_message=\"You are a helpful assistant that can take in all of the suggestions and advice from the other agents and provide a detailed tfinal travel plan. You must ensure th b at the final plan is integrated and complete. YOUR FINAL RESPONSE MUST BE THE COMPLETE PLAN. When the plan is complete and all perspectives are integrated, you can respond with TERMINATE.\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--------------------------------------------------------------------------------\n", + "user:\n", + "Plan a 3 day trip to Nepal.\n", + "--------------------------------------------------------------------------------\n", + "planner_agent:\n", + "Day 1: Arrival and Sightseeing in Kathmandu\n", + "\n", + "Start your trip upon arrival at Tribhuvan International Airport in Kathmandu. After checking into a hotel, head off for sightseeing in Kathmandu, the cultural heart of Nepal.\n", + "\n", + "First, visit Kathmandu Durbar Square, a UNESCO World Heritage Site. This square is filled with ancient architecture, temples, and has an old Royal Palace site.\n", + "\n", + "Next, make your way to Swayambhunath Stupa (Monkey Temple), perched on a hilltop with panoramic views of Kathmandu city. \n", + "\n", + "In the evening, visit Thamel, a bustling district known for its shops, food stalls, and nightlife. Enjoy local Nepali cuisine for dinner to experience the local flavors.\n", + "\n", + "Day 2: Explore Bhaktapur and Patan\n", + "\n", + "Take a scenic drive to Bhaktapur, the city of devotees. Start with Bhaktapur Durbar Square, another UNESCO World Heritage Site, and then explore the local pottery square where traditional ceramics are made.\n", + "\n", + "Then, head to Patan city, renowned for its vibrant arts and crafts tradition. Visit Patan Durbar Square, marvel at its architectural brilliance and learn about the unique mix of Buddhism and Hinduism in Nepal.\n", + "\n", + "Day 3: Visit Pokhara\n", + "\n", + "On your final day, take a domestic flight or a scenic 6-hour drive to Pokhara from Kathmandu. Pokhara is known for its stunning landscapes, charming water body - the Phewa lake, and the Himalayan range including the Annapurna massif.\n", + "\n", + "Swing by the charming Lakeside market for some shopping, savor a relaxing boat ride in Phewa lake and visit the Tal Barahi Temple located in the center of the lake. Take the opportunity to visit Davis Falls, a unique waterfall that directly goes into a narrow and deep tunnel leading into a few kilometers long cave.\n", + "\n", + "Please note that this is just a skeletal plan and actual trip might have variances based on your flight timings, weather, and local conditions.\n", + "\n", + "Don't forget to carry essentials like warm clothing (especially if you're visiting in winters), toiletries, good quality trekking shoes; and remember to check about any visa or entry requirements. ALWAYS respect local customs and traditions when visiting religious places.\n", + "\n", + "Please talk to local travel operators for transport, guide, and tickets to various tourist and heritage spots. Enjoy your trip!\n", + "--------------------------------------------------------------------------------\n", + "local_agent:\n", + "Day 1: Arrival and Sightseeing in Kathmandu\n", + "\n", + "Start your trip upon arrival at Tribhuvan International Airport in Kathmandu. After checking into a hotel, head off for sightseeing in Kathmandu, the cultural heart of Nepal.\n", + "\n", + "First, visit Kathmandu Durbar Square, a UNESCO World Heritage Site. This square is filled with ancient architecture, temples, and has an old Royal Palace site.\n", + "\n", + "Next, make your way to Swayambhunath Stupa (Monkey Temple), perched on a hilltop with panoramic views of Kathmandu city. \n", + "\n", + "In the evening, visit Thamel, a bustling district known for its shops, food stalls, and nightlife. Enjoy local Nepali cuisine for dinner to experience the local flavors.\n", + "\n", + "Day 2: Explore Bhaktapur and Patan\n", + "\n", + "Take a scenic drive to Bhaktapur, the city of devotees. Start with Bhaktapur Durbar Square, another UNESCO World Heritage Site, and then explore the local pottery square where traditional ceramics are made.\n", + "\n", + "Then, head to Patan city, renowned for its vibrant arts and crafts tradition. Visit Patan Durbar Square, marvel at its architectural brilliance and learn about the unique mix of Buddhism and Hinduism in Nepal.\n", + "\n", + "Day 3: Visit Pokhara\n", + "\n", + "On your final day, take a domestic flight or a scenic 6-hour drive to Pokhara from Kathmandu. Pokhara is known for its stunning landscapes, charming water body - the Phewa lake, and the Himalayan range including the Annapurna massif.\n", + "\n", + "Swing by the charming Lakeside market for some shopping, savor a relaxing boat ride in Phewa lake and visit the Tal Barahi Temple located in the center of the lake. Take the opportunity to visit Davis Falls, a unique waterfall that directly goes into a narrow and deep tunnel leading into a few kilometers long cave.\n", + "\n", + "Please note that this is just a skeletal plan and actual trip might have variances based on your flight timings, weather, and local conditions.\n", + "\n", + "Don't forget to carry essentials like warm clothing (especially if you're visiting in winters), toiletries, good quality trekking shoes; and remember to check about any visa or entry requirements. ALWAYS respect local customs and traditions when visiting religious places.\n", + "\n", + "Please talk to local travel operators for transport, guide, and tickets to various tourist and heritage spots. Enjoy your trip!\n", + "--------------------------------------------------------------------------------\n", + "language_agent:\n", + "Looking at your plan, it seems very detailed and well-thought-out. However, you have not addressed the critical language or communication aspect of travelling in Nepal. Here are some points to add:\n", + "\n", + "1. The official language of Nepal is Nepali and is spoken by a majority of the population. English is also commonly understood and spoken in urban areas and tourist centres, but do not expect everyone to be fluent or comfortable communicating in English.\n", + "\n", + "2. Before your trip, it might be worth learning a few basic Nepali words or phrases. Things like \"hello\" or \"Namaste\" (greeting), \"dhanyabad\" (thank you), or \"kati ho?\" (how much?) can go a long way.\n", + "\n", + "3. Consider bringing a pocket-sized Nepali phrasebook or downloading a language app on your phone for translation assistance when needed.\n", + "\n", + "4. For guided tours or when hiring taxis, ensure to hire English-speaking guides or drivers, which can usually be arranged through your hotel or local tourism agencies.\n", + "\n", + "By considering these language and communication tips, you can ensure that your trip is both enjoyable and easy to navigate.\n", + "--------------------------------------------------------------------------------\n", + "travel_summary_agent:\n", + "Day 1: Arrival and Kathmandu Sightseeing\n", + "\n", + "After landing at Tribhuvan International Airport, Kathmandu, move to your hotel for a quick refresh. Commence your tour with a visit to Kathmandu Durbar Square, a UNESCO World Heritage Site. Explore the historic architectures and temples here, along with the ancient Royal Palace.\n", + "\n", + "Proceed to Swayambhunath Stupa (Monkey Temple), situated on a hilltop with stunning views of the city. \n", + "\n", + "Afterwards, stroll through the bustling district of Thamel, known for shops and food stalls, and enjoy a dinner with local Nepali flavors.\n", + "\n", + "Day 2: Tour of Bhaktapur and Patan\n", + "\n", + "Embark on a scenic drive to Bhaktapur, often called the city of devotees. Spend your morning at Bhaktapur Durbar Square, another UNESCO World Heritage Site, and take some time to explore the local pottery square.\n", + "\n", + "In the afternoon, visit Patan City, known for its rich tradition of arts and crafts. Visit Patan Durbar Square, marvel at its architectural brilliance, and explore the confluence of Buddhism and Hinduism in Nepal.\n", + "\n", + "Day 3: Discover Pokhara\n", + "\n", + "On your final day, take a domestic flight or a 6-hour drive to Pokhara, a city renowned for its beautiful landscapes and the Phewa Lake overlooked by the towering Annapurna massif.\n", + "\n", + "Visit the lakeside market for shopping, enjoy a calming boat ride on Phewa Lake, and visit the Tal Barahi Temple in the middle of the lake. Conclude your tour with a visit to Davis Falls, a unique waterfall that flows directly into a deep, narrow tunnel.\n", + "\n", + "Please note:\n", + "\n", + "- This is just an indicative plan; actual trip might vary based on your flight timings, weather, and local conditions.\n", + "- Don't forget to pack essentials such as warm clothing (especially for winters), toiletries, and sturdy trekking shoes. Prioritize checking visa or entry requirements, if any.\n", + "- Always respect local customs and traditions, specifically when visiting religious places.\n", + "- Consult with local travel operators for transportation, travel guides, and tickets to heritage spots.\n", + "\n", + "Language Tips:\n", + "\n", + "- The official language is Nepali. English is generally understood and spoken in urban areas and by people associated with tourism, but do not anticipate everyone to be fluent.\n", + "- Familiarize yourself with basic Nepali phrases like \"Namaste\" (Hello), \"Dhanyabad\" (Thank you), \"Kati Ho?\" (How much?), etc.\n", + "- Consider carrying a Nepali phrasebook or installing a language translation app.\n", + "- For guided tours or taxis, hire English-speaking guides or drivers. This can be arranged through your hotel or local tourism agencies. \n", + "\n", + "Enjoy your trip! \n", + "\n", + "TERMINATE\n", + "TeamRunResult(messages=[TextMessage(source='user', content='Plan a 3 day trip to Nepal.'), TextMessage(source='planner_agent', content=\"Day 1: Arrival and Sightseeing in Kathmandu\\n\\nStart your trip upon arrival at Tribhuvan International Airport in Kathmandu. After checking into a hotel, head off for sightseeing in Kathmandu, the cultural heart of Nepal.\\n\\nFirst, visit Kathmandu Durbar Square, a UNESCO World Heritage Site. This square is filled with ancient architecture, temples, and has an old Royal Palace site.\\n\\nNext, make your way to Swayambhunath Stupa (Monkey Temple), perched on a hilltop with panoramic views of Kathmandu city. \\n\\nIn the evening, visit Thamel, a bustling district known for its shops, food stalls, and nightlife. Enjoy local Nepali cuisine for dinner to experience the local flavors.\\n\\nDay 2: Explore Bhaktapur and Patan\\n\\nTake a scenic drive to Bhaktapur, the city of devotees. Start with Bhaktapur Durbar Square, another UNESCO World Heritage Site, and then explore the local pottery square where traditional ceramics are made.\\n\\nThen, head to Patan city, renowned for its vibrant arts and crafts tradition. Visit Patan Durbar Square, marvel at its architectural brilliance and learn about the unique mix of Buddhism and Hinduism in Nepal.\\n\\nDay 3: Visit Pokhara\\n\\nOn your final day, take a domestic flight or a scenic 6-hour drive to Pokhara from Kathmandu. Pokhara is known for its stunning landscapes, charming water body - the Phewa lake, and the Himalayan range including the Annapurna massif.\\n\\nSwing by the charming Lakeside market for some shopping, savor a relaxing boat ride in Phewa lake and visit the Tal Barahi Temple located in the center of the lake. Take the opportunity to visit Davis Falls, a unique waterfall that directly goes into a narrow and deep tunnel leading into a few kilometers long cave.\\n\\nPlease note that this is just a skeletal plan and actual trip might have variances based on your flight timings, weather, and local conditions.\\n\\nDon't forget to carry essentials like warm clothing (especially if you're visiting in winters), toiletries, good quality trekking shoes; and remember to check about any visa or entry requirements. ALWAYS respect local customs and traditions when visiting religious places.\\n\\nPlease talk to local travel operators for transport, guide, and tickets to various tourist and heritage spots. Enjoy your trip!\"), TextMessage(source='local_agent', content=\"Day 1: Arrival and Sightseeing in Kathmandu\\n\\nStart your trip upon arrival at Tribhuvan International Airport in Kathmandu. After checking into a hotel, head off for sightseeing in Kathmandu, the cultural heart of Nepal.\\n\\nFirst, visit Kathmandu Durbar Square, a UNESCO World Heritage Site. This square is filled with ancient architecture, temples, and has an old Royal Palace site.\\n\\nNext, make your way to Swayambhunath Stupa (Monkey Temple), perched on a hilltop with panoramic views of Kathmandu city. \\n\\nIn the evening, visit Thamel, a bustling district known for its shops, food stalls, and nightlife. Enjoy local Nepali cuisine for dinner to experience the local flavors.\\n\\nDay 2: Explore Bhaktapur and Patan\\n\\nTake a scenic drive to Bhaktapur, the city of devotees. Start with Bhaktapur Durbar Square, another UNESCO World Heritage Site, and then explore the local pottery square where traditional ceramics are made.\\n\\nThen, head to Patan city, renowned for its vibrant arts and crafts tradition. Visit Patan Durbar Square, marvel at its architectural brilliance and learn about the unique mix of Buddhism and Hinduism in Nepal.\\n\\nDay 3: Visit Pokhara\\n\\nOn your final day, take a domestic flight or a scenic 6-hour drive to Pokhara from Kathmandu. Pokhara is known for its stunning landscapes, charming water body - the Phewa lake, and the Himalayan range including the Annapurna massif.\\n\\nSwing by the charming Lakeside market for some shopping, savor a relaxing boat ride in Phewa lake and visit the Tal Barahi Temple located in the center of the lake. Take the opportunity to visit Davis Falls, a unique waterfall that directly goes into a narrow and deep tunnel leading into a few kilometers long cave.\\n\\nPlease note that this is just a skeletal plan and actual trip might have variances based on your flight timings, weather, and local conditions.\\n\\nDon't forget to carry essentials like warm clothing (especially if you're visiting in winters), toiletries, good quality trekking shoes; and remember to check about any visa or entry requirements. ALWAYS respect local customs and traditions when visiting religious places.\\n\\nPlease talk to local travel operators for transport, guide, and tickets to various tourist and heritage spots. Enjoy your trip!\"), TextMessage(source='language_agent', content='Looking at your plan, it seems very detailed and well-thought-out. However, you have not addressed the critical language or communication aspect of travelling in Nepal. Here are some points to add:\\n\\n1. The official language of Nepal is Nepali and is spoken by a majority of the population. English is also commonly understood and spoken in urban areas and tourist centres, but do not expect everyone to be fluent or comfortable communicating in English.\\n\\n2. Before your trip, it might be worth learning a few basic Nepali words or phrases. Things like \"hello\" or \"Namaste\" (greeting), \"dhanyabad\" (thank you), or \"kati ho?\" (how much?) can go a long way.\\n\\n3. Consider bringing a pocket-sized Nepali phrasebook or downloading a language app on your phone for translation assistance when needed.\\n\\n4. For guided tours or when hiring taxis, ensure to hire English-speaking guides or drivers, which can usually be arranged through your hotel or local tourism agencies.\\n\\nBy considering these language and communication tips, you can ensure that your trip is both enjoyable and easy to navigate.'), StopMessage(source='travel_summary_agent', content='Day 1: Arrival and Kathmandu Sightseeing\\n\\nAfter landing at Tribhuvan International Airport, Kathmandu, move to your hotel for a quick refresh. Commence your tour with a visit to Kathmandu Durbar Square, a UNESCO World Heritage Site. Explore the historic architectures and temples here, along with the ancient Royal Palace.\\n\\nProceed to Swayambhunath Stupa (Monkey Temple), situated on a hilltop with stunning views of the city. \\n\\nAfterwards, stroll through the bustling district of Thamel, known for shops and food stalls, and enjoy a dinner with local Nepali flavors.\\n\\nDay 2: Tour of Bhaktapur and Patan\\n\\nEmbark on a scenic drive to Bhaktapur, often called the city of devotees. Spend your morning at Bhaktapur Durbar Square, another UNESCO World Heritage Site, and take some time to explore the local pottery square.\\n\\nIn the afternoon, visit Patan City, known for its rich tradition of arts and crafts. Visit Patan Durbar Square, marvel at its architectural brilliance, and explore the confluence of Buddhism and Hinduism in Nepal.\\n\\nDay 3: Discover Pokhara\\n\\nOn your final day, take a domestic flight or a 6-hour drive to Pokhara, a city renowned for its beautiful landscapes and the Phewa Lake overlooked by the towering Annapurna massif.\\n\\nVisit the lakeside market for shopping, enjoy a calming boat ride on Phewa Lake, and visit the Tal Barahi Temple in the middle of the lake. Conclude your tour with a visit to Davis Falls, a unique waterfall that flows directly into a deep, narrow tunnel.\\n\\nPlease note:\\n\\n- This is just an indicative plan; actual trip might vary based on your flight timings, weather, and local conditions.\\n- Don\\'t forget to pack essentials such as warm clothing (especially for winters), toiletries, and sturdy trekking shoes. Prioritize checking visa or entry requirements, if any.\\n- Always respect local customs and traditions, specifically when visiting religious places.\\n- Consult with local travel operators for transportation, travel guides, and tickets to heritage spots.\\n\\nLanguage Tips:\\n\\n- The official language is Nepali. English is generally understood and spoken in urban areas and by people associated with tourism, but do not anticipate everyone to be fluent.\\n- Familiarize yourself with basic Nepali phrases like \"Namaste\" (Hello), \"Dhanyabad\" (Thank you), \"Kati Ho?\" (How much?), etc.\\n- Consider carrying a Nepali phrasebook or installing a language translation app.\\n- For guided tours or taxis, hire English-speaking guides or drivers. This can be arranged through your hotel or local tourism agencies. \\n\\nEnjoy your trip! \\n\\nTERMINATE')])\n" + ] + } + ], + "source": [ + "group_chat = RoundRobinGroupChat([planner_agent, local_agent, language_agent, travel_summary_agent])\n", + "result = await group_chat.run(task=\"Plan a 3 day trip to Nepal.\")\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/guides/quickstart.ipynb b/python/packages/autogen-core/docs/src/agentchat-user-guide/guides/code-execution.ipynb similarity index 99% rename from python/packages/autogen-core/docs/src/agentchat-user-guide/guides/quickstart.ipynb rename to python/packages/autogen-core/docs/src/agentchat-user-guide/guides/code-execution.ipynb index 8ba79ecbfcfe..845a70cabe9b 100644 --- a/python/packages/autogen-core/docs/src/agentchat-user-guide/guides/quickstart.ipynb +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/guides/code-execution.ipynb @@ -4,7 +4,10 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Quick Start\n", + "# Code Execution\n", + "\n", + "\n", + "AgentChat offers a `CodeExecutorAgent` agent that can execute code in messages it receives. \n", "\n", ":::{note}\n", "See [here](pkg-info-autogen-agentchat) for installation instructions.\n", 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 1c2543052825..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 @@ -1,118 +1,236 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Tool Use\n", - "\n", - ":::{note}\n", - "See [here](pkg-info-autogen-agentchat) for installation instructions.\n", - ":::\n", - "\n", - ":::{warning}\n", - "🚧 Under construction 🚧\n", - ":::" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "from autogen_agentchat.agents import 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": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "async def get_weather(city: str) -> str:\n", - " return \"Sunny\"\n", - "\n", - "\n", - "get_weather_tool = FunctionTool(get_weather, description=\"Get the weather for a city\")" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tool Use\n", + "\n", + "The `AgentChat` api provides a `ToolUseAssistantAgent` with presets for adding tools that the agent can call as part of it's response. \n", + "\n", + ":::{note}\n", + "\n", + "The example presented here is a work in progress 🚧. Also, tool uses here assumed the `model_client` used by the agent supports tool calling. \n", + "::: " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from autogen_agentchat.agents import 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": [ + "In AgentChat, a Tool is a function wrapped in the `FunctionTool` class exported from `autogen_core.components.tools`. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "async def get_weather(city: str) -> str:\n", + " return f\"The weather in {city} is 72 degrees and Sunny.\"\n", + "\n", + "\n", + "get_weather_tool = FunctionTool(get_weather, description=\"Get the weather for a city\")" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "--------------------------------------------------------------------------- \n", - "\u001b[91m[2024-10-04T17:59:55.737430]:\u001b[0m\n", - "\n", - "What's the weather in New York?\n", - "From: user" - ] + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, agents that use tools are defined in the following manner. \n", + "\n", + "- An agent is instantiated based on the `ToolUseAssistantAgent` class in AgentChat. The agent is aware of the tools it can use by passing a `tools_schema` attribute to the class, which is passed to the `model_client` when the agent generates a response.\n", + "- An agent Team is defined that takes a list of `tools`. Effectively, the `ToolUseAssistantAgent` can generate messages that call tools, and the team is responsible executing those tool calls and returning the results." + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "--------------------------------------------------------------------------- \n", - "\u001b[91m[2024-10-04T17:59:56.310787], Weather_Assistant:\u001b[0m\n", - "\n", - "[FunctionCall(id='call_zxmdHPEQ1QMd2NwvYUSgxxDV', 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", - "\n", - "[FunctionExecutionResult(content='Sunny', call_id='call_zxmdHPEQ1QMd2NwvYUSgxxDV')]\n", - "From: tool_agent_for_Weather_Assistant\n", - "--------------------------------------------------------------------------- \n", - "\u001b[91m[2024-10-04T17:59:56.767874], Weather_Assistant:\u001b[0m\n", - "\n", - "The weather in New York is sunny. \n", - "\n", - "TERMINATE\n", - "From: Weather_Assistant" - ] + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:50:13.202461]:\u001b[0m\n", + "\n", + "What's the weather in New York?\n", + "From: user\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:50:14.090696], Weather_Assistant:\u001b[0m\n", + "\n", + "[FunctionCall(id='call_wqkaIBdYjWklWG0GQkYz7FZ0', arguments='{\"city\":\"New York\"}', name='get_weather')]\n", + "From: Weather_Assistant\n", + "--------------------------------------------------------------------------- \n", + "\u001b[91m[2024-10-08T09:50:14.092050], tool_agent_for_Weather_Assistant:\u001b[0m\n", + "\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-08T09:50:14.714470], Weather_Assistant:\u001b[0m\n", + "\n", + "The weather in New York is 72 degrees and sunny. \n", + "\n", + "TERMINATE\n", + "From: Weather_Assistant" + ] + } + ], + "source": [ + "assistant = ToolUseAssistantAgent(\n", + " \"Weather_Assistant\",\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", + " registered_tools=[get_weather_tool],\n", + ")\n", + "team = RoundRobinGroupChat([assistant])\n", + "result = await team.run(\"What's the weather in New York?\")\n", + "# print(result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using Langchain Tools \n", + "\n", + "AutoGen also provides direct support for tools from LangChain via the `autogen_ext` package.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# pip install langchain, langchain-community, wikipedia , autogen-ext\n", + "\n", + "from autogen_ext.tools.langchain import LangChainToolAdapter\n", + "from langchain.tools import WikipediaQueryRun\n", + "from langchain_community.utilities import WikipediaAPIWrapper\n", + "\n", + "api_wrapper = WikipediaAPIWrapper(top_k_results=1, doc_content_chars_max=100)\n", + "tool = WikipediaQueryRun(api_wrapper=api_wrapper)\n", + "\n", + "langchain_wikipedia_tool = LangChainToolAdapter(tool)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\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" + ] + } + ], + "source": [ + "wikipedia_assistant = ToolUseAssistantAgent(\n", + " \"WikiPedia_Assistant\",\n", + " model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", + " registered_tools=[langchain_wikipedia_tool],\n", + ")\n", + "team = RoundRobinGroupChat([wikipedia_assistant])\n", + "result = await team.run(\"Who was the first president of the United States?\")\n", + "\n", + "# print(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" } - ], - "source": [ - "assistant = ToolUseAssistantAgent(\n", - " \"Weather_Assistant\",\n", - " model_client=OpenAIChatCompletionClient(model=\"gpt-4o-mini\"),\n", - " registered_tools=[get_weather_tool],\n", - ")\n", - "team = RoundRobinGroupChat([assistant])\n", - "result = await team.run(\"What's the weather in New York?\")\n", - "# print(result)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": ".venv", - "language": "python", - "name": "python3" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 + "nbformat": 4, + "nbformat_minor": 2 } 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 f4f12a3db1bc..bf35017413eb 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 @@ -2,21 +2,59 @@ myst: html_meta: "description lang=en": | - User Guide for AutoGen AgentChat, a framework for building multi-agent applications with AI agents. + User Guide for AgentChat, a high-level api for AutoGen --- # AgentChat -```{warning} -🚧 Under construction 🚧 +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: + +- `CodingAssistantAgent` - Generates responses using an LLM on receipt of a message +- `CodeExecutionAgent` - Extracts and executes code snippets found in received messages and returns the output +- `ToolUseAssistantAgent` - Responds with tool call messages based on received messages and a list of tool schemas provided at initialization + +## Teams + +Teams define how groups of agents communicate to address tasks. The following Teams are currently supported: + +- `RoundRobinGroupChat` - A team where agents take turns sending messages (in a round robin fashion) until a termination condition is met +- `SelectorGroupChat` - A team where a model is used to select the next agent to send a message based on the current conversation history. + ```{toctree} :caption: Getting Started -:maxdepth: 1 +:maxdepth: 2 :hidden: -guides/quickstart +quickstart + +``` + +```{toctree} +:caption: Guides +:maxdepth: 2 +:hidden: + +guides/code-execution guides/tool_use guides/selector-group-chat + +``` + +```{toctree} +:caption: Examples +:maxdepth: 3 +:hidden: + +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 new file mode 100644 index 000000000000..973100a51200 --- /dev/null +++ b/python/packages/autogen-core/docs/src/agentchat-user-guide/quickstart.md @@ -0,0 +1,45 @@ +--- +myst: + 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. + +## Installation + +Install the `autogen-agentchat` package using pip: + +```bash + +pip install autogen-agentchat==0.4.0dev0 +``` + +:::{note} +For further installation instructions, please refer to the [package information](pkg-info-autogen-agentchat). +::: + +## Creating a Simple Agent Team + +The following example illustrates creating a simple agent team with two agents that interact to solve a task. + +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'." + +```{include} stocksnippet.md + +``` + +```{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. +``` + +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. +3. Configuration in v0.4x is more modular, with separate components for code execution and LLM clients. 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 @@ + + + + + + + + + + + + + + + + + + + + +