diff --git a/docs/sphinx_doc/source/tutorial/101-agentscope.md b/docs/sphinx_doc/source/tutorial/101-agentscope.md new file mode 100644 index 000000000..23760f361 --- /dev/null +++ b/docs/sphinx_doc/source/tutorial/101-agentscope.md @@ -0,0 +1,115 @@ +(101-agentscope)= + +# About AgentScope + +In this tutorial, we will provide an overview of AgentScope by answering +several questions, including what's AgentScope, what can AgentScope provide, +and why we should choose AgentScope. Let's get started! + +## What is AgentScope? + +AgentScope is a developer-centric multi-agent platform, which enables +developers to build their LLM-empowered multi-agent applications with less +effort. + +With the advance of large language models, developers are able to build +diverse applications. +In order to connect LLMs to data and services and solve complex tasks, +AgentScope provides a series of development tools and components for ease of +development. +It features + - **usability**, + - **robustness**, and + - **the support of multi-modal data** and + - **distributed deployment**. + +## Key Concepts + +### Message +Message is a carrier of information (e.g. instructions, multi-modal +data, and dialogue). In AgentScope, message is a Python dict subclass +with `name` and `content` as necessary fields, and `url` as an optional +field referring to additional resources. + +### Agent +Agent is an autonomous entity capable of interacting with environment and +agents, and taking actions to change the environment. In AgentScope, an +agent takes message as input and generates corresponding response message. + +### Service +Service refers to the functional APIs that enable agents to perform +specific tasks. In AgentScope, services are categorized into model API +services, which are channels to use the LLMs, and general API services, +which provide a variety of tool functions. + +### Workflow +Workflow represents ordered sequences of agent executions and message +exchanges between agents, analogous to computational graphs in TensorFlow, +but with the flexibility to accommodate non-DAG structures. + + +## Why AgentScope? + +**Exceptional usability for developers.** +AgentScope provides high usability for developers with flexible syntactic +sugars, ready-to-use components, and pre-built examples. + +**Robust fault tolerance for diverse models and APIs.** +AgentScope ensures robust fault tolerance for diverse models, APIs, and +allows developers to build customized fault-tolerant strategies. + +**Extensive compatibility for multi-modal application.** +AgentScope supports multi-modal data (e.g., files, images, audio and videos) +in both dialog presentation, message transmission and data storage. + +**Optimized efficiency for distributed multi-agent operations.** AgentScope +introduces an actor-based distributed mechanism that enables centralized +programming of complex distributed workflows, and automatic parallel +optimization. + + +## How is AgentScope designed? + +[]() + +The architecture of AgentScope comprises three hierarchical layers. The +layers provide supports for multi-agent applications from different levels, +including elementary and advanced functionalities of a single agent +(**utility layer**), resources and runtime management (**manager and wrapper +layer**), and agent-level to workflow-level programming interfaces (**agent +layer**). AgentScope introduces intuitive abstractions designed to fulfill +the diverse functionalities inherent to each layer and simplify the +complicated interlayer dependencies when building multi-agent systems. +Furthermore, we offer programming interfaces and default mechanisms to +strengthen the resilience of multi-agent systems against faults within +different layers. + +## AgentScope Code Structure + +```bash +AgentScope +├── src +│ ├── agentscope +│ | ├── agents # Core components and implementations pertaining to agents. +│ | ├── memory # Structures for agent memory. +│ | ├── models # Interfaces for integrating diverse model APIs. +│ | ├── pipeline # Fundamental components and implementations for running pipelines. +│ | ├── rpc # Rpc module for agent distributed deployment. +│ | ├── service # Services offering functions independent of memory and state. +| | ├── web # WebUI used to show dialogs. +│ | ├── utils # Auxiliary utilities and helper functions. +│ | ├── message.py # Definitions and implementations of messaging between agents. +│ | ├── prompt.py # Prompt engineering module for model input. +│ | ├── ... .. +│ | ├── ... .. +├── scripts # Scripts for launching local Model API +├── examples # Pre-built examples of different applications. +├── docs # Documentation tool for API reference. +├── tests # Unittest modules for continuous integration. +├── LICENSE # The official licensing agreement for AgentScope usage. +└── setup.py # Setup script for installing. +├── ... .. +└── ... .. +``` + +[[Return to the top]](#fundamental-concepts) \ No newline at end of file diff --git a/docs/sphinx_doc/source/tutorial/102-concepts.md b/docs/sphinx_doc/source/tutorial/102-concepts.md deleted file mode 100644 index 745c2cc50..000000000 --- a/docs/sphinx_doc/source/tutorial/102-concepts.md +++ /dev/null @@ -1,46 +0,0 @@ -(102-concepts)= - -# Fundamental Concepts - -In this tutorial, you'll have an initial understanding of the **fundamental concepts** of AgentScope. We will focus on how a multi-agent application runs based on our platform and familiarize you with the essential terms. Let's get started! - -![Concepts](https://img.alicdn.com/imgextra/i1/O1CN01ELiTw41KGKqTmWZua_!!6000000001136-2-tps-756-598.png) - -## Essential Terms and Concepts - -* **Agent** refers to an autonomous entity capable of performing actions to achieve specific objectives (probably powered by LLMs). In AgentScope, an agent takes the message as input and generates a corresponding response message. Agents can interact with each other to simulate human-like behaviors (e.g., discussion or debate) and cooperate to finish complicated tasks (e.g., generate runnable and reliable code). -* **Message** is a carrier of communication information among agents. It encapsulates information that needs to be conveyed, such as instructions, multi-modal data, or status updates. In AgentScope, a message is a subclass of Python's dict with additional features for inter-agent communication, including fields such as `name` and `content` for identification and payload delivery. -* **Memory** refers to the structures (e.g., list-like memory, database-based memory) used to store and manage `Msg` (Message) that agents need to remember and store. This can include chat history, knowledge, or other data that informs the agent's future actions. -* **Service** is a collection of functionality tools (e.g., web search, code interpreter, file processing) that provide specific capabilities or processes that are independent of an agent's memory state. Services can be invoked by agents or other components and designed to be reusable across different scenarios. -* **Pipeline** refers to the interaction order or pattern of agents in a task. AgentScope provides built-in `pipelines` to streamline the process of collaboration across multiple agents, such as `SequentialPipeline` and `ForLoopPipeline`. When a `Pipeline` is executed, the *message* passes from predecessors to successors with intermediate results for the task. - -## Code Structure - -```bash -AgentScope -├── src -│ ├── agentscope -│ | ├── agents # Core components and implementations pertaining to agents. -│ | ├── configs # Configurations that can be customized for the application's needs. -│ | ├── memory # Structures for agent memory. -│ | ├── models # Interfaces for integrating diverse model APIs. -│ | ├── pipeline # Fundamental components and implementations for running pipelines. -│ | ├── rpc # Rpc module for agent distributed deployment. -│ | ├── service # Services offering functions independent of memory and state. -│ | ├── utils # Auxiliary utilities and helper functions. -│ | ├── message.py # Definitions and implementations of messaging between agents. -| | ├── web # WebUI used to show dialogs. -│ | ├── prompt.py # Prompt engineering module for model input. -│ | ├── ... .. -│ | ├── ... .. -├── scripts # Scripts for launching local Model API -├── examples # Pre-built examples of different applications. -├── docs # Documentation tool for API reference. -├── tests # Unittest modules for continuous integration. -├── LICENSE # The official licensing agreement for AgentScope usage. -└── setup.py # Setup script for installing. -├── ... .. -└── ... .. -``` - -[[Return to the top]](#fundamental-concepts) diff --git a/docs/sphinx_doc/source/tutorial/101-installation.md b/docs/sphinx_doc/source/tutorial/102-installation.md similarity index 99% rename from docs/sphinx_doc/source/tutorial/101-installation.md rename to docs/sphinx_doc/source/tutorial/102-installation.md index 633c3cec1..e3233ca9a 100644 --- a/docs/sphinx_doc/source/tutorial/101-installation.md +++ b/docs/sphinx_doc/source/tutorial/102-installation.md @@ -1,4 +1,4 @@ -(101-installation)= +(102-installation)= # Installation diff --git a/docs/sphinx_doc/source/tutorial/103-example.md b/docs/sphinx_doc/source/tutorial/103-example.md index 08ead7cf5..4821d493f 100644 --- a/docs/sphinx_doc/source/tutorial/103-example.md +++ b/docs/sphinx_doc/source/tutorial/103-example.md @@ -1,19 +1,35 @@ -(103-example)= +(103-start)= -# Getting Started with a Simple Example +# Quick Start -AgentScope is a versatile platform for building and running multi-agent applications. We provide various pre-built examples that will help you quickly understand how to create and use multi-agent for various applications. In this tutorial, you will learn how to set up a **simple agent-based interaction**. +AgentScope is designed with a flexible communication mechanism. +In this tutorial, we will introduce the basic usage of AgentScope via a +simple standalone conversation between two agents (e.g. user and assistant +agents). -## Step1: Prepare Model Configs +## Step1: Prepare Model -Agent is the basic composition and communication unit in AgentScope. To initialize a model-based agent, you need to prepare your configs for avaliable models. AgentScope supports a variety of APIs for pre-trained models. Here is a table outlining the supported APIs and the type of arguments required for each: +AgentScope decouples the deployment and invocation of models to better build multi-agent applications. -| Model Usage | Model Type Argument in AgentScope | Supported APIs | -| --------------------------- | --------------------------------- |-----------------------------------------------------------------------------| -| Text generation | `openai` | Standard *OpenAI* chat API, FastChat and vllm | -| Image generation | `openai_dall_e` | *DALL-E* API for generating images | -| Embedding | `openai_embedding` | API for text embeddings | -| General usages in POST | `post_api` | *Huggingface* and *ModelScope* Inference API, and other customized post API | +In terms of model deployment, users can use third-party model services such +as OpenAI API, HuggingFace/ModelScope Inference API, and can also quickly +deploy local open-source model services through the [scripts] +(https://github.com/modelscope/agentscope/blob/main/scripts/README.md) in +the repository. Currently, we support building basic model services quickly +using Flask with Transformers (or ModelScope), and also support deploying +local model services through FastChat and vllm inference engines. + +While in terms of model invocation, AgentScope provides a `ModelWrapper` class to encapsulate OpenAI API and RESTful Post Request calls. +Currently, the supported OpenAI APIs include Chat, Image generation, and Embedding. +Users can specify the model service by setting different model configs. + + +| Model Usage | Supported APIs | +| --------------------------- |-----------------------------------------------------------------------------| +| Text generation | Standard *OpenAI* chat API, FastChat and vllm | +| Image generation | *DALL-E* API for generating images | +| Embedding | API for text embeddings | +| General usages in POST | *Huggingface* and *ModelScope* Inference API, and other customized post API | Each API has its specific configuration requirements. For example, to configure an OpenAI API, you would need to fill out the following fields in the model config in a dict, a yaml file or a json file: @@ -29,7 +45,7 @@ model_config = { For open-source models, we support integration with various model interfaces such as HuggingFace, ModelScope, FastChat, and vllm. You can find scripts on deploying these services in the `scripts` directory, and we defer the detailed instructions to [[Using Different Model Sources with Model API]](203-model). -You can register your configuration by calling AgentScope's initilization method as follow. Besides, you can also load more than one config by calling init mutliple times. +You can register your configuration by calling AgentScope's initialization method as follow. Besides, you can also load more than one config by calling init multiple times. ```python import agentscope diff --git a/docs/sphinx_doc/source/tutorial/104-usecase.md b/docs/sphinx_doc/source/tutorial/104-usecase.md index 8fc6f1f7e..a6a46f9c1 100644 --- a/docs/sphinx_doc/source/tutorial/104-usecase.md +++ b/docs/sphinx_doc/source/tutorial/104-usecase.md @@ -12,7 +12,7 @@ Let the adventure begin to unlock the potential of multi-agent applications with ## Getting Started -Firstly, ensure that you have installed and configured AgentScope properly. Besides, we will involve the basic concepts of `Model API`, `Agent`, `Msg`, and `Pipeline,` as described in [Tutorial-Concept](102-concepts). The overview of this tutorial is shown below: +Firstly, ensure that you have installed and configured AgentScope properly. Besides, we will involve the basic concepts of `Model API`, `Agent`, `Msg`, and `Pipeline,` as described in [Tutorial-Concept](101-agentscope). The overview of this tutorial is shown below: - [Crafting Your First Application](#crafting-your-first-application) - [Getting Started](#getting-started) diff --git a/docs/sphinx_doc/source/tutorial/main.md b/docs/sphinx_doc/source/tutorial/main.md index 0460e6b98..9f4b048b8 100644 --- a/docs/sphinx_doc/source/tutorial/main.md +++ b/docs/sphinx_doc/source/tutorial/main.md @@ -12,8 +12,8 @@ AgentScope is an innovative multi-agent platform designed to empower developers ### Getting Started -- [Installation Guide](101-installation) -- [Fundamental Concepts](102-concepts) +- [Installation Guide](102-installation) +- [Fundamental Concepts](101-agentscope) - [Getting Started with a Simple Example](103-example) - [Crafting Your First Application](104-usecase) - [Logging and WebUI](105-logging) diff --git a/docs/sphinx_doc/source/tutorial/zh/101-agentscope.md b/docs/sphinx_doc/source/tutorial/zh/101-agentscope.md new file mode 100644 index 000000000..2db68998a --- /dev/null +++ b/docs/sphinx_doc/source/tutorial/zh/101-agentscope.md @@ -0,0 +1,91 @@ +(101-agentscope)= + +# 关于AgentScope + +在此教程中，我们将通过回答问题的方式向您介绍AgentScope，包括什么是AgentScope，AgentScope +能做什么，以及我们为什么应该选择AgentScope。让我们开始吧！ + +## 什么是AgentScope？ + +AgentScope是以开发者为中心的多智能体平台，它使开发者能够更轻松地构建基于大语言模型的多智能体应用程序。 + +大模型的出现使得开发者能够构建多样化的应用程序，为了连接大语言模型和数据以及服务，并更好地解 +决复杂任务，AgentScope提供了一系列的开发工具和组件来提高开发效率。AgentScope以 +- **易用性**， +- **鲁棒性**， +- **支持多模态数据**和 +- **分布式部署** + +为特点。 + +## 关键概念 + +### 信息（Message） +是信息的载体（例如指令、多模态数据和对话内容）。在AgentScope中，消息是Python字典的子类， +具有`name`和`content`作为必要字段，`url`作为可选字段并指向额外的资源。 + +### 智能体（Agent） +是能够与环境和其他智能体交互，并采取行动改变环境的自主实体。在AgentScope中， +智能体以消息作为输入，并生成相应的响应消息。 + +### 服务（Service） +是使智能体能够执行特定任务的功能性API。在AgentScope中，服务分为模型API服务 +（用于使用大预言模型）和通用API服务（提供各种工具函数）。 + +### 工作流（Workflow） +表示智能体执行和智能体之间的消息交换的有序序列，类似于TensorFlow中的计算图， +但其并不一定是DAG结构。 + + +## 为什么选择AgentScope？ + +**面向开发者的易用性。** +AgentScope为开发者提供了高易用性，包括灵活易用的语法糖、即拿即用的组件和预构建的multi-agent样例。 + +**可靠稳定的容错机制。** +AgentScope确保了对多种模型和APIs的容错性，并允许开发者构建定制的容错策略。 + +**全面兼容多模态数据。** +AgentScope支持多模态数据（例如文件、图像、音频和视频）的对话展示、消息传输和数据存储。 + +**高效分布式运行效率。** +AgentScope引入了基于actor的分布式机制，使得复杂的分布式工作流的集中式编程和自动并行优化成为可能。 + +## AgentScope是如何设计的？ + +[]() + +AgentScope由三个层次的层次结构组成。 +这些层次提供了对多智能体应用程序的支持，包括单个智能体的基本和高级功能（实用程序层）、资源和运行时管理（管理器和包装层）以及智能体级到工作流级的编程接口（智能体层）。 +AgentScope引入了直观的抽象，旨在满足每个层次固有的多样化功能，并简化构建多智能体系统时的复杂层间依赖关系。 +此外，我们提供了编程接口和默认机制，以增强多智能体系统在不同层次上对故障的韧性。 + +## AgentScope代码结构 + +```bash +AgentScope +├── src +│ ├── agentscope +│ | ├── agents # 与智能体相关的核心组件和实现。 +│ | ├── memory # 智能体记忆相关的结构。 +│ | ├── models # 用于集成不同模型API的接口。 +│ | ├── pipeline # 基础组件和实现，用于运行工作流。 +│ | ├── rpc # Rpc模块，用于智能体分布式部署。 +│ | ├── service # 为智能体提供各种功能的服务。 +| | ├── web # 基于网页的用户交互界面。 +│ | ├── utils # 辅助工具和帮助函数。 +│ | ├── prompt.py # 提示工程模块。 +│ | ├── message.py # 智能体之间消息传递的定义和实现。 +│ | ├── ... .. +│ | ├── ... .. +├── scripts # 用于启动本地模型API的脚本。 +├── examples # 不同应用程序的预构建示例。 +├── docs # 教程和API参考文档。 +├── tests # 单元测试模块，用于持续集成。 +├── LICENSE # AgentScope使用的官方许可协议。 +└── setup.py # 用于安装的设置脚本。 +├── ... .. +└── ... .. +``` + +[[返回顶端]](#关于agentscope) diff --git a/docs/sphinx_doc/source/tutorial/zh/102-installation.md b/docs/sphinx_doc/source/tutorial/zh/102-installation.md new file mode 100644 index 000000000..d32bea410 --- /dev/null +++ b/docs/sphinx_doc/source/tutorial/zh/102-installation.md @@ -0,0 +1,69 @@ +(102-installation)= + +# 安装 + +为了安装AgentScope，您需要安装Python 3.9或更高版本。我们建议专门为AgentScope设置一个新的虚拟环境： + +### 创建虚拟环境 + +#### 使用Conda + +如果您使用Conda作为环境管理工具，您可以使用以下命令创建一个新的Python 3.9虚拟环境： + +```bash +# 使用Python 3.9创建一个名为"agentscope"的新虚拟环境 +conda create -n agentscope python=3.9 + +# 激活虚拟环境 +conda activate agentscope +``` + +#### 使用Virtualenv + +如果您使用`virtualenv`，您可以首先安装它（如果尚未安装），然后按照以下步骤创建一个新的虚拟环境： + +```bash +# 如果尚未安装virtualenv，请先安装它 +pip install virtualenv + +# 使用Python 3.9创建一个名为"agentscope"的新虚拟环境 +virtualenv agentscope --python=python3.9 + +# 激活虚拟环境 +source agentscope/bin/activate # 在Windows上使用`agentscope\Scripts\activate` +``` + +### 安装AgentScope + +#### 从源码安装 + +按照以下步骤从源代码安装AgentScope，并以可编辑模式安装AgentScope： + +**_注意：该项目正在积极开发中，建议从源码安装AgentScope！_** + +```bash +# 从GitHub上拉取AgentScope的源代码 +git clone https://github.com/modelscope/agentscope.git +cd AgentScope + +# 针对本地化的multi-agent应用 +pip install -e . +# 为分布式multi-agent应用 +pip install -e .[distribute] # 在Mac上使用`pip install -e .\[distribute\]` +``` + +**注意**：`[distribute]`选项安装了分布式应用程序所需的额外依赖项。在运行这些命令之前，请激活您的虚拟环境。 + +#### 使用Pip安装 + +如果您选择从Pypi安装AgentScope，可以使用`pip`轻松地完成： + +```bash +# 针对本地化的multi-agent应用 +pip install agentscope + +# 为分布式multi-agent应用 +pip install agentscope[distribute] # 在Mac上使用`pip install agentscope\[distribute\]` +``` + +[[返回顶端]](#安装) diff --git a/docs/sphinx_doc/source/tutorial/zh/103-example.md b/docs/sphinx_doc/source/tutorial/zh/103-example.md new file mode 100644 index 000000000..75dc883ce --- /dev/null +++ b/docs/sphinx_doc/source/tutorial/zh/103-example.md @@ -0,0 +1,114 @@ +(103-start)= + +# 快速开始 + +AgentScope内置了灵活的通信机制。在本教程中，我们将通过一个简单的独立对话示例介绍AgentScope的基本用法。 + +## 第一步：准备模型 + +为了更好的构建多智能体应用，AgentScope将模型的部署与调用解耦开，以API服务调用的方式支持各种不同的模型。 + +在模型部署方面，用户可以使用第三方模型服务，例如OpenAI API，HuggingFace Inference +API，同时也可以通过仓库中的[脚本](https://github.com/modelscope/agentscope/blob/main/scripts/README.md)快速部署本地开源模型服务， +目前已支持通过Flask配合Transformers（或ModelScope）快速建立基础的模型服务，同时也已经支持通过FastChat和vllm等推理引擎部署本地模型服务。 + +模型调用方面，AgentScope通过`ModelWrapper`类提供OpenAI API和RESTful Post Request调用的封装。 +目前支持的OpenAI API包括了对话（Chat），图片生成（Image generation）和嵌入式（Embedding）。 +用户可以通过设定不同的model config来指定模型服务。 + + +| 模型使用 | APIs | +|--------------|-------------------------------------------------------------------------| +| 文本生成 | *OpenAI* chat API，FastChat和vllm | +| 图片生成 | *DALL-E* API | +| Embedding | 文本Embedding | +| 基于Post请求的API | *Huggingface*/*ModelScope* Inference

API，以及用户自定应的基于Post请求的API | + +每种API都有其特定的配置要求。例如，要配置OpenAI API，您需要在模型配置中填写以下字段： + +```python +model_config = { + "config_name": "{config_name}", # A unique name for the model config. + "model_type": "openai", # Choose from "openai", "openai_dall_e", or "openai_embedding". + "model_name": "{model_name}", # The model identifier used in the OpenAI API, such as "gpt-3.5-turbo", "gpt-4", or "text-embedding-ada-002". + "api_key": "xxx", # Your OpenAI API key. If unset, the environment variable OPENAI_API_KEY is used. + "organization": "xxx", # Your OpenAI organization ID. If unset, the environment variable OPENAI_ORGANIZATION is used. +} +``` + +对于开源模型，我们支持与HuggingFace、ModelScope、FastChat和vllm等各种模型接口的集成。您可以在`scripts +`目录中找到部署这些服务的脚本，详细说明请见[[Using Different Model Sources with Model API]](203-model). + +您可以通过调用AgentScope的初始化方法来注册您的配置。此外，您还可以一次性加载多个模型配置。 + +```python +import agentscope + +# 一次性初始化多个模型配置 +openai_cfg_dict = {...dict_filling...} +modelscope_cfg_dict = {...dict_filling...} +agentscope.init(model_configs=[openai_cfg_dict, modelscope_cfg_dict]) +``` + +## Step2: 创建智能体 + +创建智能体在AgentScope中非常简单。在初始化AgentScope时，您可以使用模型配置初始化AgentScope，然后定义每个智能体及其对应的角色和特定模型。 + +```python +import agentscope +from agentscope.agents import DialogAgent, UserAgent + +# 读取模型配置 +agentscope.init(model_configs="./openai_model_configs.json") + +# 创建一个对话智能体和一个用户智能体 +dialogAgent = DialogAgent(name="assistant", model_config_name="gpt-4", sys_prompt="You are a helpful ai assistant") +userAgent = UserAgent() +``` + +**注意**：请参考[[使用Agent Pool自定义您的自定义智能体]](201-agent)以获取所有可用的智能体以及创建自定义的智能体。 + +## 第三步：智能体对话 + +消息（Message）是AgentScope中智能体之间的主要通信手段。 +它是一个Python字典，包括了一些基本字段，如消息的`content`和消息发送者的`name`。可选地，消息可以包括一个`url`，指向本地文件（图像、视频或音频）或网站。 + +```python +from agentscope.message import Msg + +# 来自Alice的简单文本消息示例 +message_from_alice = Msg("Alice", "Hi!") + +# 来自Bob的带有附加图像的消息示例 +message_from_bob = Msg("Bob", "What about this picture I took?", url="/path/to/picture.jpg") +``` + +为了在两个智能体之间开始对话，例如`dialog_agent`和`user_agent`，您可以使用以下循环。对话将持续进行，直到用户输入`"exit"`，这将终止交互。 + +```python +x = None +while True: + x = dialogAgent(x) + x = userAgent(x) + + # 如果用户输入"exit"，则终止对话 + if x.content == "exit": + print("Exiting the conversation.") + break +``` + +进阶的使用中，AgentScope提供了Pipeline来管理智能体之间消息流的选项。 +其中`sequentialpipeline`代表顺序对话，每个智能体从上一个智能体接收消息并生成其响应。 + +```python +from agentscope.pipelines.functional import sequentialpipeline + +# 在Pipeline结构中执行对话循环 +x = None +while x is None or x.content != "exit": + x = sequentialpipeline([dialog_agent, user_agent]) +``` + +有关如何使用Pipeline进行复杂的智能体交互的更多细节，请参考[[Agent Interactions: Dive deeper into Pipelines and Message Hub]](202-pipeline)。 + +[[返回顶部]](#快速开始)