LangGraph vs DSPy: Tối ưu hóa lời nhắc khai báo so với máy trạng thái đồ thị cho tác nhân AI

Việc xây dựng các tác nhân AI mạnh mẽ, đạt chuẩn sản xuất vào năm 2026 đòi hỏi sự hiểu biết rõ ràng về các framework điều phối và các mô hình kỹ thuật prompt. LangGraph và DSPy đại diện cho hai cách tiếp cận riêng biệt, nhưng bổ trợ cho nhau, đối với thách thức này. LangGraph tập trung vào quản lý trạng thái rõ ràng và thực thi theo chu kỳ thông qua các máy trạng thái dựa trên đồ thị, trong khi DSPy ủng hộ tối ưu hóa prompt khai báo và biên dịch dựa trên số liệu. Hướng dẫn này sẽ phân tích cả hai, chứng minh điểm mạnh riêng của chúng và, quan trọng hơn, cách tích hợp chúng vào một kiến trúc lai mạnh mẽ cho AI doanh nghiệp.

Các Mô hình Kiến trúc: LangGraph so với DSPy

LangGraph: Máy trạng thái rõ ràng và Thực thi theo chu kỳ

LangGraph, một phần mở rộng của LangChain, cung cấp một framework để xây dựng các ứng dụng đa tác nhân, có trạng thái với LLM. Trừu tượng cốt lõi của nó là một đồ thị có hướng không chu trình (DAG) hoặc, mạnh mẽ hơn, một đồ thị trạng thái cho phép các chu trình. Điều này cho phép các quy trình làm việc phức tạp, lặp đi lặp lại, các vòng lặp tác nhân và sự can thiệp của con người.

Các đặc điểm chính:

• Các Node và Edge: Các quy trình làm việc được định nghĩa là một chuỗi các node (hàm, lời gọi LLM, lời gọi công cụ) được kết nối bằng các edge.
• Trạng thái Đồ thị: Một đối tượng trạng thái dùng chung, có thể thay đổi được truyền giữa các node, cho phép ngữ cảnh liên tục và ra quyết định.
• Các Edge có Điều kiện: Logic để định tuyến thực thi một cách linh hoạt dựa trên trạng thái đồ thị hiện tại.
• Thực thi theo Chu kỳ: Khả năng truy cập lại các node, rất quan trọng cho suy luận tác nhân, tự sửa lỗi và tinh chỉnh lặp đi lặp lại.
• Con người trong Vòng lặp: Các cơ chế rõ ràng để tạm dừng thực thi và yêu cầu đầu vào từ con người.

LangGraph vượt trội khi hành vi của tác nhân yêu cầu định tuyến phức tạp, động, tinh chỉnh lặp đi lặp lại hoặc chuyển đổi trạng thái rõ ràng mà khó có thể diễn đạt một cách thuần túy khai báo.

DSPy: Tối ưu hóa Prompt khai báo và Biên dịch dựa trên số liệu

DSPy (Declarative Self-improving Language Programs) chuyển đổi mô hình từ kỹ thuật prompt thủ công sang tối ưu hóa theo chương trình, dựa trên số liệu. Thay vì tạo prompt thủ công, các nhà phát triển định nghĩa chữ ký của một lời gọi LLM (trường đầu vào, trường đầu ra) và DSPy biên dịch chúng thành các prompt và trọng số được tối ưu hóa cho một LLM nhất định, dựa trên một số liệu được định nghĩa.

Các đặc điểm chính:

• Chữ ký: Định nghĩa trừu tượng về đầu vào và đầu ra của LLM, ví dụ: Question -> Answer.
• Module: Các thành phần có thể tái sử dụng (ví dụ: dspy.Chain, dspy.Predict, dspy.Retrieve) đóng gói các lời gọi LLM và chữ ký của chúng.
• Bộ tối ưu hóa (Trình biên dịch): Các thuật toán (ví dụ: BootstrapFewShot, BayesianSignatureOptimizer) tạo ra các ví dụ few-shot, sắp xếp lại các bản demo hoặc tinh chỉnh các mô hình để cải thiện hiệu suất so với một số liệu.
• Số liệu: Các hàm do người dùng định nghĩa để đánh giá chất lượng đầu ra của LLM, thúc đẩy quá trình tối ưu hóa.
• Khai báo: Tập trung vào những gì LLM nên làm, không phải cách để prompt nó.

DSPy mạnh mẽ để đạt được đầu ra LLM chất lượng cao, mạnh mẽ bằng cách tự động hóa quá trình kỹ thuật prompt và thích ứng với các LLM và tác vụ khác nhau.

So sánh Kiến trúc

Kiến trúc Lai: Biên dịch với DSPy, Điều phối với LangGraph

Sức mạnh thực sự xuất hiện khi kết hợp các framework này. Chúng ta có thể tận dụng DSPy để biên dịch các chữ ký prompt tối ưu cho các lời gọi LLM riêng lẻ hoặc các bước suy luận phức tạp, sau đó nhúng các module DSPy được tối ưu hóa này vào một máy trạng thái LangGraph. Điều này cho phép LangGraph quản lý luồng tác nhân tổng thể, chuyển đổi trạng thái, sử dụng công cụ và sự can thiệp của con người, trong khi DSPy đảm bảo chất lượng và độ mạnh mẽ của mỗi tương tác LLM.

Ví dụ: Tác nhân Nghiên cứu với Đánh giá của Con người

Hãy xem xét một tác nhân nghiên cứu mà:

1. Nhận một truy vấn từ người dùng.
2. Thực hiện tìm kiếm và tóm tắt ban đầu.
3. Xác định các khoảng trống hoặc sự mơ hồ tiềm ẩn.
4. Tùy chọn, yêu cầu người dùng làm rõ.
5. Tinh chỉnh tìm kiếm và tạo báo cáo cuối cùng.

Ở đây, DSPy có thể tối ưu hóa việc tạo truy vấn tìm kiếm, tóm tắt và các bước xác định khoảng trống, trong khi LangGraph điều phối trình tự, xử lý việc làm rõ của con người trong vòng lặp và quản lý trạng thái tổng thể.

Bước 1: Định nghĩa các Module DSPy cho các Tác vụ LLM cốt lõi

Đầu tiên, chúng ta định nghĩa các chữ ký và module DSPy cho các hoạt động LLM cốt lõi.

import dspy
from dspy.teleprompt import BootstrapFewShot
from typing import List, Dict, Any

# Configure DSPy with a local LLM (e.g., Ollama) or OpenAI
# For Ollama:
# llm = dspy.Ollama(model="llama3", max_tokens=2000)
# For OpenAI:
llm = dspy.OpenAI(model="gpt-4o-mini", max_tokens=2000)
dspy.settings.configure(lm=llm)

# Define a signature for generating search queries
class GenerateSearchQueries(dspy.Signature):
    """Generate a list of search queries for a given research question."""
    research_question: str = dspy.InputField(desc="The user's research question")
    search_queries: List[str] = dspy.OutputField(desc="A list of relevant search queries")

# Define a signature for summarizing search results
class SummarizeSearchResults(dspy.Signature):
    """Summarize a collection of search results into a concise overview."""
    search_results: List[str] = dspy.InputField(desc="A list of search result snippets")
    summary: str = dspy.OutputField(desc="A concise summary of the search results")

# Define a signature for identifying ambiguities or gaps
class IdentifyGaps(dspy.Signature):
    """Analyze a research summary and identify any ambiguities, missing information, or areas requiring clarification."""
    research_summary: str = dspy.InputField(desc="The current research summary")
    gaps_identified: str = dspy.OutputField(desc="A description of identified gaps or ambiguities, or 'None' if clear")
    requires_clarification: bool = dspy.OutputField(desc="True if user clarification is needed, False otherwise")

# Define DSPy Modules
class SearchQueryGenerator(dspy.Module):
    def __init__(self):
        super().__init__()
        self.generate_queries = dspy.Predict(GenerateSearchQueries)

    def forward(self, research_question: str) -> List[str]:
        prediction = self.generate_queries(research_question=research_question)
        return prediction.search_queries

class SearchResultSummarizer(dspy.Module):
    def __init__(self):
        super().__init__()
        self.summarize = dspy.Predict(SummarizeSearchResults)

    def forward(self, search_results: List[str]) -> str:
        prediction = self.summarize(search_results=search_results)
        return prediction.summary

class GapIdentifier(dspy.Module):
    def __init__(self):
        super().__init__()
        self.identify = dspy.Predict(IdentifyGaps)

    def forward(self, research_summary: str) -> Dict[str, Any]:
        prediction = self.identify(research_summary=research_summary)
        return {
            "gaps_identified": prediction.gaps_identified,
            "requires_clarification": prediction.requires_clarification
        }

# --- Optimization with BootstrapFewShot (example) ---
# In a real scenario, you'd have a dataset of (input, output) pairs
# For demonstration, we'll create a dummy dataset and compile.

# Dummy training data for GenerateSearchQueries
train_data_queries = [
    dspy.Example(research_question="Impact of AI on healthcare", search_queries=["AI in healthcare", "healthcare automation", "AI medical diagnostics"]),
    dspy.Example(research_question="Future of quantum computing", search_queries=["quantum computing trends", "quantum algorithms", "quantum hardware development"]),
]

# Dummy training data for SummarizeSearchResults
train_data_summaries = [
    dspy.Example(search_results=["Snippet 1 about AI", "Snippet 2 about healthcare"], summary="AI is transforming healthcare."),
    dspy.Example(search_results=["Snippet 1 about quantum", "Snippet 2 about future"], summary="Quantum computing holds future promise."),
]

# Dummy training data for IdentifyGaps
train_data_gaps = [
    dspy.Example(research_summary="AI is used in diagnostics.", gaps_identified="Does not specify types of AI or specific diagnostic applications.", requires_clarification=True),
    dspy.Example(research_summary="Quantum computing is a new field.", gaps_identified="None", requires_clarification=False),
]

# Define a simple metric for evaluation (e.g., checking if output is not empty)
def simple_metric(pred, gold, trace=None):
    return bool(pred.search_queries) if 'search_queries' in pred else bool(pred.summary) if 'summary' in pred else bool(pred.gaps_identified)

# Compile the modules
print("Compiling SearchQueryGenerator...")
teleprompter_queries = BootstrapFewShot(metric=simple_metric)
compiled_query_generator = teleprompter_queries.compile(SearchQueryGenerator(), trainset=train_data_queries)
print("SearchQueryGenerator compiled.")

print("Compiling SearchResultSummarizer...")
teleprompter_summaries = BootstrapFewShot(metric=simple_metric)
compiled_summarizer = teleprompter_summaries.compile(SearchResultSummarizer(), trainset=train_data_summaries)
print("SearchResultSummarizer compiled.")

print("Compiling GapIdentifier...")
teleprompter_gaps = BootstrapFewShot(metric=simple_metric)
compiled_gap_identifier = teleprompter_gaps.compile(GapIdentifier(), trainset=train_data_gaps)
print("GapIdentifier compiled.")

# Now, these compiled modules can be used within LangGraph
# For demonstration, let's test them:
# print("\nTesting compiled modules:")
# print(f"Queries: {compiled_query_generator.forward(research_question='Impact of 5G on IoT')}")
# print(f"Summary: {compiled_summarizer.forward(search_results=['5G enables faster IoT', 'IoT devices benefit from low latency'])}")
# print(f"Gaps: {compiled_gap_identifier.forward(research_summary='5G is fast.')}")

Bước 2: Định nghĩa Trạng thái và Node của LangGraph

Tiếp theo, chúng ta định nghĩa GraphState và các node sẽ sử dụng các module DSPy đã biên dịch của chúng ta.

from typing import TypedDict, Annotated, List, Dict
import operator
from langgraph.graph import StateGraph, END
from langchain_community.tools import DuckDuckGoSearchRun # Example tool

# Define the state for our graph
class ResearchState(TypedDict):
    research_question: str
    search_queries: Annotated[List[str], operator.add]
    search_results: Annotated[List[str], operator.add]
    summary: str
    gaps_identified: str
    requires_clarification: bool
    user_clarification: str
    final_report: str
    iterations: int

# Initialize tools
search_tool = DuckDuckGoSearchRun()

# Define LangGraph nodes
def generate_queries_node(state: ResearchState) -> ResearchState:
    print("---GENERATING QUERIES---")
    question = state["research_question"]
    # Use the compiled DSPy module
    queries = compiled_query_generator.forward(research_question=question)
    return {"search_queries": queries, "iterations": state.get("iterations", 0) + 1}

def perform_search_node(state: ResearchState) -> ResearchState:
    print("---PERFORMING SEARCH---")
    queries = state["search_queries"]
    results = []
    for query in queries:
        print(f"Searching for: {query}")
        # In a real scenario, you'd handle rate limits, errors, etc.
        try:
            result = search_tool.run(query)
            results.append(result)
        except Exception as e:
            print(f"Search failed for '{query}': {e}")
    return {"search_results": results}

def summarize_results_node(state: ResearchState) -> ResearchState:
    print("---SUMMARIZING RESULTS---")
    results = state["search_results"]
    # Use the compiled DSPy module
    summary = compiled_summarizer.forward(search_results=results)
    return {"summary": summary}

def identify_gaps_node(state: ResearchState) -> ResearchState:
    print("---IDENTIFYING GAPS---")
    summary = state["summary"]
    # Use the compiled DSPy module
    gap_info = compiled_gap_identifier.forward(research_summary=summary)
    return {
        "gaps_identified": gap_info["gaps_identified"],
        "requires_clarification": gap_info["requires_clarification"]
    }

def human_in_the_loop_node(state: ResearchState) -> ResearchState:
    print("---HUMAN IN THE LOOP---")
    print(f"Current Summary: {state['summary']}")
    print(f"Gaps Identified: {state['gaps_identified']}")
    user_input = input("Clarification needed. Please provide additional context or guidance (type 'continue' to proceed without further input): ")
    return {"user_clarification": user_input}

def refine_report_node(state: ResearchState) -> ResearchState:
    print("---REFINING REPORT---")
    # This node would typically use another DSPy module for final report generation
    # For simplicity, we'll just combine existing info.
    final_report_content = (
        f"Research Question: {state['research_question']}\n\n"
        f"Summary of Findings:\n{state['summary']}\n\n"
    )
    if state['gaps_identified'] != 'None':
        final_report_content += f"Identified Gaps: {state['gaps_identified']}\n"
    if state['user_clarification']:
        final_report_content += f"User Clarification: {state['user_clarification']}\n"
    final_report_content += "\n--- END OF REPORT ---"
    return {"final_report": final_report_content}

# Define conditional edge logic
def decide_next_step(state: ResearchState) -> str:
    if state["requires_clarification"] and state.get("user_clarification") == None:
        print("---DECISION: CLARIFICATION NEEDED---")
        return "human_review"
    elif state["requires_clarification"] and state.get("user_clarification") != None and state["user_clarification"].lower() != 'continue':
        print("---DECISION: RE-EVALUATE AFTER CLARIFICATION---")
        # If user provided clarification, we might want to re-run search/summarize
        # For this example, we'll just proceed to refine, but in a real system,
        # you'd likely loop back to generate_queries or summarize_results.
        return "refine_report"
    else:
        print("---DECISION: PROCEED TO FINAL REPORT---")
        return "refine_report"

Bước 3: Xây dựng và Chạy Quy trình làm việc của LangGraph

Cuối cùng, lắp ráp đồ thị và thực thi nó.

# Build the graph
workflow = StateGraph(ResearchState)

workflow.add_node("generate_queries", generate_queries_node)
workflow.add_node("perform_search", perform_search_node)
workflow.add_node("summarize_results", summarize_results_node)
workflow.add_node("identify_gaps", identify_gaps_node)
workflow.add_node("human_review", human_in_the_loop_node)
workflow.add_node("refine_report", refine_report_node)

workflow.set_entry_point("generate_queries")

workflow.add_edge("generate_queries", "perform_search")
workflow.add_edge("perform_search", "summarize_results")
workflow.add_edge("summarize_results", "identify_gaps")

# Conditional edge from identify_gaps
workflow.add_conditional_edges(
    "identify_gaps",
    decide_next_step,
    {
        "human_review": "human_review",
        "refine_report": "refine_report",
    },
)

# After human review, decide if we need to re-evaluate or finalize
workflow.add_conditional_edges(
    "human_review",
    decide_next_step, # Re-use the same decision logic
    {
        "human_review": "human_review", # Loop back if user didn't provide enough info (or if we want to ask again)
        "refine_report": "refine_report",
    },
)

workflow.add_edge("refine_report", END)

app = workflow.compile()

# Run the agent
initial_state = {"research_question": "What are the latest advancements in sustainable energy storage for grid applications?", "search_queries": [], "search_results": [], "summary": "", "gaps_identified": "", "requires_clarification": False, "user_clarification": None, "final_report": "", "iterations": 0}

print("\n--- STARTING RESEARCH AGENT ---")
for s in app.stream(initial_state):
    print(s)
    print("---")

print("\n--- FINAL REPORT ---")
final_state = app.invoke(initial_state)
print(final_state["final_report"])

Cách tiếp cận lai này cho phép module DSPy GapIdentifier được tối ưu hóa để phát hiện chính xác các sự mơ hồ, trong khi LangGraph xử lý luồng phức tạp của việc yêu cầu người dùng làm rõ và có thể lặp lại.

Những điều cần lưu ý khi triển khai & Khắc phục sự cố

1. Thiếu dữ liệu biên dịch DSPy:

   • Chế độ lỗi: BootstrapFewShot hoặc các bộ tối ưu hóa khác hoạt động kém do thiếu hoặc chất lượng dữ liệu đào tạo thấp. Các prompt đã biên dịch có thể không tối ưu, dẫn đến đầu ra LLM không nhất quán.
   • Cách khắc phục: Đầu tư vào các ví dụ minh họa chất lượng cao, đa dạng. Đối với các module quan trọng, hãy cân nhắc sử dụng BootstrapFewShotWithRandomSearch hoặc thậm chí BayesianSignatureOptimizer với ngân sách lớn hơn và các số liệu mạnh mẽ hơn. Triển khai các pipeline đánh giá và biên dịch lại liên tục.
   • Mẹo thực tế: Bắt đầu với một tập hợp nhỏ các ví dụ được tuyển chọn thủ công. Khi hệ thống chạy, thu thập phản hồi của người dùng hoặc chú thích của chuyên gia để mở rộng tập dữ liệu đào tạo của bạn.

2. Độ phức tạp của quản lý trạng thái LangGraph:

   • Chế độ lỗi: GraphState trở nên quá phức tạp, dẫn đến các chuyển đổi trạng thái khó gỡ lỗi, điều kiện tranh chấp (nếu không được xử lý cẩn thận trong môi trường đồng thời) hoặc hành vi không mong muốn do trạng thái có thể thay đổi.
   • Cách khắc phục: Giữ GraphState càng tinh gọn càng tốt. Sử dụng Annotated[List[str], operator.add] để tích lũy danh sách nhằm ngăn chặn việc ghi đè ngẫu nhiên. Triển khai các quy ước đặt tên rõ ràng. Đối với trạng thái phức tạp, hãy cân nhắc sử dụng các mô hình Pydantic để thực thi và xác thực kiểu tốt hơn. Ghi nhật ký các thay đổi trạng thái tại mỗi node để dễ gỡ lỗi hơn.

3. Giới hạn tốc độ LLM và Chi phí vượt mức:

   • Chế độ lỗi: Thực thi LangGraph theo chu kỳ, đặc biệt với khả năng DSPy thực hiện nhiều lời gọi LLM trên mỗi module, có thể nhanh chóng đạt giới hạn tốc độ API hoặc phát sinh chi phí cao.
   • Cách khắc phục: Triển khai các cơ chế thử lại mạnh mẽ với thời gian chờ tăng dần theo cấp số nhân. Lưu trữ phản hồi LLM cho các đầu vào giống hệt nhau khi thích hợp. Giám sát việc sử dụng token và các số liệu chi phí. Đối với DSPy, hãy cân nhắc sử dụng các mô hình nhỏ hơn, được tinh chỉnh hoặc các mô hình cục bộ (ví dụ: thông qua Ollama) cho các bước ít quan trọng hơn trong quá trình phát triển và thử nghiệm. Bộ đếm iterations của LangGraph có thể giúp ngăn chặn các vòng lặp vô hạn.

4. Sự cố tích hợp công cụ (LangGraph):

   • Chế độ lỗi: Các công cụ (ví dụ: tìm kiếm, lời gọi API) lỗi âm thầm hoặc trả về dữ liệu không đúng định dạng, dẫn đến lỗi LLM tiếp theo hoặc hành vi tác nhân không chính xác.
   • Cách khắc phục: Đóng gói các lời gọi công cụ trong các khối try-except. Triển khai xác thực đầu vào cho các công cụ. Đảm bảo đầu ra của công cụ được định dạng nhất quán để LLM tiêu thụ. Sử dụng các node phân tích cú pháp chuyên dụng trong LangGraph để xử lý đầu ra công cụ thô trước khi đưa chúng vào các module DSPy.

5. Gỡ lỗi các hệ thống lai:

   • Chế độ lỗi: Xác định xem một vấn đề bắt nguồn từ việc điều phối của LangGraph hay biên dịch prompt của DSPy.
   • Cách khắc phục: Cô lập các thành phần. Kiểm tra các module DSPy độc lập với các đầu vào khác nhau để đảm bảo chúng tạo ra đầu ra mong đợi. Sử dụng phương pháp stream của LangGraph để quan sát các thay đổi trạng thái ở mỗi bước. Triển khai ghi nhật ký chi tiết trong cả module DSPy và các node LangGraph, bao gồm đầu vào/đầu ra của LLM và các sửa đổi trạng thái. dspy.settings.trace = True của DSPy có thể cung cấp những hiểu biết có giá trị về việc tạo prompt.

Các câu hỏi thường gặp

1. Khi nào tôi nên chọn LangGraph thay vì DSPy, hoặc ngược lại?

   • Chọn LangGraph khi tác nhân của bạn yêu cầu suy luận phức tạp, nhiều bước, luồng điều khiển động (ví dụ: phân nhánh có điều kiện, vòng lặp), quản lý trạng thái rõ ràng giữa các lượt, sự can thiệp của con người trong vòng lặp hoặc tích hợp với nhiều công cụ bên ngoài theo một trình tự cụ thể.
   • Chọn DSPy khi mối quan tâm chính của bạn là tối ưu hóa chất lượng và độ mạnh mẽ của các lời gọi LLM riêng lẻ hoặc các chuỗi lời gọi LLM ngắn, giảm nỗ lực kỹ thuật prompt thủ công và đạt được hiệu suất cao so với một số liệu cụ thể.
   • Đối với các tác nhân cấp doanh nghiệp, cách tiếp cận lai thường vượt trội, sử dụng DSPy cho các tương tác LLM mạnh mẽ trong một quy trình làm việc được điều phối bởi LangGraph.

2. DSPy có thể tối ưu hóa toàn bộ quy trình làm việc của LangGraph từ đầu đến cuối không?

   • Không trực tiếp. DSPy tối ưu hóa các prompt và trọng số cho các lời gọi LLM riêng lẻ hoặc các chuỗi lời gọi được định nghĩa là module. Nó không tối ưu hóa cấu trúc đồ thị hoặc logic có điều kiện của LangGraph. Tuy nhiên, bằng cách tối ưu hóa các tương tác LLM trong các node LangGraph, DSPy gián tiếp cải thiện hiệu suất tổng thể của quy trình làm việc.

3. Làm cách nào để xử lý việc quản lý phiên bản và triển khai các module DSPy đã biên dịch trong sản xuất?

   • Xử lý các module DSPy đã biên dịch (về cơ bản là các đối tượng Python với các trạng thái nội bộ được tối ưu hóa) giống như bất kỳ tạo phẩm mô hình nào khác. Lưu chúng bằng module.save("path/to/module.json") và tải chúng trong thời gian chạy. Tích hợp điều này vào pipeline CI/CD của bạn, đảm bảo rằng một phiên bản đã biên dịch cụ thể được triển khai với ứng dụng LangGraph của bạn. Triển khai thử nghiệm A/B cho các phiên bản đã biên dịch khác nhau.

4. Ý nghĩa về hiệu suất của việc sử dụng cả hai framework là gì?

   • Có một chi phí chung liên quan đến cả hai framework. LangGraph thêm chi phí chung cho việc quản lý trạng thái và duyệt đồ thị. DSPy thêm chi phí chung trong quá trình biên dịch (đây là chi phí một lần cho mỗi lần triển khai) và có thể trong quá trình suy luận nếu nó tạo ra các ví dụ few-shot phức tạp một cách nhanh chóng. Tuy nhiên, những cải thiện về hiệu suất từ các tương tác LLM được tối ưu hóa (ít thử lại hơn, đầu ra chính xác hơn) và việc điều phối rõ ràng hơn thường vượt trội hơn chi phí chung này, đặc biệt đối với các tác vụ phức tạp mà việc prompt thủ công sẽ dễ bị lỗi.

5. Điều này so sánh với các framework tác nhân khác như CrewAI hay AutoGen như thế nào?

   • CrewAI và AutoGen là các framework cấp cao hơn tập trung vào hợp tác đa tác nhân, thường trừu tượng hóa việc điều phối cơ bản. Chúng có thể sử dụng LangChain (và do đó có thể là LangGraph) hoặc các cơ chế khác bên trong. LangGraph cung cấp máy trạng thái nền tảng để xây dựng các hệ thống đa tác nhân như vậy, cung cấp khả năng kiểm soát chi tiết hơn. DSPy tập trung hoàn toàn vào lớp tương tác LLM. Bạn có thể sử dụng DSPy để tối ưu hóa các lời gọi LLM trong các tác nhân được định nghĩa trong CrewAI hoặc AutoGen, hoặc sử dụng LangGraph để xây dựng một hệ thống đa tác nhân tùy chỉnh cạnh tranh với khả năng của chúng nhưng với khả năng kiểm soát rõ ràng hơn.