/*
 * Purpose of This File:
 * This file is required for Quarto to render both HTML and MDX files in the `website` folder.
 * These rendered files are essential for Mintlify to function correctly.
 *
 * Context:
 * - The `quarto render` command behaves differently when the `docusaurus.config.js` file is
 *   present in the `website` folder.
 * - Without this file, Quarto does not render MDX files, leading to failures
 *   when running the `process_notebook.py` script.
 * - As a result, this file is retained temporarily until a better solution is identified.
 *
 * Options Tried (and Issues Faced):
 * 1. Adding a `_quarto.yml` file in the `website` folder with the following configurations:
 *
 *    **Minimal Configuration:**
 *    ```
 *    project:
 *      type: docusaurus
 *
 *    format:
 *      html: default
 *      docusaurus-md: default
 *    ```
 *
 *    **Full Configuration from Quarto Repository:**
 *    The configuration from [Quarto's docusaurus extension](https://github.com/quarto-dev/quarto-cli/blob/main/src/resources/extensions/quarto/docusaurus/_extension.yml).
 *
 *    - Both configurations instruct Quarto to render HTML and MDX files.
 *    - However, in both cases, Mintlify fails to generate docs, raising the following error:
 *      > Warning: data for page "/[[...slug]]" (path "/docs/Home") is 56.1 MB which exceeds
 *      > the threshold of 21 MB. This amount of data can reduce performance.
 *    - More info: https://nextjs.org/docs/messages/large-page-data
 */


// Load jQuery if not present
if (typeof jQuery === "undefined") {
  const jqueryScript = document.createElement("script");
  jqueryScript.src =
    "https://cdnjs.cloudflare.com/ajax/libs/jquery/3.7.1/jquery.min.js";
  document.head.appendChild(jqueryScript);

  jqueryScript.onload = function () {
    // Load Chosen after jQuery
    const chosenScript = document.createElement("script");
    chosenScript.src =
      "https://cdnjs.cloudflare.com/ajax/libs/chosen/1.8.7/chosen.jquery.min.js";
    document.head.appendChild(chosenScript);

    // Add Chosen CSS
    const chosenStyles = document.createElement("link");
    chosenStyles.rel = "stylesheet";
    chosenStyles.href =
      "https://cdnjs.cloudflare.com/ajax/libs/chosen/1.8.7/chosen.min.css";
    document.head.appendChild(chosenStyles);

    // Initialize Chosen when everything is loaded
    chosenScript.onload = function () {
      initializeGallerySelect();
    };
  };
}

function getTagsFromURL() {
  const searchParams = new URLSearchParams(window.location.search);
  const tags = searchParams.get("tags");
  return tags ? tags.split(",") : [];
}

// Function to initialize Chosen on gallery select
function initializeGallerySelect() {
  // Add flag to check if already initialized
  const selectElement = $(".examples-gallery-container .tag-filter");
  if (selectElement.length && !selectElement.data("chosen-initialized")) {
    selectElement
      .chosen({
        width: "100%",
        placeholder_text_multiple: "Filter by tags",
      })
      .data("chosen-initialized", true);

    // Get tags from URL and update chosen
    const urlTags = getTagsFromURL();
    if (urlTags.length > 0) {
      selectElement.val(urlTags);
      selectElement.trigger("chosen:updated");

      // Trigger the gallery:tagChange event with URL tags
      const customEvent = new CustomEvent("gallery:tagChange", {
        detail: urlTags,
      });
      document.dispatchEvent(customEvent);
    }

    // Set up change handler
    selectElement.on("change", function (evt, params) {
      const selectedValues = $(this).val() || [];
      const customEvent = new CustomEvent("gallery:tagChange", {
        detail: selectedValues,
      });
      document.dispatchEvent(customEvent);
    });
  }
}

// Debounce function
function debounce(func, wait) {
  let timeout;
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout);
      func(...args);
    };
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
}

// Debounced version of initialize
const debouncedInitialize = debounce(initializeGallerySelect, 100);

// Watch for URL changes using MutationObserver
const observer = new MutationObserver((mutations) => {
  if (window.location.pathname.includes("/use-cases")) {
    debouncedInitialize();
  }
});

observer.observe(document.body, {
  childList: true,
  subtree: true,
  attributes: false,
  characterData: false,
});

// Initialize on page load
document.addEventListener("DOMContentLoaded", function () {
  if (window.jQuery && window.jQuery.fn.chosen) {
    initializeGallerySelect();
  }
});


Instance Attributes

above_run

context_variables

cost

events

last_speaker

messages

summary

uuid

Instance Methods

process

set_ui_tools

AsyncRunResponse

autogen.io.run_response.AsyncRunResponse

Quick Start

Installing AG2

Community Gallery

Contributing to AG2

Setting up Development Environment

Documentation Contribution Guide

File a Bug Report

Guidance for Maintainers

Pre-commit

Tests

Research

Frequently Asked Questions

Agent Monitoring and Debugging with AgentOps

Azure Cosmos DB

Composio

Databricks

Llamaindex

Mem0:Long-Term Memory and Personalization for Agents

MemGPT

Microsoft Fabric

Ollama

PGVector

Portkey Integration

Promptflow

Home

User Guide

API References

Use Cases

User Stories

Contribute

FAQs

Ecosystem

Blog

LLM Configuration: Powering Agent Intelligence

ConversableAgent: Building Intelligent Agents

Human in the Loop: Adding Human Oversight

Agent Orchestration: Coordinating Multiple Agents

Tools: Extending Agent Capabilities

Structured Outputs: Ensuring Consistent Responses

LLM Config Deep-dive

Code Execution

Amazon Bedrock

Anthropic

Cerebras

Cohere

DeepSeek

Google Gemini

Google Vertex AI

Groq

LM Studio

Mistral AI

OpenAI

Together AI

vLLM

Overview

CaptainAgent

DocAgent

DocAgent Performance

ReasoningAgent

DeepResearchAgent

WebSurferAgent

WikipediaAgent

Perplexity Search Tool

Wikipedia Search Tools

Browser Use

Deep Research

Crawl4AI

Getting under the hood

Chat workflow

Generating a reply

Hooks

Creating a new tool

Creating a new agent

Customer Service

Game Design

Travel Planning

All Notebooks

Websockets facilitate real-time, bidirectional communication between web clients and servers, enhancing the responsiveness and interactivity of AG2-powered applications.

Websockets: Streaming input and output using websockets

Code generation, execution, debugging and human feedback.

Auto Generated Agent Chat: Task Solving with Code Generation, Execution, Debugging & Human Feedback

FalkorDB GraphRAG utilises a knowledge graph and can be added as a capability to agents. Together with a swarm orchestration of agents is highly effective at providing a RAG capability.

Using a local Telemetry server to monitor a GraphRAG agent

Register function calls using AssistantAgent and UserProxyAgent to execute python or shell code in customized ways. Demonstrating two ways of registering functions.

Auto Generated Agent Chat: Task Solving with Provided Tools as Functions

RealtimeAgent with gemini client using websockets

RealtimeAgent with gemini client

Agentic RAG workflow on tabular data from a PDF file

Language Agent Tree Search

Config loader utility functions

Wikipedia Agent

Google Drive Tools

Explore the demonstration of the Finite State Machine implementation, which allows the user to input speaker transition constraints.

FSM - User can input speaker transition constraints

Implement and manage a multi-agent chat system using AG2, where AI assistants retrieve information, generate code, and interact collaboratively to solve complex tasks, especially in areas not covered by their training data.

Group Chat with Retrieval Augmented Generation

AgentOptimizer is able to prompt LLMs to iteratively optimize function/skills of AutoGen agents according to the historical conversation and performance.

AgentOptimizer: An Agentic Way to Train Your LLM Agent

This notebook demonstrates the usage of QdrantRetrieveUserProxyAgent for RAG.

Using RetrieveChat with Qdrant for Retrieve Augmented Code Generation and Question Answering

RealtimeAgent with WebRTC connection

Agent with memory using Mem0

Preprocessing chat history with `TransformMessages`

Preprocessing Chat History with `TransformMessages`

RealtimeAgent in a Swarm Orchestration

OpenAI Assistant with retrieval augmentation.

RAG OpenAI Assistants in AG2

Using Guidance with AG2

Explore the use of AG2's RetrieveChat for tasks like code generation from docstrings, answering complex questions with human feedback, and exploiting features like Update Context, custom prompts, and few-shot learning.

Using RetrieveChat Powered by MongoDB Atlas for Retrieve Augmented Code Generation and Question Answering

Neo4j GraphRAG utilises a knowledge graph and can be added as a capability to agents.

Using Neo4j's graph database with AG2 agents for Question & Answering

Use Databricks DBRX and Foundation Model APIs to build AG2 applications backed by open-source LLMs.

Use AG2 in Databricks with DBRX

Solve complex tasks with a chat nested as inner monologue.

Solving Complex Tasks with Nested Chats

DeepSeek: Adding Browsing Capabilities to AG2

Solve complex tasks with one or more sequence chats nested as inner monologue.

Solving Complex Tasks with A Sequence of Nested Chats

LLM-backed agents playing chess with each other using nested chats.

Nested Chats for Tool Use in Conversational Chess

OpenAI Assistants in AG2

Explore a group chat example using agents such as a coder and visualization agent.

Group Chat with Coder and Visualization Critic

Agent Chat with Multimodal Models: LLaVA

Explore the demonstration of the SocietyOfMindAgent in the AG2 library, which runs a group chat as an internal monologue, but appears to the external world as a single agent, offering a structured way to manage complex interactions among multiple agents and handle issues such as extracting responses from complex dialogues and dealing with context window constraints.

SocietyOfMindAgent

Conversational Workflows with MCP: A Marie Antoinette Take on The Eiffel Tower

Multimodal agent chat with DALL-E and GPT-4v.

Agent Chat with Multimodal Models: DALLE  and GPT-4V

StateFlow: Build workflows through state-oriented actions.

StateFlow: Build Workflows through State-Oriented Actions

Optimizing Small, Local LLMs in Multi-Agent RAG Workflows using IBM Granite, Document Retrieval, Web Search, and Ollama

Small, Local Model (IBM Granite) Multi-Agent RAG

Group Chat with Tools

DuckDuckGo Search Tool

Load the configuration including the response format

MCP Clients

Use AgentOps to simplify the development process and monitor your agents in production.

Agent Tracking with AgentOps

Natural language text to SQL query using the Spider text-to-SQL benchmark.

SQL Agent for Spider text-to-SQL benchmark

Automatically build multi-agent system with AgentBuilder

AutoBuild

Automatically build multi-agent system from agent library

Automatically Build Multi-agent System from Agent Library

Generate Dalle Images With Conversable Agents

Use OpenLIT to easily monitor AI agents in production with OpenTelemetry.

Agent Observability with OpenLIT

Using RetrieveChat Powered by Couchbase Capella for Retrieve Augmented Code Generation and Question Answering

A Uniform interface to call different LLMs

This is a nested chat re-implementation of OptiGuide which is an LLM-based supply chain optimization framework.

OptiGuide with Nested Chats in AG2

Conversational Chess using non-OpenAI clients

Chat Context Dependency Injection

`run` function examples with event processing

Use tools in a GPTAssistantAgent Multi-Agent System by utilizing functions such as calling an API and writing to a file.

From Dad Jokes To Sad Jokes: Function Calling with GPTAssistantAgent

Use JSON mode and Agent Descriptions to mitigate prompt manipulation and control speaker transition.

Mitigating Prompt hacking with JSON Mode in Autogen

Introduce group chat with customized speaker selection method.

Group Chat with Customized Speaker Selection Method

Trip planning with a FalkorDB GraphRAG agent using a Swarm

Tavily Search Tool

LLM providers offer functionality for defining a structure of the messages generated by LLMs, AG2 enables this functionality by propagating a `response_format`, in the LLM configuration for your agents, to the underlying client.

Structured output

Adding Google Search Capability to AG2

Learn how to implement both synchronous and asynchronous function calls using AssistantAgent and UserProxyAgent in AutoGen, with examples of their application in individual and group chat settings for task execution with language models.

Task Solving with Provided Tools as Functions (Asynchronous Function Calls)

Conversational Workflows with MCP: A French joke on a random Wikipedia article

Auto Generated Agent Chat: Using MathChat to Solve Math Problems

Agent Chat with custom model loading

Function Inception: Enable AG2 agents to update/remove functions during conversations.

Auto Generated Agent Chat: Function Inception

Use AG2 to Tune ChatGPT

Auto Generated Agent Chat: Group Chat with GPTAssistantAgent

Using FalkorGraphRagCapability with agents for GraphRAG Question & Answering

Use conversational agents to solve a set of tasks with a sequence of async chats.

Name	Description
`iostream`	Type: AsyncThreadIOStream
`agents`	Type: list[Agent]

API Reference

​AsyncRunResponse

​Instance Attributes

​above_run

​context_variables

​cost

​events

​last_speaker

​messages

​summary

​uuid

​Instance Methods

​process

​set_ui_tools