wow-agent---Day3 Zigent 智能代理开发框架

这个框架是课程讲解的，但资料比较少，觉得框架比较小众，所以这里只分析代码，计划把更多的精力放在metagpt的学习上，毕竟还是要学教为主流的框架，这对后续维护升级都有资助，当然感爱好作为研究，可以研究下这个小框架。
代码目的是要生成一个一个教程编写智能体，其主要功能是输入教程主题，然后自动生成完备的教程内容，首先定义WriteDirectoryAction类，用于生成教程的目次，然后再定义生成教程的类，最后是执行层的代码。

1. Python复制
2. class WriteDirectoryAction(BaseAction):
3.     """
4.     生成教程目录结构的动作类。
6.     该类用于根据给定的主题和语言，生成教程的目录结构。目录结构以字典格式输出，包含主目录和子目录，每个目录标题都有实际意义。
8.     Attributes:
9.         action_name (str): 动作名称，固定为"WriteDirectory"。
10.         action_desc (str): 动作描述，固定为"Generate tutorial directory structure"。
11.         params_doc (dict): 参数文档，包含主题(topic)和语言(language)两个参数的类型和说明。
13.     Methods:
14.         __call__(**kwargs): 根据给定的主题和语言生成教程目录结构。
16.     Example:
17.         >>> action = WriteDirectoryAction()
18.         >>> result = action(topic="Python编程", language="Chinese")
19.         >>> print(result)
20.         {'topic': 'Python编程', 'language': 'Chinese', 'directory_data': {'title': 'Python编程', 'directory': [{'基础概念': ['变量', '数据类型']}, {'进阶应用': ['函数', '模块']}]}}
22.     Note:
23.         该类依赖于LLM模型来生成目录结构，如果LLM模型返回的数据不符合预期格式，将返回默认的目录数据。
24.     """
26.     def __init__(self) -> None:
27.         """
28.         初始化WriteDirectoryAction类。
30.         初始化时设置动作名称、描述和参数文档。
31.         """
32.         action_name = "WriteDirectory"
33.         action_desc = "Generate tutorial directory structure"
34.         params_doc = {
35.             "topic": "(Type: string): The tutorial topic name",
36.             "language": "(Type: string): Output language (default: 'Chinese')"
37.         }
38.         super().__init__(action_name, action_desc, params_doc)
40.     def __call__(self, **kwargs):
41.         """
42.         根据给定的主题和语言生成教程目录结构。
44.         Args:
45.             **kwargs: 关键字参数，包含主题(topic)和语言(language)两个参数。
46.                 topic (str): 教程主题名称，默认为空字符串。
47.                 language (str): 输出语言，默认为"Chinese"。
49.         Returns:
50.             dict: 包含主题、语言和目录数据的字典。
52.         Raises:
53.             json.JSONDecodeError: 如果LLM模型返回的数据不符合JSON格式。
54.         """
55.         topic = kwargs.get("topic", "")
56.         language = kwargs.get("language", "Chinese")
58.         directory_prompt = f"""
59.         请为主题"{topic}"生成教程目录结构,要求:
60.         1. 输出语言必须是{language}
61.         2. 严格按照以下字典格式输出: {
62.   
63.   {"title": "xxx", "directory": [{
64.   
65.   {"章节1": ["小节1", "小节2"]}}, {
66.   
67.   {"章节2": ["小节3", "小节4"]}}]}}
68.         3. 目录层次要合理,包含主目录和子目录
69.         4. 每个目录标题要有实际意义
70.         5. 不要有多余的空格或换行
71.         """
73.         # 调用 LLM 生成目录
74.         directory_data = llm.llm_chain.invoke({"prompt": directory_prompt})
75.         try:
76.             directory_data = json.loads(directory_data)
77.         except:
78.             directory_data = {"title": topic, "directory": []}
80.         return {
81.             "topic": topic,
82.             "language": language,
83.             "directory_data": directory_data
84.         }

复制代码

1. class WriteContentAction(BaseAction):
2.     """
3.     生成教程详细内容的动作类。
5.     该类用于根据给定的教程标题、章节、小节标题、目录结构和语言，生成教程的详细内容。内容以Markdown格式输出，包含代码示例（如有），长度适中。
7.     Attributes:
8.         action_name (str): 动作名称，固定为"WriteContent"。
9.         action_desc (str): 动作描述，固定为"Generate detailed tutorial content based on directory structure"。
10.         params_doc (dict): 参数文档，包含标题(title)、章节(chapter)、目录数据(directory_data)和语言(language)四个参数的类型和说明。
12.     Methods:
13.         __call__(**kwargs): 根据给定的参数生成教程详细内容。
15.     Example:
16.         >>> action = WriteContentAction()
17.         >>> directory_data = {'title': 'Python编程', 'directory': [{'基础概念': ['变量', '数据类型']}, {'进阶应用': ['函数', '模块']}]}
18.         >>> content = action(title="变量", chapter="基础概念", language="Chinese", directory_data=directory_data)
19.         >>> print(content)
20.         # 变量
21.         在Python中，变量是用来存储数据的容器...
23.     Note:
24.         该类依赖于LLM模型来生成内容，如果LLM模型返回的数据不符合预期，可能需要手动调整。
25.     """
27.     def __init__(self) -> None:
28.         """
29.         初始化WriteContentAction类。
31.         初始化时设置动作名称、描述和参数文档。
32.         """
33.         action_name = "WriteContent"
34.         action_desc = "Generate detailed tutorial content based on directory structure"
35.         params_doc = {
36.             "title": "(Type: string): The section title",
37.             "chapter": "(Type: string): The chapter title",
38.             "directory_data": "(Type: dict): The complete directory structure",
39.             "language": "(Type: string): Output language (default: 'Chinese')"
40.         }
41.         super().__init__(action_name, action_desc, params_doc)
43.     def __call__(self, **kwargs):
44.         """
45.         根据给定的参数生成教程详细内容。
47.         Args:
48.             **kwargs: 关键字参数，包含标题(title)、章节(chapter)、语言(language)和目录数据(directory_data)四个参数。
49.                 title (str): 小节标题，默认为空字符串。
50.                 chapter (str): 章节标题，默认为空字符串。
51.                 language (str): 输出语言，默认为"Chinese"。
52.                 directory_data (dict): 完整的目录结构，默认为空字典。
54.         Returns:
55.             str: 生成的教程详细内容。
57.         Raises:
58.             Exception: 如果LLM模型调用失败。
59.         """
60.         title = kwargs.get("title", "")
61.         chapter = kwargs.get("chapter", "")
62.         language = kwargs.get("language", "Chinese")
63.         directory_data = kwargs.get("directory_data", {})
65.         content_prompt = f"""
66.         请为教程章节生成详细内容:
67.         教程标题: {directory_data.get('title', '')}
68.         章节: {chapter}
69.         小节: {title}
70.         
71.         要求:
72.         1. 内容要详细且准确
73.         2. 如果需要代码示例,请按标准规范提供
74.         3. 使用 Markdown 格式
75.         4. 输出语言必须是{language}
76.         5. 内容长度适中,通常在500-1000字之间
77.         """
79.         # 调用 LLM 生成内容
80.         content = llm.llm_chain.invoke({"prompt": content_prompt})
81.         return content

复制代码

1. class TutorialAssistant(BaseAgent):
2.     """
3.     教程生成助手类，管理目录和内容创建。
5.     该类用于生成完整教程，包括目录结构和详细内容。它依赖于WriteDirectoryAction和WriteContentAction两个动作类来分别生成目录结构和详细内容。
7.     Attributes:
8.         name (str): 助手名称，固定为"TutorialAssistant"。
9.         role (str): 助手角色描述，说明其专业领域和能力。
10.         llm (BaseLLM): 语言模型实例，用于生成目录结构和详细内容。
11.         language (str): 输出语言，默认为"Chinese"。
12.         directory_action (WriteDirectoryAction): 生成目录结构的动作实例。
13.         content_action (WriteContentAction): 生成详细内容的动作实例。
15.     Methods:
16.         _generate_tutorial(directory_data): 根据目录结构生成完整教程内容。
17.         __call__(task): 处理教程生成任务，生成目录结构和详细内容，并保存结果。
18.         _add_tutorial_example(): 添加教程生成助手的示例用例。
20.     Example:
21.         >>> assistant = TutorialAssistant(llm)
22.         >>> task = TaskPackage(instruction="Create a Python tutorial for beginners")
23.         >>> result = assistant(task)
24.         >>> print(result.answer)
25.         # Python基础教程
26.         ## 目录
27.         1. 第一章：Python介绍
28.            1.1 什么是Python
29.            1.2 环境搭建
30.         ...
32.     Note:
33.         该类假设语言模型能够正常工作，如果语言模型返回的数据不符合预期，可能需要手动调整。
34.     """
36.     def __init__(
37.         self,
38.         llm: BaseLLM,
39.         language: str = "Chinese"
40.     ):
41.         """
42.         初始化TutorialAssistant类。
44.         初始化时设置助手名称、角色描述、语言模型实例、输出语言、目录动作实例和内容动作实例。
46.         Args:
47.             llm (BaseLLM): 语言模型实例。
48.             language (str, optional): 输出语言，默认为"Chinese"。
49.         """
50.         name = "TutorialAssistant"
51.         role = """You are a professional tutorial writer. You can create well-structured,
52.         comprehensive tutorials on various topics. You excel at organizing content logically
53.         and explaining complex concepts clearly."""
54.         
55.         super().__init__(
56.             name=name,
57.             role=role,
58.             llm=llm,
59.         )
60.         
61.         self.language = language
62.         self.directory_action = WriteDirectoryAction()
63.         self.content_action = WriteContentAction()
64.    
65.         # Add example for the tutorial assistant
66.         self._add_tutorial_example()
67.         
68.     def _generate_tutorial(self, directory_data: Dict) -> str:
69.         """
70.         根据目录结构生成完整教程内容。
72.         Args:
73.             directory_data (Dict): 目录结构数据，包含教程标题和章节信息。
75.         Returns:
76.             str: 生成的完整教程内容。
78.         Raises:
79.             Exception: 如果目录结构数据不符合预期格式。
80.         """
81.         full_content = []
82.         title = directory_data["title"]
83.         full_content.append(f"# {title}\n")
84.         
85.         # Generate table of contents
86.         full_content.append("## 目录\n")
87.         for idx, chapter in enumerate(directory_data["directory"], 1):
88.             for chapter_title, sections in chapter.items():
89.                 full_content.append(f"{idx}. {chapter_title}")
90.                 for section_idx, section in enumerate(sections, 1):
91.                     full_content.append(f"   {idx}.{section_idx}. {section}")
92.         full_content.append("\n---\n")
93.         
94.         # Generate content for each section
95.         for chapter in directory_data["directory"]:
96.             for chapter_title, sections in chapter.items():
97.                 for section in sections:
98.                     content = self.content_action(
99.                         title=section,
100.                         chapter=chapter_title,
101.                         directory_data=directory_data,
102.                         language=self.language
103.                     )
104.                     full_content.append(content)
105.                     full_content.append("\n---\n")
106.         
107.         return "\n".join(full_content)
109.     def __call__(self, task: TaskPackage):
110.         """
111.         处理教程生成任务，生成目录结构和详细内容，并保存结果。
113.         Args:
114.             task (TaskPackage): 教程生成任务，包含指令信息。
116.         Returns:
117.             TaskPackage: 处理后的任务，包含生成的教程内容和完成状态。
119.         Raises:
120.             Exception: 如果任务指令不符合预期格式。
121.         """
122.         # Extract topic from task
123.         topic = task.instruction.split("Create a ")[-1].split(" tutorial")[0]
124.         if not topic:
125.             topic = task.instruction
126.             
127.         # Generate directory structure
128.         directory_result = self.directory_action(
129.             topic=topic,
130.             language=self.language
131.         )
133.         print(directory_result)
134.         
135.         # Generate complete tutorial
136.         tutorial_content = self._generate_tutorial(directory_result["directory_data"])
138.         # Save the result
139.         task.answer = tutorial_content
140.         task.completion = "completed"
141.         
142.         return task
144.     def _add_tutorial_example(self):
145.         """
146.         添加教程生成助手的示例用例。
148.         示例用例用于演示教程生成助手的工作流程和输出格式。
149.         """
150.         exp_task = "Create a Python tutorial for beginners"
151.         exp_task_pack = TaskPackage(instruction=exp_task)
152.         topic = "Python基础教程"
154.         act_1 = AgentAct(
155.             name=ThinkAct.action_name,
156.             params={INNER_ACT_KEY: """First, I'll create a directory structure for the Python tutorial,
157.             then generate detailed content for each section."""}
158.         )
159.         obs_1 = "OK. I'll start with the directory structure."
161.         act_2 = AgentAct(
162.             name=self.directory_action.action_name,
163.             params={
164.                 "topic": topic,
165.                 "language": self.language
166.             }
167.         )
168.         obs_2 = """{"title": "Python基础教程", "directory": [
169.             {"第一章：Python介绍": ["1.1 什么是Python", "1.2 环境搭建"]},
170.             {"第二章：基础语法": ["2.1 变量和数据类型", "2.2 控制流"]}
171.         ]}"""
173.         act_3 = AgentAct(
174.             name=self.content_action.action_name,
175.             params={
176.                 "title": "什么是Python",
177.                 "chapter": "第一章：Python介绍",
178.                 "directory_data": json.loads(obs_2),
179.                 "language": self.language
180.             }
181.         )
182.         obs_3 = """# 第一章：Python介绍\n## 什么是Python\n\nPython是一种高级编程语言..."""
184.         act_4 = AgentAct(
185.             name=FinishAct.action_name,
186.             params={INNER_ACT_KEY: "Tutorial structure and content generated successfully."}
187.         )
188.         obs_4 = "Tutorial generation task completed successfully."
190.         exp_act_obs = [(act_1, obs_1), (act_2, obs_2), (act_3, obs_3), (act_4, obs_4)]
191.         
192.         self.prompt_gen.add_example(
193.             task=exp_task_pack,
194.             action_chain=exp_act_obs
195.         )

复制代码

执行层：

1. if __name__ == "__main__":
3.     #这行代码创建了一个TutorialAssistant实例，传入了一个语言模型llm。这个实例将用于生成教程
4.     assistant = TutorialAssistant(llm=llm)
6.     # 交互式生成教程
7.     FLAG_CONTINUE = True
8.     #使用一个while循环来持续接收用户输入，直到用户选择不再生成新的教程。
9.     while FLAG_CONTINUE:
10.         #通过input函数接收用户想要生成的教程主题。
11.         input_text = input("What tutorial would you like to create?\n")
12.         #将用户输入的主题封装成一个TaskPackage对象，这个对象将传递给TutorialAssistant实例。
13.         task = TaskPackage(instruction=input_text)
14.         #调用TutorialAssistant实例的__call__方法来处理任务，生成教程内容
15.         result = assistant(task)
16.         #将生成的教程内容打印到控制台。
17.         print("\nGenerated Tutorial:\n")
18.         print(result.answer)
20.         # 创建输出目录，使用当前时间创建一个唯一的输出目录，确保每次生成的教程文件不会互相覆盖。
21.         output_dir = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
22.         os.makedirs(output_dir, exist_ok=True)
23.         
24.         # 处理文件名，确保有效
25.         safe_input_text = "".join([c if c.isalnum() or c in (' ', '_') else '_' for c in input_text])
26.         output_file = os.path.join(output_dir, f"{safe_input_text}.md")
27.         
28.         # 保存文件
29.         with open(output_file, 'w', encoding='utf-8') as f:
30.             f.write(result.answer)
31.         
32.         # 询问用户是否继续
33.         #通过input函数询问用户是否想要继续生成新的教程，如果用户输入n，则退出循环。
34.         if input("\nDo you want to create another tutorial? (y/n): ").lower() != "y":
35.             FLAG_CONTINUE = False

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。