AI代理的3个提示技巧

APPLICATOIN Jan 12, 2025

推荐： ComfyUI-PandasAI | ComfyUI-Autodistill | HDRI-Pack高清环境贴图包

在我们之前对AI代理架构的探索中，我们讨论了角色、指令和记忆等核心组件。现在，我们将深入探讨不同的提示策略如何增强代理的推理能力，使其在解决问题时更加有条理和透明。

有效的提示工程技术已被证明在帮助大型语言模型（LLMs）生成更可靠、结构化和合理推理的响应方面至关重要。这些技术利用了以下几个关键原则：

逐步分解：将复杂任务分解为更小、可管理的步骤，帮助LLMs更系统地处理信息，减少错误并提高逻辑一致性。
明确的格式指令：提供清晰的输出结构，指导模型组织其思维并以更易消化的格式呈现信息。
自我反思提示：鼓励模型审查自己的推理过程，帮助捕捉潜在错误并考虑替代视角。
上下文框架：提供特定的框架（如“分析利弊”或“考虑多种情景”），帮助模型从不同角度处理问题。

这些技术构成了我们实现的推理策略的基础，每种策略都旨在利用LLM能力的不同方面，同时保持响应的一致性和可靠性。

1、理解基于策略的推理

虽然基础代理可以直接处理任务，但高级推理需要结构化的解决问题方法。该实现使用策略模式来定义不同的推理框架。让我们看看这些策略在我们增强的代理架构中是如何定义的：

class ExecutionStrategy(ABC):
    @abstractmethod
    def build_prompt(self, task: str, instruction: Optional[str] = None) -&gt; str:
        """Build the prompt according to the strategy."""
        pass
 
    @abstractmethod
    def process_response(self, response: str) -&gt; str:
        """Process the LLM response according to the strategy."""
        pass

这个抽象基类为实现各种推理策略提供了基础。每种策略都提供了独特的方法来：

结构化问题解决过程；
分解复杂任务；
组织代理的思维过程；
确保对问题的全面考虑。

让我们仔细看看三种不同的技术：ReAct、Chain of Thought和Reflection。该框架也便于添加其他技术。

2、ReAct：推理与行动

ReAct策略（Reasoning and Action）实现了思考、行动和观察的循环，使代理的决策过程变得明确且可追踪。以下是其实现方式：

class ReactStrategy(ExecutionStrategy):
    def build_prompt(self, task: str, instruction: Optional[str] = None) -&gt; str:
        base_prompt = """Approach this task using the following steps:
1) Thought: Analyze what needs to be done
2) Action: Decide on the next action
3) Observation: Observe the result
4) Repeat until task is complete
 
Follow this format for your response:
Thought: [Your reasoning about the current situation]
Action: [The action you decide to take]
Observation: [What you observe after the action]
... (continue steps as needed)
Final Answer: [Your final response to the task]
 
Task: {task}"""

该策略确保：

明确的推理：思维过程的每一步都清晰表达。
基于行动的方法：决策与具体行动相关联。
迭代优化：通过多次观察和调整逐步完善解决方案。

3、Chain of Thought：逐步解决问题

Chain of Thought策略将复杂问题分解为可管理的步骤，使推理过程更加透明和可验证。以下是其实现：

class ChainOfThoughtStrategy(ExecutionStrategy):
    def build_prompt(self, task: str, instruction: Optional[str] = None) -&gt; str:
        base_prompt = """Let's solve this step by step:
 
Task: {task}
 
Please break down your thinking into clear steps:
1) First, ...
2) Then, ...
(continue with your step-by-step reasoning)
 
Final Answer: [Your conclusion based on the above reasoning]"""

该方法提供了：

复杂问题的线性进展；
步骤与结论之间的清晰联系；
更容易验证推理过程；
更好地理解结论是如何得出的。

4、Reflection：深度分析与自我审查

Reflection策略增加了一个元认知层，鼓励代理审查自己的假设并考虑替代方法。以下是其代码实现：

class ReflectionStrategy(ExecutionStrategy):
    def build_prompt(self, task: str, instruction: Optional[str] = None) -&gt; str:
        base_prompt = """Complete this task using reflection:
 
Task: {task}
 
1) Initial Approach:
   - What is your first impression of how to solve this?
   - What assumptions are you making?
 
2) Analysis:
   - What could go wrong with your initial approach?
   - What alternative approaches could you consider?
 
3) Refined Solution:
   - Based on your reflection, what is the best approach?
   - Why is this approach better than the alternatives?"""

5、与代理架构的集成

这些策略通过工厂模式和策略设置器无缝集成到代理架构中：

class Agent:
    @property
    def strategy(self) -&gt; Optional[ExecutionStrategy]:
        return self._strategy
 
    @strategy.setter
    def strategy(self, strategy_name: str):
        """Set the execution strategy by name."""
        self._strategy = StrategyFactory.create_strategy(strategy_name)

执行流程结合了所选策略：

    def execute(self, task: Optional[str] = None) -&gt; str:
        if task is not None:
            self._task = task
        
        messages = self._build_messages()
        
        try:
            response = client.chat.completions.create(
                model=self._model,
                messages=messages
            )
            
            response_content = response.choices[0].message.content
            
            # Process response through strategy if set
            if self._strategy:
                response_content = self._strategy.process_response(response_content)

6、实际应用

以下是这些策略在实际中的应用示例：

from agent import Agent
 
def main():
    # Initialize the agent
    agent = Agent("Problem Solver")
    
    # Configure the agent
    agent.persona = """You are an analytical problem-solving assistant.
You excel at breaking down complex problems and explaining your thought process.
You are thorough, logical, and clear in your explanations."""
 
    agent.instruction = "Ensure your responses are clear, detailed, and well-structured."
 
    # Define the park planning task
    park_planning_task = """
            A city is planning to build a new park. They have the following constraints:
            - Budget: $2 million
            - Space: 5 acres
            - Must include: playground, walking trails, and parking
            - Environmental concerns: preserve existing trees
            - Community request: include area for community events
            How should they approach this project?"""
 
    # Display available reasoning strategies
    print("Available reasoning strategies:", agent.available_strategies())
    print("\n" + "="*50)
 
    # Test ReAct strategy
    print("\n=== Using ReAct Strategy ===")
    agent.strategy = "ReactStrategy"
    agent.task = park_planning_task
    response = agent.execute()
    print(f"\nTask: {park_planning_task}")
    print("\nResponse:")
    print(response)
    print("\n" + "="*50)
 
    # Test Chain of Thought strategy
    print("\n=== Using Chain of Thought Strategy ===")
    agent.clear_history()  # Clear previous interaction history
    agent.strategy = "ChainOfThoughtStrategy"
    agent.task = park_planning_task
    response = agent.execute()
    print(f"\nTask: {park_planning_task}")
    print("\nResponse:")
    print(response)
    print("\n" + "="*50)
 
    # Test Reflection strategy
    print("\n=== Using Reflection Strategy ===")
    agent.clear_history()  # Clear previous interaction history
    agent.strategy = "ReflectionStrategy"
    agent.task = park_planning_task
    response = agent.execute()
    print(f"\nTask: {park_planning_task}")
    print("\nResponse:")
    print(response)
    print("\n" + "="*50)
 
if __name__ == "__main__":
    main()

该实现允许：