Repository: antgroup/agentUniverse (language: python)

Issue:
merge master



Discussion / hints:

Fix patch:
diff --git a/agentuniverse/agent_serve/web/dal/request_library.py b/agentuniverse/agent_serve/web/dal/request_library.py
index 377143c1..3b598453 100644
--- a/agentuniverse/agent_serve/web/dal/request_library.py
+++ b/agentuniverse/agent_serve/web/dal/request_library.py
@@ -45,13 +45,15 @@ class RequestLibrary:
     def __init__(self, configer: Configer = None):
         """Init the database connection. Use uri in config file or use sqlite
         as default database."""
-        mysql_uri = None
+        system_db_uri = None
         if Configer:
-            mysql_uri = configer.get('DB', {}).get('mysql_uri')
-        if mysql_uri and mysql_uri.strip():
-            db_uri = mysql_uri
+            system_db_uri = configer.get('DB', {}).get('system_db_uri')
+            if not system_db_uri:
+                system_db_uri = configer.get('DB', {}).get('mysql_uri')
+        if system_db_uri and system_db_uri.strip():
+            db_uri = system_db_uri
         else:
-            db_path = get_project_root_path() / 'DB' / 'agent_framework.db'
+            db_path = get_project_root_path() / 'DB' / 'agent_universe.db'
             db_path.parent.mkdir(parents=True, exist_ok=True)
             db_uri = f'sqlite:////{db_path}'
 
diff --git a/docs/guidebook/_picture/agent.jpg b/docs/guidebook/_picture/agent.jpg
index 14fc58b7..d6098181 100644
Binary files a/docs/guidebook/_picture/agent.jpg and b/docs/guidebook/_picture/agent.jpg differ
diff --git a/docs/guidebook/en/0_index.md b/docs/guidebook/en/0_index.md
index b01171ec..7f8fbe72 100644
--- a/docs/guidebook/en/0_index.md
+++ b/docs/guidebook/en/0_index.md
@@ -13,6 +13,8 @@
 * 2.1 Framework Principles
 * 2.2 [Domain Components](2_2_Domain_Component_Principles.md)
   * 2.2.1 [Agent](2_2_1_Agent.md)
+    * 2.2.1.1 [Create And Use](2_2_1_Agent_Create_And_Use.md)
+    * 2.2.1.2 [Related Domain Objects](2_2_1_Agents_Related_Domain_Objects.md)
   * 2.2.2 LLM
   * 2.2.3 Tool
   * 2.2.4 Knowledge
@@ -24,6 +26,7 @@
     * 2.4.1.1 [Registration and Usage](2_4_1_Service_Registration_and_Usage.md)
     * 2.4.1.2 [Web Server](2_4_1_Web_Server.md)
     * 2.4.1.3 [Web API](2_4_1_Web_Api.md)
+    * 2.4.1.4 [Service Information Storage](./2_4_1_Service_Information_Storage.md)
   * 2.4.2 Prompt Management
   * 2.4.3 Multi-turn Dialogue
   * 2.4.4 Logging
@@ -57,4 +60,4 @@
 
 **7. Frequently Asked Questions (FAQ)**
 
-**[8. Contact Us](8_1_Contact_Us.md)**
+**[8. Contact Us](6_1_Contact_Us.md)**
diff --git a/docs/guidebook/en/2_2_1_Agent.md b/docs/guidebook/en/2_2_1_Agent.md
index 2819bc8d..8f8f0374 100644
--- a/docs/guidebook/en/2_2_1_Agent.md
+++ b/docs/guidebook/en/2_2_1_Agent.md
@@ -9,6 +9,9 @@ Let's introduce the roles of the various components within the Agent component s
 ## Profile
 This section is the global settings of the Agent, including the Agent's Target, Introduction, and LLM parts.
 
+### Introduction
+For the description of the Agent's role, for example: You are an AI assistant skilled in information analysis.
+
 ### Target
 The goal that the Agent needs to achieve. The Agent will revolve around this goal to complete a series of subsequent tasks.
   
@@ -20,12 +23,11 @@ When setting the goal for an agent, it needs to be concise and impactful, descri
 ❌ Bad examples: aimless descriptions such as "just chatting."
 ```
   
-### Introduction
-The comprehensive introduction of the Agent includes the setting of the Agent's personality, background knowledge, behavioral guidance, etc.
+### Instruction
+It includes specific settings for the Agent, such as personality traits, background knowledge, and behavioral guidelines.
 
 ```text
-How to write a good Introduction? We can adopt the following paradigm:
-The role played by the agent (recommended) + 
+How to write a good Instruction? We can adopt the following paradigm:
 A clear scope of responsibilities the agent excels in (recommended) + Personality setting (fill in as needed) + 
 Background knowledge (fill in as needed) + 
 User input format (fill in as needed) + 
@@ -39,13 +41,14 @@ You are Jerry's personal exclusive chatbot [The role played by the agent].
 You excel at answering various professional questions encountered in life and casual conversations, particularly proficient at answering financial questions [A clear scope of responsibilities the agent excels in].
 Your personality is cheerful and lively [Personality setting].
 Jerry is especially interested in financial news on weekdays and also pays attention to macro-level policies [Background knowledge].
-Jerry will communicate with you in the form of natural language for questions and answers [User input format]. Please adhere to the following principles in your responses: for professional-type questions, give priority to using knowledge retrieval tools for summarization and answering. Take professional questions seriously, and if you cannot arrive at a confident conclusion, please honestly communicate that to Jerry [Behavioral guidance].
+Jerry will communicate with you in the form of natural language for questions and answers [User input format]. 
+Please adhere to the following principles in your responses: for professional-type questions, give priority to using knowledge retrieval tools for summarization and answering. Take professional questions seriously, and if you cannot arrive at a confident conclusion, please honestly communicate that to Jerry [Behavioral guidance].
 Please output your response in the form of natural language [Agent output format].
 Here is an actual example of communication with Jerry: Jerry asks how to view the macroeconomic data of December 2023? Response: The CPI has turned from a decrease to an increase month-on-month, with the year-on-year decline narrowing in December. Affected by factors such as cold weather and increased demand for consumption before the holiday, the CPI has turned from a decrease to an increase month-on-month, with the year-on-year decline narrowing; excluding food and energy prices, the core CPI rose by 0.6% year-on-year, with the increase remaining stable. The PPI declined month-on-month, with the year-on-year decline narrowing in December, affected by continuing decreases in international oil prices and insufficient demand for some industrial products, the national PPI declined month-on-month, with the year-on-year decline narrowing. [Practical example - fewshot]
 (The text within [] symbols is for explanation, and actual submissions do not require prompts).
 
 ❌ For instance, a bad example would be:
-You are a fitness coach, skilled at providing various fitness plans tailored to different groups of people (the information provided is too scant, resulting in high uncertainty in outcomes, leading to generic advice that often does not meet the actual demands).
+You are skilled at providing various fitness plans tailored to different groups of people (the information provided is too scant, resulting in high uncertainty in outcomes, leading to generic advice that often does not meet the actual demands).
 ```
 
 ### LLM
diff --git a/docs/guidebook/en/2_2_1_Agent_Create_And_Use.md b/docs/guidebook/en/2_2_1_Agent_Create_And_Use.md
new file mode 100644
index 00000000..8563cc2e
--- /dev/null
+++ b/docs/guidebook/en/2_2_1_Agent_Create_And_Use.md
@@ -0,0 +1,382 @@
+# How to create agents.
+You might have already learned how to quickly create an agent in the [Quick Start](1_3_Quick_Start.md) chapter, or grasped the important components of an agent in the [Principles of Agents](2_2_1_Agent.md). In this section, we will further elaborate on how to create an agent in detail.
+
+Based on the design features of the agentUniverse domain components, creating an agent consists of two parts during the creation process.
+* agent_xx.yaml
+* agent_xx.py
+
+Among them, `agent_xx.yaml` must be created, which includes important attribute information of the agent such as Introduction, Target, Instruction, LLM, etc.; `agent_xx.py` is created as needed, containing specific behaviors of the agent and supporting users to inject custom domain behaviors into the agent. Understanding this principle, let's take a closer look at how to create these two parts.
+
+## Creating Agent Configuration - agent_xx.yaml
+We will provide detailed descriptions of each component in the configuration.
+
+### Setting the basic information of the agent.
+**`info` - basic information of the agent**
+* `name`:  name of the agent
+* `description`:  description of the agent
+
+### Setting the global configurations for the agent.
+**`profile` - Agent global settings.**
+* `introduction`:  introduction to the agent's role
+* `target`:  target of the agent
+* `instruction`: instruction of the agent
+* `llm_model`: The LLM used by the agent
+  * `name`: name of LLM
+  * `model_name`: model_name of LLM
+
+  You can choose any existing LLM or connect to any LLM of your choice. We will not elaborate on this part here; you can refer to the LLM section for more details.
+
+### Setting the agent's plan
+**`plan` - plan of agent**
+* `planner` : planner of agent
+  * `name`: name of planner
+  
+  You can choose any existing Planner or connect to any Planner of your choice. We will not elaborate on this part here; you can refer to the Planner section for more details.
+
+### Setting the agent's action
+**`action` - action of agent**
+* `Tool` : Tools available for the agent's use.
+  * tool_name_list，list of tool names, for example:  
+    \- tool_name_a  
+    \- tool_name_b  
+    \- tool_name_c  
+
+  You can choose any existing Tool or connect to any Tool of your choice. We will not elaborate on this part here; you can refer to the Tool section for more details.
+
+* `Knowledge` : Knowledge available for the agent's use.
+  * knowledge_name_list，list of knowledge names, for example:   
+    \- knowledge_name_a  
+    \- knowledge_name_b  
+    \- knowledge_name_c
+  
+  You can choose any existing Knowledge or connect to any Knowledge of your choice. We will not elaborate on this part here; you can refer to the Knowledge section for more details.
+
+### Setting up the agent's memory.
+**`memory` - memory of agent**
+
+The agent already has a default memory mode built-in, so you do not need to set it up. Additionally, memory supports customization and type selection, and we will make this capability available in an upcoming feature.
+
+### Setting up component metadata.
+**`metadata` - metadata of component**
+* `type` : type of component，use 'AGENT'
+* `module`: Agent entity package path
+* `class`: Agent entity class name
+
+All provided Agent components will have their corresponding `module` and `class` copied to this section. This section will integrate all configurations and behaviors of the agent into a whole. If you have extended the behavior of the agent, you need to fill in this section according to the actual path. We will further explain this in the "Creating from an Existing Agent Object" section later in the text.
+
+### An actual example of an agent configuration.
+```yaml
+info:
+  name: 'demo_rag_agent'
+  description: 'demo rag agent'
+profile:
+  introduction: You are an AI assistant proficient in information analysis.
+  target: Your goal is to determine whether the answer to a question provides valuable information and to make suggestions and evaluations about the answer.
+  instruction: |
+    The rules you need to follow are:
+
+    1.Must answer the question posed by the user in Chinese, combining the background information and your knowledge.
+    2.Generate structured answers, and when necessary, use blank lines to enhance the reading experience.
+    3.Do not adopt incorrect information from the background.
+    4.Consider the relevance of the answer to the question, and do not provide answers that are not helpful to the question.
+    5.Answer the question comprehensively, with emphasis on the main points, without excessive fancy wording.
+    6.Do not make vague speculations.
+    7.Use numerical information as much as possible. 
+    
+    Background information is: {background} 
+    
+    Begin! 
+    
+    The question to answer is: {input}
+  llm_model:
+    name: 'demo_llm'
+    model_name: 'gpt-4o'
+plan:
+  planner:
+    name: 'rag_planner'
+action:
+  tool:
+    - 'google_search_tool'
+#  knowledge:
+#    - 'knowledge_a'
+metadata:
+  type: 'AGENT'
+  module: 'sample_standard_app.app.core.agent.rag_agent_case.demo_rag_agent'
+  class: 'DemoRagAgent'
+```
+The above is an actual example of an agent configuration. In addition to the standard configuration items introduced above, the observant among you may have noticed variables in the prompt like `{background}` and `{input}`. This is a very practical prompt replacement feature, which we will explain in the section on defining behaviors in the agent domain.
+
+You can find more agent configuration YAML examples in our sample project under the path `sample_standard_app.app.core.agent`.
+
+In addition to this, agentUniverse does not restrict users from extending the YAML configuration content for agents. You can create any custom configuration key according to your own requirements, but please be careful not to duplicate the default configuration keywords mentioned above.
+
+## Creating Agent Domain Behavior Definition - agent_xx.py
+In this section, you can orchestrate and customize the behavior of any agent. Of course, if you are completely using existing Agent capabilities, this section is not mandatory.
+
+In this section, we will focus on commonly used definitions of agent domain behavior and the common techniques you may use in the actual process of defining agent domain behaviors.
+
+### Create an Agent class object.
+Create the corresponding Agent class object and inherit the AgentUniverse framework's base class Agent.
+
+### Customize the corresponding agent domain behaviors.
+Common customizable agent behaviors are as follows.
+
+#### input_keys method
+Represents the list of input key parameters from users in the agent's execution process, which needs to be implemented by each custom Agent class.
+
+For example, if the agent runs with only one parameter passed in, such as question=xxx, then the input_keys method should return ['question'].
+
+#### output_keys method
+Represents the list of output key parameters when the agent's execution ends, which needs to be implemented by each custom Agent class.
+
+For example, if the agent outputs a result that includes a response, then the output_keys method should return ['response'].
+
+#### parse_input method
+The input processing node before agent execution; an agent's input can be natural language or structured data such as JSON. You can process any user input in this part, and it needs to be implemented by each custom Agent class.
+
+This section has two input parameters, as follows:
+
+* `input_object`: The original data inputted to the agent
+  * You can retrieve corresponding data from input_object using the `input_object.get_data('input_key')` method.
+  
+    For example, if a user inputs `question=xxx` to the agent, we can obtain the current question from the user by using `input_object.get_data('question')`.
+
+* `agent_input`: The data processed by the agent's input handler, of type `dict`.
+  * `agent_input` includes the following key parameters and data by default.
+    * `chat_history`: Includes historical chat data.
+    * `background`: Includes background.
+    * `date`: Includes the current date.
+  * Append the user input to agent_input.
+    * For example: `agent_input['input'] = input_object.get_data('question')`.
+  
+The output object for the `parse_input` method is generally used `agent_input`.
+
+#### parse_result method
+The output processing node before agent execution, where an agent's output can be natural language or structured data such as JSON. You can manage any content that needs to be output in this part, and it needs to be implemented by each custom Agent class.
+
+This section has one input parameter, as follows:
+* `agent_result`: Agent output data, of type `dict`.  
+`parse_result`方法的输出对象一般使用`agent_result`
+
+#### execute method
+This method is the core entry point for the agent's execution flow. The agent's base class implements the execution method by default, and users can also override this method to customize the execution method for any agent.
+
+##### Default execute implementation.
+* The default logic for the execute method in the agent base class is as follows:
+
+  * Get the planner name corresponding to the agent YAML configuration
+  * Obtain a Planner instance through the Planner manager
+  * Execute the invoke method of the Planner instance
+
+##### Custom execute implementation.
+You can also customize the execution flow of the agent by overriding the execute method. Overriding execute will override the default implementation of the agent's base class, meaning the agent will lose the ability to automatically select a Planner. If needed, you can refer to the default implementation of the agent's base class to load and use the corresponding planner.
+
+Below is an example of a custom execute implementation:
+```text
+def execute(self, input_object: InputObject, agent_input: dict) -> dict:
+    # Do anything, as exemplified below.
+    
+    # Invoke tool A to get data.
+    
+    # Analyze the data and determine whether it can answer the user's questions.
+    
+    # Organize language to answer questions.
+    
+    # Output the answer.
+    
+    return {'output': 'xxx'}
+```
+
+#### Get the properties of the agent object.
+Through `self.agent_model`, the agent object can access the properties of the agent. In the definition of agent domain behaviors, you can read all the properties configured in the agent configuration section.
+
+A specific example is as follows:
+```text
+def execute(self, input_object: InputObject, agent_input: dict) -> dict:
+    """Execute agent instance.
+
+    Args:
+        input_object (InputObject): input parameters passed by the user.
+        agent_input (dict): agent input parsed from `input_object` by the user.
+
+    Returns:
+        dict: planner result generated by the planner execution.
+    """
+
+    planner_base: Planner = PlannerManager().get_instance_obj(self.agent_model.plan.get('planner').get('name'))
+    planner_result = planner_base.invoke(self.agent_model, agent_input, input_object)
+    return planner_result
+```
+
+In this example, the `plan` section from the agent configuration attributes is accessed within the execution method using `self.agent_model.plan`, and further, the actual name of the `planner` is obtained through the get method.
+
+
+The properties and domain behaviors of the agent are both dependent on the Agent base class in the agentUniverse framework, which is located at `agentuniverse.agent.agent.Agent`. We will also focus on the underlying objects in the sections on agents and related domain objects. If you are interested in the underlying technical implementation, you can further refer to the corresponding code and documentation.
+
+## Pay attention to the package path where your defined agent is located
+With the agent configuration and domain definition outlined above, you now have mastered all the steps to create an agent. Moving forward, we will use these agents, but before doing so, please ensure that the created agents are within the correct package scan path.
+
+In the `config.toml` of the agentUniverse project, you need to configure the package corresponding to the agent file. Please confirm again that the package path where your created file is located is under the `CORE_PACKAGE` in the `agent` path or its subpaths.
+
+Taking the configuration of the example project as a reference, it would be as follows：
+
+```yaml
+[CORE_PACKAGE]
+# Scan and register agent components for all paths under this list, with priority over the default.
+agent = ['sample_standard_app.app.core.agent']
+```
+
+## Practical tips for agent development
+### Customize and orchestrate the execution process of agents freely
+In the 'Creating Agent Domain Behavior Definitions' section of this document, we have already detailed how to customize an execute method. This method is often used in practice customizing processes and inject SOPs (Standard Operating Procedures) according to user demands.
+
+### How to dynamically adjust settings based on user input
+
+**Method 1 (Recommended): Through the standard prompt template variable replacement method.**  
+
+In the "A Practical Example of an Agent Configuration" section of this document, the prompt includes variables like `{background}`,`{input}`, etc. This feature is the prompt variable template replacement function, aimed at dynamically influencing the prompt based on the user's input. One only needs to define the text using `{variable}` format in the agent configuration settings section, and define it in the parse_input's `agent_input` to dynamically replace the corresponding prompt based on the input portion.
+
+For example, in the sample agent `sample_standard_app.app.core.agent.rag_agent_case.demo_rag_agent.py`, there is the following `parse_input` method.
+
+```text
+def parse_input(self, input_object: InputObject, agent_input: dict) -> dict:
+    agent_input['input'] = input_object.get_data('input')
+    return agent_input
+```
+
+In its agent settings `sample_standard_app.app.core.agent.rag_agent_case.demo_rag_agent.yaml`, in the `instruction` section, we can see the following configuration.
+
+```text
+instruction: |
+    The rules you need to follow are:
+
+    1.Must answer the question posed by the user in Chinese, combining the background information and your knowledge.
+    2.Generate structured answers, and when necessary, use blank lines to enhance the reading experience.
+    3.Do not adopt incorrect information from the background.
+    4.Consider the relevance of the answer to the question, and do not provide answers that are not helpful to the question.
+    5.Answer the question comprehensively, with emphasis on the main points, without excessive fancy wording.
+    6.Do not make vague speculations.
+    7.Use numerical information as much as possible. 
+    
+    Background information is: {background} 
+    
+    Begin! 
+    
+    The question to answer is: {input}
+```
+
+Through this process, we can bring each input, memory or background knowledge, and any information you care about into the interaction between the agent and the LLM using this method.
+
+**Method 2: Adjust the prompt within the parse_input method or the execute method**
+
+Through the agent's `parse_input` method or `execute` method, we can customize the agent in terms of data or behavior. Additionally, by combining the get method in `self.agent_model` with the agent input parameter `input_object`, this means that you can modify any of your settings content through these customization methods.
+
+### Create an agent from an existing agent object
+
+In the actual process of creating applications, we may have many agents of the same type. For example, we might want to create several Retrieval Augmented Generation (RAG) type agents to be used in different question-answering scenarios. By analyzing their similarities and differences, it is not difficult to find that most RAG type agents share the following commonalities and differences:
+
+* Main similarity: They often need to retrieve multiple types of knowledge simultaneously.
+* Main difference: RAG agents in different scenarios need to retrieve using different tools and may have different global agent settings.
+
+Upon further analysis, we can achieve this goal through the same domain behavior and differentiated attribute configurations. This is why configuring settings in YAML is essential during the agent creation process, while domain behavior customization is based on actual needs.
+
+Fortunately, we have a significant number of effective agent types, and they are still expanding. As described in this case, combining the agent domain component setting process, we only need to set different types of agent configuration YAMLs, and complete this goal by setting `metadata`.
+
+
+For example:
+
+**Financial RAG Agent Settings**
+```yaml
+info:
+  name: 'financial_RAG_agent'
+  description: 'demo financial rag agent'
+profile:
+  introduction:  Demo introduction, such as you are a financial RAG agent.
+  target: Demo target, such as use financial tools to retrieve and enhance answer performance.
+  instruction: |
+    demo instruction, xxx, {input}
+  llm_model:
+    name: 'demo_llm'
+    model_name: 'gpt-4o'
+plan:
+  planner:
+    name: 'rag_planner'
+action:
+  tool:
+    - 'financial_data_tool'
+metadata:
+  type: 'AGENT'
+  module: 'agentuniverse.agent.default.rag_agent.rag_agent'
+  class: 'RagAgent'
+```
+
+**Tech RAG Agent Settings**
+```yaml
+info:
+  name: 'tech_RAG_agent'
+  description: 'demo tech rag agent'
+profile:
+  introduction:  Demo introduction, such as you are a tech RAG agent.
+  target: Demo target, such as use tech tools to retrieve and enhance answer performance.
+  instruction: |
+    demo instruction, xxx, {input}
+  llm_model:
+    name: 'demo_llm'
+    model_name: 'gpt-4o'
+plan:
+  planner:
+    name: 'rag_planner'
+action:
+  tool:
+    - 'tech_data_tool'
+metadata:
+  type: 'AGENT'
+  module: 'agentuniverse.agent.default.rag_agent.rag_agent'
+  class: 'RagAgent'
+```
+
+You can find more information about existing agents and understand their roles in the "Learn More About Existing Agents" section of this document.
+
+# How to Use an Agent
+In the agentUniverse, all agent entities are managed by a global agent manager. If you need to use an agent during any framework execution process, you can do so through the agent manager. Additionally, leveraging the framework's service capabilities, you can quickly turn an agent into a service and make network calls to it using standard HTTP or RPC protocols.
+
+## Solution 1: Use the agent manager
+
+Through the `get_instance_obj('agent_name_xxx')` method in the agent manager, you can obtain the agent instance with the corresponding name. Meanwhile, the agent can be utilized through its own `run(input='xxx')` method. The `test_rag_agent(self)` method in the test class below demonstrates debugging the agent using this approach.
+
+```python
+import unittest
+
+from agentuniverse.agent.agent import Agent
+from agentuniverse.agent.agent_manager import AgentManager
+from agentuniverse.agent.output_object import OutputObject
+from agentuniverse.base.agentuniverse import AgentUniverse
+
+
+class RagAgentTest(unittest.TestCase):
+    """
+    Test cases for the rag agent
+    """
+
+    def setUp(self) -> None:
+        AgentUniverse().start(config_path='../../config/config.toml')
+
+    def test_rag_agent(self):
+        """Test demo rag agent."""
+        instance: Agent = AgentManager().get_instance_obj('demo_rag_agent')
+        output_object: OutputObject = instance.run(input="What is the reason for the sharp rise in Nvidia's stock?")
+        print(output_object.get_data('output'))
+
+if __name__ == '__main__':
+    unittest.main()
+```
+
+## Solution 2: Utilize the service capabilities of agent_serve
+
+The agentUniverse offers a variety of standard web serve capabilities, along with standard HTTP and RPC protocols. You can further refer to the documentation sections on [Service Registration and Usage](2_4_1_Service_Registration_and_Usage.md) and [Web_Server](2_4_1_Web_Server.md).
+
+# Learn more about agents
+The agents provided by the framework can be found under the `agentuniverse.agent.default` package path. You can further explore the corresponding code or learn more about them in our extension component introduction section.
+
+# Conclusion
+By now, you have mastered all the content related to the creation and use of agents. Let's use this knowledge to customize your own exclusive agent.
\ No newline at end of file
diff --git a/docs/guidebook/en/2_2_1_Agents_Related_Domain_Objects.md b/docs/guidebook/en/2_2_1_Agents_Related_Domain_Objects.md
new file mode 100644
index 00000000..0e6af2e0
--- /dev/null
+++ b/docs/guidebook/en/2_2_1_Agents_Related_Domain_Objects.md
@@ -0,0 +1,17 @@
+# Agents and Related Domain Objects
+In this chapter, we will highlight agents and related core domain objects. We have omitted their corresponding code parts. If you wish to learn more, please read the [API Reference](4_1_API_Reference.md) Section.
+
+## Agent Base Class
+Package path: `agentuniverse.agent.agent.Agent`
+
+## Agent Manager
+Package path: `agentuniverse.agent.agent_manager.AgentManager`
+
+## Agent Model Attribute Class
+Package path: `agentuniverse.agent.agent_model.AgentModel`
+
+## Input Object
+Package path: `agentuniverse.agent.input_object.InputObject`
+
+## Output Object
+Package path:`agentuniverse.agent.output_object.OutputObject`
diff --git a/docs/guidebook/en/2_4_1_Service_Information_Storage.md b/docs/guidebook/en/2_4_1_Service_Information_Storage.md
new file mode 100644
index 00000000..0f384206
--- /dev/null
+++ b/docs/guidebook/en/2_4_1_Service_Information_Storage.md
@@ -0,0 +1,34 @@
+# Service Information Storage
+
+agentUniverse uses a system-level database to store various types of information generated during application runtime, such as the results of asynchronous service requests, which are stored in this database.
+
+## System Database Configuration
+You can configure the system database address in the `config.toml` file:
+```toml
+[DB]
+# A sqlalchemy db uri used for storing various info, for example, service request, generated during application running.
+# If it's empty, agentUniverse will create a local sqlite db as default choice.
+system_db_uri = ''
+```
+Please note that this URI should comply with the URI format specification in SQLAlchemy.
+When this value is empty, a `DB` folder will be created in the project root directory, and a SQLite DB file named `agent_universe.db` will be created in the folder as the default system database.
+
+## Service Information Table Format
+agentUniverse uses the following ORM to store request information:
+```text
+class RequestORM(Base):
+    """SQLAlchemy ORM Model for RequestDO."""
+    __tablename__ = 'request_task'
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    request_id = Column(String(20), nullable=False)
+    query = Column(Text)
+    session_id = Column(String(50))
+    state = Column(String(20))
+    result = Column(JSON)
+    steps = Column(JSON)
+    additional_args = Column(JSON)
+    gmt_create = Column(DateTime, default=datetime.datetime.now)
+    gmt_modified = Column(DateTime, default=datetime.datetime.now,
+                          onupdate=datetime.datetime.now)
+```
+Where `id` is an auto-incremented primary key, `request_id` is a unique ID for each request, `stat`e represents the execution state of the agent task corresponding to the request, `result` is the execution result, `steps` are the intermediate outputs during the execution process, `session_id` and `additional_args` are reserved fields in the current version.
\ No newline at end of file
diff --git a/docs/guidebook/en/5_1_1_Docker_Container_Deployment.md b/docs/guidebook/en/5_1_1_Docker_Container_Deployment.md
index 4c3b3b4a..8afa9008 100644
--- a/docs/guidebook/en/5_1_1_Docker_Container_Deployment.md
+++ b/docs/guidebook/en/5_1_1_Docker_Container_Deployment.md
@@ -22,7 +22,7 @@ The`-p 8888:8888`represents the port mapping for the Web Server. The first 8888
 If you need multiple containers to mount the same directory, it's advised to pay attention to the following points when using this method:：
 1. Specify a SQLite database file address outside the mounted path `/usr/local/etc/workspace/project`in the config.toml, such as inside `/usr/local/etc` in the container, for example,
     ```toml
-    mysql_uri = 'sqlite:////usr/local/etc/agent_universe.db'
+    system_db_uri = 'sqlite:////usr/local/etc/agent_universe.db'
     ```
     This can reduce the problems with SQLite concurrency (as SQLite does not handle concurrency very well). Alternatively, you can directly use MySQL, which will offer better concurrency performance.
 2. Specify a directory outside the mounted path in the log_config.toml, like
diff --git a/docs/guidebook/en/8_1_Contact_Us.md b/docs/guidebook/en/6_1_Contact_Us.md
similarity index 100%
rename from docs/guidebook/en/8_1_Contact_Us.md
rename to docs/guidebook/en/6_1_Contact_Us.md
diff --git "a/docs/guidebook/zh/0_\347\233\256\345\275\225.md" "b/docs/guidebook/zh/0_\347\233\256\345\275\225.md"
index f4482c4d..d391d0dd 100644
--- "a/docs/guidebook/zh/0_\347\233\256\345\275\225.md"
+++ "b/docs/guidebook/zh/0_\347\233\256\345\275\225.md"
@@ -17,6 +17,8 @@
 * 2.1 框架原理
 * 2.2 [领域组件](2_2_领域组件原理.md)
   * 2.2.1 [智能体(Agent)](2_2_1_智能体.md)
+    * 2.2.1.1 [智能体创建与使用](2_2_1_智能体创建与使用.md)
+    * 2.2.1.2 [智能体及相关领域对象](2_2_1_智能体及相关领域对象.md)
   * 2.2.2 模型(LLM)
   * 2.2.3 工具(Tool)
   * 2.2.4 知识(Knowledge)
@@ -28,6 +30,7 @@
     * 2.4.1.1 [注册与使用](2_4_1_服务注册与使用.md)
     * 2.4.1.2 [Web Server](2_4_1_Web_Server.md)
     * 2.4.1.3 [服务API](2_4_1_服务Api.md)
+    * 2.4.1.4 [服务信息存储](2_4_1_服务信息存储.md)
   * 2.4.2 prompt管理
   * 2.4.3 多轮会话
   * 2.4.4 日志体系
@@ -61,4 +64,4 @@
 
 **7.常见问题FAQ**
 
-**[8.联系我们](8_1_联系我们.md)**
+**[8.联系我们](6_1_联系我们.md)**
diff --git "a/docs/guidebook/zh/2_2_1_\346\231\272\350\203\275\344\275\223.md" "b/docs/guidebook/zh/2_2_1_\346\231\272\350\203\275\344\275\223.md"
index ad957ff0..15020d06 100644
--- "a/docs/guidebook/zh/2_2_1_\346\231\272\350\203\275\344\275\223.md"
+++ "b/docs/guidebook/zh/2_2_1_\346\231\272\350\203\275\344\275\223.md"
@@ -9,6 +9,9 @@
 ## 全局设定（Profile）
 该部分是Agent的全局设定，包含了Agent的Target、Introduction、LLM部分。
 
+### 介绍（Introduction）
+对于Agent的角色描述，例如：你是一位精通信息分析的ai助手。
+
 ### 目标（Target）
 Agent需要实现的核心目标, Agent会围绕着这个目标去完成后续一系列的工作。
   
@@ -19,27 +22,27 @@ Agent需要实现的核心目标, Agent会围绕着这个目标去完成后续
 
 ❌ 不太好的例子，如：随便聊聊等无目的性的描述  
 ```
-  
-### 介绍（Introduction）
-对于Agent的全面介绍，包含了对于Agent的性格设定、背景知识、行为指导等。
+
+### 指令（Instruction）
+包含了对于Agent的具体设定，如性格设定、背景知识、行为指导等。
 
 ```text
-如何写好Introduction？我们可以采取如下范式：
-智能体扮演的角色（推荐填写）+  明确的擅长的职责范围（推荐填写）+  性格设定（按需填写） + 背景知识（按需填写）+ 用户输入格式（按需填写）+ 行为指导（推荐填写） +  agent输出格式（按需填写） +  实际的例子-fewshot（推荐填写）
+如何写好Instruction？我们可以采取如下范式：
+明确的擅长的职责范围（推荐填写）+  性格设定（按需填写） + 背景知识（按需填写）+ 用户输入格式（按需填写）+ 行为指导（推荐填写） +  agent输出格式（按需填写） +  实际的例子-fewshot（推荐填写）
 
 根据上述范式定义有如下举例：
 ✅ 比较好的例子，如：
-你是Jerry的个人专属聊天机器人【智能体扮演的角色】。
 你擅长回答各类生活中遇见的专业问题与闲聊，你尤为擅长回答金融类问题【明确的擅长的职责范围】。
 你的性格开朗活泼【性格设定】。
 Jerry平日里对于财经类新闻特别感兴趣，同时比较关注宏观层面的政策【背景知识】。
-Jerry会用自然语言的形式与你进行问答交流【用户输入格式】。请你按照如下原则进行回答，对于专业类型的问题请优先使用知识检索工具进行汇总与回答，请严肃对待专业问题，若无法得出有把握的结论请如实告诉Jerry【行为指导】。
+Jerry会用自然语言的形式与你进行问答交流【用户输入格式】。
+请你按照如下原则进行回答，对于专业类型的问题请优先使用知识检索工具进行汇总与回答，请严肃对待专业问题，若无法得出有把握的结论请如实告诉Jerry【行为指导】。
 请你用自然语言的形式输出你的回答【agent输出格式】。
 下面是一个与Jerry交流的实际例子：Jerry问如何看待 2023年12月宏观数据? 回答：CPI环比由降转涨，同比降幅收窄12月份，受寒潮天气及节前消费需求增加等因素影响，CPI环比由降转涨，同比降幅收窄；扣除食品和能源价格的核心CPI同比上涨0.6%，涨幅保持稳定。PPI环比下降，同比降幅收窄12月份，受国际油价继续下行、部分工业品需求不足等因素影响，全国PPI环比下降，同比降幅收窄。【实际的例子-fewshot】
 （【】符号中的文字为说明，实际填写不需要提示）。
 
 ❌ 不太好的例子，如：
-你是一位健身教练，善于针对不同人群给出各类健身计划（给出的信息太少，给出的结果不确定性高，会比较泛泛而谈，往往不符合实际诉求） 
+你善于针对不同人群给出各类健身计划（给出的信息太少，给出的结果不确定性高，会比较泛泛而谈，往往不符合实际诉求） 
 ```
 
 ### 模型（LLM）
diff --git "a/docs/guidebook/zh/2_2_1_\346\231\272\350\203\275\344\275\223\345\210\233\345\273\272\344\270\216\344\275\277\347\224\250.md" "b/docs/guidebook/zh/2_2_1_\346\231\272\350\203\275\344\275\223\345\210\233\345\273\272\344\270\216\344\275\277\347\224\250.md"
new file mode 100644
index 00000000..e7bd533c
--- /dev/null
+++ "b/docs/guidebook/zh/2_2_1_\346\231\272\350\203\275\344\275\223\345\210\233\345\273\272\344\270\216\344\275\277\347\224\250.md"
@@ -0,0 +1,366 @@
+# 如何创建智能体
+您或许已经在[快速开始](1_3_快速开始.md)章节中了解如何快速创建一个智能体，亦或是在[智能体原理](2_2_1_智能体.md)掌握了智能体的重要组成部分，在本节我们会进一步详细说明如何创建智能体。
+
+根据agentUniverse领域组件的设计特性，创建一个智能体在创建过程中由2部分组成:
+* agent_xx.yaml
+* agent_xx.py
+
+其中`agent_xx.yaml`必须创建, 其包含了agent的Introduction、Target、Instruction、LLM等重要属性信息；`agent_xx.py`为按需创建，其包含了agent的特定行为并且支持了用户对于agent进行领域行为自定义注入。理解这一原理后，让我们具体看看该如何创建这两部分内容。
+
+## 创建智能体配置 - agent_xx.yaml
+我们将详细介绍配置中的各组成部分。
+
+### 设置智能体的基本信息
+**`info` - 智能体基本信息**
+* `name`:  智能体名称
+* `description`:  智能体描述
+
+### 设置智能体的全局设定
+**`profile` - 智能体全局设定**
+* `introduction`:  智能体角色介绍
+* `target`:  智能体目标
+* `instruction`: 智能体指令
+* `llm_model`: 智能体使用的LLM
+  * `name`: LLM 名称
+  * `model_name`: LLM 模型名  
+
+  您可以选择已有或接入任意的LLM，我们在本部分不展开说明，您可以关注LLM章节。
+
+### 设置智能体计划
+**`plan` - 智能体计划**
+* `planner` : 智能体计划器
+  * `name`: 计划器名称  
+  
+  您可以选择已有或接入任意的Planner，我们在本部分不展开说明，您可以关注Planner章节。
+
+### 设置智能体动作
+**`action` - 智能体动作**
+* `Tool` : 供智能体使用的工具
+  * tool_name_list，工具名称列表, 如:  
+    \- tool_name_a  
+    \- tool_name_b  
+    \- tool_name_c  
+
+  您可以选择已有或接入任意的Tool，我们在本部分不展开说明，您可以关注Tool章节。
+
+* `Knowledge` : 供智能体使用的知识
+  * knowledge_name_list，知识名称列表, 如:  
+    \- knowledge_name_a  
+    \- knowledge_name_b  
+    \- knowledge_name_c
+  
+  您可以选择已有或接入任意的Knowledge，我们在本部分不展开说明，您可以关注Knowledge章节。
+
+### 设置智能体记忆
+**`memory` - 智能体记忆**
+
+agent目前已经内置了默认记忆模式，您无需设置，同时memory是支持定制与类型选择的，我们会在近期的feature中开放这部分能力。
+
+### 设置组件元信息
+**`metadata` - 组件元信息**
+* `type` : 组件类型，'AGENT'
+* `module`: Agent实体包路径
+* `class`: Agent实体类名
+
+所有已经提供的Agent组件都将提供对应的`module`、`class`复制到该部分即可。该部分会将智能体的所有配置与其行为组成一个整体，若您扩展了智能体的行为，则需要按照实际路径填写这部分，我们将在后文中的 '从已有的智能体对象创建' 小节进一步说明。
+
+### 一个智能体配置的实际样例
+```yaml
+info:
+  name: 'demo_rag_agent'
+  description: 'demo rag agent'
+profile:
+  introduction: 你是一位精通信息分析的ai助手。
+  target: 你的目标是判断问题对应的答案是否提供了有价值的信息，并对问题的答案做出建议和评价。
+  instruction: |
+    你需要遵守的规则是:
+    1. 必须使用中文结合查询的背景信息结合你所拥有的知识回答用户提出的问题。
+    2. 结构化答案生成，必要时通过空行提升阅读体验。
+    3. 不采用背景信息中的错误信息。
+    4. 要考虑答案和问题的相关性，不做对问题没有帮助的回答。
+    5. 详尽回答问题，重点突出，不过多花哨词藻。
+    6. 不说模糊的推测。
+    7. 尽量多的使用数值类信息。
+
+    背景信息是:
+    {background}
+
+    开始!
+
+    需要回答的问题是: {input}
+  llm_model:
+    name: 'demo_llm'
+    model_name: 'gpt-4o'
+plan:
+  planner:
+    name: 'rag_planner'
+action:
+  tool:
+    - 'google_search_tool'
+#  knowledge:
+#    - 'knowledge_a'
+metadata:
+  type: 'AGENT'
+  module: 'sample_standard_app.app.core.agent.rag_agent_case.demo_rag_agent'
+  class: 'DemoRagAgent'
+```
+上述是一个实际的智能体配置的样例。除了上述介绍的标准配置项，细心的你可能发现了prompt中包含了类似`{background}`、`{input}`等变量，这是一个非常实用的prompt替换功能，我们在智能体领域行为定义中将解释这部分能力。
+
+您可以在我们的样例工程中的`sample_standard_app.app.core.agent`路径下更多的智能体配置yaml样例。
+
+除此之外agentuniverse不限制用户对agent yaml配置内容进行扩展，您可以根据自己的要求创建任何自定义配置key,但请注意不要与上述默认的配置关键字重名。
+
+## 创建智能体领域行为定义 - agent_xx.py
+在本部分您可以对任何智能体的行为进行编排与定制，当然如果您完全使用已有的Agent能力那么本部分并非必须。
+
+在本节我们将重点介绍常用的智能体领域行为定义与您可能在实际智能体领域行为定义过程中使用的常用技巧。
+
+### 创建Agent类对象
+创建对应的Agent类对象并继承agentUniverse框架Agent基础类 `Agent`;
+
+### 定制对应的智能体领域行为
+常用可定制的智能体行为如下。
+
+#### input_keys方法
+代表agent智能体运行流程中用户的入参key列表，需要由各自定义Agent类实现。
+
+例如：agent智能体运行只传入一个参数 question=xxx，则 input_keys 方法 return ['question']
+
+#### output_keys方法
+代表agent智能体运行结束时的出参key列表，需要由各自定义Agent类实现。
+
+例如：agent智能体运行输出结果包含response，则 output_keys 方法 return ['response']
+
+#### parse_input方法
+agent执行前的输入处理节点, agent的输入可以是自然语言或者json等结构化数据，您可以将任何用户输入的内容在该部分做处理，需要由各自定义Agent类实现。
+
+该部分拥有两个输入参数，如下:
+* `input_object`: 智能体输入原始数据
+  * 可通过 `input_object.get_data('input_key')` 方法获取input_object中的对于数据。  
+  
+    例如： 用户对智能体输入`question=xxx`， 我们可以通过`input_object.get_data('question')`获取用户当前的提问。
+
+* `agent_input`: 智能体输入处理后的数据, `dict类型`
+  * `agent_input`默认包含了如下关键参数key及数据
+    * `chat_history`: 包含了多轮会话数据
+    * `background`: 包含了背景知识
+    * `date`: 包含了当前的时间日期
+  * 将用户输入追加到`agent_input`中
+    * 例如： `agent_input['input'] = input_object.get_data('question')`
+  
+`parse_input`方法的输出对象一般使用`agent_input`。
+
+#### parse_result方法
+agent执行前的输出处理节点, agent的输出可以是自然语言或者json等结构化数据，您可以将任何需要输出的内容在该部分做处理，需要由各自定义Agent类实现。
+
+该部分拥有一个输入参数，如下:
+* `agent_result`: 智能体输出数据, `dict类型`  
+`parse_result`方法的输出对象一般使用`agent_result`
+
+#### execute方法
+该方法是agent最核心的执行流程入口， agent基础类默认实现了执行方法，用户也可以重写该方法定制任何agent的执行方法。
+
+##### 默认execute实现
+* agent基础类默认execute方法逻辑如下：
+  * 获取agent yaml配置中对应的planner名称
+  * 通过Planner管理器获取Planner实例
+  * 执行Planner实例invoke方法
+
+##### 自定义execute实现
+您也可以通过重写execute对于编排和定制agent的执行流程，重写execute会覆盖原有的agent基础类默认实现，这意味着agent将失去自动选择Planner的能力，若您需要您可以参考agent基础类默认实现加载对应的planner进行使用。
+
+以下是自定义execute的一个例子：
+```text
+def execute(self, input_object: InputObject, agent_input: dict) -> dict:
+    # Do anything, as exemplified below.
+    
+    # Invoke tool A to get data.
+    
+    # Analyze the data and determine whether it can answer the user's questions.
+    
+    # Organize language to answer questions.
+    
+    # Output the answer.
+    
+    return {'output': 'xxx'}
+```
+
+#### 获取智能体对象属性
+智能体对象通过`self.agent_model`可以智能体的属性，在智能体领域行为定义中您可以读取在智能体配置部分配置的所有属性。
+
+一个具体的例子如下:
+```text
+def execute(self, input_object: InputObject, agent_input: dict) -> dict:
+    """Execute agent instance.
+
+    Args:
+        input_object (InputObject): input parameters passed by the user.
+        agent_input (dict): agent input parsed from `input_object` by the user.
+
+    Returns:
+        dict: planner result generated by the planner execution.
+    """
+
+    planner_base: Planner = PlannerManager().get_instance_obj(self.agent_model.plan.get('planner').get('name'))
+    planner_result = planner_base.invoke(self.agent_model, agent_input, input_object)
+    return planner_result
+```
+在这段例子中通过`self.agent_model.plan`方式在执行方法内获取了智能体配置属性中的`plan`部分,进一步通过get方法最终获取了`planner`的实际名称。
+
+智能体的属性与领域行为都依赖于agentUniverse框架中Agent基础类，其路径为`agentuniverse.agent.agent.Agent`, 我们在智能体及相关领域对象章节中也会重点介绍相关的底层对象，若您关注底层技术实现可进一步参考对应的代码与文档；
+
+## 关注您定义的智能体所在的包路径
+通过上面的agent配置与领域定于部分，您已经掌握了agent创建的所有步骤；接下去我们将使用这些agent，在使用前请关注创建的agent是否在正确的包扫描路径内。
+
+在agentUniverse项目的config.toml中需要配置agent文件对应的package, 请再次确认您创建的文件所在的包路径是否在`CORE_PACKAGE`中`agent`路径或其子路径下。
+
+以示例工程中的配置为例，如下：
+```yaml
+[CORE_PACKAGE]
+# Scan and register agent components for all paths under this list, with priority over the default.
+agent = ['sample_standard_app.app.core.agent']
+```
+
+## agent创建的实用技巧
+### 自由定制与编排agent的执行过程
+在本文的 '创建智能体领域行为定义' 的 'execute方法' 部分中我们已经详细说明了如何自定义一个execute方法，这个方法在实践过程经常用来根据用户的诉求定制流程与注入SOP(Standard Operating Procedure)。
+
+### 如何通过用户的输入动态调整设置
+
+**方法一(推荐)： 通过标准的prompt模版变量替换方式**  
+
+我们在本文的 '一个智能体配置的实际样例' 小节中prompt中包含了类似`{background}`、`{input}`等变量，这是prompt变量模版替换功能，其目的是能够通过用户的输入去动态的影响prompt， 只需要在智能体配置的设置部分将文本使用`{变量名}`的方式进行定义，并在`parse_input`的`agent_input`中进行定义即可动态根据输入的部分替换对应的prompt。
+
+例如在样例agent中 `sample_standard_app.app.core.agent.rag_agent_case.demo_rag_agent.py` 有如下的`parse_input`方法。
+```text
+def parse_input(self, input_object: InputObject, agent_input: dict) -> dict:
+    agent_input['input'] = input_object.get_data('input')
+    return agent_input
+```
+在其对应agent设置`sample_standard_app.app.core.agent.rag_agent_case.demo_rag_agent.yaml`中的`instruction`部分我们可以看到如下配置:
+```text
+instruction: |
+    你需要遵守的规则是:
+    1. 必须使用中文结合查询的背景信息结合你所拥有的知识回答用户提出的问题。
+    2. 结构化答案生成，必要时通过空行提升阅读体验。
+    3. 不采用背景信息中的错误信息。
+    4. 要考虑答案和问题的相关性，不做对问题没有帮助的回答。
+    5. 详尽回答问题，重点突出，不过多花哨词藻。
+    6. 不说模糊的推测。
+    7. 尽量多的使用数值类信息。
+
+    背景信息是:
+    {background}
+
+    开始!
+
+    需要回答的问题是: {input}
+```
+
+通过这个过程我们可以将每次的输入与记忆或背景知识及任何你关注的信息通过该方法带入agent与LLM的交互中。
+
+**方法二： 在parse_input方法或execute方法中调整prompt**
+通过agent的`parse_input`方法或`execute`方法我们可以对agent做数据或行为上的定制，同时结合`self.agent_model`中的get方法与智能体输入参数`input_object`，这意味着您可以通过这些定制方法将你的任意设置内容进行修改。
+
+### 从已有的智能体对象创建智能体
+在实际的应用创建过程中，我们可能存在很多同类型的智能体，例如我们想创建许多检索增强RAG(Retrieval Augmented Generation)类型的智能体，运用于不同的问答场景中。分析他们的相同与不同点我们不难发现对于大部分RAG类型的智能体，他们具有如下共性与差异。
+* 主要的相同点：他们往往都需要同时检索多种知识
+* 主要的不同点： 不同场景的RAG智能体需要对应检索不同的工具，可能拥有不同的智能体全局设置
+
+进一步分析，我们通过相同的领域行为与差异化的属性配置可以实现这一目标。这也就是为什么agent的创建过程中配置设置yaml是必须的, 但是领域行为定制是按实际需求的。
+
+幸运的是我们拥有非常多有效的智能体类型, 并且他们仍在不断扩充。如这个case所述，结合agent领域组件的设置过程，我们仅需要设置非常多不同的类型的agent配置设置yaml，并且在agent的组件元信息中通过设置`metadata`完成这一目标。
+
+例如：  
+**金融类RAG agent设置**
+```yaml
+info:
+  name: 'financial_RAG_agent'
+  description: 'demo financial rag agent'
+profile:
+  introduction:  Demo introduction, such as you are a financial RAG agent.
+  target: Demo target, such as use financial tools to retrieve and enhance answer performance.
+  instruction: |
+    demo instruction, xxx, {input}
+  llm_model:
+    name: 'demo_llm'
+    model_name: 'gpt-4o'
+plan:
+  planner:
+    name: 'rag_planner'
+action:
+  tool:
+    - 'financial_data_tool'
+metadata:
+  type: 'AGENT'
+  module: 'agentuniverse.agent.default.rag_agent.rag_agent'
+  class: 'RagAgent'
+```
+
+**科技类RAG agent设置**
+```yaml
+info:
+  name: 'tech_RAG_agent'
+  description: 'demo tech rag agent'
+profile:
+  introduction:  Demo introduction, such as you are a tech RAG agent.
+  target: Demo target, such as use tech tools to retrieve and enhance answer performance.
+  instruction: |
+    demo instruction, xxx, {input}
+  llm_model:
+    name: 'demo_llm'
+    model_name: 'gpt-4o'
+plan:
+  planner:
+    name: 'rag_planner'
+action:
+  tool:
+    - 'tech_data_tool'
+metadata:
+  type: 'AGENT'
+  module: 'agentuniverse.agent.default.rag_agent.rag_agent'
+  class: 'RagAgent'
+```
+
+您可以在本文的 '了解更多已有的智能体' 部分查询更多的agent元信息并了解他们的作用。
+
+# 如何使用智能体
+在agentUniverse中所有agent实体都由全局agent管理器进行管理，在任何框架执行过程中如果您需要使用智能体可以通过agent管理器。同时通过框架的服务化能力，您可以将agent快速服务化并通过标准的http或rpc协议对其进行网络调用。
+
+## 方案一: 使用agent管理器
+通过agent管理器中的`get_instance_obj('agent_name_xxx')` 方法可以获取对应名称的agent实例，同时通过agent自身的`run(input='xxx')`方法使用agent，下面的test类中的`test_rag_agent(self)`方法就是使用该方式对于agent进行了调试。
+```python
+import unittest
+
+from agentuniverse.agent.agent import Agent
+from agentuniverse.agent.agent_manager import AgentManager
+from agentuniverse.agent.output_object import OutputObject
+from agentuniverse.base.agentuniverse import AgentUniverse
+
+
+class RagAgentTest(unittest.TestCase):
+    """
+    Test cases for the rag agent
+    """
+
+    def setUp(self) -> None:
+        AgentUniverse().start(config_path='../../config/config.toml')
+
+    def test_rag_agent(self):
+        """Test demo rag agent."""
+        instance: Agent = AgentManager().get_instance_obj('demo_rag_agent')
+        output_object: OutputObject = instance.run(input='英伟达股票大涨原因是什么？')
+        print(output_object.get_data('output'))
+
+if __name__ == '__main__':
+    unittest.main()
+```
+
+## 方案二: 使用agent_serve服务化能力
+agentUniverse提供多套标准的web serve能力, 同时提供标准的http与rpc协议。您可以进一步关注文档[服务注册与使用](2_4_1_服务注册与使用.md)与[Web_Server](2_4_1_Web_Server.md)部分。
+
+# 了解更多已有的智能体
+框架提供的智能体在`agentuniverse.agent.default`包路径下，您可以进一步查看对应代码或在我们的扩展组件介绍部分进一步了解他们。
+
+# 总结
+至此您已经掌握了智能体创建与使用的全部内容，让我们用这些内容去定制专属agent吧。
\ No newline at end of file
diff --git "a/docs/guidebook/zh/2_2_1_\346\231\272\350\203\275\344\275\223\345\217\212\347\233\270\345\205\263\351\242\206\345\237\237\345\257\271\350\261\241.md" "b/docs/guidebook/zh/2_2_1_\346\231\272\350\203\275\344\275\223\345\217\212\347\233\270\345\205\263\351\242\206\345\237\237\345\257\271\350\261\241.md"
new file mode 100644
index 00000000..6ccb4056
--- /dev/null
+++ "b/docs/guidebook/zh/2_2_1_\346\231\272\350\203\275\344\275\223\345\217\212\347\233\270\345\205\263\351\242\206\345\237\237\345\257\271\350\261\241.md"
@@ -0,0 +1,17 @@
+# 智能体与相关领域对象
+在本章节我们会重点列出智能体与相关的核心领域对象, 我们省略了其对应的代码部分，若您希望进一步了解请阅读对应的[API参考部分](4_1_API参考.md)。
+
+## Agent基础类
+包路径：`agentuniverse.agent.agent.Agent`
+
+## Agent管理器
+包路径：`agentuniverse.agent.agent_manager.AgentManager`
+
+## Agent属性类
+包路径：`agentuniverse.agent.agent_model.AgentModel`
+
+## 输入对象
+包路径：`agentuniverse.agent.input_object.InputObject`
+
+## 输出对象
+包路径：`agentuniverse.agent.output_object.OutputObject`
diff --git "a/docs/guidebook/zh/2_4_1_\346\234\215\345\212\241\344\277\241\346\201\257\345\255\230\345\202\250.md" "b/docs/guidebook/zh/2_4_1_\346\234\215\345\212\241\344\277\241\346\201\257\345\255\230\345\202\250.md"
new file mode 100644
index 00000000..6693718f
--- /dev/null
+++ "b/docs/guidebook/zh/2_4_1_\346\234\215\345\212\241\344\277\241\346\201\257\345\255\230\345\202\250.md"
@@ -0,0 +1,34 @@
+# 服务信息存储
+
+agentUniverse使用了一个系统级别的数据库用于存储应用运行时产生的各类信息，如异步服务请求中的运行结果就是存储在该数据库中。
+
+## 系统数据库配置
+您可以在`config.toml`文件中配置系统数据库地址：
+```toml
+[DB]
+# A sqlalchemy db uri used for storing various info, for example, service request, generated during application running.
+# If it's empty, agentUniverse will create a local sqlite db as default choice.
+system_db_uri = ''
+```
+需注意该uri应当符合`SQLAlchemy`中的uri格式规范。  
+当该值为空的时候，会在项目根目录创建一个DB文件夹，并在文件夹中创建一个名为`agent_universe.db`的sqlite DB文件作为默认系统数据库。
+
+## 服务信息表格式
+agentUniverse中使用如下ORM存储请求信息：
+```text
+class RequestORM(Base):
+    """SQLAlchemy ORM Model for RequestDO."""
+    __tablename__ = 'request_task'
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    request_id = Column(String(20), nullable=False)
+    query = Column(Text)
+    session_id = Column(String(50))
+    state = Column(String(20))
+    result = Column(JSON)
+    steps = Column(JSON)
+    additional_args = Column(JSON)
+    gmt_create = Column(DateTime, default=datetime.datetime.now)
+    gmt_modified = Column(DateTime, default=datetime.datetime.now,
+                          onupdate=datetime.datetime.now)
+```
+其中`id`为自增的主key，`request_id`为每个请求独一无二的ID，`state`表示该请求对应的Agent任务执行状态，`result`为执行结果，`steps`是执行过程的中间产出，`session_id`和`additional_args`在当前版本中为保留字段。
\ No newline at end of file
diff --git "a/docs/guidebook/zh/5_1_1_Docker\345\256\271\345\231\250\345\214\226\351\203\250\347\275\262.md" "b/docs/guidebook/zh/5_1_1_Docker\345\256\271\345\231\250\345\214\226\351\203\250\347\275\262.md"
index bcbbf782..a1d4c23b 100644
--- "a/docs/guidebook/zh/5_1_1_Docker\345\256\271\345\231\250\345\214\226\351\203\250\347\275\262.md"
+++ "b/docs/guidebook/zh/5_1_1_Docker\345\256\271\345\231\250\345\214\226\351\203\250\347\275\262.md"
@@ -22,7 +22,7 @@ docker run -d -p 8888:8888 -e OPENAI_API_KEY=XXX -v ./sample_standard_app/:/usr/
 由于多个容器在相同的挂载目录进行文件的读写，有几处设置可以优化并发读写的冲突：
 1. 当您使用本地Sqlite库时，sqlite的本地数据库文件默认保存在项目主目录下，因此所有容器会读写同一个数据库文件，可能引发并发问题。建议在config.toml中指定一个非挂载路径 `/usr/local/etc/workspace/project`下的sqlite数据库文件地址，如容器内的`/usr/local/etc`下，例如
     ```toml
-    mysql_uri = 'sqlite:////usr/local/etc/agent_universe.db'
+    system_db_uri = 'sqlite:////usr/local/etc/agent_universe.db'
     ```
     或者也可以使用mysql，避免在本地进行数据库文件的读写。
 2. 日志文件输出的默认路径是在项目工程的主目录，也就是挂载目录中，因此推荐在log_config.toml中指定一个非挂载路径下的目录，如
diff --git "a/docs/guidebook/zh/8_1_\350\201\224\347\263\273\346\210\221\344\273\254.md" "b/docs/guidebook/zh/6_1_\350\201\224\347\263\273\346\210\221\344\273\254.md"
similarity index 100%
rename from "docs/guidebook/zh/8_1_\350\201\224\347\263\273\346\210\221\344\273\254.md"
rename to "docs/guidebook/zh/6_1_\350\201\224\347\263\273\346\210\221\344\273\254.md"
diff --git a/sample_standard_app/config/config.toml b/sample_standard_app/config/config.toml
index 4c3f0c9f..d301bba8 100644
--- a/sample_standard_app/config/config.toml
+++ b/sample_standard_app/config/config.toml
@@ -31,8 +31,9 @@ gunicorn_config_path = './gunicorn_config.toml'
 #custom_key_path = './custom_key.toml'
 
 [DB]
-# A mysql db uri used to save web request task status. Status will be saved in sqllite if the uri is empty all not exist.
-mysql_uri = ''
+# A sqlalchemy db uri used for storing various info, for example, service request, generated during application running.
+# If it's empty, agentUniverse will create a local sqlite db as default choice.
+system_db_uri = ''
 
 [GRPC]
 activate = 'true'


Test patch:
diff --git a/tests/test_agentuniverse/unit/agent/config.toml b/tests/test_agentuniverse/unit/agent/config.toml
index b26516f4..206c07ae 100644
--- a/tests/test_agentuniverse/unit/agent/config.toml
+++ b/tests/test_agentuniverse/unit/agent/config.toml
@@ -32,4 +32,4 @@ gunicorn_config_path = './gunicorn_config.toml'
 
 [DB]
 # A mysql db uri used to save web request task status. Status will be saved in sqllite if the uri is empty all not exist.
-mysql_uri = ''
\ No newline at end of file
+system_db_uri = ''
\ No newline at end of file