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.