LangChain vs. LangGraph: Tại sao 2026 là năm của "Cyclic Graph" và cái chết của "Chain" tuyến tính?

[AI Hunter]

LangChain vs. LangGraph: Tại sao 2026 là năm của "Cyclic Graph" và cái chết của "Chain" tuyến tính?

Bạn viết một ứng dụng AI bằng LangChain:
1. AI viết Code.
2. AI chạy Test.
3. Xuất kết quả.

Nhưng nếu bước 2 (Chạy Test) bị lỗi thì sao? Trong kiến trúc Chain truyền thống, chương trình sẽ báo lỗi và dừng lại (Crash).
Nhưng một lập trình viên con người sẽ không dừng lại. Họ sẽ **quay lại** bước 1 để sửa code và thử lại.

Đó chính là lý do **LangGraph** ra đời. Nó cho phép tạo ra các **Vòng lặp (Cycles)** trong quy trình xử lý của AI.

1. Tư duy: Chain vs. Graph​

• LangChain (Linear): Input -> Bước 1 -> Bước 2 -> Output. (Cứng nhắc, một chiều).
• LangGraph (Cyclic): Các bước là các "Node". Chúng nối với nhau bằng các điều kiện. Luồng đi có thể quay ngược lại Node cũ.

2. Kiến trúc của LangGraph​

LangGraph hoạt động dựa trên 3 thành phần cốt lõi:
1. **State (Trạng thái):** Một bộ nhớ chung (Shared Memory) chứa dữ liệu hiện tại của Agent (ví dụ: code hiện tại, lỗi hiện tại, số lần đã thử lại).
2. **Nodes (Nút):** Các hàm Python thực hiện công việc (như: Viết code, Search Google).
3. **Edges (Cạnh):** Logic điều hướng. (Ví dụ: Nếu có lỗi -> Quay lại Node Viết code. Nếu không lỗi -> Đi tới Kết thúc).

3. Triển khai Code: Agent "Tự sửa lỗi"​

Chúng ta sẽ xây dựng một Agent đơn giản: Nó viết code Python, sau đó tự chạy thử. Nếu lỗi, nó tự sửa và chạy lại (tối đa 3 lần).

Bước 1: Cài đặt​

pip install langgraph langchain langchain-openai

Bước 2: Định nghĩa State (Bộ nhớ)​

from typing import TypedDict, List
import operator

class AgentState(TypedDict):
    code: str        # Code do AI viết
    output: str      # Kết quả chạy code
    error: str       # Lỗi nếu có
    iterations: int  # Số lần đã thử

Bước 3: Định nghĩa Nodes (Hành động)​

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

# Node 1: Lập trình viên
def coder_node(state: AgentState):
    print("👨‍💻 Đang viết code...")
    prompt = f"Hãy viết code Python để giải quyết: {state.get('task')}. Chỉ trả về code, không giải thích."
   
    # Nếu có lỗi từ lần trước, hãy đưa vào prompt để sửa
    if state.get('error'):
        prompt += f"\nLần trước code bị lỗi: {state['error']}. Hãy sửa nó."
       
    code = llm.invoke(prompt).content
    # Cập nhật State
    return {"code": code, "iterations": state['iterations'] + 1}

# Node 2: Tester (Chạy thử code)
def tester_node(state: AgentState):
    print("🧪 Đang test code...")
    try:
        # Lưu ý: exec() nguy hiểm, chỉ dùng trong môi trường Sandbox!
        # Ở đây dùng demo đơn giản
        exec_globals = {}
        exec(state['code'], exec_globals)
        return {"error": None, "output": "Chạy thành công!"}
    except Exception as e:
        return {"error": str(e), "output": None}

Bước 4: Xây dựng Đồ thị (Graph)​

Đây là nơi ma thuật xảy ra. Chúng ta định nghĩa logic "quay đầu".

from langgraph.graph import StateGraph, END

# Hàm điều kiện (Router)
def router(state: AgentState):
    if state['iterations'] > 3:
        print("🛑 Quá số lần thử. Dừng lại.")
        return "end"
    if state['error']:
        print("⚠️ Có lỗi! Quay lại sửa.")
        return "retry" # Quay lại Node Coder
   
    print("✅ Thành công!")
    return "end"

# Khởi tạo Graph
workflow = StateGraph(AgentState)

# Thêm các Node
workflow.add_node("coder", coder_node)
workflow.add_node("tester", tester_node)

# Thiết lập luồng đi
workflow.set_entry_point("coder") # Bắt đầu ở Coder
workflow.add_edge("coder", "tester") # Coder xong thì qua Tester

# Thiết lập luồng rẽ nhánh (Conditional Edge)
workflow.add_conditional_edges(
    "tester", # Từ node Tester
    router,   # Dựa vào hàm router
    {
        "retry": "coder", # Nếu router trả về 'retry' -> Quay lại 'coder'
        "end": END        # Nếu router trả về 'end' -> Kết thúc
    }
)

# Biên dịch (Compile)
app = workflow.compile()

Bước 5: Chạy thử​

inputs = {"task": "Tính giai thừa của 5 và in ra màn hình", "iterations": 0, "error": None}
result = app.invoke(inputs)

print("\n--- KẾT QUẢ CUỐI CÙNG ---")
print(result['output'])
# Bạn sẽ thấy AI tự động lặp lại quy trình nếu code lần đầu bị sai cú pháp.

4. Khi nào dùng LangGraph?​

* **Multi-Agent Collaboration:** Khi bạn có 1 Researcher, 1 Writer, 1 Editor cần trao đổi qua lại nhiều vòng.
* **Human-in-the-loop:** Khi AI cần dừng lại để hỏi ý kiến người dùng trước khi đi tiếp (LangGraph hỗ trợ việc "tạm dừng" và "resume" trạng thái cực tốt).
* **Self-Correction:** Khi AI cần khả năng tự kiểm tra và sửa lỗi.

Kết luận​

Tư duy tuyến tính (Linear) đã lỗi thời. Thế giới thực là phi tuyến tính và đầy rẫy những vòng lặp. **LangGraph** chính là tấm bản đồ giúp các Developer điều hướng sự phức tạp đó để tạo ra những AI Agent thực sự thông minh và bền bỉ.