diff --git a/genai-on-vertex-ai/agents/reasoning_engine/ag2/README.md b/genai-on-vertex-ai/agents/reasoning_engine/ag2/README.md
new file mode 100644
index 00000000..fac73cca
--- /dev/null
+++ b/genai-on-vertex-ai/agents/reasoning_engine/ag2/README.md
@@ -0,0 +1,35 @@
+# AG2 Multi-Agent Research Notebook on Vertex AI Reasoning Engine
+
+This notebook provides a practical demonstration of utilizing the AG2 (formerly Autogen) framework, a framework for developing and deploying multi-agent AI systems, with Vertex AI's Reasoning Engine to conduct collaborative research using multiple AI agents. This notebook demonstrates the following key features:
+
+## Functionality
+
+- **Multi-Agent Collaboration:** Creates a research team of specialized AI agents, including a Researcher, Data Analyst, Literature Reviewer, and Fact Checker. These agents work together using AG2's group chat functionality to efficiently conduct research and generate reports.
+
+- **Topic Customization:** Allows users to specify the research topic of interest, providing control over the scope and focus of the multi-agent investigation.
+
+- **Remote Deployment:** Leverages Vertex AI's Reasoning Engine for remote deployment and execution of the multi-agent application, ensuring scalability and resource management.
+
+- **Literature Review Generation:** Facilitates the generation of a comprehensive literature review based on the research conducted by the AI agents.
+
+- **Report Persistence:** Provides the option to save the generated literature review to a file for offline review, editing, and collaboration.
+
+## What This Notebook Covers
+
+1. **Environment Setup:** Guides users through installing the necessary dependencies, including AG2 and the Vertex AI SDK, as well as setting up authentication for Google Cloud access.
+
+2. **Configuration:** Explains and demonstrates the configuration of essential parameters, such as the Gemini model to use, project ID, storage bucket, caching seed, and location for deployment.
+
+3. **Topic Definition:** Shows how to specify the research topic for the multi-agent team, empowering users to tailor the research to their specific interests.
+
+4. **Deployment:** Provides instructions on deploying the multi-agent application to Vertex AI's Reasoning Engine for efficient and scalable execution.
+
+5. **Monitoring:** Guides users on how to monitor the deployment progress and status within the Google Cloud Platform (GCP) console.
+
+6. **Report Persistence:** Demonstrates how to save the generated literature review to a file for offline access and further analysis.
+
+This notebook serves as a valuable resource for understanding and implementing multi-agent research workflows with AG2 and deployed on Google Cloud's Vertex AI via the Reasoning Engine.
+
+[Link to Notebook](genai-on-vertex-ai/agents/reasoning_engine/ag2/ag2_on_reasoning_engine_via_vertex.ipynb)
+
+Explore the notebook and contribute to the project!
diff --git a/genai-on-vertex-ai/agents/reasoning_engine/ag2/ag2_on_reasoning_engine_via_vertex.ipynb b/genai-on-vertex-ai/agents/reasoning_engine/ag2/ag2_on_reasoning_engine_via_vertex.ipynb
new file mode 100644
index 00000000..2f453b21
--- /dev/null
+++ b/genai-on-vertex-ai/agents/reasoning_engine/ag2/ag2_on_reasoning_engine_via_vertex.ipynb
@@ -0,0 +1,856 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "z4UWyDywJ6tj"
+ },
+ "source": [
+ "# AG2 (formerly Autogen) Multi-Agents Example on Vertex AI Reasoning Engine\n",
+ "\n",
+ "\n",
+ " \n",
+ " \n",
+ " ![\"Google](\"https://www.gstatic.com/pantheon/images/bigquery/welcome_page/colab-logo.svg\")
Open in Colab\n",
+ " \n",
+ " | \n",
+ " \n",
+ " \n",
+ " ![\"Google](\"https://lh3.googleusercontent.com/JmcxdQi-qOpctIvWKgPtrzZdJJK-J3sWE1RsfjZNwshCFgE_9fULcNpuXYTilIR2hjwN\")
Open in Colab Enterprise\n",
+ " \n",
+ " | \n",
+ " \n",
+ " \n",
+ " ![\"Vertex](\"https://www.gstatic.com/images/branding/gcpiconscolors/vertexai/v1/32px.svg\")
Open in Vertex AI Workbench\n",
+ " \n",
+ " | \n",
+ " \n",
+ " \n",
+ " ![\"GitHub](\"https://upload.wikimedia.org/wikipedia/commons/9/91/Octicons-mark-github.svg\")
View on GitHub\n",
+ " \n",
+ " | \n",
+ "
\n",
+ "\n",
+ "\n",
+ "\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "Share to:\n",
+ "\n",
+ " ![\"LinkedIn](\"https://upload.wikimedia.org/wikipedia/commons/8/81/LinkedIn_icon.svg\")
\n",
+ "\n",
+ "\n",
+ "\n",
+ " ![\"Bluesky](\"https://upload.wikimedia.org/wikipedia/commons/7/7a/Bluesky_Logo.svg\")
\n",
+ "\n",
+ "\n",
+ "\n",
+ " ![\"X](\"https://upload.wikimedia.org/wikipedia/commons/5/53/X_logo_2023_original.svg\")
\n",
+ "\n",
+ "\n",
+ "\n",
+ " ![\"Reddit](\"https://redditinc.com/hubfs/Reddit%20Inc/Brand/Reddit_Logo.png\")
\n",
+ "\n",
+ "\n",
+ "\n",
+ " ![\"Facebook](\"https://upload.wikimedia.org/wikipedia/commons/5/51/Facebook_f_logo_%282019%29.svg\")
\n",
+ "\n",
+ "\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "
\n",
+ "\n",
+ "| | |\n",
+ "|-|-|\n",
+ "| Author(s) | [Emmanuel Awa](https://github.com/awaemmanuel)|\n",
+ "| Reviewer(s) | Turan Bulmus, [Rajesh Thallam](https://github.com/rthallam)|\n",
+ "| Last updated | 2024 12 19: Review |\n",
+ "| | 2024 12 20: Initial Publication|\n",
+ "\n",
+ "This notebook showcases how to deploy [AG2](https://ag2.ai/) on Vertex AI through [Reasoning Engine API](https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/reasoning-engine). AG2 (formerly AutoGen) is an open-source framework for building AI agents that can collaborate to solve tasks. It simplifies agent development, supports LLMs and tools, and enables various workflows, making it suitable for building multiagent applications on Vertex AI.\n",
+ "\n",
+ "\n",
+ "### **Limitations**\n",
+ "\n",
+ "- The Reasoning Engine API only supports Python orchestration frameworks.\n",
+ "- The Reasoning Engine API is only supported in the `us-central1` region."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "VyKi7eTEgVwk"
+ },
+ "source": [
+ "## Prerequisites\n",
+ "In other to run this notebook, you will need to set up your Google Cloud project and enable the Vertex AI API. \n",
+ "\n",
+ "1. [Select or create a Google Cloud project](https://console.cloud.google.com/cloud-resource-manager).\n",
+ "1. [Make sure that billing is enabled for your project](https://cloud.google.com/billing/docs/how-to/modify-project).\n",
+ "1. [Enable the Service Usage API](https://console.cloud.google.com/apis/library/serviceusage.googleapis.com)\n",
+ "1. [Enable the Vertex AI API](https://console.cloud.google.com/flows/enableapi?apiid=aiplatform.googleapis.com).\n",
+ "1. [Enable Logs Explorer](https://console.cloud.google.com/logs/query;query=resource.type%3D%22aiplatform.googleapis.com%2FReasoningEngine%22)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "7NX_Q-pOqMRi"
+ },
+ "source": [
+ "## Step 1: Environment Setup: GCP and Ag2"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "6M7rdk_jw2bq"
+ },
+ "source": [
+ "\n",
+ "Next, we need to first install AG2 with Gemini features."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "Jv4YSAecekxA"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Install Ag2/Dependencies\n",
+ "!pip install autogen-agentchat[gemini]~=0.2 chromadb markdownify pypdf dask[dataframe] --quiet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "1LCcbgeYqXx6"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Install/Upgrade Vertex AI SDK - Restart Runtime (If needed)\n",
+ "def install_or_upgrade_vertex_ai():\n",
+ " package_name = \"google-cloud-aiplatform\"\n",
+ " required_version = \"1.73.0\"\n",
+ "\n",
+ " try:\n",
+ " import google.cloud.aiplatform as aiplatform\n",
+ " installed_version = aiplatform.__version__\n",
+ "\n",
+ " if installed_version < required_version:\n",
+ " print(f\"Upgrading {package_name} from version {installed_version} to {required_version}...\")\n",
+ " !pip install google-cloud-aiplatform --upgrade --quiet --user\n",
+ " print(f\"Successfully upgraded {package_name}.\")\n",
+ " restart_runtime()\n",
+ " else:\n",
+ " print(f\"{package_name} is already installed with version {installed_version}.\")\n",
+ " except ImportError:\n",
+ " print(f\"{package_name} is not installed. Installing version {required_version}...\")\n",
+ " !pip install google-cloud-aiplatform --upgrade --quiet --user\n",
+ " print(f\"Successfully installed {package_name}.\")\n",
+ " restart_runtime()\n",
+ "\n",
+ "def restart_runtime():\n",
+ " import IPython\n",
+ "\n",
+ " print('The kernel is going to restart. In Colab or Colab Enterprise, you might see an error message that says \"Your session crashed for an unknown reason.\" This is expected.')\n",
+ " print('Once the runtime is restarted you can continue running individual cells or run the entire notebook with the \"Run all\" command.')\n",
+ " IPython.Application.instance().kernel.do_shutdown(True)\n",
+ "\n",
+ "install_or_upgrade_vertex_ai()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "txTCLHoghI2F"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Import relevant packages\n",
+ "import sys\n",
+ "import pprint\n",
+ "import vertexai\n",
+ "from google.colab import auth\n",
+ "from vertexai.preview import reasoning_engines\n",
+ "from vertexai.preview.reasoning_engines import ReasoningEngine, Queryable\n",
+ "\n",
+ "from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager\n",
+ "from autogen.cache import Cache\n",
+ "from autogen.code_utils import content_str\n",
+ "\n",
+ "print('Required libraries successfully imported.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "8yfWpe5Nctnb"
+ },
+ "source": [
+ "### Authentication \n",
+ "\n",
+ "If you're using Colab, run the code in the next cell. Follow the popups and authenticate with an account that has access to your Google Cloud [project](https://cloud.google.com/resource-manager/docs/creating-managing-projects#identifying_projects).\n",
+ "\n",
+ "If you're running this notebook somewhere besides Colab, make sure your environment has the right Google Cloud access. If that's a new concept to you, consider looking into [Application Default Credentials for your local environment](https://cloud.google.com/docs/authentication/provide-credentials-adc#local-dev) and [initializing the Google Cloud CLI](https://cloud.google.com/docs/authentication/gcloud).\n",
+ "\n",
+ "In many cases, running `gcloud auth application-default login` in a shell on the machine running the notebook kernel is sufficient.\n",
+ "\n",
+ "More authentication options are discussed [here](https://cloud.google.com/docs/authentication)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "rPZA1RYSj0Vs"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Authenticate - Google Colab Only\n",
+ "if \"google.colab.auth\" in sys.modules:\n",
+ " auth.authenticate_user()\n",
+ " print(\"Authenticated\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "UmnZKKAnxHz6"
+ },
+ "source": [
+ "### Configuration Parameters\n",
+ "\n",
+ "Before proceeding, you need to define the following parameters:\n",
+ "\n",
+ "1. **`MODEL`**: Specifies the Gemini model to utilize for the multi-agent conversation. Choose from available options such as `gemini-2.0-flash`, `gemini-1.5-flash`, `gemini-1.5-pro`, or `gemini-1.0-pro`.\n",
+ "2. **`PROJECT_ID`**: Identifies the Google Cloud project where the executions will occur.\n",
+ "3. **`STAGING_BUCKET`**: Designates a Google Cloud Storage bucket that you own and have write access to. This bucket will be used for temporary storage during the execution process. Bucket name must begin with `gs://`\n",
+ "4. **`CACHING_SEED`**: Provides an integer value for best-effort deterministic sampling. Note that determinism is not guaranteed.\n",
+ "5. **`LOCATION`**: Indicates the Google Cloud region for the deployment. Currently, Reasoning Engine is only supported in `us-central1`.\n",
+ "\n",
+ "These parameters will be employed to configure the `Ag2` framework and set up the remote deployment environment for the Reasoning Engine."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "-eVuRe2efbnj"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Set Configuration Parameters\n",
+ "MODEL_NAME = 'gemini-1.5-flash' # @param ['gemini-2.0-flash-exp', 'gemini-1.5-flash', 'gemini-1.5-pro', 'gemini-1.0-pro']\n",
+ "PROJECT_ID = '[your-project-id-here]' # @param {'type': 'string'}\n",
+ "STAGING_BUCKET = 'gs://[your-gcs-bucket-name-here]' # @param {'type': 'string'}\n",
+ "CACHING_SEED = 42 # @param {'type': 'integer'}\n",
+ "LOCATION = 'us-central1'\n",
+ "\n",
+ "STAGING_BUCKET = STAGING_BUCKET if STAGING_BUCKET.startswith('gs://') else f'gs://{STAGING_BUCKET}'\n",
+ "\n",
+ "config_list = [{\n",
+ " 'model': MODEL_NAME,\n",
+ " 'project_id': PROJECT_ID,\n",
+ " 'location': LOCATION,\n",
+ " 'api_type': 'google',\n",
+ "}]\n",
+ "seed = CACHING_SEED\n",
+ "all_config = {\n",
+ " 'Gemini Configuration': config_list,\n",
+ " 'Caching Seed': seed,\n",
+ " 'Staging_Bucket': STAGING_BUCKET,\n",
+ "}\n",
+ "print('Configuration:')\n",
+ "pprint.pprint(all_config)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "30HHGyoChnay"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Initialize Vertex AI\n",
+ "vertexai.init(project=PROJECT_ID, location=LOCATION, staging_bucket=STAGING_BUCKET)\n",
+ "print('Vertex AI successfully initialized')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "TOPhtR7tfYls"
+ },
+ "source": [
+ "## Step 2: An Ag2 Example of Multi-Agent Conversations\n",
+ "\n",
+ "AG2 supports multi-agent collaboration through a conversational pattern called **group chat**. This general pattern shares characteristics with known multi-agent patterns like **Router Agent (one-by-one)**, where a central agent delegates tasks sequentially, and **Dynamic (all-to-all)**, where agents communicate freely.\n",
+ "\n",
+ "However, Ag2's `GroupChat` offers a distinct approach. A `GroupChatManager` orchestrates the conversation by selecting a speaker, broadcasting their message, and repeating the process. While not strictly sequential like a Router, the manager guides the flow depending on the strategy the user chooses.\n",
+ "\n",
+ "Unlike a purely Dynamic system, the manager provides a degree of control, preventing chaotic interactions. Agent selection strategies include: `round_robin`, `random`, `manual`, and the default `auto` (based on the manager's llm configuration). We have choosen the `auto` mode to allow Gemini's reasoning ability decide who the next speaker should be.\n",
+ "\n",
+ "This example showcases a research-focused group chat with five agents:\n",
+ "\n",
+ "* **Researcher:** Conducts research and identifies key information.\n",
+ "* **Data Analyst:** Analyzes data and extracts insights.\n",
+ "* **Literature Reviewer:** Synthesizes research into a literature review.\n",
+ "* **Fact Checker:** Verifies information accuracy.\n",
+ "* **User Proxy:** Represents the user, initiates the conversation, and can execute code.\n",
+ "\n",
+ "These agents reside in a `GroupChat` orchestrated by a `GroupChatManager` using the `auto` strategy. The `User_proxy` initiates the collaborative research workflow.\n",
+ "\n",
+ "The diagram below shows the `GroupChatManager` workflow.\n",
+ "\n",
+ "> **NOTE:** If the image is not legible, please right click and view in new tab"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "71UX5MQMGjhR"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "CbqXfcfi5Zsm"
+ },
+ "source": [
+ "**Defining the Research Topic**\n",
+ "\n",
+ "This section allows you to specify the topic of interest for the multi-agent research team. By default, the agents will focus on \"Large Language Models.\" However, you can customize the research topic by modifying the `topic` below:\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "_-rGbQxQ5J8L"
+ },
+ "outputs": [],
+ "source": [
+ "research_topic = \"Large Language Models\" # @param [\"Large Language Models\", \"Real Estate\", \"Agentic Workflows\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "hvqc_EdH6cTX"
+ },
+ "source": [
+ "The specialized agents (researcher, fact-checker, data analysts and literature reviewer) utilize this topic as their primary focus for information gathering and analysis. By defining a clear research topic, you ensure that the multi-agent conversation remains relevant and productive."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true,
+ "id": "RTJBQ5_OngMh"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Define Agents\n",
+ "\n",
+ "# Define the Researcher agent. This agent conducts thorough research on the given topic,\n",
+ "# identifying key trends, publications, experts, and relevant data sources.\n",
+ "researcher = AssistantAgent(\n",
+ " name=\"Researcher\",\n",
+ " llm_config={\"config_list\": config_list, \"seed\": seed},\n",
+ " description=\"Conducts thorough research on the given topic.\",\n",
+ " system_message=\"\"\"You are a meticulous researcher. Your goal is to conduct thorough research, identifying key trends, publications, experts, and relevant data sources. You should provide accurate and well-cited information.\"\"\"\n",
+ ")\n",
+ "\n",
+ "# Define the Literature Reviewer agent. This agent synthesizes research findings into a\n",
+ "# coherent and well-structured literature review, identifying key themes, connections, and gaps in the existing research.\n",
+ "literature_reviewer = AssistantAgent(\n",
+ " name=\"Literature_Reviewer\",\n",
+ " llm_config={\"config_list\": config_list, \"seed\": seed},\n",
+ " description=\"Synthesizes research findings into a coherent literature review.\",\n",
+ " system_message=\"\"\"You are a skilled literature reviewer. Your goal is to synthesize the provided research findings into a coherent and well-structured literature review. You should identify key themes, connections, and gaps in the existing research.\"\"\"\n",
+ ")\n",
+ "\n",
+ "# Define the Fact Checker agent. This agent verifies the accuracy and validity of information,\n",
+ "# checking sources, identifying potential biases, and ensuring consistency with established knowledge.\n",
+ "fact_checker = AssistantAgent(\n",
+ " name=\"Fact_Checker\",\n",
+ " llm_config={\"config_list\": config_list, \"seed\": seed},\n",
+ " description=\"Verifies the accuracy and validity of information.\",\n",
+ " system_message=\"\"\"You are a meticulous fact-checker. Your goal is to verify the accuracy and validity of any information presented to you. You should check sources, identify potential biases, and ensure the information is consistent with established knowledge.\"\"\"\n",
+ ")\n",
+ "\n",
+ "# Define the Data Analyst agent. This agent analyzes data related to the research topic and\n",
+ "# extracts meaningful insights, identifying trends, patterns, and correlations.\n",
+ "data_analyst = AssistantAgent(\n",
+ " name=\"Data_Analyst\",\n",
+ " llm_config={\"config_list\": config_list, \"seed\": seed},\n",
+ " description=\"Analyzes data and extracts meaningful insights.\",\n",
+ " system_message=\"\"\"You are a skilled data analyst. Your goal is to analyze data and extract meaningful insights. You should identify trends, patterns, and correlations in the data and present your findings in a clear and concise manner.\"\"\"\n",
+ ")\n",
+ "\n",
+ "# Define the User Proxy agent. This agent represents the user and can run code to facilitate tasks.\n",
+ "user_proxy = UserProxyAgent(\n",
+ " name=\"User_proxy\",\n",
+ " code_execution_config={\"last_n_messages\": 20, \"work_dir\": \"coding\", \"use_docker\": False},\n",
+ " human_input_mode=\"TERMINATE\",\n",
+ " is_termination_msg=lambda x: content_str(x.get(\"content\")).find(\"TERMINATE\") >= 0,\n",
+ " description=\"I represent the user, and can run code.\",\n",
+ ")\n",
+ "\n",
+ "# Create the GroupChat, a conversable pattern, that facilitates the collaboration on tasks requiring interaction among multiple agents.\n",
+ "# All agents contribute to a single conversation thread and share the same context. We have set the max turns of conversation to 12\n",
+ "groupchat = GroupChat(agents=[user_proxy, researcher, literature_reviewer, fact_checker, data_analyst], messages=[], max_round=12)\n",
+ "\n",
+ "# Create the GroupChatManager, a specialized agent, to orchestrate the group chat. A GroupChatManager selects an agent to speak,\n",
+ "# broadcasts the message to all other agents, and repeats this process until the conversation stops or maximum number of turns is reached.\n",
+ "# The default selection strategy is \"auto\", where the manager's LLM, in our case Gemini, chooses the next speaker.\n",
+ "manager = GroupChatManager(\n",
+ " groupchat=groupchat,\n",
+ " llm_config={\"config_list\": config_list, \"seed\": seed},\n",
+ " is_termination_msg=lambda x: content_str(x.get(\"content\")).find(\"TERMINATE\") >= 0,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "fXcoq_nrBLgu"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Start Multi-agent Conversations\n",
+ "\n",
+ "with Cache.disk() as cache: # enable caching to reduce inference cost\n",
+ " result = user_proxy.initiate_chat(\n",
+ " manager,\n",
+ " message=f\"Conduct research on the latest advancements in {research_topic}, analyze relevant data, and produce a comprehensive literature review with verified facts.\",\n",
+ " summary_method=\"last_msg\",\n",
+ " cache=cache,\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "rAohpblo98OT"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Inspect Report Generated By Agents\n",
+ "result = content_str(result.summary)\n",
+ "print(result)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "w1YCBTrbZtlg"
+ },
+ "source": [
+ "## Step 3. Deploy agents to Reasoning Engine"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "uXgl1m3cxPW3"
+ },
+ "source": [
+ "### Deploying The Ag2 Multi-Agent Conversations Example On Vertex AI Reasoning Engine.\n",
+ "\n",
+ "1. Create a class `ResearchApp`, that implements a reasoning engine `Queryable` class. This class will wrap the agents from cell above.\n",
+ "\n",
+ "2. The syntax used to create a register a reasoning engine resource needs to implement `set_up` and `query` methods. Here is an example of a Reasoning Engine [advanced app configuration](https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/reasoning-engine#deploy_an_advanced_app_configuration) that show this.\n",
+ "\n",
+ "\n",
+ "> **NOTE:** All agents and boostrapping code must be initialized in the `set_up` method and not the `__init__` method. Multi-agent conversation and user proxy code will go into the `query` method.\n",
+ "\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "Gr24G_qzFhZ9"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Define Ag2 Agents As a Reasoning Engine QueryAble\n",
+ "class ResearchApp(Queryable):\n",
+ " \"\"\"This class defines a research application using AG2. It facilitates multi-agent conversations for research tasks.\"\"\"\n",
+ " base_question = \"Conduct research on the latest advancements in {topic}, analyze relevant data, and produce a comprehensive literature review with verified facts.\"\n",
+ "\n",
+ " def __init__(self, project_id: str, location: str):\n",
+ " \"\"\"\n",
+ " Initializes the ResearchApp instance.\n",
+ "\n",
+ " Args:\n",
+ " project_id (str): The project ID for AG2.\n",
+ " location (str): The location of the AG2 instance.\n",
+ " \"\"\"\n",
+ " self.project_id = project_id\n",
+ " self.location = location\n",
+ " self.set_up_complete = False\n",
+ "\n",
+ " def set_up(self):\n",
+ " \"\"\"Sets up the research agents and conversation environment.\"\"\"\n",
+ " self.researcher = AssistantAgent(\n",
+ " name=\"Researcher\",\n",
+ " llm_config={\"config_list\": config_list, \"seed\": seed},\n",
+ " description=\"Conducts thorough research on the given topic.\",\n",
+ " system_message=\"\"\"You are a meticulous researcher. Your goal is to conduct thorough research, identifying key trends, publications, experts, and relevant data sources. You should provide accurate and well-cited information.\"\"\"\n",
+ " )\n",
+ "\n",
+ " self.literature_reviewer = AssistantAgent(\n",
+ " name=\"Literature_Reviewer\",\n",
+ " llm_config={\"config_list\": config_list, \"seed\": seed},\n",
+ " description=\"Synthesizes research findings into a coherent literature review.\",\n",
+ " system_message=\"\"\"You are a skilled literature reviewer. Your goal is to synthesize the provided research findings into a coherent and well-structured literature review. You should identify key themes, connections, and gaps in the existing research.\"\"\"\n",
+ " )\n",
+ "\n",
+ " self.fact_checker = AssistantAgent(\n",
+ " name=\"Fact_Checker\",\n",
+ " llm_config={\"config_list\": config_list, \"seed\": seed},\n",
+ " description=\"Verifies the accuracy and validity of information.\",\n",
+ " system_message=\"\"\"You are a meticulous fact-checker. Your goal is to verify the accuracy and validity of any information presented to you. You should check sources, identify potential biases, and ensure the information is consistent with established knowledge.\"\"\"\n",
+ " )\n",
+ "\n",
+ " self.data_analyst = AssistantAgent(\n",
+ " name=\"Data_Analyst\",\n",
+ " llm_config={\"config_list\": config_list, \"seed\": seed},\n",
+ " description=\"Analyzes data and extracts meaningful insights.\",\n",
+ " system_message=\"\"\"You are a skilled data analyst. Your goal is to analyze data and extract meaningful insights. You should identify trends, patterns, and correlations in the data and present your findings in a clear and concise manner.\"\"\"\n",
+ " )\n",
+ "\n",
+ " self.user_proxy = UserProxyAgent(\n",
+ " name=\"User_proxy\",\n",
+ " code_execution_config={\"last_n_messages\": 20, \"work_dir\": \"coding\", \"use_docker\": False},\n",
+ " human_input_mode=\"NEVER\",\n",
+ " is_termination_msg=lambda x: content_str(x.get(\"content\")).find(\"TERMINATE\") >= 0,\n",
+ " description=\"I represent the user, and can run code.\",\n",
+ " )\n",
+ "\n",
+ " self.groupchat = GroupChat(agents=[self.user_proxy, self.researcher, self.literature_reviewer, self.fact_checker, self.data_analyst], messages=[], max_round=12)\n",
+ " self.manager = GroupChatManager(\n",
+ " groupchat=self.groupchat,\n",
+ " llm_config={\"config_list\": config_list, \"seed\": seed},\n",
+ " is_termination_msg=lambda x: content_str(x.get(\"content\")).find(\"TERMINATE\") >= 0,\n",
+ " )\n",
+ " self.set_up_complete = True\n",
+ "\n",
+ " def query(self, topic: str = \"Large Language Models\"):\n",
+ " \"\"\"\n",
+ " Queries the multi-agent research system.\n",
+ "\n",
+ " Args:\n",
+ " topic (str): The research topic. Defaults to \"Large Language Models\".\n",
+ "\n",
+ " Returns:\n",
+ " str: A summary of the research conducted by the multi-agent system.\n",
+ " \"\"\"\n",
+ " if not self.set_up_complete:\n",
+ " self.set_up()\n",
+ " question = self.base_question.format(topic=topic)\n",
+ " with Cache.disk() as cache:\n",
+ " result = self.user_proxy.initiate_chat(\n",
+ " self.manager,\n",
+ " message=question,\n",
+ " summary_method=\"last_msg\",\n",
+ " cache=cache,\n",
+ " )\n",
+ " try:\n",
+ " return content_str(result.summary)\n",
+ " except (TypeError, AttributeError) as e:\n",
+ " print(f\"Error extracting summary: {e}\")\n",
+ " return \"Error: Could not extract summary.\"\n",
+ "print('Research App with multi-agents created.')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "9Kwmo5QJx8Dv"
+ },
+ "source": [
+ "### Test\n",
+ "\n",
+ "This section demonstrates how to test the Reasoning Engine locally before deploying it to Vertex AI. By running the `ResearchApp` locally, you can observe a multi-agent conversation flow similar to the previous example. This local testing helps ensure that the agents and their interactions are functioning as expected before deploying to the cloud."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "collapsed": true,
+ "id": "z89kARQryAfb"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Testing - Local Development\n",
+ "local_engine = ResearchApp(project_id=PROJECT_ID, location=LOCATION)\n",
+ "local_engine.set_up()\n",
+ "report = local_engine.query(topic=research_topic)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "_PF03F9A_yuk"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Inspect Report\n",
+ "print(report)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "eOk6mEfYxl9n"
+ },
+ "source": [
+ "### Setup and Deploy to Vertex AI Reasoning Engine\n",
+ "\n",
+ "This section guides you through deploying the Ag2 multi-agent application to Vertex AI Reasoning Engine. Before proceeding with the deployment, we'll ensure there are no existing deployments to avoid conflicts. This involves listing and deleting any previous Reasoning Engine deployments to start with a clean slate. Subsequently, we'll utilize the `ReasoningEngine.create` method to deploy the application, specifying dependencies and configurations.\n",
+ "\n",
+ "> **NOTE:** Please be patient as the deployment is a long running operation. Once successful, the cell will return the resource URI of deployment that can be used for subsequent executions. \n",
+ ">**Example:**\n",
+ "> ` reasoning_engine = vertexai.preview.reasoning_engines.ReasoningEngine('projects//locations/us-central1/reasoningEngines/')`\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "cellView": "form",
+ "id": "BpXwgjnrXLto"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Clean up deployment if needed\n",
+ "def cleanup_deployments():\n",
+ " reasoning_engine_list = reasoning_engines.ReasoningEngine.list()\n",
+ " if reasoning_engine_list:\n",
+ " print(\"Found existing deployments:\")\n",
+ " pprint.pprint(reasoning_engine_list)\n",
+ " for re in reasoning_engine_list:\n",
+ " re.delete()\n",
+ " else:\n",
+ " print(\"No deployments found.\")\n",
+ "cleanup_deployments()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "DLNQyaOjLfAY"
+ },
+ "source": [
+ "Now, we'll deploy the multi-agent application to Vertex AI Reasoning Engine. This process might take a few minutes as it involves setting up the necessary infrastructure for remote execution.\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "3KXt3Kg7q08K"
+ },
+ "outputs": [],
+ "source": [
+ "# @title Deploy to Reasoning Engine - Please Wait\n",
+ "reasoning_engine = ReasoningEngine.create(\n",
+ " ResearchApp(project_id=PROJECT_ID, location=LOCATION),\n",
+ " display_name='Ag2 Research Application',\n",
+ " description='Ag2 example deployed on Vertex AI Reasoning Engine',\n",
+ " requirements=['autogen-agentchat[gemini]~=0.2',\n",
+ " 'cloudpickle==3.1.0',\n",
+ " 'python-dotenv>=1.0.1,<2.0.0',\n",
+ " 'chromadb>=0.5.13,<0.6.0',\n",
+ " 'markdownify>=0.13.1,<0.14.0',\n",
+ " 'pypdf>=5.0.1,<6.0.0',\n",
+ " 'flaml[automl]>=2.3.1,<3.0.0',\n",
+ " 'google-cloud-aiplatform[reasoningengine]>=1.70.0,<2.0.0',\n",
+ " 'langchain-google-vertexai>=2.0.5,<3.0.0',\n",
+ " 'traceloop-sdk>=0.33.1,<0.34.0 ',\n",
+ " 'opentelemetry-exporter-gcp-trace>=1.7.0,<2.0.0',\n",
+ " ],\n",
+ " extra_packages=[],\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "18I5QCPkagp2"
+ },
+ "source": [
+ "### Monitoring Deployment Progress with GCP Logs Explorer\n",
+ "\n",
+ "You can track the progress of your deployment by examining the logs in the GCP Logs Explorer - [Click Here!](https://console.cloud.google.com/logs/query;query=resource.type%3D%22aiplatform.googleapis.com%2FReasoningEngine%22). A successfully progressing deployment will typically exhibit log entries indicating the initialization of agents, the exchange of messages between agents, and the completion of various stages in the research process.\n",
+ "\n",
+ "**Here's what to look for in the logs:**\n",
+ "\n",
+ "* **Agent initialization messages:** Logs confirming that each agent (Researcher, Literature Reviewer, etc.) has been successfully initialized.\n",
+ "* **Conversation logs:** Entries showing the back-and-forth communication between agents as they collaborate on the research task.\n",
+ "* **Progress indicators:** Messages signaling the completion of key steps, such as data analysis, fact-checking, and literature review generation.\n",
+ "* **Absence of error messages:** A lack of error or warning messages suggests that the deployment is proceeding without issues.\n",
+ "\n",
+ "\n",
+ "Monitoring deployment progress through the deployment logs [here](https://console.cloud.google.com/logs/query;query=resource.type%3D%22aiplatform.googleapis.com%2FReasoningEngine%22) provides valuable insights into the health and functionality of your multi-agent application."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "yDmacPdS1ONB"
+ },
+ "source": [
+ "### Testing the Deployed Multi-Agent Application\n",
+ "\n",
+ "Now that the multi-agent application is deployed to Vertex AI Reasoning Engine, we can test its functionality. We expect the interaction flow and results to be consistent with the local testing performed earlier. This ensures that the deployed application behaves as intended and provides the same user experience."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "e8q38AWUwjQI"
+ },
+ "outputs": [],
+ "source": [
+ "result = reasoning_engine.query(topic=research_topic)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "zOt1dlPH5a5P"
+ },
+ "source": [
+ "### Writing Report To Disk (Optional)\n",
+ "\n",
+ "The comprehensive literature review generated by the multi-agent conversation can be saved to a file. This allows for easy access, review, and potential modifications by users or other stakeholders.\n",
+ "\n",
+ "**Here's how you can persist the report to disk:**"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "zz15hGQRwj4e"
+ },
+ "outputs": [],
+ "source": [
+ "with open('report.md', 'w') as f:\n",
+ " f.write(str(result))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "83m7sycmZ9GI"
+ },
+ "source": [
+ "## Step 4: Clean up"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "WuqHrWIXakMa"
+ },
+ "source": [
+ "\n",
+ "To avoid incurring unnecessary costs, we can now safely remove the deployed Reasoning Engines."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "T2Vf4H2ZqtSw"
+ },
+ "outputs": [],
+ "source": [
+ "reasoning_engine.delete()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "A1XZlgAKan8I"
+ },
+ "source": [
+ "## Conclusion\n",
+ "\n",
+ "This notebook demonstrated how to build and deploy a multi-agent AI system on Vertex AI using AG2 (formerly AutoGen) and its Reasoning Engine. We showcased a collaborative workflow where specialized agents worked together to perform complex research and analysis.\n",
+ "\n",
+ "### Agent Roles and Responsibilities\n",
+ "\n",
+ "The system comprises the following agents, each with a distinct role:\n",
+ "\n",
+ "* **Researcher:** Conducts in-depth research on the given topic, identifying key trends, publications, experts, and relevant data sources. The Researcher provides accurate and well-cited information as the foundation for subsequent analysis.\n",
+ "\n",
+ "* **Literature Reviewer:** Synthesizes the Researcher's findings into a coherent and structured literature review. This agent identifies key themes, connections, and gaps in the existing research to provide a comprehensive overview of the current state of knowledge.\n",
+ "\n",
+ "* **Fact Checker:** Verifies the accuracy and validity of information presented by other agents, particularly the Researcher and Literature Reviewer. The Fact Checker meticulously checks sources, identifies potential biases, and ensures consistency with established knowledge.\n",
+ "\n",
+ "* **Data Analyst:** Analyzes data related to the research topic, extracting meaningful insights, identifying trends, patterns, and correlations. The Data Analyst provides quantitative support for the research with clear and concise presentations of findings.\n",
+ "\n",
+ "* **User Proxy:** Represents the user, initiating the conversation with the initial prompt or task. This agent can also execute code to support other agents, acting as an interface between the user and the multi-agent system.\n",
+ "\n",
+ "The `GroupChatManager` orchestrates the interaction between these agents. It selects an agent to contribute, broadcasts the message to all other agents, and repeats this process until the conversation concludes. The default \"auto\" selection strategy utilizes the manager's LLM to intelligently choose the next speaker based on the conversation's context. This collaborative approach enables more comprehensive and robust analyses than a single agent could achieve.\n",
+ "\n",
+ "### Key Takeaways\n",
+ "\n",
+ "* **Collaborative Multi-Agent Workflow:** Demonstrated a workflow where distinct agents (Researcher, Data Analyst, Literature Reviewer, Fact Checker, and User Proxy) collaborate to conduct research, analyze data, synthesize findings, and ensure accuracy.\n",
+ "* **Vertex AI Deployment:** Showcased the deployment and execution of this multi-agent system on Vertex AI's Reasoning Engine, providing scalable and efficient cloud-based execution.\n",
+ "* **Simplified Agent Development with AG2:** Highlighted AG2's framework for building and managing AI agents, streamlining development and facilitating complex agent interactions.\n",
+ "\n",
+ "This example provides a foundation for building and deploying custom multi-agent applications on Vertex AI, leveraging the power of AG2 for collaborative AI solutions.\n"
+ ]
+ }
+ ],
+ "metadata": {
+ "colab": {
+ "provenance": []
+ },
+ "kernelspec": {
+ "display_name": "Python 3",
+ "name": "python3"
+ },
+ "language_info": {
+ "name": "python"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}