AI Agents & Agentic AI
Trang chủ / Module 5
🧩 Module 5 / 16 · 1 tuần

Workflow Patterns — 5 mẫu điều phối trước khi cần Agent

Prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer: năm khối xây dựng giải quyết phần lớn bài toán 'agentic' mà không cần trao toàn quyền cho model.

ChainingRoutingParallelEvaluator-Optimizer
📌 Vì sao module này quan trọng

Phần lớn hệ thống "agent" chạy tốt trong production thực chất là workflow: luồng do code điều khiển, LLM làm từng bước hẹp. Chúng rẻ hơn, nhanh hơn, dễ test và dễ giải thích hơn agent tự do. Năm pattern trong module này là bộ từ vựng chung của ngành — bạn sẽ gặp lại chúng dưới tên khác trong mọi framework. Nắm chắc chúng giúp bạn (a) không dùng agent cho bài toán chỉ cần workflow, và (b) ghép chúng bên trong một hệ agent khi cần.

🎯 Mục tiêu học tập

  • Nhận diện và cài đặt được 5 workflow pattern cơ bản bằng code thuần
  • Chọn đúng pattern theo đặc điểm bài toán: cố định hay rẽ nhánh, tuần tự hay song song, có tiêu chí đánh giá rõ hay không
  • Dùng structured output để nối các bước một cách đáng tin cậy
  • Biết điểm giới hạn của workflow — dấu hiệu cho thấy đã đến lúc cần agent loop

Tổng quan 5 pattern

PatternHình dạng luồngDùng khiVí dụ
Prompt chainingA → B → C, có cổng kiểm tra giữa các bướcTác vụ tách được thành các bước cố địnhDàn ý → kiểm tra dàn ý → viết bài
RoutingPhân loại → một trong N nhánh chuyên biệtĐầu vào thuộc vài loại khác hẳn nhauTicket: hoàn tiền / kỹ thuật / hỏi chung
ParallelizationTách ra N lời gọi chạy cùng lúc → gộpCác phần độc lập, hoặc cần nhiều góc nhìnReview code theo 4 khía cạnh; bỏ phiếu kiểm duyệt
Orchestrator-workersLLM điều phối tự chia việc → worker → tổng hợpKhông biết trước cần chia thành mấy phầnSửa một tính năng chạm vào số file chưa biết trước
Evaluator-optimizerSinh → chấm → sửa, lặp đến khi đạtCó tiêu chí rõ và phản hồi giúp cải thiện thậtDịch văn học; viết code đến khi test pass

Ba pattern đầu là workflow thuần (code quyết định luồng). Hai pattern sau bắt đầu trao quyền cho model (model quyết định chia việc gì, hoặc khi nào đạt) — chúng là cầu nối sang agent.

Prompt chaining và cổng kiểm tra

Đổi một lời gọi khó lấy nhiều lời gọi dễ. Giá trị thật nằm ở cổng (gate) giữa các bước: một kiểm tra bằng code (hoặc LLM) quyết định đi tiếp, làm lại, hay dừng.

from pydantic import BaseModel

class Outline(BaseModel):
    title: str
    sections: list[str]

def write_article(topic: str) -> str:
    outline = client.messages.parse(
        model="claude-opus-5-5", max_tokens=16000,
        messages=[{"role": "user", "content": f"Lập dàn ý bài viết kỹ thuật về: {topic}"}],
        output_format=Outline,
    ).parsed_output

    # Cổng: kiểm tra bằng code, rẻ và chắc chắn
    if not (4 <= len(outline.sections) <= 8):
        raise ValueError("Dàn ý không đạt, cần sinh lại")

    draft = client.messages.create(
        model="claude-opus-5-5", max_tokens=16000,
        messages=[{"role": "user", "content": f"Viết bài theo dàn ý sau:\n{outline.model_dump_json()}"}],
    )
    return draft.content[0].text

Structured output (schema Pydantic/JSON) là keo nối các bước: bước sau nhận dữ liệu có kiểu thay vì phải phân tích văn bản tự do. Ưu tiên cổng bằng code (đếm, regex, validate schema, chạy test) trước khi nghĩ đến cổng bằng LLM.

Routing

Một bước phân loại rẻ quyết định nhánh xử lý; mỗi nhánh có prompt, tool, thậm chí model riêng. Lợi ích: mỗi nhánh được tối ưu độc lập mà không làm hỏng nhánh khác, và việc dễ được đưa cho model rẻ.

from typing import Literal

class Route(BaseModel):
    category: Literal["refund", "technical", "general"]
    reason: str

def handle_ticket(ticket: str) -> str:
    route = client.messages.parse(
        model="claude-haiku-4-5", max_tokens=512,          # phân loại: model nhỏ là đủ
        system="Phân loại ticket hỗ trợ vào đúng một nhóm.",
        messages=[{"role": "user", "content": ticket}],
        output_format=Route,
    ).parsed_output

    handlers = {"refund": handle_refund, "technical": run_support_agent, "general": answer_faq}
    return handlers[route.category](ticket)

Chú ý nhánh technical gọi một agent: routing là cách phổ biến để chỉ trả chi phí agent cho phần đầu vào thật sự cần nó. Luôn có nhánh mặc định cho trường hợp phân loại không chắc, và theo dõi phân bố các nhánh trong production — phân bố lệch đột ngột là tín hiệu có vấn đề.

Parallelization: chia phần và bỏ phiếu

Hai biến thể:

  • Chia phần (sectioning): các phần việc độc lập chạy đồng thời — review bảo mật, hiệu năng, độ dễ đọc bằng ba lời gọi riêng, mỗi lời gọi tập trung một khía cạnh nên kỹ hơn một lời gọi "review tất cả".
  • Bỏ phiếu (voting): cùng một câu hỏi chạy nhiều lần (hoặc với các prompt khác nhau) rồi lấy đa số/ngưỡng — dùng cho quyết định cần độ tin cậy cao như kiểm duyệt nội dung.
import asyncio
from anthropic import AsyncAnthropic

aclient = AsyncAnthropic()

ASPECTS = {
    "security":    "Chỉ tìm lỗ hổng bảo mật: injection, lộ secret, thiếu kiểm tra quyền.",
    "performance": "Chỉ tìm vấn đề hiệu năng: N+1 query, vòng lặp thừa, thiếu index.",
    "correctness": "Chỉ tìm lỗi logic và trường hợp biên chưa xử lý.",
}

async def review_one(aspect: str, instruction: str, diff: str) -> str:
    r = await aclient.messages.create(
        model="claude-opus-5-5", max_tokens=16000,
        system=instruction,
        messages=[{"role": "user", "content": diff}],
    )
    return f"## {aspect}\n{r.content[0].text}"

async def review(diff: str) -> str:
    parts = await asyncio.gather(*(review_one(a, i, diff) for a, i in ASPECTS.items()))
    return "\n\n".join(parts)

Song song hoá giảm độ trễ nhưng không giảm tổng token. Nhớ đặt giới hạn đồng thời (semaphore) để không vượt rate limit.

Orchestrator-workers

Khác parallelization ở chỗ số lượng và nội dung phần việc không biết trước — một LLM điều phối đọc yêu cầu rồi tự quyết định chia thành những việc con nào, giao cho worker, và tổng hợp.

class Subtask(BaseModel):
    title: str
    instructions: str      # đủ ngữ cảnh để worker làm độc lập

class Plan(BaseModel):
    subtasks: list[Subtask]

def orchestrate(request: str) -> str:
    plan = client.messages.parse(
        model="claude-opus-5-5", max_tokens=16000,
        system="Chia yêu cầu thành các việc con độc lập. Mỗi việc con phải tự đủ ngữ cảnh.",
        messages=[{"role": "user", "content": request}],
        output_format=Plan,
    ).parsed_output

    results = [run_worker(t.instructions) for t in plan.subtasks[:8]]   # giới hạn cứng số worker
    return synthesize(request, results)

Đây là dạng "một lượt" của hệ multi-agent (Module 10): điều phối viên lập kế hoạch một lần. Khi bạn cho điều phối viên xem kết quả rồi quyết định giao thêm việc, nó trở thành agent thật sự.

Evaluator-optimizer

class Verdict(BaseModel):
    passed: bool
    feedback: str

def generate_until_good(task: str, criteria: str, max_rounds: int = 3) -> str:
    draft, feedback = "", ""
    for _ in range(max_rounds):
        draft = generate(task, previous=draft, feedback=feedback)
        verdict = client.messages.parse(
            model="claude-opus-5-5", max_tokens=16000,
            system=f"Bạn là người thẩm định khắt khe. Tiêu chí:\n{criteria}",
            messages=[{"role": "user", "content": draft}],
            output_format=Verdict,
        ).parsed_output
        if verdict.passed:
            break
        feedback = verdict.feedback
    return draft

Pattern này chỉ đáng dùng khi thoả cả hai: có tiêu chí đánh giá rõ ràng, và phản hồi thực sự giúp bản sau tốt hơn. Vài lưu ý thực tế:

  • Người chấm tốt nhất là thứ không phải LLM: test suite, compiler, linter, validator. Chỉ dùng LLM chấm cho tiêu chí không tự động hoá được.
  • Người chấm cần context khác người viết (prompt riêng, lý tưởng là không thấy quá trình suy nghĩ của người viết) — nếu không nó dễ đồng tình với chính lập luận đã sinh ra lỗi.
  • Luôn có số vòng tối đa, và ghi lại số vòng thực tế: nếu gần như luôn đạt ở vòng 1, bạn đang trả tiền gấp đôi vô ích.

Khi nào workflow không còn đủ

Dấu hiệu nên chuyển một phần (không nhất thiết toàn bộ) sang agent loop:

  • Số nhánh if/else trong code điều phối tăng không ngừng để xử lý ngoại lệ.
  • Bước tiếp theo phụ thuộc vào nội dung kết quả bước trước theo cách không liệt kê trước được.
  • Số bước cần thiết dao động mạnh giữa các đầu vào (có ca 2 bước, có ca 40 bước).
  • Cần khả năng phục hồi: thử cách A, thất bại, hiểu vì sao, thử cách B.

Kiến trúc lai rất phổ biến và thường là tốt nhất: workflow ở ngoài, agent ở trong — code lo routing, kiểm tra quyền, cổng duyệt và ghi nhận kết quả; agent chỉ được thả tự do trong một bước có phạm vi và bộ tool giới hạn.

🏋️ Bài tập thực hành

Một bài toán, ba cách giải

Bài toán: nhận một pull request (diff + mô tả) và sinh bản review. Cài đặt ba phiên bản: (A) một lời gọi LLM duy nhất; (B) workflow: routing theo loại thay đổi (docs/refactor/feature) → parallelization theo 3 khía cạnh → tổng hợp → evaluator kiểm tra "mỗi nhận xét có trỏ đúng dòng và có đề xuất sửa không"; (C) agent loop ở Module 2 với tool đọc file trong repo để hiểu ngữ cảnh ngoài diff. Chạy cả ba trên 10 PR thật của một repo mã nguồn mở, so sánh: chất lượng (bạn tự chấm mù), chi phí, độ trễ. Viết nửa trang kết luận: phiên bản nào bạn sẽ đưa vào production và vì sao.

📚 Tài nguyên học tập

✅ Tự đánh giá hoàn thành

  • Cài đặt được cả 5 pattern bằng code thuần, không framework
  • Nói được pattern nào do code điều khiển luồng, pattern nào đã trao một phần quyền cho model
  • Dùng structured output và cổng kiểm tra bằng code giữa các bước
  • Đã so sánh bằng số liệu giữa 1 lời gọi, workflow, và agent trên cùng một bài toán