Agent Loop vs Prompt Chaining — Chọn pattern đúng cho bài toán của bạn

Khi xây dựng ứng dụng với Claude API, một trong những quyết định kiến trúc quan trọng nhất là chọn pattern tương tác phù hợp. Chọn sai pattern có thể dẫn đến chi phí cao gấp 10 lần, độ tin cậy thấp, hoặc giới hạn khả năng mở rộng. Bài viết này phân tích chi tiết 3 pattern chính và cung cấp ma trận quyết định giúp bạn chọn đúng ngay từ đầu.

Ba pattern cơ bản

Mọi ứng dụng AI đều thuộc về hoặc kết hợp từ 3 pattern cơ bản sau:

Pattern 1: Single Prompt (Một lần gọi)

Gửi toàn bộ input và nhận output trong một lần gọi API duy nhất. Đây là pattern đơn giản nhất và phù hợp nhất cho đa số tác vụ.

import anthropic

client = anthropic.Anthropic()

# Single prompt: 1 input -> 1 output
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": "Phan tich bai viet sau va tra ve JSON voi "
                   "cac truong: sentiment, topics, summary.

"
                   "[Noi dung bai viet...]"
    }]
)

result = response.content[0].text

Khi nào dùng: tác vụ có input rõ ràng và output xác định, không cần nhiều bước xử lý. Ví dụ: dịch văn bản, phân loại email, tóm tắt tài liệu, trích xuất thông tin từ CV.

Pattern 2: Prompt Chaining (Chuỗi prompt)

Chia tác vụ phức tạp thành nhiều bước tuần tự, output của bước trước trở thành input cho bước sau. Logic điều khiển nằm hoàn toàn trong code của bạn, không phải trong model.

def prompt_chain_content_pipeline(topic):
    """Pipeline tao noi dung: outline -> draft -> review -> final."""

    # Buoc 1: Tao outline
    outline_response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[{
            "role": "user",
            "content": f"Tao outline chi tiet cho bai viet ve: {topic}. "
                       f"Tra ve danh sach cac heading va subheading."
        }]
    )
    outline = outline_response.content[0].text

    # Buoc 2: Viet draft dua tren outline
    draft_response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": f"Viet bai viet day du dua tren outline sau:

"
                       f"{outline}

"
                       f"Yeu cau: 1500-2000 tu, gong dieu chuyen nghiep."
        }]
    )
    draft = draft_response.content[0].text

    # Buoc 3: Review va danh gia chat luong
    review_response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"Review bai viet sau va chi ra:
"
                       f"1. Diem manh
"
                       f"2. Diem can cai thien
"
                       f"3. Loi chinh ta hoac ngu phap

"
                       f"{draft}"
        }]
    )
    review = review_response.content[0].text

    # Buoc 4: Chinh sua dua tren review
    final_response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": f"Chinh sua bai viet sau dua tren feedback:

"
                       f"BAI VIET GOC:
{draft}

"
                       f"FEEDBACK:
{review}

"
                       f"Hay tra ve ban chinh sua hoan chinh."
        }]
    )

    return final_response.content[0].text

Khi nào dùng: tác vụ có thể chia thành các bước rõ ràng, mỗi bước có input/output xác định, và bạn muốn kiểm soát chính xác luồng xử lý. Ví dụ: pipeline tạo nội dung, quy trình xử lý đơn hàng, phân tích dữ liệu nhiều giai đoạn.

Pattern 3: Agent Loop (Vòng lặp agent)

Model tự quyết định hành động tiếp theo dựa trên kết quả của hành động trước. Model được cung cấp các tool (hàm) và tự chọn tool nào cần gọi, khi nào dừng. Logic điều khiển nằm trong model, không phải trong code.

import json

tools = [
    {
        "name": "search_database",
        "description": "Tim kiem san pham trong database",
        "input_schema": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "category": {"type": "string"}
            },
            "required": ["query"]
        }
    },
    {
        "name": "check_inventory",
        "description": "Kiem tra ton kho cua san pham",
        "input_schema": {
            "type": "object",
            "properties": {
                "product_id": {"type": "string"}
            },
            "required": ["product_id"]
        }
    },
    {
        "name": "calculate_shipping",
        "description": "Tinh phi van chuyen",
        "input_schema": {
            "type": "object",
            "properties": {
                "product_id": {"type": "string"},
                "destination": {"type": "string"}
            },
            "required": ["product_id", "destination"]
        }
    }
]

def execute_tool(tool_name, tool_input):
    """Thuc thi tool va tra ve ket qua."""
    if tool_name == "search_database":
        return json.dumps({"results": [{"id": "P001", "name": "Laptop X"}]})
    elif tool_name == "check_inventory":
        return json.dumps({"in_stock": True, "quantity": 15})
    elif tool_name == "calculate_shipping":
        return json.dumps({"cost": 50000, "delivery_days": 3})
    return json.dumps({"error": "Unknown tool"})

def agent_loop(user_message, max_turns=10):
    """Agent loop: model tu quyet dinh hanh dong tiep theo."""
    messages = [{"role": "user", "content": user_message}]

    for turn in range(max_turns):
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=4096,
            tools=tools,
            messages=messages
        )

        # Kiem tra model co muon goi tool khong
        if response.stop_reason == "end_turn":
            # Model da tra loi xong, khong can goi tool nua
            final_text = ""
            for block in response.content:
                if block.type == "text":
                    final_text += block.text
            return final_text

        # Xu ly tool calls
        assistant_content = response.content
        messages.append({"role": "assistant", "content": assistant_content})

        tool_results = []
        for block in assistant_content:
            if block.type == "tool_use":
                result = execute_tool(block.name, block.input)
                tool_results.append({
                    "type": "tool_result",
                    "tool_use_id": block.id,
                    "content": result
                })

        messages.append({"role": "user", "content": tool_results})

    return "Da dat gioi han so vong lap"

# Su dung
answer = agent_loop("Tim laptop duoi 20 trieu, con hang, ship ve Ha Noi")

Khi nào dùng: tác vụ không thể dự đoán trước số bước cần thực hiện, cần tương tác với nhiều hệ thống bên ngoài, hoặc logic xử lý phụ thuộc vào kết quả runtime. Ví dụ: chatbot hỗ trợ khách hàng với quyền truy cập database, trợ lý nghiên cứu tự động, agent xử lý sự cố.

Ma trận quyết định

Sử dụng bảng sau để chọn pattern phù hợp cho bài toán của bạn:

Phân tích chi phí chi tiết

Chi phí là yếu tố quyết định quan trọng. Dưới đây là ví dụ với cùng một tác vụ: "Phân tích website đối thủ và tạo báo cáo cạnh tranh".

Single Prompt

# 1 API call
# Input: ~2000 tokens (prompt + context)
# Output: ~3000 tokens (bao cao)
# Chi phi: (2000 * $3 + 3000 * $15) / 1M = $0.051

Prompt Chain (4 bước)

# Buoc 1: Phan tich co cau website (~1500 input, ~1000 output)
# Buoc 2: Phan tich noi dung (~2500 input, ~1500 output)
# Buoc 3: Phan tich SEO (~2000 input, ~1000 output)
# Buoc 4: Tong hop bao cao (~5000 input, ~3000 output)
# Tong: 11000 input tokens, 6500 output tokens
# Chi phi: (11000 * $3 + 6500 * $15) / 1M = $0.131

Agent Loop (5-15 vòng)

# Moi vong: ~2000 input, ~500 output (trung binh)
# 10 vong trung binh: 20000 input, 5000 output
# Cong them context tich luy: +15000 input tokens
# Tong: ~35000 input tokens, 5000 output tokens
# Chi phi: (35000 * $3 + 5000 * $15) / 1M = $0.18
# Truong hop xau (15 vong): co the len $0.35+

Khi nào mỗi pattern thắng

Single Prompt thắng khi:

• Tác vụ có thể mô tả trong một prompt ngắn gọn
• Output có format xác định (JSON, bảng, danh sách)
• Không cần truy cập dữ liệu bên ngoài
• Latency là ưu tiên (cần phản hồi nhanh)
• Chi phí cần tối thiểu

Ví dụ thực tế: phân loại email, trích xuất thông tin từ hóa đơn, dịch văn bản, tạo mô tả sản phẩm.

Prompt Chain thắng khi:

• Tác vụ có các bước rõ ràng, mỗi bước tạo ra artifact cụ thể
• Bạn muốn kiểm soát chất lượng ở từng bước (gate check)
• Có thể dùng model khác nhau cho từng bước (Haiku cho bước đơn giản, Sonnet cho bước phức tạp)
• Cần xử lý lỗi và retry ở từng bước riêng biệt
• Output của một bước cần validation trước khi chuyển sang bước tiếp

Ví dụ thực tế: pipeline tạo nội dung (outline -> draft -> review -> edit), quy trình phân tích dữ liệu (clean -> analyze -> visualize -> report), multi-step form processing.

Agent Loop thắng khi:

• Không biết trước cần bao nhiêu bước
• Model cần quyết định hành động dựa trên kết quả runtime
• Tác vụ yêu cầu tương tác với nhiều tool/API khác nhau
• Người dùng mong đợi trải nghiệm "trợ lý thông minh" có thể tự giải quyết vấn đề
• Tác vụ có tính khám phá (exploratory): tìm kiếm, nghiên cứu, troubleshooting

Ví dụ thực tế: customer support bot, coding assistant, research agent, DevOps troubleshooting agent.

Lộ trình nâng cấp: từ đơn giản đến phức tạp

Nguyên tắc vàng: luôn bắt đầu với pattern đơn giản nhất có thể giải quyết bài toán, rồi nâng cấp khi thực sự cần thiết.

Giai đoạn 1: Single Prompt

# Bat dau voi single prompt
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=4096,
    messages=[{
        "role": "user",
        "content": f"Phan tich va tao bao cao cho: {data}"
    }]
)

Giai đoạn 2: Thêm validation, chuyển sang Chain

# Khi single prompt khong du chat luong
# -> Tach thanh chain voi validation

# Buoc 1: Phan tich
analysis = call_claude("Phan tich data nay: ...")

# Gate check: kiem tra output co hop le khong
if not validate_analysis(analysis):
    analysis = call_claude("Phan tich lai, can bao gom: ...")

# Buoc 2: Tao bao cao tu phan tich da validate
report = call_claude(f"Tao bao cao tu phan tich: {analysis}")

Giai đoạn 3: Thêm tool, chuyển sang Agent

# Khi chain khong du linh hoat
# -> Chuyen sang agent loop voi tools

# Chi chuyen sang agent khi:
# 1. So buoc khong co dinh
# 2. Can truy cap nhieu data source
# 3. Logic phu thuoc vao du lieu runtime

Hybrid Pattern: Kết hợp nhiều pattern

Trong thực tế, nhiều ứng dụng kết hợp các pattern. Ví dụ: dùng agent loop cho phần tương tác với người dùng, nhưng bên trong agent gọi các prompt chain cho từng tác vụ cụ thể:

def hybrid_customer_support(user_message):
    """Agent loop o cap cao, prompt chain cho tung tac vu."""

    tools = [
        {
            "name": "process_refund",
            "description": "Xu ly hoan tien. "
                           "Ben trong dung prompt chain 3 buoc: "
                           "verify -> calculate -> confirm",
            "input_schema": {
                "type": "object",
                "properties": {
                    "order_id": {"type": "string"},
                    "reason": {"type": "string"}
                },
                "required": ["order_id", "reason"]
            }
        },
        {
            "name": "analyze_complaint",
            "description": "Phan tich khieu nai. "
                           "Ben trong dung single prompt.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "complaint_text": {"type": "string"}
                },
                "required": ["complaint_text"]
            }
        }
    ]

    # Agent loop quyet dinh goi tool nao
    # Moi tool ben trong co the la single prompt hoac chain
    return agent_loop(user_message, tools=tools)

Anti-patterns cần tránh

Một số sai lầm phổ biến khi chọn pattern:

1. Agent Loop cho tác vụ đơn giản

Dùng agent với tool cho tác vụ mà single prompt đã xử lý tốt. Kết quả: chi phí tăng 10-20x, latency tăng 5-10x, và thêm phức tạp không cần thiết.

2. Single Prompt cho tác vụ quá phức tạp

Nhồi nhét tất cả hướng dẫn vào một prompt khổng lồ. Kết quả: model bỏ sót bước, output không đồng nhất, khó debug khi có lỗi.

3. Prompt Chain cứng nhắc cho tác vụ động

Thiết kế chain cố định cho tác vụ mà mỗi input cần số bước khác nhau. Kết quả: lãng phí token cho bước không cần thiết, hoặc thiếu bước khi cần.

4. Không đặt giới hạn cho Agent Loop

Agent loop không có max_turns có thể chạy vô tận, tiêu tốn hàng trăm nghìn token. Luôn đặt giới hạn số vòng lặp tối đa.

Bước tiếp theo

Chọn đúng pattern là bước đầu tiên để xây dựng ứng dụng AI hiệu quả. Bước tiếp theo là triển khai kiểm soát chi phí cho agent loop (token budget, max iterations, monitoring) để đảm bảo ứng dụng không vượt ngân sách. Khám phá thêm tại Thư viện Nâng cao Claude.