简介

在本案例中，我们将展示如何创建一个可用于文本摘要的自定义智能体。

安装

通过下述命令安装需要的依赖包

  1. pip install "dbgpt[agent]>=0.5.9rc1" -U
  2. pip install openai

创建自定义智能体

初始化智能体

绝大多数情况下，你只需要继承基础Agent并重写相应的方法即可。 

  1. from dbgpt.agent import ConversableAgent
  3. class MySummarizerAgent(ConversableAgent):
  4.     def __init__(self, **kwargs):
  5.         super().__init__(**kwargs)

定义Profile

在设计每个智能体之前，需要定义它的角色、身份和功能角色。具体定义如下

  1. from dbgpt.agent import ConversableAgent, ProfileConfig
  3. class MySummarizerAgent(ConversableAgent):
  4.     profile: ProfileConfig = ProfileConfig(
  5.         # The name of the agent
  6.         name="Aristotle",
  7.         # The role of the agent
  8.         role="Summarizer",
  9.         # The core functional goals of the agent tell LLM what it can do with it.
  10.         goal=(
  11.             "Summarize answer summaries based on user questions from provided "
  12.             "resource information or from historical conversation memories."
  13.         ),
  14.         # Introduction and description of the agent, used for task assignment and display. 
  15.         # If it is empty, the goal content will be used.
  16.         desc=(
  17.             "You can summarize provided text content according to user's questions"
  18.             " and output the summarization."
  19.         ),
  20.     )
  21.     def __init__(self, **kwargs):
  22.         super().__init__(**kwargs)

提供Prompt约束

智能体的Prompt默认使用固定的模版组装(如有特殊需求，可绑定外部模版)。其中主要包括

  • 角色认定(自动生成)
  • 资源信息(自动生成)
  • 约束逻辑
  • 参考案例
  • 输出格式模版和限制

所以我们定义的智能体提示词如下：

  1. from dbgpt.agent import ConversableAgent, ProfileConfig
  3. class MySummarizerAgent(ConversableAgent):
  4.     profile: ProfileConfig = ProfileConfig(
  5.         # The name of the agent
  6.         name="Aristotle",
  7.         # The role of the agent
  8.         role="Summarizer",
  9.         # The core functional goals of the agent tell LLM what it can do with it.
  10.         goal=(
  11.             "Summarize answer summaries based on user questions from provided "
  12.             "resource information or from historical conversation memories."
  13.         ),
  14.         # Introduction and description of the agent, used for task assignment and display. 
  15.         # If it is empty, the goal content will be used.
  16.         desc=(
  17.             "You can summarize provided text content according to user's questions"
  18.             " and output the summarization."
  19.         ),
  20.         # Refer to the following. It can contain multiple constraints and reasoning 
  21.         # restriction logic, and supports the use of parameter template {{ param_name }}.
  22.         constraints=[
  23.             "Prioritize the summary of answers to user questions from the improved resource"
  24.             " text. If no relevant information is found, summarize it from the historical "
  25.             "dialogue memory given. It is forbidden to make up your own.",
  26.             "You need to first detect user's question that you need to answer with your"
  27.             " summarization.",
  28.             "Extract the provided text content used for summarization.",
  29.             "Then you need to summarize the extracted text content.",
  30.             "Output the content of summarization ONLY related to user's question. The "
  31.             "output language must be the same to user's question language.",
  32.             "If you think the provided text content is not related to user questions at "
  33.             "all, ONLY output '{{ not_related_message }}'!!.",
  34.         ]
  35.     )
  36.     def __init__(self, **kwargs):
  37.         super().__init__(**kwargs)

Prompt模版格式

如果提示中使用了动态参数，则需要实际的对话过程来组装这些值，需要重载并实现以下接口(_init_reply_message)

  1. from dbgpt.agent import AgentMessage, ConversableAgent, ProfileConfig
  3. NOT_RELATED_MESSAGE = "Did not find the information you want."
  6. class MySummarizerAgent(ConversableAgent):
  7.     profile: ProfileConfig = ProfileConfig(
  8.         # The name of the agent
  9.         name="Aristotle",
  10.         # The role of the agent
  11.         role="Summarizer",
  12.         # The core functional goals of the agent tell LLM what it can do with it.
  13.         goal=(
  14.             "Summarize answer summaries based on user questions from provided "
  15.             "resource information or from historical conversation memories."
  16.         ),
  17.         # Introduction and description of the agent, used for task assignment and display.
  18.         # If it is empty, the goal content will be used.
  19.         desc=(
  20.             "You can summarize provided text content according to user's questions"
  21.             " and output the summarization."
  22.         ),
  23.         # Refer to the following. It can contain multiple constraints and reasoning
  24.         # restriction logic, and supports the use of parameter template {{ param_name }}.
  25.         constraints=[
  26.             "Prioritize the summary of answers to user questions from the improved resource"
  27.             " text. If no relevant information is found, summarize it from the historical "
  28.             "dialogue memory given. It is forbidden to make up your own.",
  29.             "You need to first detect user's question that you need to answer with your"
  30.             " summarization.",
  31.             "Extract the provided text content used for summarization.",
  32.             "Then you need to summarize the extracted text content.",
  33.             "Output the content of summarization ONLY related to user's question. The "
  34.             "output language must be the same to user's question language.",
  35.             "If you think the provided text content is not related to user questions at "
  36.             "all, ONLY output '{{ not_related_message }}'!!.",
  37.         ],
  38.     )
  40.     def __init__(self, **kwargs):
  41.         super().__init__(**kwargs)
  43.     def _init_reply_message(self, received_message: AgentMessage) -> AgentMessage:
  44.         reply_message = super()._init_reply_message(received_message)
  45.         # Fill in the dynamic parameters in the prompt template
  46.         reply_message.context = {"not_related_message": NOT_RELATED_MESSAGE}
  47.         return reply_message

资源预加载(可选)

如果有一些特定的资源，则必须在智能体初始化时提前加载绑定的资源。可以参考下面的实现。根据资源的实际情况确定。在大多数情况下，是没有必要的。

  1. from dbgpt.agent import ConversableAgent, AgentMessage
  3. class MySummarizerAgent(ConversableAgent):
  4.     # ... other code
  5.     async def preload_resource(self) -> None:
  6.         # Load the required resources
  7.         for resource in self.resources:
  8.             # Load your resource, please write your own code here
  9.             pass

结果检查

如果动作执行结果需要严格验证与校验，有两种模式: 代码逻辑验证和LLM验证。当然，验证不是必须的，也没有默认实现。如下使用LLM的例子

  2. from typing import Tuple, Optional
  4. from dbgpt.agent import ConversableAgent, AgentMessage
  5. from dbgpt.core import ModelMessageRoleType
  7. CHECK_RESULT_SYSTEM_MESSAGE = (
  8.     "You are an expert in analyzing the results of a summary task."
  9.     "Your responsibility is to check whether the summary results can summarize the "
  10.     "input provided by the user, and then make a judgment. You need to answer "
  11.     "according to the following rules:\n"
  12.     "    Rule 1: If you think the summary results can summarize the input provided"
  13.     " by the user, only return True.\n"
  14.     "    Rule 2: If you think the summary results can NOT summarize the input "
  15.     "provided by the user, return False and the reason, split by | and ended "
  16.     "by TERMINATE. For instance: False|Some important concepts in the input are "
  17.     "not summarized. TERMINATE"
  18. )
  20. class MySummarizerAgent(ConversableAgent):
  21.     # ... other code
  22.     async def correctness_check(
  23.         self, message: AgentMessage
  24.     ) -> Tuple[bool, Optional[str]]:
  25.         current_goal = message.current_goal
  26.         action_report = message.action_report
  27.         task_result = ""
  28.         if action_report:
  29.             task_result = action_report.get("content", "")
  31.         check_result, model = await self.thinking(
  32.             messages=[
  33.                 AgentMessage(
  34.                     role=ModelMessageRoleType.HUMAN,
  35.                     content=(
  36.                         "Please understand the following user input and summary results"
  37.                         " and give your judgment:\n"
  38.                         f"User Input: {current_goal}\n"
  39.                         f"Summary Results: {task_result}"
  40.                     ),
  41.                 )
  42.             ],
  43.             prompt=CHECK_RESULT_SYSTEM_MESSAGE,
  44.         )
  46.         fail_reason = ""
  47.         if check_result and (
  48.             "true" in check_result.lower() or "yes" in check_result.lower()
  49.         ):
  50.             success = True
  51.         else:
  52.             success = False
  53.             try:
  54.                 _, fail_reason = check_result.split("|")
  55.                 fail_reason = (
  56.                     "The summary results cannot summarize the user input due"
  57.                     f" to: {fail_reason}. Please re-understand and complete the summary"
  58.                     " task."
  59.                 )
  60.             except Exception:
  61.                 fail_reason = (
  62.                     "The summary results cannot summarize the user input. "
  63.                     "Please re-understand and complete the summary task."
  64.                 )
  65.         return success, fail_reason

创建自定义Action

初始化Action

所有的智能体操作外部环境或者跟真实世界交互都是通过行动(Action)。Action定义了Agent的输出内容结构，并实际执行相应的操作。具体Action实现继承Action基类，如下

  1. from typing import Optional
  2. from pydantic import BaseModel, Field
  3. from dbgpt.vis import Vis
  4. from dbgpt.agent import Action, ActionOutput, AgentResource, ResourceType
  5. from dbgpt.agent.util import cmp_string_equal
  7. NOT_RELATED_MESSAGE = "Did not find the information you want."
  9. # The parameter object that the Action that the current Agent needs to execute needs to output.
  10. class SummaryActionInput(BaseModel):
  11.     summary: str = Field(
  12.         ...,
  13.         description="The summary content",
  14.     )
  16. class SummaryAction(Action[SummaryActionInput]):
  17.     def __init__(self):
  18.         super().__init__()
  20.     @property
  21.     def resource_need(self) -> Optional[ResourceType]:
  22.         # The resource type that the current Agent needs to use
  23.         # here we do not need to use resources, just return None
  24.         return None
  26.     @property
  27.     def render_protocol(self) -> Optional[Vis]:
  28.         # The visualization rendering protocol that the current Agent needs to use
  29.         # here we do not need to use visualization rendering, just return None
  30.         return None
  32.     @property
  33.     def out_model_type(self):
  34.         return SummaryActionInput
  36.     async def run(
  37.         self,
  38.         ai_message: str,
  39.         resource: Optional[AgentResource] = None,
  40.         rely_action_out: Optional[ActionOutput] = None,
  41.         need_vis_render: bool = True,
  42.         **kwargs,
  43.     ) -> ActionOutput:
  44.         """Perform the action.
  46.         The entry point for actual execution of Action. Action execution will be 
  47.         automatically initiated after model inference. 
  48.         """
  49.         try:
  50.             # Parse the input message
  51.             param: SummaryActionInput = self._input_convert(ai_message, SummaryActionInput)
  52.         except Exception:
  53.             return ActionOutput(
  54.                 is_exe_success=False,
  55.                 content="The requested correctly structured answer could not be found, "
  56.                 f"ai message: {ai_message}",
  57.             )
  58.         # Check if the summary content is not related to user questions
  59.         if param.summary and cmp_string_equal(
  60.             param.summary, 
  61.             NOT_RELATED_MESSAGE,
  62.             ignore_case=True,
  63.             ignore_punctuation=True,
  64.             ignore_whitespace=True,
  65.         ):
  66.             return ActionOutput(
  67.                 is_exe_success=False,
  68.                 content="the provided text content is not related to user questions at all."
  69.                 f"ai message: {ai_message}",
  70.             )
  71.         else:
  72.             return ActionOutput(
  73.                 is_exe_success=True,
  74.                 content=param.summary,
  75.             )

绑定Action到智能体

在开发并且定义好Agent和Action之后，将Action绑定到对应的智能体

  1. from pydantic import BaseModel
  2. from dbgpt.agent import Action,ConversableAgent
  4. class SummaryActionInput(BaseModel):
  5.     ...
  7. class SummaryAction(Action[SummaryActionInput]):
  8.     ...
  10. class MySummarizerAgent(ConversableAgent):
  11.     def __init__(self, **kwargs):
  12.         super().__init__(**kwargs)
  13.         self._init_actions([SummaryAction])

Action扩展参数处理

  1. from typing import Optional, Dict, Any
  2. from pydantic import BaseModel
  3. from dbgpt.agent import Action, ActionOutput, AgentResource, ConversableAgent
  6. class SummaryActionInput(BaseModel):
  7.     ...
  9. class SummaryAction(Action[SummaryActionInput]):
  10.     ...
  12.     async def run(
  13.         self,
  14.         ai_message: str,
  15.         resource: Optional[AgentResource] = None,
  16.         rely_action_out: Optional[ActionOutput] = None,
  17.         need_vis_render: bool = True,
  18.         **kwargs,
  19.     ) -> ActionOutput:
  20.         # Read the extended parameters passed in by the agent
  21.         extra_param = kwargs.get("action_extra_param_key", None)
  22.         pass
  24. class MySummarizerAgent(ConversableAgent):
  25.     def __init__(self, **kwargs):
  26.         super().__init__(**kwargs)
  27.         self._init_actions([SummaryAction])
  29.     def prepare_act_param(self) -> Dict[str, Any]:
  30.         return {"action_extra_param_key": "this is extra param"}

使用自定义智能体

自定义智能体创建好之后，可以通过下面的方式使用对应的智能体。

  2. import asyncio
  4. from dbgpt.agent import AgentContext, ConversableAgent, AgentMemory, LLMConfig, UserProxyAgent
  5. from dbgpt.model.proxy import OpenAILLMClient
  7. class MySummarizerAgent(ConversableAgent):
  8.     ...
  10. async def main():
  11.     llm_client = OpenAILLMClient(model_alias="gpt-3.5-turbo")
  12.     context: AgentContext = AgentContext(conv_id="summarize")
  14.     agent_memory: AgentMemory = AgentMemory()
  16.     summarizer = (
  17.         await MySummarizerAgent()
  18.         .bind(context)
  19.         .bind(LLMConfig(llm_client=llm_client))
  20.         .bind(agent_memory)
  21.         .build()
  22.     )
  24.     user_proxy = await UserProxyAgent().bind(agent_memory).bind(context).build()
  27.     await user_proxy.initiate_chat(
  28.         recipient=summarizer,
  29.         reviewer=user_proxy,
  30.         message="""I want to summarize advantages of Nuclear Power according to the following content.
  31.             Nuclear power in space is the use of nuclear power in outer space, typically either small fission systems or radioactive decay for electricity or heat. Another use is for scientific observation, as in a Mössbauer spectrometer. The most common type is a radioisotope thermoelectric generator, which has been used on many space probes and on crewed lunar missions. Small fission reactors for Earth observation satellites, such as the TOPAZ nuclear reactor, have also been flown.[1] A radioisotope heater unit is powered by radioactive decay and can keep components from becoming too cold to function, potentially over a span of decades.[2]
  32.             The United States tested the SNAP-10A nuclear reactor in space for 43 days in 1965,[3] with the next test of a nuclear reactor power system intended for space use occurring on 13 September 2012 with the Demonstration Using Flattop Fission (DUFF) test of the Kilopower reactor.[4]
  33.             After a ground-based test of the experimental 1965 Romashka reactor, which used uranium and direct thermoelectric conversion to electricity,[5] the USSR sent about 40 nuclear-electric satellites into space, mostly powered by the BES-5 reactor. The more powerful TOPAZ-II reactor produced 10 kilowatts of electricity.[3]
  34.             Examples of concepts that use nuclear power for space propulsion systems include the nuclear electric rocket (nuclear powered ion thruster(s)), the radioisotope rocket, and radioisotope electric propulsion (REP).[6] One of the more explored concepts is the nuclear thermal rocket, which was ground tested in the NERVA program. Nuclear pulse propulsion was the subject of Project Orion.[7]
  35.             Regulation and hazard prevention[edit]
  36.             After the ban of nuclear weapons in space by the Outer Space Treaty in 1967, nuclear power has been discussed at least since 1972 as a sensitive issue by states.[8] Particularly its potential hazards to Earth's environment and thus also humans has prompted states to adopt in the U.N. General Assembly the Principles Relevant to the Use of Nuclear Power Sources in Outer Space (1992), particularly introducing safety principles for launches and to manage their traffic.[8]
  37.             Benefits
  38.             Both the Viking 1 and Viking 2 landers used RTGs for power on the surface of Mars. (Viking launch vehicle pictured)
  39.             While solar power is much more commonly used, nuclear power can offer advantages in some areas. Solar cells, although efficient, can only supply energy to spacecraft in orbits where the solar flux is sufficiently high, such as low Earth orbit and interplanetary destinations close enough to the Sun. Unlike solar cells, nuclear power systems function independently of sunlight, which is necessary for deep space exploration. Nuclear-based systems can have less mass than solar cells of equivalent power, allowing more compact spacecraft that are easier to orient and direct in space. In the case of crewed spaceflight, nuclear power concepts that can power both life support and propulsion systems may reduce both cost and flight time.[9]
  40.             Selected applications and/or technologies for space include:
  41.             Radioisotope thermoelectric generator
  42.             Radioisotope heater unit
  43.             Radioisotope piezoelectric generator
  44.             Radioisotope rocket
  45.             Nuclear thermal rocket
  46.             Nuclear pulse propulsion
  47.             Nuclear electric rocket
  48.             """,
  49.     )
  50.     print(await agent_memory.gpts_memory.one_chat_completions("summarize"))
  52. if __name__ == "__main__":
  53.     asyncio.run(main())

全部代码如下

  1. import asyncio
  2. from typing import Any, Dict, Optional, Tuple
  4. from dbgpt.agent import (
  5.     Action,
  6.     ActionOutput,
  7.     AgentContext,
  8.     AgentMemory,
  9.     AgentMessage,
  10.     AgentResource,
  11.     ConversableAgent,
  12.     LLMConfig,
  13.     ProfileConfig,
  14.     ResourceType,
  15.     UserProxyAgent,
  16. )
  17. from dbgpt.agent.util import cmp_string_equal
  18. from dbgpt.core import ModelMessageRoleType
  19. from dbgpt.model.proxy import OpenAILLMClient
  20. from dbgpt.vis import Vis
  21. from pydantic import BaseModel, Field
  23. NOT_RELATED_MESSAGE = "Did not find the information you want."
  25. CHECK_RESULT_SYSTEM_MESSAGE = (
  26.     "You are an expert in analyzing the results of a summary task."
  27.     "Your responsibility is to check whether the summary results can summarize the "
  28.     "input provided by the user, and then make a judgment. You need to answer "
  29.     "according to the following rules:\n"
  30.     "    Rule 1: If you think the summary results can summarize the input provided"
  31.     " by the user, only return True.\n"
  32.     "    Rule 2: If you think the summary results can NOT summarize the input "
  33.     "provided by the user, return False and the reason, split by | and ended "
  34.     "by TERMINATE. For instance: False|Some important concepts in the input are "
  35.     "not summarized. TERMINATE"
  36. )
  39. class MySummarizerAgent(ConversableAgent):
  40.     profile: ProfileConfig = ProfileConfig(
  41.         # The name of the agent
  42.         name="Aristotle",
  43.         # The role of the agent
  44.         role="Summarizer",
  45.         # The core functional goals of the agent tell LLM what it can do with it.
  46.         goal=(
  47.             "Summarize answer summaries based on user questions from provided "
  48.             "resource information or from historical conversation memories."
  49.         ),
  50.         # Introduction and description of the agent, used for task assignment and display.
  51.         # If it is empty, the goal content will be used.
  52.         desc=(
  53.             "You can summarize provided text content according to user's questions"
  54.             " and output the summarization."
  55.         ),
  56.         # Refer to the following. It can contain multiple constraints and reasoning
  57.         # restriction logic, and supports the use of parameter template {{ param_name }}.
  58.         constraints=[
  59.             "Prioritize the summary of answers to user questions from the improved resource"
  60.             " text. If no relevant information is found, summarize it from the historical "
  61.             "dialogue memory given. It is forbidden to make up your own.",
  62.             "You need to first detect user's question that you need to answer with your"
  63.             " summarization.",
  64.             "Extract the provided text content used for summarization.",
  65.             "Then you need to summarize the extracted text content.",
  66.             "Output the content of summarization ONLY related to user's question. The "
  67.             "output language must be the same to user's question language.",
  68.             "If you think the provided text content is not related to user questions at "
  69.             "all, ONLY output '{{ not_related_message }}'!!.",
  70.         ],
  71.     )
  73.     def __init__(self, **kwargs):
  74.         super().__init__(**kwargs)
  75.         self._init_actions([SummaryAction])
  77.     def _init_reply_message(self, received_message: AgentMessage) -> AgentMessage:
  78.         reply_message = super()._init_reply_message(received_message)
  79.         # Fill in the dynamic parameters in the prompt template
  80.         reply_message.context = {"not_related_message": NOT_RELATED_MESSAGE}
  81.         return reply_message
  83.     def prepare_act_param(self) -> Dict[str, Any]:
  84.         return {"action_extra_param_key": "this is extra param"}
  86.     async def correctness_check(
  87.         self, message: AgentMessage
  88.     ) -> Tuple[bool, Optional[str]]:
  89.         current_goal = message.current_goal
  90.         action_report = message.action_report
  91.         task_result = ""
  92.         if action_report:
  93.             task_result = action_report.get("content", "")
  95.         check_result, model = await self.thinking(
  96.             messages=[
  97.                 AgentMessage(
  98.                     role=ModelMessageRoleType.HUMAN,
  99.                     content=(
  100.                         "Please understand the following user input and summary results"
  101.                         " and give your judgment:\n"
  102.                         f"User Input: {current_goal}\n"
  103.                         f"Summary Results: {task_result}"
  104.                     ),
  105.                 )
  106.             ],
  107.             prompt=CHECK_RESULT_SYSTEM_MESSAGE,
  108.         )
  110.         fail_reason = ""
  111.         if check_result and (
  112.             "true" in check_result.lower() or "yes" in check_result.lower()
  113.         ):
  114.             success = True
  115.         else:
  116.             success = False
  117.             try:
  118.                 _, fail_reason = check_result.split("|")
  119.                 fail_reason = (
  120.                     "The summary results cannot summarize the user input due"
  121.                     f" to: {fail_reason}. Please re-understand and complete the summary"
  122.                     " task."
  123.                 )
  124.             except Exception:
  125.                 fail_reason = (
  126.                     "The summary results cannot summarize the user input. "
  127.                     "Please re-understand and complete the summary task."
  128.                 )
  129.         return success, fail_reason
  132. # The parameter object that the Action that the current Agent needs to execute needs to output.
  133. class SummaryActionInput(BaseModel):
  134.     summary: str = Field(
  135.         ...,
  136.         description="The summary content",
  137.     )
  140. class SummaryAction(Action[SummaryActionInput]):
  141.     def __init__(self):
  142.         super().__init__()
  144.     @property
  145.     def resource_need(self) -> Optional[ResourceType]:
  146.         # The resource type that the current Agent needs to use
  147.         # here we do not need to use resources, just return None
  148.         return None
  150.     @property
  151.     def render_protocol(self) -> Optional[Vis]:
  152.         # The visualization rendering protocol that the current Agent needs to use
  153.         # here we do not need to use visualization rendering, just return None
  154.         return None
  156.     @property
  157.     def out_model_type(self):
  158.         return SummaryActionInput
  160.     async def run(
  161.         self,
  162.         ai_message: str,
  163.         resource: Optional[AgentResource] = None,
  164.         rely_action_out: Optional[ActionOutput] = None,
  165.         need_vis_render: bool = True,
  166.         **kwargs,
  167.     ) -> ActionOutput:
  168.         """Perform the action.
  170.         The entry point for actual execution of Action. Action execution will be
  171.         automatically initiated after model inference.
  172.         """
  173.         extra_param = kwargs.get("action_extra_param_key", None)
  174.         try:
  175.             # Parse the input message
  176.             param: SummaryActionInput = self._input_convert(
  177.                 ai_message, SummaryActionInput
  178.             )
  179.         except Exception:
  180.             return ActionOutput(
  181.                 is_exe_success=False,
  182.                 content="The requested correctly structured answer could not be found, "
  183.                 f"ai message: {ai_message}",
  184.             )
  185.         # Check if the summary content is not related to user questions
  186.         if param.summary and cmp_string_equal(
  187.             param.summary,
  188.             NOT_RELATED_MESSAGE,
  189.             ignore_case=True,
  190.             ignore_punctuation=True,
  191.             ignore_whitespace=True,
  192.         ):
  193.             return ActionOutput(
  194.                 is_exe_success=False,
  195.                 content="the provided text content is not related to user questions at all."
  196.                 f"ai message: {ai_message}",
  197.             )
  198.         else:
  199.             return ActionOutput(
  200.                 is_exe_success=True,
  201.                 content=param.summary,
  202.             )
  205. async def main():
  206.     llm_client = OpenAILLMClient(model_alias="gpt-3.5-turbo")
  207.     context: AgentContext = AgentContext(conv_id="summarize")
  209.     agent_memory: AgentMemory = AgentMemory()
  211.     summarizer = (
  212.         await MySummarizerAgent()
  213.         .bind(context)
  214.         .bind(LLMConfig(llm_client=llm_client))
  215.         .bind(agent_memory)
  216.         .build()
  217.     )
  219.     user_proxy = await UserProxyAgent().bind(agent_memory).bind(context).build()
  221.     await user_proxy.initiate_chat(
  222.         recipient=summarizer,
  223.         reviewer=user_proxy,
  224.         message="""I want to summarize advantages of Nuclear Power according to the following content.
  225.             Nuclear power in space is the use of nuclear power in outer space, typically either small fission systems or radioactive decay for electricity or heat. Another use is for scientific observation, as in a Mössbauer spectrometer. The most common type is a radioisotope thermoelectric generator, which has been used on many space probes and on crewed lunar missions. Small fission reactors for Earth observation satellites, such as the TOPAZ nuclear reactor, have also been flown.[1] A radioisotope heater unit is powered by radioactive decay and can keep components from becoming too cold to function, potentially over a span of decades.[2]
  226.             The United States tested the SNAP-10A nuclear reactor in space for 43 days in 1965,[3] with the next test of a nuclear reactor power system intended for space use occurring on 13 September 2012 with the Demonstration Using Flattop Fission (DUFF) test of the Kilopower reactor.[4]
  227.             After a ground-based test of the experimental 1965 Romashka reactor, which used uranium and direct thermoelectric conversion to electricity,[5] the USSR sent about 40 nuclear-electric satellites into space, mostly powered by the BES-5 reactor. The more powerful TOPAZ-II reactor produced 10 kilowatts of electricity.[3]
  228.             Examples of concepts that use nuclear power for space propulsion systems include the nuclear electric rocket (nuclear powered ion thruster(s)), the radioisotope rocket, and radioisotope electric propulsion (REP).[6] One of the more explored concepts is the nuclear thermal rocket, which was ground tested in the NERVA program. Nuclear pulse propulsion was the subject of Project Orion.[7]
  229.             Regulation and hazard prevention[edit]
  230.             After the ban of nuclear weapons in space by the Outer Space Treaty in 1967, nuclear power has been discussed at least since 1972 as a sensitive issue by states.[8] Particularly its potential hazards to Earth's environment and thus also humans has prompted states to adopt in the U.N. General Assembly the Principles Relevant to the Use of Nuclear Power Sources in Outer Space (1992), particularly introducing safety principles for launches and to manage their traffic.[8]
  231.             Benefits
  232.             Both the Viking 1 and Viking 2 landers used RTGs for power on the surface of Mars. (Viking launch vehicle pictured)
  233.             While solar power is much more commonly used, nuclear power can offer advantages in some areas. Solar cells, although efficient, can only supply energy to spacecraft in orbits where the solar flux is sufficiently high, such as low Earth orbit and interplanetary destinations close enough to the Sun. Unlike solar cells, nuclear power systems function independently of sunlight, which is necessary for deep space exploration. Nuclear-based systems can have less mass than solar cells of equivalent power, allowing more compact spacecraft that are easier to orient and direct in space. In the case of crewed spaceflight, nuclear power concepts that can power both life support and propulsion systems may reduce both cost and flight time.[9]
  234.             Selected applications and/or technologies for space include:
  235.             Radioisotope thermoelectric generator
  236.             Radioisotope heater unit
  237.             Radioisotope piezoelectric generator
  238.             Radioisotope rocket
  239.             Nuclear thermal rocket
  240.             Nuclear pulse propulsion
  241.             Nuclear electric rocket
  242.             """,
  243.     )
  244.     print(await agent_memory.gpts_memory.one_chat_completions("summarize"))
  247. if __name__ == "__main__":
  248.     asyncio.run(main())

附录