Giới thiệu

Sau khi đã biết cách xây dựng Agent cơ bản với tool calling và memory, bước tiếp theo là làm cho Agent thông minh hơn: biết lập kế hoạch trước khi hành động, tự đánh giá kết quả của mình, và phối hợp với nhiều Agent khác để giải quyết bài toán phức tạp. Ba kỹ thuật Planning, Reflection và Multi-Agent là nền tảng để xây dựng các hệ thống AI tự động hoá cao cấp, từ trợ lý nghiên cứu đến hệ thống phân tích dữ liệu tự động.

Planning: Agent biết lập kế hoạch

Planning là khả năng Agent phân tách một nhiệm vụ lớn thành các bước nhỏ hơn trước khi thực thi. Thay vì gọi tool ngay lập tức, Agent sẽ suy nghĩ trước về chiến lược tổng thể. Có hai cách phổ biến:

Cách 1 là Plan-and-Execute: Agent tạo ra một kế hoạch hoàn chỉnh dạng danh sách bước, sau đó thực thi tuần tự từng bước. Cách 2 là ReAct (Reasoning and Acting): Agent xen kẽ giữa suy luận và hành động, mỗi bước sẽ suy nghĩ ngắn trước khi quyết định tool nào cần gọi.

from langchain.agents import create_structured_chat_agent
from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI

planning_prompt = ChatPromptTemplate.from_messages([
    ("system", """Bạn là một Agent có khả năng lập kế hoạch.
Trước khi thực hiện nhiệm vụ, hãy:
1. Phân tích yêu cầu của người dùng
2. Liệt kê các bước cần thực hiện theo thứ tự logic
3. Xác định tool nào cần dùng cho mỗi bước
4. Sau đó mới bắt đầu thực thi từng bước

Tools available: {tools}"""),
    ("human", "{input}"),
    ("assistant", "Để thực hiện yêu cầu này, tôi sẽ lập kế hoạch như sau:\n{agent_scratchpad}")
])

llm = ChatOpenAI(model="gpt-4", temperature=0)
agent = create_structured_chat_agent(llm, tools, planning_prompt)

Prompt engineering đóng vai trò quan trọng: bạn hướng dẫn Agent phải suy nghĩ trước khi hành động. Với prompt trên, Agent sẽ tự động tạo ra một mini-plan trước khi gọi tool đầu tiên.

Reflection: Agent tự đánh giá kết quả

Reflection là khả năng Agent nhìn lại kết quả của mình và tự hỏi liệu có đúng, đủ hay hợp lý không. Nếu phát hiện lỗi, Agent có thể tự sửa hoặc thử lại với cách khác. Kỹ thuật này cực kỳ hữu ích cho các tác vụ cần độ chính xác cao như viết code, phân tích dữ liệu, hoặc trả lời câu hỏi phức tạp.

Cách triển khai đơn giản nhất là thêm một vòng lặp kiểm tra sau khi Agent cho ra kết quả. Bạn có thể cho Agent một prompt reflection riêng để đánh giá output của chính nó:

reflection_prompt = """Bạn vừa hoàn thành nhiệm vụ: {task}
Kết quả bạn đưa ra: {result}

Hãy tự đánh giá:
- Kết quả có trả lời đúng câu hỏi không?
- Có thông tin nào còn thiếu hoặc sai sót không?
- Nếu có vấn đề, bạn cần làm gì để cải thiện?

Đánh giá của bạn:"""

def agent_with_reflection(task, max_iterations=3):
    for i in range(max_iterations):
        result = agent.run(task)
        
        reflection = llm.predict(reflection_prompt.format(
            task=task,
            result=result
        ))
        
        if "không có vấn đề" in reflection.lower():
            return result
        
        task = f"{task}\n\nLần trước bạn đã thử: {result}\nVấn đề phát hiện: {reflection}\nHãy thử lại với cách tiếp cận khác."
    
    return result

Ở đây Agent sẽ tự kiểm tra kết quả, và nếu phát hiện vấn đề, nó sẽ tự động thử lại với thông tin phản hồi từ bước reflection. Giới hạn số lần lặp để tránh Agent chạy mãi.

Multi-Agent: Nhiều Agent phối hợp

Khi bài toán quá phức tạp cho một Agent, bạn có thể chia nhỏ thành nhiều Agent chuyên biệt, mỗi Agent giỏi một lĩnh vực riêng. Ví dụ: một Agent chuyên search thông tin, một Agent chuyên phân tích dữ liệu, một Agent chuyên viết báo cáo.

Có hai mô hình phổ biến: Sequential (tuần tự) và Hierarchical (phân cấp). Sequential nghĩa là các Agent làm việc nối tiếp nhau như một pipeline. Hierarchical nghĩa là có một Agent Manager điều phối, giao việc cho các Agent con.

from langchain.agents import AgentExecutor

class MultiAgentSystem:
    def __init__(self):
        self.researcher = self.create_researcher_agent()
        self.analyst = self.create_analyst_agent()
        self.writer = self.create_writer_agent()
    
    def create_researcher_agent(self):
        prompt = "Bạn chuyên tìm kiếm và thu thập thông tin từ internet."
        return AgentExecutor(agent=create_agent(prompt, search_tools), tools=search_tools)
    
    def create_analyst_agent(self):
        prompt = "Bạn chuyên phân tích dữ liệu và rút ra insight."
        return AgentExecutor(agent=create_agent(prompt, analysis_tools), tools=analysis_tools)
    
    def create_writer_agent(self):
        prompt = "Bạn chuyên viết báo cáo chuyên nghiệp từ dữ liệu có sẵn."
        return AgentExecutor(agent=create_agent(prompt, []), tools=[])
    
    def run(self, task):
        raw_data = self.researcher.run(f"Tìm thông tin về: {task}")
        
        insights = self.analyst.run(f"Phân tích dữ liệu sau: {raw_data}")
        
        report = self.writer.run(f"Viết báo cáo từ phân tích: {insights}")
        
        return report

multi_agent = MultiAgentSystem()
result = multi_agent.run("xu hướng AI trong 2024")

Mỗi Agent có prompt riêng và toolset riêng, output của Agent này trở thành input của Agent tiếp theo. Cách này giúp code dễ maintain hơn và mỗi Agent có thể tối ưu độc lập.

Lỗi thường gặp và cách xử lý

Với Planning, lỗi phổ biến là Agent tạo plan quá chi tiết hoặc quá mơ hồ. Nếu plan quá chi tiết, Agent sẽ mất thời gian suy nghĩ mà không hành động. Nếu plan quá mơ hồ, Agent sẽ không biết bước tiếp theo làm gì. Giải pháp là điều chỉnh prompt để yêu cầu plan ở mức độ vừa phải: 3-5 bước tổng quát, không cần quá cụ thể.

Với Reflection, nguy cơ là Agent sa vào vòng lặp vô hạn: tự đánh giá mãi không bao giờ hài lòng với kết quả. Luôn đặt giới hạn max_iterations và có điều kiện dừng rõ ràng.

Với Multi-Agent, chi phí token tăng nhanh vì mỗi Agent đều tiêu tốn token riêng. Cần cân nhắc giữa độ phức tạp của hệ thống và ngân sách. Một số trường hợp một Agent đơn với prompt tốt vẫn hiệu quả hơn.

Một lỗi khác là truyền quá nhiều context giữa các Agent. Nếu output của Agent A dài 5000 token, Agent B sẽ tốn rất nhiều token để xử lý. Nên tóm tắt hoặc lọc thông tin trước khi truyền sang Agent tiếp theo.

Tổng kết

Planning giúp Agent suy nghĩ trước khi hành động, Reflection giúp Agent tự cải thiện kết quả, Multi-Agent giúp chia nhỏ bài toán phức tạp. Ba kỹ thuật này không loại trừ nhau, bạn có thể kết hợp cả ba: một hệ thống Multi-Agent mà mỗi Agent có khả năng Planning và Reflection sẽ cực kỳ mạnh mẽ. Tuy nhiên cũng cần cân nhắc về chi phí, độ phức tạp code và thời gian xử lý. Trong thực tế, hãy bắt đầu từ đơn giản, chỉ thêm Planning hoặc Reflection khi Agent đơn thuần không đủ tốt, và chỉ tách thành Multi-Agent khi thực sự cần thiết.