Skip to content

A programming framework for agentic AI

Update agent documentation (#6394)

Eric Zhud96aaebc8d7e
diff --git a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
index b51ded56e..cce76eaed 100644
--- a/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
+++ b/python/packages/autogen-agentchat/src/autogen_agentchat/agents/_assistant_agent.py
@@ -90,10 +90,20 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
the inner messages as they are created, and the :class:`~autogen_agentchat.base.Response`
object as the last item before closing the generator.
+ The :meth:`BaseChatAgent.run` method returns a :class:`~autogen_agentchat.base.TaskResult`
+ containing the messages produced by the agent. In the list of messages,
+ :attr:`~autogen_agentchat.base.TaskResult.messages`,
+ the last message is the final response message.
+
+ The :meth:`BaseChatAgent.run_stream` method creates an async generator that produces
+ the inner messages as they are created, and the :class:`~autogen_agentchat.base.TaskResult`
+ object as the last item before closing the generator.
+
.. attention::
The caller must only pass the new messages to the agent on each call
- to the :meth:`on_messages` or :meth:`on_messages_stream` method.
+ to the :meth:`on_messages`, :meth:`on_messages_stream`, :meth:`BaseChatAgent.run`,
+ or :meth:`BaseChatAgent.run_stream` methods.
The agent maintains its state between calls to these methods.
Do not pass the entire conversation history to the agent on each call.
@@ -215,10 +225,8 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
.. code-block:: python
import asyncio
- from autogen_core import CancellationToken
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent
- from autogen_agentchat.messages import TextMessage
async def main() -> None:
@@ -228,10 +236,8 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
)
agent = AssistantAgent(name="assistant", model_client=model_client)
- response = await agent.on_messages(
- [TextMessage(content="What is the capital of France?", source="user")], CancellationToken()
- )
- print(response)
+ result = await agent.run(task="Name two cities in North America.")
+ print(result)
asyncio.run(main())
@@ -246,8 +252,6 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent
- from autogen_agentchat.messages import TextMessage
- from autogen_core import CancellationToken
async def main() -> None:
@@ -261,9 +265,7 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
model_client_stream=True,
)
- stream = agent.on_messages_stream(
- [TextMessage(content="Name two cities in North America.", source="user")], CancellationToken()
- )
+ stream = agent.run_stream(task="Name two cities in North America.")
async for message in stream:
print(message)
@@ -272,27 +274,23 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
.. code-block:: text
- source='assistant' models_usage=None content='Two' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' cities' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' in' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' North' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' America' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' are' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' New' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' York' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' City' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' in' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' the' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' United' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' States' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' and' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' Toronto' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' in' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' Canada' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content='.' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content=' TERMIN' type='ModelClientStreamingChunkEvent'
- source='assistant' models_usage=None content='ATE' type='ModelClientStreamingChunkEvent'
- Response(chat_message=TextMessage(source='assistant', models_usage=RequestUsage(prompt_tokens=0, completion_tokens=0), content='Two cities in North America are New York City in the United States and Toronto in Canada. TERMINATE', type='TextMessage'), inner_messages=[])
+ source='user' models_usage=None metadata={} content='Name two cities in North America.' type='TextMessage'
+ source='assistant' models_usage=None metadata={} content='Two' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' cities' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' in' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' North' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' America' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' are' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' New' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' York' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' City' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' and' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' Toronto' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content='.' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content=' TERMIN' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=None metadata={} content='ATE' type='ModelClientStreamingChunkEvent'
+ source='assistant' models_usage=RequestUsage(prompt_tokens=0, completion_tokens=0) metadata={} content='Two cities in North America are New York City and Toronto. TERMINATE' type='TextMessage'
+ messages=[TextMessage(source='user', models_usage=None, metadata={}, content='Name two cities in North America.', type='TextMessage'), TextMessage(source='assistant', models_usage=RequestUsage(prompt_tokens=0, completion_tokens=0), metadata={}, content='Two cities in North America are New York City and Toronto. TERMINATE', type='TextMessage')] stop_reason=None
**Example 3: agent with tools**
@@ -312,9 +310,7 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
import asyncio
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent
- from autogen_agentchat.messages import TextMessage
from autogen_agentchat.ui import Console
- from autogen_core import CancellationToken
async def get_current_time() -> str:
@@ -327,12 +323,7 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
# api_key = "your_openai_api_key"
)
agent = AssistantAgent(name="assistant", model_client=model_client, tools=[get_current_time])
-
- await Console(
- agent.on_messages_stream(
- [TextMessage(content="What is the current time?", source="user")], CancellationToken()
- )
- )
+ await Console(agent.run_stream(task="What is the current time?"))
asyncio.run(main())
@@ -390,9 +381,7 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
from typing import Literal
from autogen_agentchat.agents import AssistantAgent
- from autogen_agentchat.messages import TextMessage
from autogen_agentchat.ui import Console
- from autogen_core import CancellationToken
from autogen_core.tools import FunctionTool
from autogen_ext.models.openai import OpenAIChatCompletionClient
from pydantic import BaseModel
@@ -430,7 +419,7 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
async def main() -> None:
- stream = agent.on_messages_stream([TextMessage(content="I am happy today!", source="user")], CancellationToken())
+ stream = agent.run_stream(task="I am happy today!")
await Console(stream)
@@ -458,8 +447,6 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
import asyncio
from autogen_agentchat.agents import AssistantAgent
- from autogen_agentchat.messages import TextMessage
- from autogen_core import CancellationToken
from autogen_core.model_context import BufferedChatCompletionContext
from autogen_ext.models.openai import OpenAIChatCompletionClient
@@ -482,20 +469,14 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
system_message="You are a helpful assistant.",
)
- response = await agent.on_messages(
- [TextMessage(content="Name two cities in North America.", source="user")], CancellationToken()
- )
- print(response.chat_message.content) # type: ignore
+ result = await agent.run(task="Name two cities in North America.")
+ print(result.messages[-1].content) # type: ignore
- response = await agent.on_messages(
- [TextMessage(content="My favorite color is blue.", source="user")], CancellationToken()
- )
- print(response.chat_message.content) # type: ignore
+ result = await agent.run(task="My favorite color is blue.")
+ print(result.messages[-1].content) # type: ignore
- response = await agent.on_messages(
- [TextMessage(content="Did I ask you any question?", source="user")], CancellationToken()
- )
- print(response.chat_message.content) # type: ignore
+ result = await agent.run(task="Did I ask you any question?")
+ print(result.messages[-1].content) # type: ignore
asyncio.run(main())
@@ -518,8 +499,6 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
import asyncio
from autogen_agentchat.agents import AssistantAgent
- from autogen_agentchat.messages import TextMessage
- from autogen_core import CancellationToken
from autogen_core.memory import ListMemory, MemoryContent
from autogen_ext.models.openai import OpenAIChatCompletionClient
@@ -544,10 +523,8 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
system_message="You are a helpful assistant.",
)
- response = await agent.on_messages(
- [TextMessage(content="One idea for a dinner.", source="user")], CancellationToken()
- )
- print(response.chat_message.content) # type: ignore
+ result = await agent.run(task="What is a good dinner idea?")
+ print(result.messages[-1].content) # type: ignore
asyncio.run(main())
@@ -573,10 +550,8 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
.. code-block:: python
import asyncio
- from autogen_core import CancellationToken
from autogen_ext.models.openai import OpenAIChatCompletionClient
from autogen_agentchat.agents import AssistantAgent
- from autogen_agentchat.messages import TextMessage
async def main() -> None:
@@ -587,10 +562,8 @@ class AssistantAgent(BaseChatAgent, Component[AssistantAgentConfig]):
# The system message is not supported by the o1 series model.
agent = AssistantAgent(name="assistant", model_client=model_client, system_message=None)
- response = await agent.on_messages(
- [TextMessage(content="What is the capital of France?", source="user")], CancellationToken()
- )
- print(response)
+ result = await agent.run(task="What is the capital of France?")
+ print(result.messages[-1].content) # type: ignore
asyncio.run(main())
diff --git a/python/packages/autogen-core/docs/src/index.md b/python/packages/autogen-core/docs/src/index.md
index 1f13cc8dc..ca41ee79c 100644
--- a/python/packages/autogen-core/docs/src/index.md
+++ b/python/packages/autogen-core/docs/src/index.md
@@ -46,40 +46,12 @@ A framework for building AI agents and applications
::::{grid}
:gutter: 2
-:::{grid-item-card}
-:shadow: none
-:margin: 2 0 0 0
-:columns: 12 12 6 6
-
-<div class="sd-card-title sd-font-weight-bold docutils">
-
-{fas}`book;pst-color-primary`
-Magentic-One CLI [![PyPi magentic-one-cli](https://img.shields.io/badge/PyPi-magentic--one--cli-blue?logo=pypi)](https://pypi.org/project/magentic-one-cli/)
-</div>
-A console-based multi-agent assistant for web and file-based tasks.
-Built on AgentChat.
-
-```bash
-pip install -U magentic-one-cli
-m1 "Find flights from Seattle to Paris and format the result in a table"
-```
-
-+++
-
-```{button-ref} user-guide/agentchat-user-guide/magentic-one
-:color: secondary
-
-Get Started
-```
-
-:::
-
:::{grid-item-card} {fas}`palette;pst-color-primary` Studio [![PyPi autogenstudio](https://img.shields.io/badge/PyPi-autogenstudio-blue?logo=pypi)](https://pypi.org/project/autogenstudio/)
:shadow: none
:margin: 2 0 0 0
-:columns: 12 12 6 6
+:columns: 12 12 12 12
-An app for prototyping and managing agents without writing code.
+An web-based UI for prototyping with agents without writing code.
Built on AgentChat.
```bash
@@ -87,6 +59,8 @@ pip install -U autogenstudio
autogenstudio ui --port 8080 --appdir ./myapp
```
+_Start here if you are new to AutoGen and want to prototype with agents without writing code._
+
+++
```{button-ref} user-guide/autogenstudio-user-guide/index
@@ -124,7 +98,7 @@ async def main() -> None:
asyncio.run(main())
```
-_Start here if you are building conversational agents. [Migrating from AutoGen 0.2?](./user-guide/agentchat-user-guide/migration-guide.md)._
+_Start here if you are prototyping with agents using Python. [Migrating from AutoGen 0.2?](./user-guide/agentchat-user-guide/migration-guide.md)._
+++
@@ -147,7 +121,7 @@ An event-driven programming framework for building scalable multi-agent AI syste
* Research on multi-agent collaboration.
* Distributed agents for multi-language applications.
-_Start here if you are building workflows or distributed agent systems._
+_Start here if you are getting serious about building multi-agent systems._
+++
@@ -167,7 +141,7 @@ Get Started
Implementations of Core and AgentChat components that interface with external services or other libraries.
You can find and use community extensions or create your own. Examples of built-in extensions:
-* {py:class}`~autogen_ext.tools.langchain.LangChainToolAdapter` for using LangChain tools.
+* {py:class}`~autogen_ext.tools.mcp.McpWorkbench` for using Model-Context Protocol (MCP) servers.
* {py:class}`~autogen_ext.agents.openai.OpenAIAssistantAgent` for using Assistant API.
* {py:class}`~autogen_ext.code_executors.docker.DockerCommandLineCodeExecutor` for running model-generated code in a Docker container.
* {py:class}`~autogen_ext.runtimes.grpc.GrpcWorkerAgentRuntime` for distributed agents.
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/custom-agents.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/custom-agents.ipynb
index 4ca98a433..b24b49e76 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/custom-agents.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/custom-agents.ipynb
@@ -16,7 +16,9 @@
"- {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_reset`: The abstract method that resets the agent to its initial state. This method is called when the agent is asked to reset itself.\n",
"- {py:attr}`~autogen_agentchat.agents.BaseChatAgent.produced_message_types`: The list of possible {py:class}`~autogen_agentchat.messages.BaseChatMessage` message types the agent can produce in its response.\n",
"\n",
- "Optionally, you can implement the the {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages_stream` method to stream messages as they are generated by the agent. If this method is not implemented, the agent\n",
+ "Optionally, you can implement the the {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages_stream` method to stream messages as they are generated by the agent.\n",
+ "This method is called by {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run_stream` to stream messages.\n",
+ "If this method is not implemented, the agent\n",
"uses the default implementation of {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages_stream`\n",
"that calls the {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages` method and\n",
"yields all messages in the response."
@@ -731,7 +733,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.12.3"
+ "version": "3.12.7"
}
},
"nbformat": 4,
diff --git a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
index 69b5418b1..cd2dd61ae 100644
--- a/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
+++ b/python/packages/autogen-core/docs/src/user-guide/agentchat-user-guide/tutorial/agents.ipynb
@@ -11,40 +11,50 @@
"\n",
"- {py:attr}`~autogen_agentchat.agents.BaseChatAgent.name`: The unique name of the agent.\n",
"- {py:attr}`~autogen_agentchat.agents.BaseChatAgent.description`: The description of the agent in text.\n",
- "- {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages`: Send the agent a sequence of messages that subclass {py:class}`~autogen_agentchat.messages.BaseChatMessage` and get a {py:class}`~autogen_agentchat.base.Response`. **It is important to note that agents are expected to be stateful and this method is expected to be called with new messages, not the complete history**.\n",
- "- {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages_stream`: Same as {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages` but returns an iterator of messages that subclass {py:class}`~autogen_agentchat.messages.BaseAgentEvent` or {py:class}`~autogen_agentchat.messages.BaseChatMessage` followed by a {py:class}`~autogen_agentchat.base.Response` as the last item.\n",
- "- {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_reset`: Reset the agent to its initial state.\n",
- "- {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run` and {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run_stream`: convenience methods that call {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages` and {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages_stream` respectively but offer the same interface as [Teams](./teams.ipynb).\n",
- "\n",
- "See {py:mod}`autogen_agentchat.messages` for more information on AgentChat message types.\n",
- "\n",
+ "- {py:attr}`~autogen_agentchat.agents.BaseChatAgent.run`: The method that runs the agent given a task as a string or a list of messages, and returns a {py:class}`~autogen_agentchat.base.TaskResult`. **Agents are expected to be stateful and this method is expected to be called with new messages, not complete history**.\n",
+ "- {py:attr}`~autogen_agentchat.agents.BaseChatAgent.run_stream`: Same as {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run` but returns an iterator of messages that subclass {py:class}`~autogen_agentchat.messages.BaseAgentEvent` or {py:class}`~autogen_agentchat.messages.BaseChatMessage` followed by a {py:class}`~autogen_agentchat.base.TaskResult` as the last item.\n",
"\n",
+ "See {py:mod}`autogen_agentchat.messages` for more information on AgentChat message types."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
"## Assistant Agent\n",
"\n",
"{py:class}`~autogen_agentchat.agents.AssistantAgent` is a built-in agent that\n",
- "uses a language model and has the ability to use tools."
+ "uses a language model and has the ability to use tools.\n",
+ "\n",
+ "```{warning}\n",
+ "{py:class}`~autogen_agentchat.agents.AssistantAgent` is a \"kitchen sink\" agent\n",
+ "for prototyping and educational purpose -- it is very general.\n",
+ "Make sure you read the documentation and implementation to understand the design choices.\n",
+ "Once you fully understand the design, you may want to implement your own agent.\n",
+ "See [Custom Agent](../custom-agents.ipynb).\n",
+ "```"
]
},
{
"cell_type": "code",
- "execution_count": 4,
+ "execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"from autogen_agentchat.agents import AssistantAgent\n",
- "from autogen_agentchat.messages import StructuredMessage, TextMessage\n",
+ "from autogen_agentchat.messages import StructuredMessage\n",
"from autogen_agentchat.ui import Console\n",
- "from autogen_core import CancellationToken\n",
"from autogen_ext.models.openai import OpenAIChatCompletionClient"
]
},
{
"cell_type": "code",
- "execution_count": 13,
+ "execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"# Define a tool that searches the web for information.\n",
+ "# For simplicity, we will use a mock function here that returns a static string.\n",
"async def web_search(query: str) -> str:\n",
" \"\"\"Find information on the web\"\"\"\n",
" return \"AutoGen is a programming framework for building multi-agent applications.\"\n",
@@ -52,7 +62,7 @@
"\n",
"# Create an agent that uses the OpenAI GPT-4o model.\n",
"model_client = OpenAIChatCompletionClient(\n",
- " model=\"gpt-4o\",\n",
+ " model=\"gpt-4.1-nano\",\n",
" # api_key=\"YOUR_API_KEY\",\n",
")\n",
"agent = AssistantAgent(\n",
@@ -67,65 +77,51 @@
"cell_type": "markdown",
"metadata": {},
"source": [
+ "## Getting Result\n",
"\n",
- "## Getting Responses\n",
- "\n",
- "We can use the {py:meth}`~autogen_agentchat.agents.AssistantAgent.on_messages` method to get the agent response to a given message.\n"
+ "We can use the {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run` method to get the agent run on a given task."
]
},
{
"cell_type": "code",
- "execution_count": 12,
+ "execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "[ToolCallRequestEvent(source='assistant', models_usage=RequestUsage(prompt_tokens=598, completion_tokens=16), content=[FunctionCall(id='call_9UWYM1CgE3ZbnJcSJavNDB79', arguments='{\"query\":\"AutoGen\"}', name='web_search')], type='ToolCallRequestEvent'), ToolCallExecutionEvent(source='assistant', models_usage=None, content=[FunctionExecutionResult(content='AutoGen is a programming framework for building multi-agent applications.', call_id='call_9UWYM1CgE3ZbnJcSJavNDB79', is_error=False)], type='ToolCallExecutionEvent')]\n",
- "source='assistant' models_usage=None content='AutoGen is a programming framework for building multi-agent applications.' type='ToolCallSummaryMessage'\n"
+ "[TextMessage(source='user', models_usage=None, metadata={}, content='Find information on AutoGen', type='TextMessage'), ToolCallRequestEvent(source='assistant', models_usage=RequestUsage(prompt_tokens=61, completion_tokens=16), metadata={}, content=[FunctionCall(id='call_703i17OLXfztkuioUbkESnea', arguments='{\"query\":\"AutoGen\"}', name='web_search')], type='ToolCallRequestEvent'), ToolCallExecutionEvent(source='assistant', models_usage=None, metadata={}, content=[FunctionExecutionResult(content='AutoGen is a programming framework for building multi-agent applications.', name='web_search', call_id='call_703i17OLXfztkuioUbkESnea', is_error=False)], type='ToolCallExecutionEvent'), ToolCallSummaryMessage(source='assistant', models_usage=None, metadata={}, content='AutoGen is a programming framework for building multi-agent applications.', type='ToolCallSummaryMessage')]\n"
]
}
],
"source": [
- "async def assistant_run() -> None:\n",
- " response = await agent.on_messages(\n",
- " [TextMessage(content=\"Find information on AutoGen\", source=\"user\")],\n",
- " cancellation_token=CancellationToken(),\n",
- " )\n",
- " print(response.inner_messages)\n",
- " print(response.chat_message)\n",
- "\n",
- "\n",
- "# Use asyncio.run(assistant_run()) when running in a script.\n",
- "await assistant_run()"
+ "# Use asyncio.run(agent.run(...)) when running in a script.\n",
+ "result = await agent.run(task=\"Find information on AutoGen\")\n",
+ "print(result.messages)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "The call to the {py:meth}`~autogen_agentchat.agents.AssistantAgent.on_messages` method\n",
- "returns a {py:class}`~autogen_agentchat.base.Response`\n",
- "that contains the agent's final response in the {py:attr}`~autogen_agentchat.base.Response.chat_message` attribute,\n",
- "as well as a list of inner messages in the {py:attr}`~autogen_agentchat.base.Response.inner_messages` attribute,\n",
- "which stores the agent's \"thought process\" that led to the final response.\n",
+ "The call to the {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run` method\n",
+ "returns a {py:class}`~autogen_agentchat.base.TaskResult`\n",
+ "with the list of messages in the {py:attr}`~autogen_agentchat.base.TaskResult.messages` attribute,\n",
+ "which stores the agent's \"thought process\" as well as the final response.\n",
"\n",
"```{note}\n",
- "It is important to note that {py:meth}`~autogen_agentchat.agents.AssistantAgent.on_messages`\n",
+ "It is important to note that {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run`\n",
"will update the internal state of the agent -- it will add the messages to the agent's\n",
- "history. So you should call this method with new messages.\n",
- "**You should not repeatedly call this method with the same messages or the complete history.**\n",
+ "message history. You can also call {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run`\n",
+ "without a task to get the agent to generate responses given its current state.\n",
"```\n",
"\n",
"```{note}\n",
"Unlike in v0.2 AgentChat, the tools are executed by the same agent directly within\n",
- "the same call to {py:meth}`~autogen_agentchat.agents.AssistantAgent.on_messages`.\n",
+ "the same call to {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run`.\n",
"By default, the agent will return the result of the tool call as the final response.\n",
- "```\n",
- "\n",
- "You can also call the {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run` method, which is a convenience method that calls {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages`. \n",
- "It follows the same interface as [Teams](./teams.ipynb) and returns a {py:class}`~autogen_agentchat.base.TaskResult` object."
+ "```"
]
},
{
@@ -140,19 +136,19 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
- "<img src=\"data:image/png;base64,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\"/>"
+ "<img src=\"data:image/png;base64,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\"/>"
],
"text/plain": [
- "<autogen_core._image.Image at 0x12a29f9b0>"
+ "<autogen_core._image.Image at 0x7f7089c83710>"
]
},
- "execution_count": 9,
+ "execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
@@ -174,29 +170,21 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "The image depicts a vintage car, likely from the 1930s or 1940s, with a sleek, classic design. The car seems to be customized or well-maintained, as indicated by its shiny exterior and lowered stance. It has a prominent grille and round headlights. There's a license plate on the front with the text \"FARMER BOY.\" The setting appears to be a street with old-style buildings in the background, suggesting a historical or retro theme.\n"
+ "The image depicts a scenic mountain landscape under a clear blue sky. There are several rugged mountain peaks in the background, with some clouds scattered across the sky. In the valley below, there is a body of water, possibly a lake or river, surrounded by greenery. The overall scene conveys a sense of natural beauty and tranquility.\n"
]
}
],
"source": [
"# Use asyncio.run(...) when running in a script.\n",
- "response = await agent.on_messages([multi_modal_message], CancellationToken())\n",
- "print(response.chat_message)"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "You can also use {py:class}`~autogen_agentchat.messages.MultiModalMessage` as a `task`\n",
- "input to the {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run` method."
+ "result = await agent.run(task=multi_modal_message)\n",
+ "print(result.messages[-1].content) # type: ignore"
]
},
{
@@ -206,51 +194,47 @@
"## Streaming Messages\n",
"\n",
"We can also stream each message as it is generated by the agent by using the\n",
- "{py:meth}`~autogen_agentchat.agents.AssistantAgent.on_messages_stream` method,\n",
+ "{py:meth}`~autogen_agentchat.agents.BaseChatAgent.run_stream` method,\n",
"and use {py:class}`~autogen_agentchat.ui.Console` to print the messages\n",
"as they appear to the console."
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "---------- assistant ----------\n",
- "[FunctionCall(id='call_fSp5iTGVm2FKw5NIvfECSqNd', arguments='{\"query\":\"AutoGen information\"}', name='web_search')]\n",
+ "---------- TextMessage (user) ----------\n",
+ "Find information on AutoGen\n",
+ "---------- ToolCallRequestEvent (assistant) ----------\n",
+ "[FunctionCall(id='call_HOTRhOzXCBm0zSqZCFbHD7YP', arguments='{\"query\":\"AutoGen\"}', name='web_search')]\n",
"[Prompt tokens: 61, Completion tokens: 16]\n",
- "---------- assistant ----------\n",
- "[FunctionExecutionResult(content='AutoGen is a programming framework for building multi-agent applications.', call_id='call_fSp5iTGVm2FKw5NIvfECSqNd')]\n",
- "---------- assistant ----------\n",
- "AutoGen is a programming framework designed for building multi-agent applications. If you need more detailed information or specific aspects about AutoGen, feel free to ask!\n",
- "[Prompt tokens: 93, Completion tokens: 32]\n",
+ "---------- ToolCallExecutionEvent (assistant) ----------\n",
+ "[FunctionExecutionResult(content='AutoGen is a programming framework for building multi-agent applications.', name='web_search', call_id='call_HOTRhOzXCBm0zSqZCFbHD7YP', is_error=False)]\n",
+ "---------- ToolCallSummaryMessage (assistant) ----------\n",
+ "AutoGen is a programming framework for building multi-agent applications.\n",
"---------- Summary ----------\n",
- "Number of inner messages: 2\n",
- "Total prompt tokens: 154\n",
- "Total completion tokens: 48\n",
- "Duration: 4.30 seconds\n"
+ "Number of messages: 4\n",
+ "Finish reason: None\n",
+ "Total prompt tokens: 61\n",
+ "Total completion tokens: 16\n",
+ "Duration: 0.52 seconds\n"
]
}
],
"source": [
"async def assistant_run_stream() -> None:\n",
" # Option 1: read each message from the stream (as shown in the previous example).\n",
- " # async for message in agent.on_messages_stream(\n",
- " # [TextMessage(content=\"Find information on AutoGen\", source=\"user\")],\n",
- " # cancellation_token=CancellationToken(),\n",
- " # ):\n",
+ " # async for message in agent.run_stream(task=\"Find information on AutoGen\"):\n",
" # print(message)\n",
"\n",
" # Option 2: use Console to print all messages as they appear.\n",
" await Console(\n",
- " agent.on_messages_stream(\n",
- " [TextMessage(content=\"Find information on AutoGen\", source=\"user\")],\n",
- " cancellation_token=CancellationToken(),\n",
- " ),\n",
+ " agent.run_stream(task=\"Find information on AutoGen\"),\n",
" output_stats=True, # Enable stats printing.\n",
" )\n",
"\n",
@@ -263,21 +247,19 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "The {py:meth}`~autogen_agentchat.agents.AssistantAgent.on_messages_stream` method\n",
- "returns an asynchronous generator that yields each inner message generated by the agent,\n",
- "with the final item being the response message in the {py:attr}`~autogen_agentchat.base.Response.chat_message` attribute.\n",
+ "The {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run_stream` method\n",
+ "returns an asynchronous generator that yields each message generated by the agent,\n",
+ "followed by a {py:class}`~autogen_agentchat.base.TaskResult` as the last item.\n",
"\n",
"From the messages, you can observe that the assistant agent utilized the `web_search` tool to\n",
- "gather information and responded based on the search results.\n",
- "\n",
- "You can also use {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run_stream` to get the same streaming behavior as {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages_stream`. It follows the same interface as [Teams](./teams.ipynb)."
+ "gather information and responded based on the search results."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
- "## Using Tools\n",
+ "## Using Tools and Workbench\n",
"\n",
"Large Language Models (LLMs) are typically limited to generating text or code responses. \n",
"However, many complex tasks benefit from the ability to use external tools that perform specific actions,\n",
@@ -292,10 +274,13 @@
"\n",
"In AgentChat, the {py:class}`~autogen_agentchat.agents.AssistantAgent` can use tools to perform specific actions.\n",
"The `web_search` tool is one such tool that allows the assistant agent to search the web for information.\n",
- "A custom tool can be a Python function or a subclass of the {py:class}`~autogen_core.tools.BaseTool`.\n",
+ "A single custom tool can be a Python function or a subclass of the {py:class}`~autogen_core.tools.BaseTool`.\n",
+ "\n",
+ "On the other hand, a {py:class}`~autogen_core.tools.Workbench` is a collection of tools that share state and resources.\n",
"\n",
"```{note}\n",
- "For how to use model clients directly with tools, refer to the [Tools](../../core-user-guide/components/tools.ipynb) section\n",
+ "For how to use model clients directly with tools and workbench, refer to the [Tools](../../core-user-guide/components/tools.ipynb)\n",
+ "and [Workbench](../../core-user-guide/components/workbench.ipynb) sections\n",
"in the Core User Guide.\n",
"```\n",
"\n",
@@ -305,7 +290,7 @@
"can add a reflection step to have the model summarize the tool's output,\n",
"by setting the `reflect_on_tool_use=True` parameter in the {py:class}`~autogen_agentchat.agents.AssistantAgent` constructor.\n",
"\n",
- "### Built-in Tools\n",
+ "### Built-in Tools and Workbench\n",
"\n",
"AutoGen Extension provides a set of built-in tools that can be used with the Assistant Agent.\n",
"Head over to the [API documentation](../../../reference/index.md) for all the available tools\n",
@@ -314,7 +299,7 @@
"- {py:mod}`~autogen_ext.tools.graphrag`: Tools for using GraphRAG index.\n",
"- {py:mod}`~autogen_ext.tools.http`: Tools for making HTTP requests.\n",
"- {py:mod}`~autogen_ext.tools.langchain`: Adaptor for using LangChain tools.\n",
- "- {py:mod}`~autogen_ext.tools.mcp`: Tools for using Model Chat Protocol (MCP) servers."
+ "- {py:mod}`~autogen_ext.tools.mcp`: Tools and workbench for using Model Chat Protocol (MCP) servers."
]
},
{
@@ -376,11 +361,11 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "### Model Context Protocol Tools\n",
+ "### Model Context Protocol (MCP) Workbench\n",
"\n",
"The {py:class}`~autogen_agentchat.agents.AssistantAgent` can also use tools that are\n",
"served from a Model Context Protocol (MCP) server\n",
- "using {py:func}`~autogen_ext.tools.mcp.mcp_server_tools`."
+ "using {py:func}`~autogen_ext.tools.mcp.McpWorkbench`."
]
},
{
@@ -392,107 +377,34 @@
"name": "stdout",
"output_type": "stream",
"text": [
- "Seattle, located in Washington state, is the most populous city in the state and a major city in the Pacific Northwest region of the United States. It's known for its vibrant cultural scene, significant economic presence, and rich history. Here are some key points about Seattle from the Wikipedia page:\n",
- "\n",
- "1. **History and Geography**: Seattle is situated between Puget Sound and Lake Washington, with the Cascade Range to the east and the Olympic Mountains to the west. Its history is deeply rooted in Native American heritage and its development was accelerated with the arrival of settlers in the 19th century. The city was officially incorporated in 1869.\n",
- "\n",
- "2. **Economy**: Seattle is a major economic hub with a diverse economy anchored by sectors like aerospace, technology, and retail. It's home to influential companies such as Amazon and Starbucks, and has a significant impact on the tech industry due to companies like Microsoft and other technology enterprises in the surrounding area.\n",
- "\n",
- "3. **Cultural Significance**: Known for its music scene, Seattle was the birthplace of grunge music in the early 1990s. It also boasts significant attractions like the Space Needle, Pike Place Market, and the Seattle Art Museum. \n",
- "\n",
- "4. **Education and Innovation**: The city hosts important educational institutions, with the University of Washington being a leading research university. Seattle is recognized for fostering innovation and is a leader in environmental sustainability efforts.\n",
- "\n",
- "5. **Demographics and Diversity**: Seattle is noted for its diverse population, reflected in its rich cultural tapestry. It has seen a significant increase in population, leading to urban development and changes in its social landscape.\n",
- "\n",
- "These points highlight Seattle as a dynamic city with a significant cultural, economic, and educational influence within the United States and beyond.\n"
+ "Seattle is a major city located in the state of Washington, United States. It was founded on November 13, 1851, and incorporated as a town on January 14, 1865, and later as a city on December 2, 1869. The city is named after Chief Seattle. It covers an area of approximately 142 square miles, with a population of around 737,000 as of the 2020 Census, and an estimated 755,078 residents in 2023. Seattle is known by nicknames such as The Emerald City, Jet City, and Rain City, and has mottos including The City of Flowers and The City of Goodwill. The city operates under a mayor–council government system, with Bruce Harrell serving as mayor. Key landmarks include the Space Needle, Pike Place Market, Amazon Spheres, and the Seattle Great Wheel. It is situated on the U.S. West Coast, with a diverse urban and metropolitan area that extends to a population of over 4 million in the greater metropolitan region.\n"
]
}
],
"source": [
"from autogen_agentchat.agents import AssistantAgent\n",
+ "from autogen_agentchat.messages import TextMessage\n",
"from autogen_ext.models.openai import OpenAIChatCompletionClient\n",
- "from autogen_ext.tools.mcp import StdioServerParams, mcp_server_tools\n",
+ "from autogen_ext.tools.mcp import McpWorkbench, StdioServerParams\n",
"\n",
"# Get the fetch tool from mcp-server-fetch.\n",
"fetch_mcp_server = StdioServerParams(command=\"uvx\", args=[\"mcp-server-fetch\"])\n",
- "tools = await mcp_server_tools(fetch_mcp_server)\n",
- "\n",
- "# Create an agent that can use the fetch tool.\n",
- "model_client = OpenAIChatCompletionClient(model=\"gpt-4o\")\n",
- "agent = AssistantAgent(name=\"fetcher\", model_client=model_client, tools=tools, reflect_on_tool_use=True) # type: ignore\n",
- "\n",
- "# Let the agent fetch the content of a URL and summarize it.\n",
- "result = await agent.run(task=\"Summarize the content of https://en.wikipedia.org/wiki/Seattle\")\n",
- "assert isinstance(result.messages[-1], TextMessage)\n",
- "print(result.messages[-1].content)\n",
- "\n",
- "# Close the connection to the model client.\n",
- "await model_client.close()"
- ]
- },
- {
- "cell_type": "markdown",
- "metadata": {},
- "source": [
- "### Langchain Tools\n",
"\n",
- "You can also use tools from the Langchain library\n",
- "by wrapping them in {py:class}`~autogen_ext.tools.langchain.LangChainToolAdapter`."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "---------- assistant ----------\n",
- "[FunctionCall(id='call_BEYRkf53nBS1G2uG60wHP0zf', arguments='{\"query\":\"df[\\'Age\\'].mean()\"}', name='python_repl_ast')]\n",
- "[Prompt tokens: 111, Completion tokens: 22]\n",
- "---------- assistant ----------\n",
- "[FunctionExecutionResult(content='29.69911764705882', call_id='call_BEYRkf53nBS1G2uG60wHP0zf')]\n",
- "---------- assistant ----------\n",
- "29.69911764705882\n",
- "---------- Summary ----------\n",
- "Number of inner messages: 2\n",
- "Total prompt tokens: 111\n",
- "Total completion tokens: 22\n",
- "Duration: 0.62 seconds\n"
- ]
- },
- {
- "data": {
- "text/plain": [
- "Response(chat_message=ToolCallSummaryMessage(source='assistant', models_usage=None, content='29.69911764705882', type='ToolCallSummaryMessage'), inner_messages=[ToolCallRequestEvent(source='assistant', models_usage=RequestUsage(prompt_tokens=111, completion_tokens=22), content=[FunctionCall(id='call_BEYRkf53nBS1G2uG60wHP0zf', arguments='{\"query\":\"df[\\'Age\\'].mean()\"}', name='python_repl_ast')], type='ToolCallRequestEvent'), ToolCallExecutionEvent(source='assistant', models_usage=None, content=[FunctionExecutionResult(content='29.69911764705882', call_id='call_BEYRkf53nBS1G2uG60wHP0zf')], type='ToolCallExecutionEvent')])"
- ]
- },
- "execution_count": 5,
- "metadata": {},
- "output_type": "execute_result"
- }
- ],
- "source": [
- "import pandas as pd\n",
- "from autogen_ext.tools.langchain import LangChainToolAdapter\n",
- "from langchain_experimental.tools.python.tool import PythonAstREPLTool\n",
+ "# Create an MCP workbench which provides a session to the mcp server.\n",
+ "async with McpWorkbench(fetch_mcp_server) as workbench: # type: ignore\n",
+ " # Create an agent that can use the fetch tool.\n",
+ " model_client = OpenAIChatCompletionClient(model=\"gpt-4.1-nano\")\n",
+ " fetch_agent = AssistantAgent(\n",
+ " name=\"fetcher\", model_client=model_client, workbench=workbench, reflect_on_tool_use=True\n",
+ " )\n",
"\n",
- "df = pd.read_csv(\"https://raw.githubusercontent.com/pandas-dev/pandas/main/doc/data/titanic.csv\")\n",
- "tool = LangChainToolAdapter(PythonAstREPLTool(locals={\"df\": df}))\n",
- "model_client = OpenAIChatCompletionClient(model=\"gpt-4o\")\n",
- "agent = AssistantAgent(\n",
- " \"assistant\", tools=[tool], model_client=model_client, system_message=\"Use the `df` variable to access the dataset.\"\n",
- ")\n",
- "await Console(\n",
- " agent.on_messages_stream(\n",
- " [TextMessage(content=\"What's the average age of the passengers?\", source=\"user\")], CancellationToken()\n",
- " ),\n",
- " output_stats=True,\n",
- ")\n",
+ " # Let the agent fetch the content of a URL and summarize it.\n",
+ " result = await fetch_agent.run(task=\"Summarize the content of https://en.wikipedia.org/wiki/Seattle\")\n",
+ " assert isinstance(result.messages[-1], TextMessage)\n",
+ " print(result.messages[-1].content)\n",
"\n",
- "await model_client.close()"
+ " # Close the connection to the model client.\n",
+ " await model_client.close()"
]
},
{
@@ -642,7 +554,7 @@
"\n",
"You can stream the tokens generated by the model client by setting `model_client_stream=True`.\n",
"This will cause the agent to yield {py:class}`~autogen_agentchat.messages.ModelClientStreamingChunkEvent` messages\n",
- "in {py:meth}`~autogen_agentchat.agents.BaseChatAgent.on_messages_stream` and {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run_stream`.\n",
+ "in {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run_stream`.\n",
"\n",
"The underlying model API must support streaming tokens for this to work.\n",
"Please check with your model provider to see if this is supported."
@@ -650,30 +562,32 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
- "source='assistant' models_usage=None content='Two' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' cities' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' in' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' South' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' America' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' are' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' Buenos' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' Aires' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' in' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' Argentina' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' and' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' São' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' Paulo' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' in' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' Brazil' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content='.' type='ModelClientStreamingChunkEvent'\n",
- "Response(chat_message=TextMessage(source='assistant', models_usage=RequestUsage(prompt_tokens=0, completion_tokens=0), content='Two cities in South America are Buenos Aires in Argentina and São Paulo in Brazil.', type='TextMessage'), inner_messages=[])\n"
+ "source='user' models_usage=None metadata={} content='Name two cities in South America' type='TextMessage'\n",
+ "source='assistant' models_usage=None metadata={} content='Two' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' cities' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' in' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' South' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' America' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' are' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' Buenos' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' Aires' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' in' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' Argentina' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' and' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' São' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' Paulo' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' in' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content=' Brazil' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=None metadata={} content='.' type='ModelClientStreamingChunkEvent'\n",
+ "source='assistant' models_usage=RequestUsage(prompt_tokens=0, completion_tokens=0) metadata={} content='Two cities in South America are Buenos Aires in Argentina and São Paulo in Brazil.' type='TextMessage'\n",
+ "messages=[TextMessage(source='user', models_usage=None, metadata={}, content='Name two cities in South America', type='TextMessage'), TextMessage(source='assistant', models_usage=RequestUsage(prompt_tokens=0, completion_tokens=0), metadata={}, content='Two cities in South America are Buenos Aires in Argentina and São Paulo in Brazil.', type='TextMessage')] stop_reason=None\n"
]
}
],
@@ -688,10 +602,7 @@
")\n",
"\n",
"# Use an async function and asyncio.run() in a script.\n",
- "async for message in streaming_assistant.on_messages_stream( # type: ignore\n",
- " [TextMessage(content=\"Name two cities in South America\", source=\"user\")],\n",
- " cancellation_token=CancellationToken(),\n",
- "):\n",
+ "async for message in streaming_assistant.run_stream(task=\"Name two cities in South America\"): # type: ignore\n",
" print(message)"
]
},
@@ -701,48 +612,7 @@
"source": [
"You can see the streaming chunks in the output above.\n",
"The chunks are generated by the model client and are yielded by the agent as they are received.\n",
- "The final response, the concatenation of all the chunks, is yielded right after the last chunk.\n",
- "\n",
- "Similarly, {py:meth}`~autogen_agentchat.agents.BaseChatAgent.run_stream` will also yield the same streaming chunks,\n",
- "followed by a full text message right after the last chunk."
- ]
- },
- {
- "cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [
- {
- "name": "stdout",
- "output_type": "stream",
- "text": [
- "source='user' models_usage=None content='Name two cities in North America.' type='TextMessage'\n",
- "source='assistant' models_usage=None content='Two' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' cities' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' in' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' North' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' America' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' are' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' New' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' York' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' City' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' in' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' the' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' United' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' States' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' and' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' Toronto' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' in' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content=' Canada' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=None content='.' type='ModelClientStreamingChunkEvent'\n",
- "source='assistant' models_usage=RequestUsage(prompt_tokens=0, completion_tokens=0) content='Two cities in North America are New York City in the United States and Toronto in Canada.' type='TextMessage'\n",
- "TaskResult(messages=[TextMessage(source='user', models_usage=None, content='Name two cities in North America.', type='TextMessage'), TextMessage(source='assistant', models_usage=RequestUsage(prompt_tokens=0, completion_tokens=0), content='Two cities in North America are New York City in the United States and Toronto in Canada.', type='TextMessage')], stop_reason=None)\n"
- ]
- }
- ],
- "source": [
- "async for message in streaming_assistant.run_stream(task=\"Name two cities in North America.\"): # type: ignore\n",
- " print(message)"
+ "The final response, the concatenation of all the chunks, is yielded right after the last chunk."
]
},
{
@@ -854,7 +724,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.12.3"
+ "version": "3.12.7"
}
},
"nbformat": 4,