feat: +rfc243

metagpt/actions/graph_db_action.py

@@ -1,43 +0,0 @@
-"""
-graph_db_action.py
-
-This module defines the GraphDBAction class, which interacts with a graph database.
-
-Classes:
-    GraphDBAction: An action class that interacts with a graph database.
-
-Usage Example:
-    action = GraphDBAction()
-    await action.load_graph_db('path/to/graph_db')
-
-    action = GraphDBAction(graph_db=external_graph_db)
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Optional
-
-from metagpt.actions import Action
-from metagpt.utils.di_graph_repository import DiGraphRepository
-from metagpt.utils.graph_repository import GraphRepository
-
-
-class GraphDBAction(Action):
-    """
-    An action class that interacts with a graph database.
-
-    Attributes:
-        graph_db (Optional[GraphRepository]): The graph database instance.
-    """
-
-    graph_db: Optional[GraphRepository] = None
-
-    async def load_graph_db(self, pathname: str | Path):
-        """
-        Asynchronously loads the graph database from the specified path.
-
-        Args:
-            pathname (str | Path): The path to the graph database file.
-        """
-        self.graph_db = await DiGraphRepository.load_from(pathname)

metagpt/actions/requirement_analysis/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/6/13
+@Author  : mashenquan
+@File    : __init__.py
+@Desc    : The implementation of RFC243. https://deepwisdom.feishu.cn/wiki/QobGwPkImijoyukBUKHcrYetnBb
+"""
+from metagpt.actions.requirement_analysis.evaluate_action import EvaluationData, EvaluateAction
+
+__all__ = [EvaluationData, EvaluateAction]

metagpt/actions/requirement_analysis/evaluate_action.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/6/13
+@Author  : mashenquan
+@File    : evaluate_action.py
+@Desc    : The implementation of RFC243. https://deepwisdom.feishu.cn/wiki/QobGwPkImijoyukBUKHcrYetnBb
+"""
+from typing import Optional
+
+from pydantic import BaseModel
+from tenacity import retry, stop_after_attempt, wait_random_exponential
+
+from metagpt.actions import Action
+from metagpt.logs import logger
+from metagpt.utils.common import CodeParser, general_after_log, to_markdown_code_block
+
+
+class EvaluationData(BaseModel):
+    """Model to represent evaluation data.
+
+    Attributes:
+        is_pass (bool): Indicates if the evaluation passed or failed.
+        conclusion (Optional[str]): Conclusion or remarks about the evaluation.
+    """
+
+    is_pass: bool
+    conclusion: Optional[str] = None
+
+
+class EvaluateAction(Action):
+    """The base class for an evaluation action.
+
+    This class provides methods to evaluate prompts using a specified language model.
+    """
+
+    @retry(
+        wait=wait_random_exponential(min=1, max=20),
+        stop=stop_after_attempt(6),
+        after=general_after_log(logger),
+    )
+    async def _evaluate(self, prompt: str) -> (bool, str):
+        """Evaluates a given prompt.
+
+        Args:
+            prompt (str): The prompt to be evaluated.
+
+        Returns:
+            tuple: A tuple containing:
+                - bool: Indicates if the evaluation passed.
+                - str: The JSON string containing the evaluation data.
+        """
+        rsp = await self.llm.aask(prompt)
+        json_data = CodeParser.parse_code(text=rsp, lang="json")
+        data = EvaluationData.model_validate_json(json_data)
+        return data.is_pass, to_markdown_code_block(val=json_data, type_="json")
+
+    async def _vote(self, prompt: str) -> EvaluationData:
+        """Evaluates a prompt multiple times and returns the consensus.
+
+        Args:
+            prompt (str): The prompt to be evaluated.
+
+        Returns:
+            EvaluationData: An object containing the evaluation result and a summary of evaluations.
+        """
+        evaluations = {}
+        for i in range(3):
+            vote, evaluation = await self._evaluate(prompt)
+            val = evaluations.get(vote, [])
+            val.append(evaluation)
+            if len(val) > 1:
+                return EvaluationData(is_pass=vote, evaluations="\n".join(val))
+            evaluations[vote] = val

metagpt/actions/requirement_analysis/framework/__init__.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/6/13
+@Author  : mashenquan
+@File    : __init__.py
+@Desc    : The implementation of RFC243. https://deepwisdom.feishu.cn/wiki/QobGwPkImijoyukBUKHcrYetnBb
+"""
+import json
+import uuid
+from pathlib import Path
+from typing import Optional, Union, List
+
+from pydantic import BaseModel
+
+from metagpt.actions.requirement_analysis.framework.evaluate_framework import EvaluateFramework
+from metagpt.actions.requirement_analysis.framework.write_framework import WriteFramework
+from metagpt.const import DEFAULT_WORKSPACE_ROOT
+from metagpt.utils.common import CodeParser, awrite
+
+
+async def save_framework(dir_data: str, output_dir: Optional[Union[str, Path]] = None) -> List[str]:
+    output_dir = Path(output_dir) if output_dir else DEFAULT_WORKSPACE_ROOT / uuid.uuid4().hex
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    json_data = CodeParser.parse_code(text=dir_data, lang="json")
+    items = json.loads(json_data)
+
+    class Data(BaseModel):
+        path: str
+        filename: str
+        content: str
+
+    files = []
+    for i in items:
+        v = Data.model_validate(i)
+        pathname = output_dir / v.path
+        pathname.mkdir(parents=True, exist_ok=True)
+        pathname = pathname / v.filename
+        await awrite(filename=pathname, data=v.content)
+        files.append(str(pathname))
+    return files
+
+
+__all__ = [WriteFramework, EvaluateFramework]

metagpt/actions/requirement_analysis/framework/evaluate_framework.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/6/13
+@Author  : mashenquan
+@File    : evaluate_framework.py
+@Desc    : The implementation of Chapter 2.1.8 of RFC243. https://deepwisdom.feishu.cn/wiki/QobGwPkImijoyukBUKHcrYetnBb
+"""
+
+from metagpt.actions.requirement_analysis import EvaluateAction, EvaluationData
+from metagpt.utils.common import to_markdown_code_block
+
+
+class EvaluateFramework(EvaluateAction):
+    async def run(
+        self,
+        *,
+        use_case_actors: str,
+        trd: str,
+        acknowledge: str,
+        legacy_output: str,
+        additional_technical_requirements: str,
+    ) -> EvaluationData:
+        prompt = PROMPT.format(
+            use_case_actors=use_case_actors,
+            trd=to_markdown_code_block(val=trd),
+            acknowledge=to_markdown_code_block(val=acknowledge),
+            legacy_output=to_markdown_code_block(val=legacy_output),
+            additional_technical_requirements=to_markdown_code_block(val=additional_technical_requirements),
+        )
+        return await self._vote(prompt)
+
+
+PROMPT = """
+## Actor, System, External System
+{use_case_actors}
+
+## Legacy TRD
+{trd}
+
+## Acknowledge
+{acknowledge}
+
+## Legacy Outputs
+{legacy_output}
+
+## Additional Technical Requirements
+{additional_technical_requirements}
+
+---
+You are a tool that evaluates the quality of framework code based on the TRD content;
+You need to refer to the content of the "Legacy TRD" section to check for any errors or omissions in the framework code found in "Legacy Outputs";
+The content of "Actor, System, External System" provides an explanation of actors and systems that appear in UML Use Case diagram;
+Information missing from the "Legacy TRD" can be found in the "Acknowledge" section;
+Parts not mentioned in the "Legacy TRD" will be handled by other TRDs, therefore, processes not present in the "Legacy TRD" are considered ready;
+"Additional Technical Requirements" specifies the additional technical requirements that the generated software framework code must meet;
+Return a markdown JSON object with:
+- a "is_pass" key containing a true boolean value if there is not any issue in the "Legacy Outputs";
+- an "issues" key containing a string list of natural text about the issues found in the "Legacy Outputs" if any, each issue found must provide a detailed description and include reasons;
+- a "conclusion" key containing the evaluation conclusion;
+- a "misalignment" key containing the judgement detail of the natural text string list about the misalignment with "Legacy TRD";
+"""

metagpt/actions/requirement_analysis/framework/write_framework.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/6/13
+@Author  : mashenquan
+@File    : write_framework.py
+@Desc    : The implementation of Chapter 2.1.8 of RFC243. https://deepwisdom.feishu.cn/wiki/QobGwPkImijoyukBUKHcrYetnBb
+"""
+import json
+
+from tenacity import retry, stop_after_attempt, wait_random_exponential
+
+from metagpt.actions import Action
+from metagpt.logs import logger
+from metagpt.utils.common import CodeParser, general_after_log, to_markdown_code_block
+
+
+class WriteFramework(Action):
+    async def run(
+        self,
+        *,
+        use_case_actors: str,
+        trd: str,
+        acknowledge: str,
+        legacy_output: str,
+        evaluation_conclusion: str,
+        additional_technical_requirements: str,
+    ) -> str:
+        prompt = PROMPT.format(
+            use_case_actors=use_case_actors,
+            trd=to_markdown_code_block(val=trd),
+            acknowledge=to_markdown_code_block(val=acknowledge),
+            legacy_output=to_markdown_code_block(val=legacy_output),
+            evaluation_conclusion=evaluation_conclusion,
+            additional_technical_requirements=to_markdown_code_block(val=additional_technical_requirements),
+        )
+        return await self._write(prompt)
+
+    @retry(
+        wait=wait_random_exponential(min=1, max=20),
+        stop=stop_after_attempt(6),
+        after=general_after_log(logger),
+    )
+    async def _write(self, prompt: str) -> str:
+        rsp = await self.llm.aask(prompt)
+        json_data = CodeParser.parse_code(text=rsp, lang="json")
+        json.loads(json_data)  # validate
+        return json_data
+
+
+PROMPT = """
+## Actor, System, External System
+{use_case_actors}
+
+## TRD
+{trd}
+
+## Acknowledge
+{acknowledge}
+
+## Legacy Outputs
+{legacy_output}
+
+## Evaluation Conclusion
+{evaluation_conclusion}
+
+## Additional Technical Requirements
+{additional_technical_requirements}
+
+---
+You are a tool that generates software framework code based on TRD.
+The content of "Actor, System, External System" provides an explanation of actors and systems that appear in UML Use Case diagram;
+The descriptions of the interfaces used in the "TRD" can be found in the "Acknowledge" section;
+"Legacy Outputs" contains the software framework code generated by you last time, which you can improve by addressing the issues raised in "Evaluation Conclusion";
+"Additional Technical Requirements" specifies the additional technical requirements that the generated software framework code must meet;
+Develop source code based on the content of the "TRD";
+- The `README.md` file should include:
+  - The folder structure diagram of the entire project;
+  - Correspondence between classes, interfaces, and functions with the content in the "TRD" section；
+  - Prerequisites if necessary;
+  - Installation if necessary;
+  - Configuration if necessary;
+  - Usage if necessary;
+- The `CLASS.md` file should include class diagram in PlantUML format;
+- The `SEQUENCE.md` file should include sequence diagram in PlantUML format;
+  
+Return a markdown JSON object list, each object containing:
+- a "path" key with a value specifying its path;
+- a "filename" key with a value specifying its file name;
+- a "content" key with a value containing its file content;
+"""

metagpt/actions/requirement_analysis/trd/__init__.py

@@ -0,0 +1,16 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/6/13
+@Author  : mashenquan
+@File    : __init__.py
+@Desc    : The implementation of RFC243. https://deepwisdom.feishu.cn/wiki/QobGwPkImijoyukBUKHcrYetnBb
+"""
+
+
+from metagpt.actions.requirement_analysis.trd.detect_interaction import DetectInteraction
+from metagpt.actions.requirement_analysis.trd.evaluate_trd import EvaluateTRD
+from metagpt.actions.requirement_analysis.trd.write_trd import WriteTRD
+from metagpt.actions.requirement_analysis.trd.compress_external_interfaces import CompressExternalInterfaces
+
+__all__ = [CompressExternalInterfaces, DetectInteraction, WriteTRD, EvaluateTRD]

metagpt/actions/requirement_analysis/trd/compress_external_interfaces.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/6/13
+@Author  : mashenquan
+@File    : compress_external_interfaces.py
+@Desc    : The implementation of Chapter 2.1.5 of RFC243. https://deepwisdom.feishu.cn/wiki/QobGwPkImijoyukBUKHcrYetnBb
+"""
+from tenacity import retry, stop_after_attempt, wait_random_exponential
+
+from metagpt.actions import Action
+from metagpt.logs import logger
+from metagpt.utils.common import general_after_log
+
+
+class CompressExternalInterfaces(Action):
+    @retry(
+        wait=wait_random_exponential(min=1, max=20),
+        stop=stop_after_attempt(6),
+        after=general_after_log(logger),
+    )
+    async def run(
+        self,
+        *,
+        acknowledge: str,
+    ) -> str:
+        return await self.llm.aask(
+            msg=acknowledge,
+            system_msgs=[
+                "Return a markdown JSON list of objects, each object containing:\n"
+                '- an "id" key containing the interface id;\n'
+                '- an "inputs" key containing a dict of input parameters that consist of name and description pairs;\n'
+                '- an "outputs" key containing a dict of returns that consist of name and description pairs;\n'
+            ],
+        )

metagpt/actions/requirement_analysis/trd/detect_interaction.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/6/13
+@Author  : mashenquan
+@File    : detect_interaction.py
+@Desc    : The implementation of Chapter 2.1.6 of RFC243. https://deepwisdom.feishu.cn/wiki/QobGwPkImijoyukBUKHcrYetnBb
+"""
+from tenacity import retry, stop_after_attempt, wait_random_exponential
+
+from metagpt.actions import Action
+from metagpt.logs import logger
+from metagpt.utils.common import general_after_log, to_markdown_code_block
+
+
+class DetectInteraction(Action):
+    @retry(
+        wait=wait_random_exponential(min=1, max=20),
+        stop=stop_after_attempt(6),
+        after=general_after_log(logger),
+    )
+    async def run(
+        self,
+        *,
+        user_requirements: str,
+        use_case_actors: str,
+        legacy_interaction_events: str,
+        evaluation_conclusion: str,
+    ) -> str:
+        msg = PROMPT.format(
+            use_case_actors=use_case_actors,
+            original_user_requirements=to_markdown_code_block(val=user_requirements),
+            previous_version_of_interaction_events=legacy_interaction_events,
+            the_evaluation_conclusion_of_previous_version_of_trd=evaluation_conclusion,
+        )
+        return await self.llm.aask(msg=msg)
+
+
+PROMPT = """
+## Actor, System, External System
+{use_case_actors}
+
+## User Requirements
+{original_user_requirements}
+
+## Legacy Interaction Events
+{previous_version_of_interaction_events}
+
+## Evaluation Conclusion
+{the_evaluation_conclusion_of_previous_version_of_trd}
+
+---
+You are a tool for capturing interaction events.
+"Actor, System, External System" provides the possible participants of the interaction event;
+"Legacy Interaction Events" is the contents of the interaction events that you output earlier;
+Some descriptions in the "Evaluation Conclusion" relate to the content of "User Requirements", and these descriptions in the "Evaluation Conclusion" address some issues regarding the content of "Legacy Interaction Events";
+You need to capture the interaction events occurring in the description within the content of "User Requirements", including:
+1. Who is interacting with whom. An interaction event has a maximum of 2 participants. If there are multiple participants, it indicates that multiple events are combined into one event and should be further split.\;
+2. When an interaction event occurs, who is the initiator? What data did the initiator enter?
+Return a markdown JSON object list, each object of the list containing:
+- a "name" key containing the name of the interaction event;
+- a "participants" key containing a string list of the names of the two participants;
+- a "initiator" key containing the name of the participant who initiate the interaction;
+- a "input" key containing a natural text description about the input data;
+"""

metagpt/actions/requirement_analysis/trd/evaluate_trd.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/6/13
+@Author  : mashenquan
+@File    : evaluate_trd.py
+@Desc    : The implementation of Chapter 2.1.6~2.1.7 of RFC243. https://deepwisdom.feishu.cn/wiki/QobGwPkImijoyukBUKHcrYetnBb
+"""
+
+from metagpt.actions.requirement_analysis import EvaluateAction, EvaluationData
+from metagpt.utils.common import to_markdown_code_block
+
+
+class EvaluateTRD(EvaluateAction):
+    async def run(
+        self,
+        *,
+        user_requirements: str,
+        use_case_actors: str,
+        trd: str,
+        interaction_events: str = "",
+        legacy_user_requirements_interaction_events: str = "",
+        incremental_user_requirements_interaction_events: str = "",
+    ) -> EvaluationData:
+        prompt = PROMPT.format(
+            use_case_actors=use_case_actors,
+            user_requirements=to_markdown_code_block(val=user_requirements),
+            trd=to_markdown_code_block(val=trd),
+            legacy_user_requirements_interaction_events=legacy_user_requirements_interaction_events,
+            incremental_user_requirements_interaction_events=incremental_user_requirements_interaction_events,
+            interaction_events=interaction_events,
+        )
+        return await self._vote(prompt)
+
+
+PROMPT = """
+## Actor, System, External System
+{use_case_actors}
+
+## User Requirements
+{user_requirements}
+
+## TRD Design
+{trd}
+
+## Interaction Events
+{legacy_user_requirements_interaction_events}
+{incremental_user_requirements_interaction_events}
+{interaction_events}
+
+---
+You are a tool to evaluate the TRD design.
+"Actor, System, External System" provides the possible participants in interaction events;
+"User Requirements" provides the original requirements description, any parts not mentioned in this description will be handled by other modules, so do not fabricate requirements;
+"Interaction Events" provides some identified interaction events and the interacting participants based on the content of the "User Requirements";
+"TRD Design" provides a comprehensive design of the implementation steps for the original requirements, incorporating the interaction events from "Interaction Events" and adding additional steps to connect the complete upstream and downstream data flows;
+To integrate the complete upstream and downstream data flows, "TRD Design" allows for the inclusion of steps not present in the original requirements description, provided these steps do not contradict the content explicitly described in the "User Requirements";
+Which interactions from "Interaction Events" correspond to which steps in "TRD Design"? Please provide reasons.
+Which aspects of "TRD Design" and "Interaction Events" do not align with the descriptions in "User Requirements"? Please provide detailed descriptions and reasons.
+If the descriptions in "User Requirements" are divided into multiple steps in "TRD Design" and "Interaction Events," it can be considered compliant with the descriptions in "User Requirements" as long as it does not conflict with them;
+There is a possibility of missing details in the descriptions of "User Requirements". Any additional steps in "TRD Design" and "Interaction Events" are considered compliant with "User Requirements" as long as they do not conflict with the descriptions provided in "User Requirements".
+Return a markdown JSON object with:
+- a "is_pass" key containing a true boolean value if there is not any issue in the "TRD Design";
+- an "issues" key containing a string list of natural text about the issues found in the "TRD Design" if any, each issue found must provide a detailed description and include reasons;
+- a "conclusion" key containing the evaluation conclusion;
+- a "correspondence_between" key containing the judgement detail of the natural text string list about the correspondence between "Interaction Events" and "TRD Design" steps;
+- a "misalignment" key containing the judgement detail of the natural text string list about the misalignment with "User Requirements";
+"""

metagpt/actions/requirement_analysis/trd/write_trd.py

@@ -0,0 +1,195 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@Time    : 2024/6/13
+@Author  : mashenquan
+@File    : write_trd.py
+@Desc    : The implementation of Chapter 2.1.6~2.1.7 of RFC243. https://deepwisdom.feishu.cn/wiki/QobGwPkImijoyukBUKHcrYetnBb
+"""
+from tenacity import retry, stop_after_attempt, wait_random_exponential
+
+from metagpt.actions import Action
+from metagpt.logs import logger
+from metagpt.utils.common import general_after_log, to_markdown_code_block
+
+
+class WriteTRD(Action):
+    async def run(
+        self,
+        *,
+        user_requirements: str = "",
+        use_case_actors: str,
+        available_external_interfaces: str,
+        legacy_trd: str = "",
+        evaluation_conclusion: str = "",
+        interaction_events: str = "",
+        legacy_user_requirements: str = "",
+        legacy_user_requirements_trd: str = "",
+        legacy_user_requirements_interaction_events: str = "",
+        incremental_user_requirements: str = "",
+        previous_version_trd: str = "",
+        incremental_user_requirements_interaction_events: str = "",
+    ) -> str:
+        if incremental_user_requirements:
+            return await self._write_incremental_trd(
+                use_case_actors=use_case_actors,
+                legacy_user_requirements=legacy_user_requirements,
+                available_external_interfaces=available_external_interfaces,
+                legacy_user_requirements_trd=legacy_user_requirements_trd,
+                legacy_user_requirements_interaction_events=legacy_user_requirements_interaction_events,
+                incremental_user_requirements=incremental_user_requirements,
+                previous_version_trd=previous_version_trd,
+                evaluation_conclusion=evaluation_conclusion,
+                incremental_user_requirements_interaction_events=incremental_user_requirements_interaction_events,
+            )
+        return await self._write_new_trd(
+            use_case_actors=use_case_actors,
+            original_user_requirement=user_requirements,
+            available_external_interfaces=available_external_interfaces,
+            legacy_trd=legacy_trd,
+            evaluation_conclusion=evaluation_conclusion,
+            interaction_events=interaction_events,
+        )
+
+    @retry(
+        wait=wait_random_exponential(min=1, max=20),
+        stop=stop_after_attempt(6),
+        after=general_after_log(logger),
+    )
+    async def _write_new_trd(
+        self,
+        *,
+        use_case_actors: str,
+        original_user_requirement: str,
+        available_external_interfaces: str,
+        legacy_trd: str,
+        evaluation_conclusion: str,
+        interaction_events: str,
+    ) -> str:
+        prompt = NEW_PROMPT.format(
+            use_case_actors=use_case_actors,
+            original_user_requirement=to_markdown_code_block(val=original_user_requirement),
+            available_external_interfaces=available_external_interfaces,
+            legacy_trd=to_markdown_code_block(val=legacy_trd),
+            evaluation_conclusion=evaluation_conclusion,
+            interaction_events=interaction_events,
+        )
+        return await self.llm.aask(prompt)
+
+    @retry(
+        wait=wait_random_exponential(min=1, max=20),
+        stop=stop_after_attempt(6),
+        after=general_after_log(logger),
+    )
+    async def _write_incremental_trd(
+        self,
+        *,
+        use_case_actors: str,
+        legacy_user_requirements: str,
+        available_external_interfaces: str,
+        legacy_user_requirements_trd: str,
+        legacy_user_requirements_interaction_events: str,
+        incremental_user_requirements: str,
+        previous_version_trd: str,
+        evaluation_conclusion: str,
+        incremental_user_requirements_interaction_events: str,
+    ):
+        prompt = INCREMENTAL_PROMPT.format(
+            use_case_actors=use_case_actors,
+            legacy_user_requirements=to_markdown_code_block(val=legacy_user_requirements),
+            available_external_interfaces=available_external_interfaces,
+            legacy_user_requirements_trd=to_markdown_code_block(val=legacy_user_requirements_trd),
+            legacy_user_requirements_interaction_events=legacy_user_requirements_interaction_events,
+            incremental_user_requirements=to_markdown_code_block(val=incremental_user_requirements),
+            previous_version_trd=to_markdown_code_block(val=previous_version_trd),
+            evaluation_conclusion=evaluation_conclusion,
+            incremental_user_requirements_interaction_events=incremental_user_requirements_interaction_events,
+        )
+        return await self.llm.aask(prompt)
+
+
+NEW_PROMPT = """
+## Actor, System, External System
+{use_case_actors}
+
+## User Requirements
+{original_user_requirement}
+
+## Available External Interfaces
+{available_external_interfaces}
+
+## Legacy TRD
+{legacy_trd}
+
+## Evaluation Conclusion
+{evaluation_conclusion}
+
+## Interaction Events
+{interaction_events}
+
+---
+You are a TRD generator.
+The content of "Actor, System, External System" provides an explanation of actors and systems that appear in UML Use Case diagram;
+The content of "Available External Interfaces" provides the candidate steps, along with the inputs and outputs of each step;
+"User Requirements" provides the original requirements description, any parts not mentioned in this description will be handled by other modules, so do not fabricate requirements;
+"Legacy TRD" provides the old version of the TRD based on the "User Requirements" and can serve as a reference for the new TRD;
+"Evaluation Conclusion" provides a summary of the evaluation of the old TRD in the "Legacy TRD" and can serve as a reference for the new TRD;
+"Interaction Events" provides some identified interaction events and the interacting participants based on the content of the "User Requirements";
+1. What inputs and outputs are described in the "User Requirements"?
+2. How many steps are needed to achieve the inputs and outputs described in the "User Requirements"? Which actors from the "Actor, System, External System" section are involved in each step? What are the inputs and outputs of each step? Where is this output used, for example, as input for which interface or where it is required in the requirements, etc.?
+3. Output a complete Technical Requirements Document (TRD)：
+  3.1. In the description, use the actor and system names defined in the "Actor, System, External System" section to describe the interactors;
+  3.2. The content should include the original text of the requirements from "User Requirements";
+  3.3. In the TRD, each step can involve a maximum of two participants. If there are more than two participants, the step needs to be further split;
+  3.4. In the TRD, each step must include detailed descriptions, inputs, outputs, participants, initiator, and the rationale for the step's existence. The rationale should reference the original text to justify it, such as specifying which interface requires the output of this step as parameters or where in the requirements this step is mandated, etc.
+"""
+
+INCREMENTAL_PROMPT = """
+## Actor, System, External System
+{use_case_actors}
+
+## Legacy User Requirements
+{legacy_user_requirements}
+
+## Available External Interfaces
+{available_external_interfaces}
+
+## The TRD of Legacy User Requirements
+{legacy_user_requirements_trd}
+
+
+## The Interaction Events of Legacy User Requirements
+{legacy_user_requirements_interaction_events}
+
+## Incremental Requirements
+{incremental_user_requirements}
+
+## Legacy TRD
+{previous_version_trd}
+
+## Evaluation Conclusion
+{evaluation_conclusion}
+
+## Interaction Events
+{incremental_user_requirements_interaction_events}
+
+---
+You are a TRD generator.
+The content of "Actor, System, External System" provides an explanation of actors and systems that appear in UML Use Case diagram;
+The content of "Available External Interfaces" provides the candidate steps, along with the inputs and outputs of each step;
+"Legacy User Requirements" provides the original requirements description handled by other modules for your use;
+"The TRD of Legacy User Requirements" is the TRD generated by other modules based on the "Legacy User Requirements" for your use;
+"The Interaction Events of Legacy User Requirements" is the interaction events list generated by other modules based on the "Legacy User Requirements" for your use;
+"Incremental Requirements" provides the original requirements description that you need to address, any parts not mentioned in this description will be handled by other modules, so do not fabricate requirements;
+The requirements in "Legacy User Requirements" combined with the "Incremental Requirements" form a complete set of requirements, therefore, you need to add the TRD portion of the "Incremental Requirements" to "The TRD of Legacy User Requirements", the added content must not conflict with the original content of "The TRD of Legacy User Requirements";
+"Legacy TRD" provides the old version of the TRD you previously wrote based on the "Incremental Requirements" and can serve as a reference for the new TRD;
+"Evaluation Conclusion" provides a summary of the evaluation of the old TRD you generated in the "Legacy TRD", and the identified issues can serve as a reference for the new TRD you create;
+"Interaction Events" provides some identified interaction events and the interacting participants based on the content of the "Incremental Requirements";
+1. What inputs and outputs are described in the "Incremental Requirements"？
+2. How many steps are needed to achieve the inputs and outputs described in the "Incremental Requirements"? Which actors from the "Actor, System, External System" section are involved in each step? What are the inputs and outputs of each step? Where is this output used, for example, as input for which interface or where it is required in the requirements, etc.?
+3. Output a complete Technical Requirements Document (TRD)：
+  3.1. In the description, use the actor and system names defined in the "Actor, System, External System" section to describe the interactors;
+  3.2. The content should include the original text of the requirements from "User Requirements";
+  3.3. In the TRD, each step can involve a maximum of two participants. If there are more than two participants, the step needs to be further split;
+  3.4. In the TRD, each step must include detailed descriptions, inputs, outputs, participants, initiator, and the rationale for the step's existence. The rationale should reference the original text to justify it, such as specifying which interface requires the output of this step as parameters or where in the requirements this step is mandated, etc.
+    """