深入解析AutoGPT：原理、实战与源码拆解

1

pip install poetry

1
2
3
4
5
6

Poetry 要求Python 版本为2.7 或者3.5+

python3:
    curl -sSL https://install.python-poetry.org | python3 -
python2:
    curl -sSL https://install.python-poetry.org | python2 -

1

(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | py -

1
2
3
4
5
6
7

1. 对于 Bash 终端，可以执行以下命令打开 ~/.bashrc 文件：
   nano ~/.bashrc
2. 在文件中添加以下行：
   export PATH=$HOME/.local/bin:$PATH
3. 保存并关闭文件后，使用以下命令使修改生效：
   source ~/.bashrc
   

1

poetry -V

1

git clone https://github.com/Significant-Gravitas/AutoGPT

1

poetry install

1

autogpt.bat --help 

1
2
3
4
5
6
7
8
9

$ ./autogpt.sh --help
Usage: python -m autogpt [OPTIONS] COMMAND [ARGS]...

Options:
  --help  Show this message and exit.

Commands:
  run    Sets up and runs an agent, based on the task specified by the...
  serve  Starts an Agent Protocol compliant AutoGPT server, which creates...

1

./autogpt.sh run 

1

./autogpt.sh run --debug

1

./autogpt.sh --continuous

1
2

2024-07-26 09:57:05,989 DEBUG  Asking user via keyboard...
Enter the task that you want AutoGPT to execute, with as much detail as possible: 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

SYSTEM: Your job is to respond to a user-defined task, given in triple quotes, by invoking the `create_agent` function to generate an autonomous agent to complete the task. You should supply a role-based name for the agent (_GPT), an informative description for what the agent does, and 1 to 5 directives in each of the categories Best Practices and Constraints, that are optimally aligned with the successful completion of its assigned task.
Example Input:
"""Help me with marketing my business"""
Example Call:
```
[
    {
        "type": "function",
        "function": {
            "name": "create_agent",
            "arguments": {
                "name": "CMOGPT",
                "description": "a professional digital marketer AI that assists Solopreneurs in growing their businesses by providing world-class expertise in solving marketing problems for SaaS, content products, agencies, and more.",
                "directives": {
                    "best_practices": [
                        "Engage in effective problem-solving, prioritization, planning, and supporting execution to address your marketing needs as your virtual Chief Marketing Officer.",
                        "Provide specific, actionable, and concise advice to help you make informed decisions without the use of platitudes or overly wordy explanations.",
                        "Identify and prioritize quick wins and cost-effective campaigns that maximize results with minimal time and budget investment.",
                        "Proactively take the lead in guiding you and offering suggestions when faced with unclear information or uncertainty to ensure your marketing strategy remains on track."
                    ],
                    "constraints": [
                        "Do not suggest illegal or unethical plans or strategies.",
                        "Take reasonable budgetary limits into account."
                    ]
                }
            }
        }
    }
]
```
USER: """制作素食三明治食谱"""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

role=<Role.ASSISTANT: 'assistant'> content=None tool_calls=[AssistantToolCall(id='call_EamkbLMEfUnz04fi788xwujM', type='function', function=AssistantFunctionCall(name='create_agent', arguments={
    'name': 'VeggieSandwichChef_GPT',
    'description': 'an AI dedicated to creating delicious and innovative vegetarian sandwich recipes, focusing on healthy ingredients and diverse flavors.', 
    'directives': {
        'best_practices': [
        	'Always focus on a blend of nutritional balance and taste, incorporating a variety of vegetables, proteins, and grains.', 
        	'Include clear, easy-to-follow instructions that cater to both novice and experienced cooks.', 
        	'Ensure recipes can be adapted for vegan preferences whenever possible, providing suitable substitutions for dairy or other animal products.',
        	'Highlight the preparation time and serving size to help users in meal planning and preparation.'], 
       'constraints': [
       		'Avoid using ingredients that are known allergens without offering alternatives.', 		 
       		'Keep the recipes simple with ingredients that are easily accessible.', 
       		'Do not include any meat, fish, or poultry products in the recipes.', 
       		'Respect dietary restrictions by clearly indicating if a recipe contains common allergens like nuts, soy, or gluten.']
    }
} ))]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

2024-07-26 09:58:04,794 DEBUG  Executing prompt:

============== ChatPrompt ==============
Length: 5 messages
----------------- SYSTEM -----------------
You are VeggieSandwichChef_GPT, an AI dedicated to creating delicious and innovative vegetarian sandwich recipes, focusing on healthy ingredients and diverse flavors.

Your decisions must always be made independently without seeking user assistance. Play to your strengths as an LLM and pursue simple strategies with no legal complications.

## Constraints
You operate within the following constraints:
1. Exclusively use the commands listed below.
2. You can only act proactively, and are unable to start background jobs or set up webhooks for yourself. Take this into account when planning your actions.
3. You are unable to interact with physical objects. If this is absolutely necessary to fulfill a task or objective or to complete a step, you must ask the user to do it for you. If the user refuses this, and there is no other way to achieve your goals, you must terminate to avoid wasting time and energy.
4. Avoid using ingredients that are known allergens without offering alternatives.
5. Keep the recipes simple with ingredients that are easily accessible.
6. Do not include any meat, fish, or poultry products in the recipes.
7. Respect dietary restrictions by clearly indicating if a recipe contains common allergens like nuts, soy, or gluten.

## Resources
You can leverage access to the following resources:
1. Internet access for searches and information gathering.
2. The ability to read and write files.
3. You are a Large Language Model, trained on millions of pages of text, including a lot of factual knowledge. Make use of this factual knowledge to avoid unnecessary gathering of information.

## Commands
These are the ONLY commands you can use. Any action you perform must be possible through one of these commands:
1. list_folder: List the items in a folder. Params: (folder: string)
2. open_file: Opens a file for editing or continued viewing; creates it if it does not exist yet. Note: If you only need to read or write a file once, use `write_to_file` instead.. Params: (file_path: string)
3. open_folder: Open a folder to keep track of its content. Params: (path: string)
4. read_file: Read an existing file. Params: (filename: string)
5. write_file: Write a file, creating it if necessary. If the file exists, it is overwritten.. Params: (filename: string, contents: string)
6. ask_user: If you need more details or information regarding the given goals, you can ask the user for input. Params: (question: string)
7. web_search: Searches the web. Params: (query: string)
8. read_webpage: Read a webpage, and extract specific information from it. You must specify either topics_of_interest, a question, or get_raw_content.. Params: (url: string, topics_of_interest?: Array<string>, question?: string, get_raw_content?: boolean)
9. finish: Use this to shut down once you have completed your task, or when there are insurmountable problems that make it impossible for you to finish your task.. Params: (reason: string)

## Best practices
1. Continuously review and analyze your actions to ensure you are performing to the best of your abilities.
2. Constructively self-criticize your big-picture behavior constantly.
3. Reflect on past decisions and strategies to refine your approach.
4. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps.
5. Only make use of your information gathering abilities to find information that you don't yet have knowledge of.
6. Always focus on a blend of nutritional balance and taste, incorporating a variety of vegetables, proteins, and grains.
7. Include clear, easy-to-follow instructions that cater to both novice and experienced cooks.
8. Ensure recipes can be adapted for vegan preferences whenever possible, providing suitable substitutions for dairy or other animal products.
9. Highlight the preparation time and serving size to help users in meal planning and preparation.

## Your Task
The user will specify a task for you to execute, in triple quotes, in the next message. Your job is to complete the task while following your directives as given above, and terminate when your task is done.
------------------ USER ------------------
"""制作素食三明治食谱"""
----------------- SYSTEM -----------------
The current time and date is Fri Jul 26 09:58:04 2024
----------------- SYSTEM -----------------
Respond with pure JSON. The JSON object should be compatible with the TypeScript type `Response` from the following:
interface Response {
thoughts: {
// Relevant observations from your last action (if any)
observations: string;
// Thoughts
text: string;
reasoning: string;
// Constructive self-criticism
self_criticism: string;
// Short markdown-style bullet list that conveys the long-term plan
plan: string;
// Summary of thoughts, to say to user
speak: string;
};
command: {
name: string;
args: Record<string, any>;
};
}
------------------ USER ------------------
Determine exactly one command to use next based on the given goals and the progress you have made so far, and respond using the JSON schema specified previously:

1

[{"role": "user",  "content": "Determine exactly one command to use next based on the given goals and the progress you have made so far, and respond using the JSON schema specified previously"  }]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

2024-07-26 09:58:37,367 DEBUG  LLM response content:
{
  "thoughts": {
    "observations": "The task is to create a vegetarian sandwich recipe.",
    "text": "To begin recipe development, I need to define the core ingredients and structure of the sandwich. This includes selecting a bread type, the main protein source (e.g., tofu, beans), vegetables, and condiments that harmonize well.",
    "reasoning": "A systematic approach to crafting a well-balanced and appealing vegetarian sandwich involves brainstorming potential ingredients and their combinations. This forms the baseline before I can write and present a complete recipe.",
    "self_criticism": "I initially considered searching the web for existing vegetarian sandwich recipes for inspiration but realized it may lead to standard ideas. Instead, creating something unique might be more beneficial and in line with the user's expectations.",
    "plan": "- List potential ingredients for a vegetarian sandwich
            - Select a combination that ensures nutritional balance and taste
            - Write the recipe with clear instructions and indicate allergens
            - Provide the completed recipe to the user",
    "speak": "Let's start by brainstorming some exciting and nutritious ingredients for our vegetarian sandwich recipe!" 译“让我们开始集思广益一些令人兴奋和营养的食材，为我们的素食三明治食谱!”
  },
     "command": {
        "name": "web_search",
        "args": {
            "query": "popular vegetarian sandwich ingredients" 译“受欢迎的素食三明治配料”
        }
    }
 }

1
2
3
4
5

2024-07-26 10:01:24,205 INFO  NEXT ACTION: COMMAND = web_search  ARGUMENTS = {'query': 'popular vegetarian sandwich ingredients'}
2024-07-26 10:01:24,206 INFO  Enter 'y' to authorise command, 'y -N' to run N continuous commands, 'n' to exit program, or enter feedback for VeggieSandwichChef_GPT...
2024-07-26 10:01:24,206 DEBUG  Asking user via keyboard...
Input: y
2024-07-26 10:01:39,318 INFO  -=-=-=-=-=-=-= COMMAND AUTHORISED BY USER -=-=-=-=-=-=-=

1
2
3
4
5
6
7
8
9

2024-07-26 10:01:54,733 DEBUG  PROCESSING:
SYSTEM: The user is going to give you a text enclosed in triple quotes. The text represents an action, the reason for its execution, and its result. Condense the action taken and its result into one line. Preserve any specific factual information gathered by the action.

USER: """Executed `web_search(query='popular vegetarian sandwich ingredients')`
- **Reasoning:** "Considering the lack of specific user preferences, designing a versatile vegetarian sandwich recipe will cater to potentially broad tastes and preferences. This would include elements like vegetables, protein, and suitable spreads to ensure the sandwich is nutritious and delicious."
- **Status:** `error`
- **Reason:** https://duckduckgo.com RequestsError: Failed to perform, curl: (28) Connection timed out after 10001 milliseconds. See https://curl.se/libcurl/c/libcurl-errors.html first for more details.
- **Error:** CommandExecutionError('https://duckduckgo.com RequestsError: Failed to perform, curl: (28) Connection timed out after 10001 milliseconds. See https://curl.se/libcurl/c/libcurl-errors.html first for more details.')
"""

1
2
3

---------------- SUMMARY -----------------
Attempted web search for popular vegetarian sandwich ingredients but encountered a connection timeout error from DuckDuckGo.
------------------------------------------

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

2024-07-26 10:02:11,818 DEBUG  Executing prompt:

============== ChatPrompt ==============
Length: 6 messages
----------------- SYSTEM -----------------
You are VeggieSandwichChef_GPT, an AI dedicated to creating delicious and innovative vegetarian sandwich recipes, focusing on healthy ingredients and diverse flavors.

Your decisions must always be made independently without seeking user assistance. Play to your strengths as an LLM and pursue simple strategies with no legal complications.

## Constraints
You operate within the following constraints:
1. Exclusively use the commands listed below.
2. You can only act proactively, and are unable to start background jobs or set up webhooks for yourself. Take this into account when planning your actions.
3. You are unable to interact with physical objects. If this is absolutely necessary to fulfill a task or objective or to complete a step, you must ask the user to do it for you. If the user refuses this, and there is no other way to achieve your goals, you must terminate to avoid wasting time and energy.
4. Avoid using ingredients that are known allergens without offering alternatives.
5. Keep the recipes simple with ingredients that are easily accessible.
6. Do not include any meat, fish, or poultry products in the recipes.
7. Respect dietary restrictions by clearly indicating if a recipe contains common allergens like nuts, soy, or gluten.

## Resources
You can leverage access to the following resources:
1. Internet access for searches and information gathering.
2. The ability to read and write files.
3. You are a Large Language Model, trained on millions of pages of text, including a lot of factual knowledge. Make use of this factual knowledge to avoid unnecessary gathering of information.

## Commands
These are the ONLY commands you can use. Any action you perform must be possible through one of these commands:
1. list_folder: List the items in a folder. Params: (folder: string)
2. open_file: Opens a file for editing or continued viewing; creates it if it does not exist yet. Note: If you only need to read or write a file once, use `write_to_file` instead.. Params: (file_path: string)
3. open_folder: Open a folder to keep track of its content. Params: (path: string)
4. read_file: Read an existing file. Params: (filename: string)
5. write_file: Write a file, creating it if necessary. If the file exists, it is overwritten.. Params: (filename: string, contents: string)
6. ask_user: If you need more details or information regarding the given goals, you can ask the user for input. Params: (question: string)
7. web_search: Searches the web. Params: (query: string)
8. read_webpage: Read a webpage, and extract specific information from it. You must specify either topics_of_interest, a question, or get_raw_content.. Params: (url: string, topics_of_interest?: Array<string>, question?: string, get_raw_content?: boolean)
9. finish: Use this to shut down once you have completed your task, or when there are insurmountable problems that make it impossible for you to finish your task.. Params: (reason: string)

## Best practices
1. Continuously review and analyze your actions to ensure you are performing to the best of your abilities.
2. Constructively self-criticize your big-picture behavior constantly.
3. Reflect on past decisions and strategies to refine your approach.
4. Every command has a cost, so be smart and efficient. Aim to complete tasks in the least number of steps.
5. Only make use of your information gathering abilities to find information that you don't yet have knowledge of.
6. Always focus on a blend of nutritional balance and taste, incorporating a variety of vegetables, proteins, and grains.
7. Include clear, easy-to-follow instructions that cater to both novice and experienced cooks.
8. Ensure recipes can be adapted for vegan preferences whenever possible, providing suitable substitutions for dairy or other animal products.
9. Highlight the preparation time and serving size to help users in meal planning and preparation.

## Your Task
The user will specify a task for you to execute, in triple quotes, in the next message. Your job is to complete the task while following your directives as given above, and terminate when your task is done.
------------------ USER ------------------
"""制作素食三明治食谱"""
----------------- SYSTEM -----------------
## Progress

* Step 1: Executed `web_search(query='popular vegetarian sandwich ingredients')`
  - **Reasoning:** "Considering the lack of specific user preferences, designing a versatile vegetarian sandwich recipe will cater to potentially broad tastes and preferences. This would include elements like vegetables, protein, and suitable spreads to ensure the sandwich is nutritious and delicious."
  - **Status:** `error`
  - **Reason:** https://duckduckgo.com RequestsError: Failed to perform, curl: (28) Connection timed out after 10001 milliseconds. See https://curl.se/libcurl/c/libcurl-errors.html first for more details.
  - **Error:** CommandExecutionError('https://duckduckgo.com RequestsError: Failed to perform, curl: (28) Connection timed out after 10001 milliseconds. See https://curl.se/libcurl/c/libcurl-errors.html first for more details.')
----------------- SYSTEM -----------------
The current time and date is Fri Jul 26 10:02:11 2024
----------------- SYSTEM -----------------
Respond with pure JSON. The JSON object should be compatible with the TypeScript type `Response` from the following:
interface Response {
thoughts: {
// Relevant observations from your last action (if any)
observations: string;
// Thoughts
text: string;
reasoning: string;
// Constructive self-criticism
self_criticism: string;
// Short markdown-style bullet list that conveys the long-term plan
plan: string;
// Summary of thoughts, to say to user
speak: string;
};
command: {
name: string;
args: Record<string, any>;
};
}
------------------ USER ------------------
Determine exactly one command to use next based on the given goals and the progress you have made so far, and respond using the JSON schema specified previously:
==========================================

1

. /run setup

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

def run(
    continuous: bool,
    continuous_limit: Optional[int],
    speak: bool,
    gpt3only: bool,
    gpt4only: bool,
    //...省略
) -> None:
    """
    根据用户指定的任务设置并运行agent，或者恢复执行之前存在的agent。
    """
    # 将import放在函数内部，以避免在启动CLI时导入所有内容
    from autogpt.app.main import run_auto_gpt
    
    run_auto_gpt(
        continuous=continuous,
        continuous_limit=continuous_limit,
        ai_settings=ai_settings,
        prompt_settings=prompt_settings,
        //...省略
    )

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

async def run_auto_gpt(
    continuous: bool = False,
    continuous_limit: Optional[int] = None,
    //...省略
):
    # 设置配置,从配置文件.env,ai_settings.yaml、azure.yaml、plugins_config.yaml
    # prompt_settings.yaml中读取.
    config = ConfigBuilder.build_config_from_env()
    
    #配置数据存储的方式，默认为本地文件保存，其它配置选项为GCS(google云存储)、S3(亚马逊     #云存储)
    local = config.file_storage_backend == FileStorageBackendName.LOCAL
    restrict_to_root = not local or config.restrict_to_workspace
    file_storage = get_storage(
        config.file_storage_backend, root_path="data", restrict_to_root=restrict_to_root
    )
    file_storage.initialize()

   
    //...省略部分，检查openAI key、根据函数的传参覆盖默认配置
    
    //实例化llm提供者，封装与LLM的接口调用。
    llm_provider = _configure_openai_provider(config)

    //...省略部分，初始化日志处理器，配置插件等

    
    # 列出已存在的代理列表，让用户选择要运行的代理
    agent_manager = AgentManager(file_storage)
    existing_agents = agent_manager.list_agents()
    load_existing_agent = ""
    if existing_agents:
        print(
            "Existing agents\n---------------\n"
            + "\n".join(f"{i} - {id}" for i, id in enumerate(existing_agents, 1))
        )
        load_existing_agent = clean_input(
            config,
            "Enter the number or name of the agent to run,"
            " or hit enter to create a new one:",
        )
      //...省略

    //若用户有选择之前的代理，则询问用户是否恢复该代理，默认或回复“y”则恢复代理状态,并根据该状态创建代理。
    if load_existing_agent:
        agent_state = None
        while True:
            answer = clean_input(config, "Resume? [Y/n]")
            if answer == "" or answer.lower() == "y":
                agent_state = agent_manager.load_agent_state(load_existing_agent)
                break
            elif answer.lower() == "n":
                break

    if agent_state:
        //根据之前的代理状态创建代理
        agent = configure_agent_with_state(
            state=agent_state,
            app_config=config,
            file_storage=file_storage,
            llm_provider=llm_provider,
        )
        
      //检查agent的最后执行命令如果是finish，表明之前的已经完成，则询问用户给出一个后续问题或任务。
      if (
            agent.event_history.current_episode
            and agent.event_history.current_episode.action.name == finish.__name__
            and not agent.event_history.current_episode.result
        ):
            finish_reason = agent.event_history.current_episode.action.args["reason"]
            print(f"Agent previously self-terminated; reason: '{finish_reason}'")
            new_assignment = clean_input(
                config, "Please give a follow-up question or assignment:"
            )

    //没有已存在的代理或用户没有选择已存在的代理，则要求用户输入一个任务，尽可能详细描述。
    if not agent:
        task = ""
        while task.strip() == "":
            task = clean_input(
                config,
                "Enter the task that you want AutoGPT to execute,"
                " with as much detail as possible:",
            )
        
        //加载默认的指令模板数据,从prompt_settings.yaml文件中提取
        base_ai_directives = AIDirectives.from_file(config.prompt_settings_file)
		//同时请求大模型根据任务生成角色名称（_GPT），描述，以及在“最佳实践”和“约束”类别中各1至5               //条指令，这些指令与完成任务高度相关。
        ai_profile, task_oriented_ai_directives = await generate_agent_profile_for_task(
            task,
            app_config=config,
            llm_provider=llm_provider,
        )
       //整合基础模板数据和大模型生成的数据，构建提示词
        ai_directives = base_ai_directives + task_oriented_ai_directives
       
        //...省略部分
        
        //创建代理
        agent = create_agent(
            agent_id=agent_manager.generate_id(ai_profile.ai_name),
            task=task,
            ai_profile=ai_profile,
            directives=ai_directives,
            app_config=config,
            file_storage=file_storage,
            llm_provider=llm_provider,
        )

    #################
    # 运行代理主流程 #
    #################
    try:
        await run_interaction_loop(agent)
    except AgentTerminated:
         //中断或结束时，保存代理状态，可用户指定代理ID
        agent_id = agent.state.agent_id
        logger.info(f"Saving state of {agent_id}...")
        # Allow user to Save As other ID
        save_as_id = clean_input(
            config,
            f"Press enter to save as '{agent_id}',"
            " or enter a different ID to save to:",
        )
        await agent.save_state(save_as_id if not save_as_id.isspace() else None)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

#运行代理的主交互循环,传入参数agent
async def run_interaction_loop(
    agent: "Agent",
) -> None:

    //...省略部分，加载代理配置参数、设置日志处理器、设置中断信号处理等代码

    #########################
    # 应用程序主循环 #
    #########################
   #continuous_mode/continuous_limit配置默认的循环次数，同时询问用户授权交互中，用户可指定继续循环    	  #的次数（回复'y'：当前继续循环(即cycles_remaining+1)，回复‘y -n’：后面n次继续循环，回复"n"退出程    #序）,cycle_budget:为自动继续循环执行的次数，remaining：剩下循环的次数
    while cycles_remaining > 0:
        logger.debug(f"Cycle budget: {cycle_budget}; remaining: {cycles_remaining}")

        handle_stop_signal()
        
        ############
        # 让代理(内部是调用大模型进行推理决策)决定下一步要采取的行动。返回下一步执行命令
        ###########
        with spinner:
            try:
                (
                    command_name,
                    command_args,
                    assistant_reply_dict,
                ) = await agent.propose_action()
            except InvalidAgentResponseError as e:
                //记录连续的失败的次数，若超过3次，则退出
                logger.warning(f"The agent's thoughts could not be parsed: {e}")
                consecutive_failures += 1
                if consecutive_failures >= 3:
                    logger.error(
                        "The agent failed to output valid thoughts"
                        f" {consecutive_failures} times in a row. Terminating..."
                    )
                    raise AgentTerminated(
                        "The agent failed to output valid thoughts"
                        f" {consecutive_failures} times in a row."
                    )
                continue
                
        #重置连续的失败的次数
        consecutive_failures = 0

        ###############
        # 打印agent的想法和下一步执行的命令 #
        ###############
        update_user(
            ai_profile,
            command_name,
            command_args,
            //...
        )
        handle_stop_signal()
        
        //若当前继续循环次数为1时，需要征询用户的授权指令，输入'y'表示授权执行，'y -N'表示连续运行N个命         //令，' N'表示退出程序，或输入反馈建议.
        if cycles_remaining == 1:  # Last cycle
            user_feedback, user_input, new_cycles_remaining = await get_user_feedback(
                legacy_config,
                ai_profile,
            )
           //...省略部分代码
           
        ###################
        # 执行命令#
        ###################
        if command_name:
            //代理执行命令，打印执行的结果
            result = await agent.execute(command_name, command_args, user_input)
            if result.status == "success":
                logger.info(
                    result, extra={"title": "SYSTEM:", "title_color": Fore.YELLOW}
                )
            elif result.status == "error":
                logger.warning(
                    f"Command {command_name} returned an error: "
                    f"{result.error or result.reason}"
                )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

    async def propose_action(self, *args, **kwargs) -> BaseAgent.ThoughtProcessOutput:
       
       ########
       #调用大模型进行推理决策，生成下一步要采取的行动，获取响应的命令名称、参数、思考推理过程。
       ########
       command_name, command_args, thoughts = await super(
            WatchdogMixin, self
        ).propose_action(*args, **kwargs)

        #若没有禁用混合模式(即big_brain为false),则判断是否配置的fast_llm 与 smart_llm大模型不一           #致，若不一致，且上一步大模型响应结果中没有生成下一步的执行命令或执行命令与前一次调用的一样，则使         #用SMART_LLM模型重新推理。
        if not self.config.big_brain and self.config.fast_llm != self.config.smart_llm:
            previous_command, previous_command_args = None, None
            if len(self.event_history) > 1:
                # Detect repetitive commands
                previous_cycle = self.event_history.episodes[
                    self.event_history.cursor - 1
                ]
                previous_command = previous_cycle.action.name
                previous_command_args = previous_cycle.action.args

            rethink_reason = ""

            if not command_name:
                rethink_reason = "AI did not specify a command"
            elif (
                command_name == previous_command
                and command_args == previous_command_args
            ):
                rethink_reason = f"Repititive command detected ({command_name})"

            if rethink_reason:
                logger.info(f"{rethink_reason}, re-thinking with SMART_LLM...")
                with ExitStack() as stack:

                    @stack.callback
                    def restore_state() -> None:
                        # Executed after exiting the ExitStack context
                        self.config.big_brain = False

                    # Remove partial record of current cycle
                    self.event_history.rewind()

                    # Switch to SMART_LLM and re-think
                    self.big_brain = True
                    return await self.propose_action(*args, **kwargs)

        return command_name, command_args, thoughts

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

 async def propose_action(self) -> ThoughtProcessOutput:
        #######
        #基于任务和当前状态，提出要执行的下一个操作.返回: 命令名称和参数(如果有的话)以及代理的想法。
        #####
        
        # 作为临时存储的提示词生成器，应用插件添加额外提示元素。(例如命令、约束、最佳实践)
        self._prompt_scratchpad = PromptScratchpad()

        #构建提示词，
        prompt: ChatPrompt = self.build_prompt(scratchpad=self._prompt_scratchpad)
        prompt = self.on_before_think(prompt, scratchpad=self._prompt_scratchpad)

        #调用大模型生成ReAct（Reason + Act）框架的响应
        response = await self.llm_provider.create_chat_completion(
            prompt.messages,
            functions=get_openai_command_specs(
                self.command_registry.list_available_commands(self)
            )
            + list(self._prompt_scratchpad.commands.values())
            if self.config.use_functions_api
            else [],
            model_name=self.llm.name,
            completion_parser=lambda r: self.parse_and_process_response(
                r,
                prompt,
                scratchpad=self._prompt_scratchpad,
            ),
        )
        self.config.cycle_count += 1

        return self.on_response(
            llm_response=response,
            prompt=prompt,
            scratchpad=self._prompt_scratchpad,
        )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

{
    "thoughts": {
        "observations": "The user did not provide specific preferences...",
        "text": "To proceed effectively, I should create a well-rounded vegetarian ...",
        "reasoning": "Considering the lack of specific user preferences, designing a...",
        "self_criticism": "I could have followed up with another question to probe ...",
        "plan": "- Create a flexible vegetarian sandwich recipe...",
        "speak": "Let's create a delicious and balanced vegetarian sandwich!..."
    },
    "command": {
        "name": "web_search",
        "args": {
            "query": "popular vegetarian sandwich ingredients"
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

   if command_name:
            result = await agent.execute(command_name, command_args, user_input)

            if result.status == "success":
                logger.info(
                    result, extra={"title": "SYSTEM:", "title_color": Fore.YELLOW}
                )
            elif result.status == "error":
                logger.warning(
                    f"Command {command_name} returned an error: "
                    f"{result.error or result.reason}"
                )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

  #执行命令
  async def execute(
        self,
        command_name: str,
        command_args: dict[str, str] = {},
        user_input: str = "",
    ) -> ActionResult:
        result: ActionResult
        
        //在运行代理主流程代码中看到，如果cycles_remaining为1，则会询问用户输入授权确认，输入Y 即授权         //执行，也可以输入反馈信息，如果是用户反馈，这里就返回用户的反馈信息。
        if command_name == "human_feedback":
            result = ActionInterruptedByHuman(feedback=user_input)
            self.log_cycle_handler.log_cycle(
                self.ai_profile.ai_name,
                self.created_at,
                self.config.cycle_count,
                user_input,
                USER_INPUT_FILE_NAME,
            )

        else:
            //在执行命令前，遍历插件的前置处理
            for plugin in self.config.plugins:
                if not plugin.can_handle_pre_command():
                    continue
                command_name, command_args = plugin.pre_command(
                    command_name, command_args
                )

            try:
                //真正执行命令
                return_value = await execute_command(
                    command_name=command_name,
                    arguments=command_args,
                    agent=self,
                )
                result = ActionSuccessResult(outputs=return_value)
           //...省略

        # 更新行动结果
        self.event_history.register_result(result)
        #同时对该行动及结果生成总结
        await self.event_history.handle_compression(
            self.llm_provider, self.legacy_config
        )

        return result

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# 执行命令并返回结果
async def execute_command(
    command_name: str, #要执行的命令的名称
    arguments: dict[str, str],#命令的参数
    agent: Agent, #正在执行命令的代理
) -> CommandOutput:
    # 执行具有相同名称或别名(如果存在)的本机命令
    #command_registry 是包含代理可用的所有命令的注册表
    if command := agent.command_registry.get_command(command_name):
        try:
            #直接执行本机命令，获得执行结果
            result = command(**arguments, agent=agent)
            if inspect.isawaitable(result):
                return await result
            return result
        except AgentException:
            raise
        except Exception as e:
            raise CommandExecutionError(str(e))

    # 处理非本机命令 (比如扩展插件中的命令)
    if agent._prompt_scratchpad:
        for name, command in agent._prompt_scratchpad.commands.items():
            if (
                command_name == name
                or command_name.lower() == command.description.lower()
            ):
                try:
                    return command.method(**arguments)
                except AgentException:
                    raise
                except Exception as e:
                    raise CommandExecutionError(str(e))

    raise UnknownCommandError(
        f"Cannot execute command '{command_name}': unknown command."
    )

1
2
3
4
5
6
7
8

    def register_result(self, result: ActionResult) -> None:
        if not self.current_episode:
            raise RuntimeError("Cannot register result for cycle without action")
        elif self.current_episode.result:
            raise ValueError("Result for current cycle already set")

        self.current_episode.result = result
        self.cursor = len(self.episodes)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

  def parse_and_process_response(
        self, llm_response: AssistantChatMessage, *args, **kwargs
    ) -> Agent.ThoughtProcessOutput:
       
        ##解析响应内容，获取名称名称、参数、思考推理过程信息(observations、text、reasoning、               ##self_criticism、plan、speak)
        (
            command_name,
            arguments,
            assistant_reply_dict,
        ) = self.prompt_strategy.parse_response_content(llm_response)

        # 检查command_name和arguments是否已经在event_history中
        if self.event_history.matches_last_command(command_name, arguments):
            raise DuplicateOperationError(
                f"The command {command_name} with arguments {arguments} "
                f"has been just executed."
            )

    
        if command_name:
            //保存行动命令、及参数、推理信息
            self.event_history.register_action(
                Action(
                    name=command_name,
                    args=arguments,
                    reasoning=assistant_reply_dict["thoughts"]["reasoning"],
                )
            )

        return command_name, arguments, assistant_reply_dict

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

  #执行命令
  async def execute(
        self,
        command_name: str,
        command_args: dict[str, str] = {},
        user_input: str = "",
    ) -> ActionResult:

        //...省略

        # 更新行动结果
        self.event_history.register_result(result)
        #同时对该行动及结果生成总结
        await self.event_history.handle_compression(
            self.llm_provider, self.legacy_config
        )

        return result

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

    async def handle_compression(
        self, llm_provider: ChatModelProvider, app_config: Config
    ) -> None:
        ######
        ##迭代动作历史中的所有不包含摘要的行动记录，并使用LLM生成摘要。
        #####
        compress_instruction = (
            "The text represents an action, the reason for its execution, "
            "and its result. "
            "Condense the action taken and its result into one line. "
            "Preserve any specific factual information gathered by the action."
        )
        async with self._lock:
            # 收集所有没有摘要的行动记录
            episodes_to_summarize = [ep for ep in self.episodes if ep.summary is None]

            #并行化调用生成总结
            summarize_coroutines = [
                #该方法调用大模型生成总结，
                summarize_text(
                    episode.format(),
                    instruction=compress_instruction,
                    llm_provider=llm_provider,
                    config=app_config,
                )
                for episode in episodes_to_summarize
            ]
            summaries = await asyncio.gather(*summarize_coroutines)

            # 将摘要保存到对应的历史行动中
            for episode, (summary, _) in zip(episodes_to_summarize, summaries):
                episode.summary = summary

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

    def build_prompt(
        self,
        scratchpad: PromptScratchpad,
        extra_commands: Optional[list[CompletionModelFunction]] = None,
        extra_messages: Optional[list[ChatMessage]] = None,
        **extras,
    ) -> ChatPrompt:
  
        ##使用' self.prompt_strategy '构造一个提示符`.
        prompt = self.prompt_strategy.build_prompt(
            task=self.state.task,
            ai_profile=self.ai_profile,
            ai_directives=ai_directives,
            commands=get_openai_command_specs(
                self.command_registry.list_available_commands(self)
            )
            + extra_commands,
            //历史行动步骤记录
            event_history=self.event_history,
            //...
            ),
            extra_messages=extra_messages,
            **extras,
        )

        return prompt

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

## Commands
These are the ONLY commands you can use. Any action you perform must be possible through one of these commands:
1. list_folder: List the items in a folder. Params: (folder: string)
2. open_file: Opens a file for editing or continued viewing; creates it if it does not exist yet. Note: If you only need to read or write a file once, use `write_to_file` instead.. Params: (file_path: string)
3. open_folder: Open a folder to keep track of its content. Params: (path: string)
4. read_file: Read an existing file. Params: (filename: string)
5. write_file: Write a file, creating it if necessary. If the file exists, it is overwritten.. Params: (filename: string, contents: string)
6. ask_user: If you need more details or information regarding the given goals, you can ask the user for input. Params: (question: string)
7. web_search: Searches the web. Params: (query: string)
8. read_webpage: Read a webpage, and extract specific information from it. You must specify either topics_of_interest, a question, or get_raw_content.. Params: (url: string, topics_of_interest?: Array<string>, question?: string, get_raw_content?: boolean)
9. finish: Use this to shut down once you have completed your task, or when there are insurmountable problems that make it impossible for you to finish your task.. Params: (reason: string)