在实际的 AI 应用开发中，一个常见的瓶颈是：我们总是需要手动设计、触发和监控 AI Agent 的执行流程。无论是处理用户查询、分析数据还是执行自动化任务，开发者或运营人员往往需要编写大量固定的提示词（prompt），并在每个环节进行人工判断和干预。这不仅效率低下，也限制了 AI 系统自主处理复杂、多步骤任务的能力。一个理想的 AI 系统应该能够理解目标，自主分解任务，寻找并调用合适的工具，处理过程中的异常，并在完成后寻找下一个任务，形成一个持续运转的“循环”（Loop）。

本文将围绕如何构建一个“会自己找活干”的自主循环 AI 系统展开。我们将从核心概念入手，逐步搭建一个最小可运行的 Loop 系统原型，并深入探讨其关键组件、实现细节、常见问题以及如何将其应用于实际业务场景。通过本文，你将掌握构建自主 AI 系统的核心思想与实践方法，并能将其应用于自动化客服、智能数据分析、流程自动化等多个领域。

1. 理解自主循环 AI 系统的核心概念

在开始搭建之前，我们需要明确几个核心概念，这有助于理解整个系统的设计哲学。

1.1 什么是 AI Agent 与 Loop？

AI Agent通常指一个具备感知、决策和执行能力的软件实体。它接收来自环境（如用户输入、系统事件、数据流）的输入，利用大语言模型（LLM）进行推理和规划，然后通过调用工具（Tools）或 API 来执行具体操作，最终影响环境。一个简单的 Agent 可能只完成单次任务。

Loop（循环系统）则是指多个 Agent 或一个 Agent 在更高层次调度下，能够自动、持续地运作。它不仅仅是执行一个任务，而是具备以下能力：

1. 任务发现与触发：系统能自动识别需要处理的新任务（如监控消息队列、扫描数据库变更、监听 API 事件）。
2. 任务规划与分解：将复杂任务拆解为一系列可执行的原子步骤。
3. 自主执行与工具调用：按规划步骤，自动选择并调用合适的工具（如搜索、计算、读写数据库、调用第三方服务）。
4. 状态管理与异常处理：在执行过程中维护任务状态，处理工具调用失败、结果不符合预期等异常情况。
5. 结果评估与后续行动：完成一个任务后，能评估结果，并自动触发下一个相关任务或进入等待状态，形成闭环。

1.2 为什么需要 Loop？从手动 Prompt 到自主系统的演进

手动编写和触发 prompt 的模式存在明显局限：

• 上下文碎片化：复杂的多轮对话或任务处理中，需要人工维护和传递上下文，容易出错。
• 缺乏状态持久化：Agent 通常是无状态的，每次交互都是独立的，难以处理长周期任务。
• 无法处理异常流程：当工具调用失败或返回意外结果时，需要人工介入判断和修复。
• 效率瓶颈：无法实现 7x24 小时无人值守的自动化处理。

构建 Loop 系统的目标正是为了解决这些问题，实现从“人工驾驶”到“自动驾驶”的转变。系统能够根据预设的目标和规则，自主运行，仅在真正需要人类判断或出现无法处理的错误时才请求介入。

1.3 核心组件剖析

一个典型的自主循环 AI 系统通常包含以下组件：

• Orchestrator（协调器）：系统的大脑。负责监听任务源、初始化任务、调用 Agent 进行规划与执行，并管理整个 Loop 的生命周期。
• Agent Core（代理核心）：基于 LLM 的推理引擎。接收 Orchestrator 的指令和当前上下文，进行任务规划、工具选择、参数生成和结果解析。
• Toolkit（工具集）：Agent 可以调用的能力集合。例如：搜索引擎、计算器、数据库客户端、文件操作、邮件发送、特定业务 API 等。
• Memory（记忆）：用于持久化任务状态、执行历史、会话上下文等。可以是数据库、向量数据库或简单的文件存储。
• Task Source（任务源）：系统任务的来源。可以是消息队列（如 RabbitMQ, Kafka）、数据库表、API 网关、定时任务调度器（如 Cron）或文件系统监听器。
• State Manager（状态管理器）：跟踪每个任务实例的当前状态（如 PENDING, RUNNING, SUCCESS, FAILED, WAITING_FOR_INPUT）。

2. 环境准备与项目结构搭建

我们将使用 Python 作为主要开发语言，并借助 LangChain 框架来简化 Agent 的构建，因为它提供了良好的工具抽象和 Agent 执行器。同时，我们会使用一个轻量级的内存（如 SQLite）和任务队列（如 RQ 或 Celery，这里为简化使用while循环模拟）来构建原型。

2.1 开发环境与依赖

首先，确保你的 Python 环境版本在 3.8 以上。我们使用venv创建虚拟环境并安装依赖。

# 创建并激活虚拟环境 python -m venv agent_loop_env source agent_loop_env/bin/activate # Linux/macOS # agent_loop_env\Scripts\activate # Windows # 安装核心依赖 pip install langchain langchain-openai # LangChain 核心及 OpenAI 集成 pip install sqlalchemy # 用于 ORM 操作数据库（作为 Memory） pip install requests # 用于编写自定义工具（如调用外部 API）

注意：本文示例使用 OpenAI 的模型（如 gpt-3.5-turbo）。你需要准备有效的OPENAI_API_KEY并设置环境变量。你也可以替换为其他兼容的模型提供商。

2.2 项目目录结构

一个清晰的项目结构有助于管理复杂的系统。建议按如下方式组织：

autonomous_loop_system/ ├── core/ │ ├── __init__.py │ ├── orchestrator.py # 协调器，主循环逻辑 │ ├── agent_core.py # Agent 核心，封装 LLM 和工具调用 │ └── state_manager.py # 任务状态管理 ├── tools/ │ ├── __init__.py │ ├── calculator_tool.py # 计算器工具示例 │ ├── web_search_tool.py # 网络搜索工具示例 │ └── custom_api_tool.py # 自定义业务 API 工具 ├── memory/ │ ├── __init__.py │ └── sqlite_memory.py # 基于 SQLite 的记忆存储 ├── task_sources/ │ ├── __init__.py │ ├── dummy_source.py # 模拟任务源 │ └── queue_source.py # 基于消息队列的任务源（示例） ├── config.py # 配置文件（API Key， 模型设置等） ├── models.py # SQLAlchemy 数据模型定义 ├── main.py # 程序入口 └── requirements.txt # 依赖列表

在requirements.txt中记录依赖：

langchain==0.1.0 langchain-openai==0.0.5 openai==1.6.1 sqlalchemy==2.0.23 requests==2.31.0

3. 构建最小可运行的原型系统

我们将从最简单的组件开始，逐步拼装出一个可以处理数学计算和简单信息查询的自主循环系统。

3.1 步骤一：定义数据模型与记忆存储

首先，在models.py中定义任务和记忆的数据模型。

# models.py from sqlalchemy import create_engine, Column, Integer, String, Text, DateTime, Enum from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.sql import func import enum Base = declarative_base() class TaskStatus(enum.Enum): PENDING = "pending" RUNNING = "running" SUCCESS = "success" FAILED = "failed" WAITING = "waiting_for_input" class Task(Base): __tablename__ = 'tasks' id = Column(Integer, primary_key=True) # 任务来源标识，例如：”user_query“, ”system_generated“, ”api_trigger“ source = Column(String(50)) # 原始输入或任务描述 raw_input = Column(Text) # 由 Agent 解析后的目标描述 goal = Column(Text) # 当前状态 status = Column(Enum(TaskStatus), default=TaskStatus.PENDING) # 执行结果或输出 result = Column(Text, nullable=True) # 错误信息 error_message = Column(Text, nullable=True) created_at = Column(DateTime(timezone=True), server_default=func.now()) updated_at = Column(DateTime(timezone=True), onupdate=func.now()) class Memory(Base): __tablename__ = 'memories' id = Column(Integer, primary_key=True) # 关联的任务ID task_id = Column(Integer, nullable=True) # 记忆内容，可以是对话历史、中间结果等 content = Column(Text) # 记忆类型，例如：”conversation“, ”intermediate_result“, ”user_preference“ memory_type = Column(String(50)) created_at = Column(DateTime(timezone=True), server_default=func.now())

接着，在memory/sqlite_memory.py中实现一个简单的记忆存储类。

# memory/sqlite_memory.py from sqlalchemy.orm import sessionmaker from core.models import Base, Memory import sqlite3 import os class SQLiteMemory: def __init__(self, db_path=":memory:"): # 使用 SQLite 内存数据库或文件数据库 self.engine = create_engine(f'sqlite:///{db_path}') Base.metadata.create_all(self.engine) self.Session = sessionmaker(bind=self.engine) def add_memory(self, task_id, content, memory_type="conversation"): session = self.Session() memory = Memory(task_id=task_id, content=content, memory_type=memory_type) session.add(memory) session.commit() session.close() def get_memories_by_task(self, task_id, memory_type=None): session = self.Session() query = session.query(Memory).filter(Memory.task_id == task_id) if memory_type: query = query.filter(Memory.memory_type == memory_type) memories = query.order_by(Memory.created_at.desc()).all() session.close() return [m.content for m in memories]

3.2 步骤二：实现工具集

工具是 Agent 的手和脚。我们实现两个基础工具：计算器和网络搜索（模拟）。

首先，在tools/calculator_tool.py中：

# tools/calculator_tool.py from langchain.tools import tool import re @tool def calculator(expression: str) -> str: """ 执行一个数学表达式计算。支持加减乘除和括号。 例如：`calculator("(3 + 5) * 2")` 返回 `16`。 注意：使用 `eval` 仅用于演示，生产环境需使用更安全的库如 `ast.literal_eval` 或专门数学库。 """ # 安全警告：实际生产环境应对输入进行严格校验和沙箱化，或使用安全计算库。 try: # 移除可能存在的危险字符（简单示例，不完整） safe_expr = re.sub(r'[^0-9+\-*/().\s]', '', expression) result = eval(safe_expr, {"__builtins__": {}}, {}) return f"计算结果: {result}" except Exception as e: return f"计算错误: {e}"

然后，在tools/web_search_tool.py中模拟一个搜索工具：

# tools/web_search_tool.py from langchain.tools import tool import requests import json @tool def web_search(query: str) -> str: """ 根据查询词进行网络搜索，并返回摘要信息。 这是一个模拟工具，实际应接入搜索引擎API（如SerperAPI、Google Custom Search）。 """ # 这里模拟一个返回固定结果的搜索，真实场景替换为API调用 mock_results = { "python tutorial": "Python是一种广泛使用的高级编程语言，以简洁易读著称。", "weather today": "今天天气晴朗，气温20-25摄氏度。", "latest news": "当前暂无重大新闻更新。" } # 简单匹配，实际应用需更复杂的逻辑 for key in mock_results: if key in query.lower(): return f"搜索 `{query}` 的结果: {mock_results[key]}" return f"未找到关于 `{query}` 的明确信息。您可以尝试更具体的关键词。"

3.3 步骤三：构建 Agent 核心

Agent Core负责接收任务目标，利用 LLM 进行规划并调用工具。我们使用 LangChain 的create_react_agent来构建一个 ReAct 风格的 Agent。

# core/agent_core.py from langchain import hub from langchain.agents import create_react_agent, AgentExecutor from langchain_openai import ChatOpenAI from tools.calculator_tool import calculator from tools.web_search_tool import web_search import os class AgentCore: def __init__(self, model_name="gpt-3.5-turbo", temperature=0): # 初始化 LLM self.llm = ChatOpenAI(model=model_name, temperature=temperature, openai_api_key=os.getenv("OPENAI_API_KEY")) # 定义工具列表 self.tools = [calculator, web_search] # 从 LangChain Hub 拉取 ReAct 提示词模板（也可自定义） self.prompt = hub.pull("hwchase17/react") # 创建 Agent self.agent = create_react_agent(self.llm, self.tools, self.prompt) # 创建执行器 self.agent_executor = AgentExecutor(agent=self.agent, tools=self.tools, verbose=True, handle_parsing_errors=True) def run(self, goal: str, memory_context: str = "") -> str: """ 执行一个任务目标。 goal: 任务描述，如“计算一下(12+34)*2等于多少，然后搜索一下Python的特点”。 memory_context: 来自记忆的上下文信息。 """ # 将记忆上下文整合到输入中 if memory_context: input_text = f"之前的上下文：{memory_context}\n\n当前任务：{goal}" else: input_text = goal try: result = self.agent_executor.invoke({"input": input_text}) return result["output"] except Exception as e: return f"Agent 执行过程中出现错误: {e}"

3.4 步骤四：实现协调器与主循环

协调器是系统运转的引擎。它从任务源获取任务，交给 Agent 处理，并更新状态。

首先，在task_sources/dummy_source.py中创建一个模拟任务源，它从一个列表中生成任务。

# task_sources/dummy_source.py class DummyTaskSource: def __init__(self, task_list): self.task_list = task_list self.index = 0 def has_next(self): return self.index < len(self.task_list) def get_next(self): if self.has_next(): task = self.task_list[self.index] self.index += 1 return task return None @staticmethod def generate_sample_tasks(): return [ {"source": "demo", "raw_input": "计算 (100 - 25) / 5 的值", "goal": "计算表达式 (100 - 25) / 5 的结果。"}, {"source": "demo", "raw_input": "搜索一下机器学习的基本概念", "goal": "查找并总结机器学习的基本概念。"}, {"source": "demo", "raw_input": "先算一下 2的10次方是多少，再了解一下它的应用", "goal": "首先计算 2 的 10 次方，然后搜索 2 的 10 次方在计算机领域的常见应用。"}, ]

然后，在core/orchestrator.py中实现协调器：

# core/orchestrator.py from core.agent_core import AgentCore from core.state_manager import StateManager from memory.sqlite_memory import SQLiteMemory import time import logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) class Orchestrator: def __init__(self, task_source, db_path="loop_system.db"): self.task_source = task_source self.agent = AgentCore() self.state_manager = StateManager(db_path) self.memory = SQLiteMemory(db_path) def run_loop(self, interval_seconds=2): """ 主循环：持续检查任务源，处理任务。 interval_seconds: 每次循环后的等待时间，避免空转消耗CPU。 """ logger.info("自主循环系统启动...") while True: if self.task_source.has_next(): task_data = self.task_source.get_next() if task_data: self._process_task(task_data) else: logger.info("当前任务源已无新任务，循环结束。") break time.sleep(interval_seconds) logger.info("系统运行结束。") def _process_task(self, task_data): """处理单个任务：创建记录 -> 执行 -> 更新状态 -> 存储记忆""" # 1. 创建任务记录并设置为 RUNNING task_id = self.state_manager.create_task( source=task_data["source"], raw_input=task_data["raw_input"], goal=task_data.get("goal", task_data["raw_input"]), # 若无解析后的goal，使用原始输入 status="running" ) logger.info(f"开始处理任务 ID-{task_id}: {task_data['goal']}") try: # 2. 获取与该任务相关的历史记忆作为上下文 memory_context = "\n".join(self.memory.get_memories_by_task(task_id)) # 3. 调用 Agent 执行任务 result = self.agent.run(task_data["goal"], memory_context) # 4. 任务成功，更新状态和结果 self.state_manager.update_task(task_id, status="success", result=result) # 5. 将本次执行结果存入记忆 self.memory.add_memory(task_id, f"任务执行成功。目标：{task_data['goal']}。结果：{result}", "execution_result") logger.info(f"任务 ID-{task_id} 处理成功。结果：{result[:100]}...") # 日志截断 except Exception as e: # 6. 任务失败，记录错误 error_msg = str(e) self.state_manager.update_task(task_id, status="failed", error_message=error_msg) self.memory.add_memory(task_id, f"任务执行失败。错误：{error_msg}", "error") logger.error(f"任务 ID-{task_id} 处理失败: {error_msg}")

core/state_manager.py负责与数据库交互，管理任务状态：

# core/state_manager.py from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from models import Base, Task, TaskStatus class StateManager: def __init__(self, db_path="loop_system.db"): self.engine = create_engine(f'sqlite:///{db_path}') Base.metadata.create_all(self.engine) self.Session = sessionmaker(bind=self.engine) def create_task(self, source, raw_input, goal, status="pending"): session = self.Session() task = Task( source=source, raw_input=raw_input, goal=goal, status=TaskStatus(status) ) session.add(task) session.commit() task_id = task.id session.close() return task_id def update_task(self, task_id, status=None, result=None, error_message=None): session = self.Session() task = session.query(Task).filter(Task.id == task_id).first() if task: if status: task.status = TaskStatus(status) if result is not None: task.result = result if error_message is not None: task.error_message = error_message session.commit() session.close()

3.5 步骤五：创建程序入口并运行

最后，在main.py中整合所有组件，启动系统。

# main.py import os from task_sources.dummy_source import DummyTaskSource from core.orchestrator import Orchestrator # 设置 OpenAI API Key (请替换为你的真实 Key，或通过环境变量设置) os.environ["OPENAI_API_KEY"] = "your-openai-api-key-here" def main(): # 1. 初始化模拟任务源 sample_tasks = DummyTaskSource.generate_sample_tasks() task_source = DummyTaskSource(sample_tasks) # 2. 初始化协调器 orchestrator = Orchestrator(task_source, db_path="autonomous_loop.db") # 3. 运行主循环 orchestrator.run_loop(interval_seconds=1) if __name__ == "__main__": main()

运行程序：

python main.py

4. 运行验证与结果分析

执行main.py后，你将在控制台看到类似以下的输出（具体内容因模型随机性略有不同）：

INFO:__main__:自主循环系统启动... INFO:core.orchestrator:开始处理任务 ID-1: 计算表达式 (100 - 25) / 5 的结果。 > Entering new AgentExecutor chain... 我需要计算表达式 (100 - 25) / 5。 Action: calculator Action Input: (100 - 25) / 5 Observation: 计算结果: 15.0 Thought:我得到了计算结果 15.0。 Final Answer: 表达式 (100 - 25) / 5 的计算结果是 15.0。 > Finished chain. INFO:core.orchestrator:任务 ID-1 处理成功。结果：表达式 (100 - 25) / 5 的计算结果是 15.0。 INFO:core.orchestrator:开始处理任务 ID-2: 查找并总结机器学习的基本概念。 > Entering new AgentExecutor chain... 我需要搜索机器学习的基本概念。 Action: web_search Action Input: 机器学习的基本概念 Observation: 搜索 `机器学习的基本概念` 的结果: 机器学习是人工智能的一个分支，使计算机系统能够从数据中学习并改进，而无需进行明确的编程。 Thought:我已经找到了机器学习基本概念的描述。 Final Answer: 机器学习是人工智能的一个分支，它使计算机系统能够从数据中学习和改进，而无需依赖明确的指令编程。 > Finished chain. INFO:core.orchestrator:任务 ID-2 处理成功。结果：机器学习是人工智能的一个分支，它使计算机系统能够从数据中学习和改进，而无需依赖明确的指令编程。 INFO:core.orchestrator:开始处理任务 ID-3: 首先计算 2 的 10 次方，然后搜索 2 的 10 次方在计算机领域的常见应用。 > Entering new AgentExecutor chain... 我需要先计算 2 的 10 次方，然后搜索其应用。 Action: calculator Action Input: 2 ** 10 Observation: 计算结果: 1024 Thought:我得到了 2 的 10 次方是 1024。现在需要搜索 1024 在计算机领域的应用。 Action: web_search Action Input: 1024 在计算机领域的应用 Observation: 搜索 `1024 在计算机领域的应用` 的结果: 1024（1KB）是计算机存储容量的一个常见单位，也常用于表示内存分页大小、屏幕分辨率（如1024x768）等。 Thought:我已经找到了 1024 在计算机领域的应用信息。 Final Answer: 2 的 10 次方等于 1024。在计算机领域，1024 字节等于 1KB，是存储容量的基本单位。它也常用于表示内存分页大小和屏幕分辨率（例如 1024x768 像素）。 > Finished chain. INFO:core.orchestrator:任务 ID-3 处理成功。结果：2 的 10 次方等于 1024。在计算机领域，1024 字节等于 1KB，是存储容量的基本单位。它也常用于表示内存分页大小和屏幕分辨率（例如 1024x768 像素）。 INFO:core.orchestrator:当前任务源已无新任务，循环结束。 INFO:core.orchestrator:系统运行结束。

结果分析：

1. 自主规划与执行：系统成功处理了三个任务。对于第三个复合任务（先计算再搜索），Agent 自主规划了步骤：先调用计算器，再调用搜索工具。
2. 状态管理：任务状态（从 PENDING 到 RUNNING 再到 SUCCESS/FAILED）被持久化到数据库autonomous_loop.db的tasks表中。
3. 记忆存储：每次任务的执行结果都被存入memories表。虽然本例中未在后续任务使用，但架构已支持上下文传递。
4. 工具调用：Agent 正确识别了任务意图，并选择了合适的工具（calculator或web_search）。

你可以使用 SQLite 命令行或 DB Browser for SQLite 等工具查看数据库内容，验证数据是否被正确记录。

5. 关键配置与参数详解

在原型系统中，有几个关键配置点决定了系统的行为和能力。

5.1 Agent 核心配置 (core/agent_core.py)

5.2 协调器配置 (core/orchestrator.py)

5.3 工具定义规范

工具是扩展系统能力的关键。定义工具时需注意：

• 清晰的描述 (docstring)：LLM 依靠工具的描述来决定是否以及如何调用它。描述应准确说明工具的功能、输入格式和输出示例。
• 安全的输入处理：工具函数必须对输入进行验证和清理，防止注入攻击（如示例中calculator工具的简单正则过滤，生产环境需更强）。
• 健壮的异常处理：工具内部应捕获异常并返回清晰的错误信息，供 Agent 或协调器处理，而不是直接抛出导致系统崩溃。

6. 常见问题排查与优化

在开发和运行自主循环系统时，你可能会遇到以下典型问题。

6.1 Agent 执行问题

6.2 系统运行与集成问题

6.3 性能与稳定性优化

1. 异步处理：如果任务处理是 I/O 密集型（如调用网络 API），可以将AgentCore.run和工具调用改为异步 (async/await)，并使用asyncio来并发处理多个任务，显著提升吞吐量。
2. 任务优先级与队列：引入优先级队列，让重要任务优先被处理。可以在Task模型中增加priority字段，协调器根据优先级获取任务。
3. Agent 超时与重试：为agent_executor.invoke设置超时时间，避免单个任务卡死整个循环。对于因网络波动导致的失败，可以实现重试机制。
4. 监控与告警：记录关键指标，如任务处理时长、成功率、工具调用次数、Token 消耗等。当失败率超过阈值或队列积压时，发送告警通知（如邮件、Slack）。

7. 从原型到生产：最佳实践与扩展方向

原型系统证明了概念的可行性，但要投入实际业务运行（如自动化客服、内部流程审批、数据报告生成），还需要考虑更多工程化因素。

7.1 生产环境部署清单

7.2 扩展系统能力

1. 更丰富的工具集：
   • 内部系统集成：开发工具连接 CRM、ERP、OA 等内部系统，实现自动创建工单、查询订单状态、发送审批通知等。
   • 数据操作：集成数据库客户端、Pandas 数据处理工具，让 Agent 能直接查询、分析和生成数据报告。
   • 文件处理：开发工具处理 Excel、PDF、Word 文档，提取信息或生成文件。
2. 多 Agent 协作：引入“主管 Agent”（Supervisor Agent），根据任务类型将其分发给不同的“专家 Agent”（如数据分析 Agent、客服 Agent、代码生成 Agent）处理，实现更复杂的流水线。
3. 动态任务生成：让系统不仅能处理外部输入的任务，还能基于规则或 AI 分析自动生成新任务。例如，监控系统日志，发现错误模式后自动创建排查任务；分析销售数据，自动生成客户跟进任务。
4. 人机协同（Human-in-the-loop）：在关键决策点（如执行高风险操作、结果置信度低时）设计中断机制，通过 Slack、钉钉等渠道请求人工确认，再将结果反馈给系统继续执行。

7.3 安全与合规考量

• 工具权限控制：为不同的工具或 API 调用设置权限等级，确保 Agent 只能在授权范围内操作。例如，查询工具对所有任务开放，但“删除数据库记录”工具仅对特定来源的高优先级任务开放。
• 输入输出审查：对用户输入和 Agent 生成的输出进行内容安全过滤，防止生成不当或有害内容。
• 审计追踪：详细记录每个任务的完整执行轨迹，包括使用的工具、输入参数、返回结果，满足合规和事后复盘的需求。

构建一个成熟的自主循环 AI 系统是一个持续迭代的过程。从最小可行原型出发，逐步接入真实数据源，丰富工具生态，完善监控和运维体系，最终才能让 AI 真正成为团队中一个“会自己找活干”的可靠成员。