Multi-Agent Systems

Hệ thống đa Agent (Multi-Agent System — MAS) sử dụng nhiều AI Agent chuyên biệt phối hợp để hoàn thành 1 nhiệm vụ. Mỗi agent có: (1) role — vai trò riêng, (2) tools — công cụ riêng, (3) memory — bộ nhớ local hoặc shared. Khác với 1 LLM đơn độc, multi-agent chia việc theo chuyên môn và cho phép kiểm chứng chéo.

Ba topology phối hợp phổ biến:

• Điều phối trung tâm (Hub-and-Spoke): 1 coordinator phân công và giám sát. Đơn giản, dễ debug. Đây chính là pattern chúng ta vừa mô phỏng phía trên. Nhược điểm: coordinator là nút cổ chai — nếu nó chậm hoặc bị hallucinate, cả hệ thống chịu.
• Ngang hàng (Peer-to-Peer): Agent giao tiếp trực tiếp. Linh hoạt nhưng phức tạp $O(n^2)$. Phù hợp debate pattern (2–3 agent tranh luận) hoặc swarm intelligence.
• Phân cấp (Hierarchical): Tổ chức theo cây. Coordinator → sub-coordinator → agents. Mở rộng tốt cho hệ thống 10+ agent. Giống cơ cấu công ty: CEO → manager → staff.

Hai framework phổ biến hiện nay: LangGraph (của LangChain) — workflow graph-based với state + node + edge, phù hợp khi bạn cần kiểm soát flow chi tiết + loop + conditional routing. CrewAI — role-based, trực quan hơn khi bạn nghĩ theo "đội ngũ", agent có role/goal/backstory và coordinator gán tasks. Code bên dưới minh hoạ 2 style.

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, WebsiteSearchTool

# ─── Khai báo tools ──────────────────────────────────
search_tool   = SerperDevTool()
web_read_tool = WebsiteSearchTool()


# ─── 3 agent chuyên biệt ────────────────────────────
researcher = Agent(
    role="Senior Research Analyst",
    goal="Tìm 3 xu hướng LLM agent nổi bật năm 2026",
    backstory=(
        "Bạn là một analyst kỳ cựu chuyên theo dõi arXiv, "
        "blog của các lab AI lớn, và GitHub trending."
    ),
    tools=[search_tool, web_read_tool],
    verbose=True,
    allow_delegation=False,
)

writer = Agent(
    role="Technical Writer",
    goal="Viết báo cáo 300 từ chuyên nghiệp bằng Tiếng Việt",
    backstory=(
        "Bạn là một technical writer có 10 năm kinh nghiệm "
        "giải thích các khái niệm AI phức tạp cho cả developer và PM."
    ),
    verbose=True,
    allow_delegation=False,
)

reviewer = Agent(
    role="Quality Reviewer",
    goal="Kiểm tra tính chính xác và độ rõ ràng của báo cáo",
    backstory="Bạn là editor kỹ tính nhất công ty.",
    verbose=True,
)


# ─── Định nghĩa tasks với dependency ─────────────────
research_task = Task(
    description=(
        "Tìm 3 xu hướng LLM agent nổi bật năm 2026. "
        "Trả về JSON [{title, why_it_matters, source_url}]."
    ),
    expected_output="JSON array với 3 xu hướng kèm nguồn.",
    agent=researcher,
)

write_task = Task(
    description=(
        "Viết báo cáo 300 từ dựa trên research output. "
        "Giọng văn chuyên nghiệp, dùng ngôi thứ ba."
    ),
    expected_output="Báo cáo Markdown, khoảng 300 từ.",
    agent=writer,
    context=[research_task],   # phụ thuộc output của research
)

review_task = Task(
    description="Review báo cáo, chỉ ra lỗi hoặc điểm cần cải thiện.",
    expected_output="Danh sách feedback + bản sửa nếu cần.",
    agent=reviewer,
    context=[write_task],
)


# ─── Lập Crew + chạy ────────────────────────────────
crew = Crew(
    agents=[researcher, writer, reviewer],
    tasks=[research_task, write_task, review_task],
    process=Process.sequential,   # có thể đổi sang hierarchical
    verbose=2,
)

result = crew.kickoff(inputs={"topic": "AI Agents 2026"})
print(result)

CrewAI nhấn mạnh khía cạnh role-play: mỗi agent có một "nhân vật" rõ ràng (backstory, goal) giúp LLM giữ vai nhất quán. Tuy trừu tượng đẹp nhưng khi flow phức tạp với loop + conditional, LangGraph tự nhiên hơn.

from typing import TypedDict, Literal
from langgraph.graph import StateGraph, END
from langchain_core.messages import HumanMessage, AIMessage
from langchain_openai import ChatOpenAI


# ─── Shared state (blackboard) ───────────────────────
class AgentState(TypedDict):
    task: str
    research: str | None
    draft: str | None
    review: str | None
    iterations: int


llm = ChatOpenAI(model="gpt-4o-mini", temperature=0.2)


# ─── 3 node — mỗi node là 1 "agent" ─────────────────
def researcher_node(state: AgentState) -> AgentState:
    prompt = (
        f"Task: {state['task']}\n"
        "Tìm 3 xu hướng LLM agent 2026, trả JSON."
    )
    resp = llm.invoke([HumanMessage(content=prompt)])
    return {**state, "research": resp.content}


def writer_node(state: AgentState) -> AgentState:
    feedback = state.get("review") or "(chưa có review)"
    prompt = (
        f"Viết báo cáo 300 từ dựa trên:\n{state['research']}\n"
        f"Phản hồi lần trước (nếu có): {feedback}"
    )
    resp = llm.invoke([HumanMessage(content=prompt)])
    return {
        **state,
        "draft": resp.content,
        "iterations": state.get("iterations", 0) + 1,
    }


def reviewer_node(state: AgentState) -> AgentState:
    prompt = (
        f"Review báo cáo:\n{state['draft']}\n"
        "Trả 'OK' nếu đạt, hoặc liệt kê điểm cần sửa."
    )
    resp = llm.invoke([HumanMessage(content=prompt)])
    return {**state, "review": resp.content}


# ─── Conditional edge — quyết định loop hay kết thúc ─
def route_after_review(state: AgentState) -> Literal["writer", "end"]:
    review = (state.get("review") or "").strip().upper()
    iters = state.get("iterations", 0)
    if review.startswith("OK") or iters >= 3:
        return "end"
    return "writer"   # loop lại nếu review không đạt


# ─── Xây graph ──────────────────────────────────────
graph = StateGraph(AgentState)
graph.add_node("researcher", researcher_node)
graph.add_node("writer",     writer_node)
graph.add_node("reviewer",   reviewer_node)

graph.set_entry_point("researcher")
graph.add_edge("researcher", "writer")
graph.add_edge("writer",     "reviewer")
graph.add_conditional_edges(
    "reviewer",
    route_after_review,
    {"writer": "writer", "end": END},
)

app = graph.compile()

# ─── Chạy ───────────────────────────────────────────
final = app.invoke({
    "task": "Viết báo cáo xu hướng LLM agent 2026",
    "research": None,
    "draft": None,
    "review": None,
    "iterations": 0,
})

print(final["draft"])

LangGraph đưa bạn gần với tư duy state machine: flow có thể loop (writer ↔ reviewer) đến khi reviewer OK hoặc đạt max iterations. Đây là điểm mạnh then chốt so với CrewAI "tuần tự" thuần.

Self-reflection vs separate reviewer— một quyết định thiết kế thường gặp. Self-reflection (1 agent tự review) rẻ hơn, ít latency, nhưng thiên vị: LLM có xu hướng đánh giá tích cực với chính output của mình. Separate reviewer tốn 1 LLM call nữa nhưng cho perspective khác — đặc biệt hiệu quả khi reviewer dùng model khác writer (ví dụ writer = gpt-4o-mini, reviewer = claude-opus). "Cross-model review" giảm systematic bias. Rule of thumb: task consequence cao (code production, medical advice) → dùng separate reviewer; task nội dung (email, summary) → self-reflection đủ.

Agent memory — 3 tầng. Working memory: context hiện tại trong 1 lần chạy (thread). Episodic memory: lịch sử các task đã làm — lưu vector DB, retrieve khi task mới vào. Semantic memory: kiến thức trừu tượng rút ra (ví dụ "công ty này ưu tiên phong cách formal"). Multi-agent càng phức tạp càng cần phân biệt rõ: mỗi agent có working memory riêng, nhưng episodic + semantic nên share để đồng bộ hành vi.

So sánh nhanh CrewAI vs LangGraph

Không có "đúng"/"sai" — cả 2 framework đều production-ready. Startup thường bắt đầu với CrewAI để prototype nhanh, rồi chuyển sang LangGraph khi flow đủ phức tạp cần kiểm soát. Một số team còn kết hợp: dùng LangGraph làm "meta-orchestrator" và CrewAI cho sub-crew bên trong.

Ví dụ case-study thực tế: một startup travel dùng 5 agent để trả lời yêu cầu "lên kế hoạch du lịch 5 ngày ở Đà Nẵng cho gia đình có 2 trẻ nhỏ":

1. Intent Parser— đọc yêu cầu, trích xuất: điểm đến, thời lượng, số người, ràng buộc ("trẻ nhỏ").
2. Flight/Transport Agent — tra chuyến bay, thời gian, giá qua tool calls API Skyscanner.
3. Hotel Agent — tìm khách sạn family-friendly, có hồ bơi, gần biển.
4. Itinerary Agent — xếp lịch 5 ngày, tính drive-time giữa các điểm.
5. Coordinator— tổng hợp thành itinerary, kiểm tra conflict (ví dụ: giờ check-in khách sạn > giờ đáp máy bay).

Kết quả: latency ~18s (so với 4s của single-agent), nhưng chất lượng lịch trình cao hơn hẳn — có link booking thật, thời gian hợp lý. Người dùng chấp nhận latency vì đây là task "thi thoảng" chứ không phải realtime chat.

Các nguyên tắc thiết kế MAS tốt:

1. Single source of truth: 1 state dùng chung, tránh mỗi agent giữ bản copy riêng.
2. Explicit contract: mỗi agent định nghĩa rõ input/output schema (JSON/Pydantic) — giảm ambiguity.
3. Timeout + fallback: nếu 1 agent timeout, có strategy thay thế (dùng LLM mạnh hơn? escalate người dùng?).
4. Stop condition: mọi loop phải có điều kiện dừng — max iterations, confidence threshold, hoặc human approval.
5. Observability: log mọi message + trace chi phí. Không có logs = không debug được.

Công thức chi phí đơn giản cho multi-agent:

Với $N$ là tổng số LLM call (tính cả message lẫn processing step). Overhead coordination thường thêm 20–40% so với single-agent cho cùng chất lượng đầu ra. Nếu bài toán của bạn không cần chất lượng cao hơn đáng kể, single-agent + prompt engineering tốt vẫn là lựa chọn kinh tế hơn.

Lưu ý production: multi-agent đưa ra thách thức vận hành mới so với chatbot thường:

• Debugging: khi output cuối sai, lỗi ở agent nào? Cần tracing tool (LangSmith, Langfuse, Helicone) để xem message timeline.
• Retry logic: nếu 1 agent fail, retry cả chain hay chỉ agent đó? Cần checkpoint state (LangGraph có built-in).
• Cost cap: đặt hard limit token per request — debate loop có thể chạy vô hạn nếu quên stop condition.
• Prompt drift: khi 1 agent đổi prompt, downstream agent có thể hiểu sai format. Snapshot + version prompt.

Tham khảo bài học liên quan: Agent architecture, Orchestration patterns, Agentic workflows.