初识（认识HELLO_AGENT）

下面这些图片主要是用来给大家初体验的，下一板块主包会带大家分析我的理解

这里带着大家一步步解析helloagentllm框架，首先就是对于不同服务商的不同需求是不一样的，所以这里面我面需要自己去重写父类的初始化方法，让他去使用我们自己定义的大模型，这的的话需要先去配置.env文件用来加载自己的api_key等，至于怎么去重写，这需要我们去打开原生态框架去查看参数，


这样的话我们就能去初始化我们的客户端，这样的话就能和商户的环境兼容

开始（ReAct，Plan_and_Solve,Reflection）

• React
• Plan_and_Solve
• Reflection

React：

MY_REACT_PROMPT = """你是一个具备推理和行动能力的AI助手。你可以通过思考分析问题，然后调用合适的工具来获取信息，最终给出准确的答案。

## 可用工具
{tools}

## 工作流程
请严格按照以下格式进行回应，每次只能执行一个步骤:

Thought: 分析当前问题，思考需要什么信息或采取什么行动。
Action: 选择一个行动，格式必须是以下之一:
- `{{tool_name}}[{{tool_input}}]` - 调用指定工具
- `Finish[最终答案]` - 当你有足够信息给出最终答案时

## 重要提醒
1. 每次回应必须包含Thought和Action两部分
2. 工具调用的格式必须严格遵循:工具名[参数]
3. 只有当你确信有足够信息回答问题时，才使用Finish
4. 如果工具返回的信息不够，继续使用其他工具或相同工具的不同参数

## 当前任务
**Question:** {question}

## 执行历史
{history}

现在开始你的推理和行动:
"""

这里面就是我们在学习agent的时候需要知道的第一个知识点prompt提示词，在react范式里面，是用来对于自己构建的agent的定义，例如：你是一个**助手，主要负责****

然后可以将自己定义的tools放在里面，然后设置workflow以及限制，注意在提示词里面最主要的是workflow，对于react范式来说提示词的质量直接关联agent的输出质量

# my_react_agent.py
import re
from typing import Optional, List, Tuple
from hello_agents import ReActAgent, HelloAgentsLLM, Config, Message, ToolRegistry

class MyReActAgent(ReActAgent):
    """
    重写的ReAct Agent - 推理与行动结合的智能体
    """

    def __init__(
        self,
        name: str,
        llm: HelloAgentsLLM,
        tool_registry: ToolRegistry,
        system_prompt: Optional[str] = None,
        config: Optional[Config] = None,
        max_steps: int = 5,
        custom_prompt: Optional[str] = None
    ):
        super().__init__(name, llm, system_prompt, config)
        self.tool_registry = tool_registry
        self.max_steps = max_steps
        self.current_history: List[str] = []
        self.prompt_template = custom_prompt if custom_prompt else MY_REACT_PROMPT
        print(f"✅ {name} 初始化完成，最大步数: {max_steps}")

这里主要是用来书写基于框架hello-agents来进行搭建的，所以是继承的该框架里面的reactagent作为父类，重写初始化方法，至于这里为什么不设置大模型采样参数，是因为在基类helloagentllm当中已经进行过初始化，但是大家依然可以将采样参数自定义

采样参数主要是包括模型温度，最大token传递，top-k,top-p
，感兴趣的读者可以自己搜索，这里简略介绍，一般正常助手都是讲temperature设置在0.3-0.7，这样模型思维中规中矩

接下来就是关于运行

def run(self, input_text: str, **kwargs) -> str:
    """运行ReAct Agent"""
    self.current_history = []
    current_step = 0

    print(f"\n🤖 {self.name} 开始处理问题: {input_text}")

    while current_step < self.max_steps:
        current_step += 1
        print(f"\n--- 第 {current_step} 步 ---")

        # 1. 构建提示词
        tools_desc = self.tool_registry.get_tools_description()
        history_str = "\n".join(self.current_history)
        prompt = self.prompt_template.format(
            tools=tools_desc,
            question=input_text,
            history=history_str
        )

        # 2. 调用LLM
        messages = [{"role": "user", "content": prompt}]
        response_text = self.llm.invoke(messages, **kwargs)

        # 3. 解析输出
        thought, action = self._parse_output(response_text)

        # 4. 检查完成条件
        if action and action.startswith("Finish"):
            final_answer = self._parse_action_input(action)
            self.add_message(Message(input_text, "user"))
            self.add_message(Message(final_answer, "assistant"))
            return final_answer

        # 5. 执行工具调用
        if action:
            tool_name, tool_input = self._parse_action(action)
            observation = self.tool_registry.execute_tool(tool_name, tool_input)
            self.current_history.append(f"Action: {action}")
            self.current_history.append(f"Observation: {observation}")

    # 达到最大步数
    final_answer = "抱歉，我无法在限定步数内完成这个任务。"
    self.add_message(Message(input_text, "user"))
    self.add_message(Message(final_answer, "assistant"))
    return final_answer

流程是上面code，先初始化提示词，调用llm，解析，查找key，调用tool，最后将输出的msg.add到history[ ]

Reflection：

DEFAULT_PROMPTS = {
    "initial": """
请根据以下要求完成任务:

任务: {task}

请提供一个完整、准确的回答。
""",
    "reflect": """
请仔细审查以下回答，并找出可能的问题或改进空间:

# 原始任务:
{task}

# 当前回答:
{content}

请分析这个回答的质量，指出不足之处，并提出具体的改进建议。
如果回答已经很好，请回答"无需改进"。
""",
    "refine": """
请根据反馈意见改进你的回答:

# 原始任务:
{task}

# 上一轮回答:
{last_attempt}

# 反馈意见:
{feedback}

请提供一个改进后的回答。
"""
}

上面关于reflection范式的prompt流程是初始化思考，反思，反馈，最后输出，也就相当于发送的token变多了，每一次llm回答都是基于上一次回答的基础上查缺补漏的，要是让珠宝使用RPC的话，珠宝是不愿意的，第一思考时间长，虽然输出的准确，类似于初代的deepseek，但是给用户的体验十分差，更何况是RPC调用，耗时更长，用户体验差，不如react范式来的快,这个更像AI助手里面的深度思考plugin

# test_reflection_agent.py
from dotenv import load_dotenv
from hello_agents import HelloAgentsLLM
from my_reflection_agent import MyReflectionAgent

load_dotenv()
llm = HelloAgentsLLM()

# 使用默认通用提示词
general_agent = MyReflectionAgent(name="我的反思助手", llm=llm)

# 使用自定义代码生成提示词（类似第四章）
code_prompts = {
    "initial": "你是Python专家，请编写函数:{task}",
    "reflect": "请审查代码的算法效率:\n任务:{task}\n代码:{content}",
    "refine": "请根据反馈优化代码:\n任务:{task}\n反馈:{feedback}"
}
code_agent = MyReflectionAgent(
    name="我的代码生成助手",
    llm=llm,
    custom_prompts=code_prompts
)

# 测试使用
result = general_agent.run("写一篇关于人工智能发展历程的简短文章")
print(f"最终结果: {result}")

PlanAndSolve

提示词工程里面的角色扮演，给定llm一个角色，并给出示例样本

from typing import Optional, List, Tuple, Dict
from hello_agents import  HelloAgentsLLM, Config, ToolRegistry


class Planner:

    def __init__(self,
                 llm:HelloAgentsLLM,
                 planner_prompt:Optional[str]=None):
        self.llm=llm
        self.planner_prompt=planner_prompt
    def plan(self,question:str,**kwargs)->List[str]:
        prompt= self.planner_prompt.format(question=question)
        messages=[{"role":"user","content":prompt}]
        response_text=self.llm.invoke(messages,**kwargs) or ""
        print(f"计划已经生成:\b{response_text}")
        try:
            plan_str=response_text.split("'''python")[1].split("'''")[0].strip()
            plan =ast.literal_eval(plan_str);
            return plan if isinstance(plan,list) else[]
        except Exception as  e:
            print("出错了")



class Executor:
    def __init__(self,
                 llm:HelloAgentsLLM,
                 executor_prompt:Optional[str]=None):
        self.llm=llm
        self.executor_prompt=executor_prompt if executor_prompt else DEFAULT_EXECUTOR_PROMPT
    def exec(self,question:str,plan:List[str],**kwargs)->str:
        history=[]
        final_answer=""
        for i,step in enumerate(plan,1):
            print(f"\n-> 正在执行步骤 {i}/{len(plan)}: {step}")

            prompt=self.executor_prompt.format(
                question=question,
                plan = plan,
                history = history if history else "无",
                current_step = step
            )
            messages=[{"role":"user","content":prompt}]
            response_text= self.llm.invoke(messages,**kwargs)
            history+=f"步骤{i}：执行{plan}，执行结果为：\n{response_text}"
            final_answer=response_text
        return final_answer
class MYPLANANDSOLVEAGENT(Agent):




    def __init__(self, name: str,
                 llm: HelloAgentsLLM,
                 system_prompt: Optional[str] = None,
                 config: Optional[Config] = None,
                 custom_prompts: Optional[Dict[str, str]] = None,
                 tool_register:Optional[ToolRegistry]=None):
        super().__init__(name,llm,config,custom_prompts)
        if custom_prompts :
            Planner_prompt=custom_prompts.get("planner")
            Executor_prompt=custom_prompts.get("planner")
        else:
            Planner_prompt = None
            Executor_prompt = None
        self.planner =Planner(self.llm,Planner_prompt)
        self.executor =Executor(self.llm,Executor_prompt)

    def run(self, input_text: str, **kwargs) -> str:
        print(f"{self.name}准备执行{input_text}")
        plan=self.planner.plan(input_text,**kwargs)
        if  not plan :
            print("有问题")
            final_answer="无法生成有效计划"
            self.add_messages(Message(input_text,"user"))
            self.add_messages(Message(final_answer,"assistant"))
            return final_answer
        final_answer=        self.executor.exec(input_text,plan,**kwargs)
        self.add_messages(Message(input_text, "user"))
        self.add_messages(Message(final_answer, "assistant"))
        return final_answer

实现agent基类，重写里面的初始化方法以及run方法，在初始化的时候将提示词实现拆分成planner以及executor，接下来去使用两个自创类里面的方法去获得我们想要的类型，先说planner，无异于是去根据planner提示词去让llm生成步骤，这个时候问题来了，llm生成之后的response我们是不能直接去使用的，需要去format，获取到我们在execprompt中定义的{}，接下来实现execuor，也是先解析出来里面的{}，转换成messages格式传递给llm，然后将得到的response+=history