📱 AI智能体框架怎么选？8大主流工具全面对比

最近很多开发朋友都在问：AI智能体开发到底该选哪个框架？ 确实，现在市面上的框架太多了。每个都号称自己是最好的，但真到要用的时候，才发现各有各的坑。 我花了两周时间，把8个主流框架都试了一遍。今天就来聊聊真实的体验感受。

---

📌 1. 先说说LangChain

这个框架大家应该都听过。

优点是资料多，社区活跃。你想查点什么，基本都能搜到。而且组件丰富，RAG、摘要、提取这些常用功能都有现成的。

但缺点也很明显。代码结构有点复杂，新手看文档容易晕。而且处理循环逻辑特别麻烦，经常要绕很大一圈才能实现简单功能。

适合场景：基础的RAG系统，简单的文本处理任务

推荐指数：⭐⭐⭐⭐（新手入门够用）

---

📌 2. LangGraph是个不错的补充

如果你觉得LangChain不够用，可以看看LangGraph。

它在LangChain基础上加了图结构，支持循环和条件分支。这意味着你可以做更复杂的状态管理，比如让AI先计划再执行，最后还要反思。

实际用下来，感觉比纯LangChain灵活很多。多智能体协作也能搞定。

适合场景：需要复杂推理的系统，多步骤任务

推荐指数：⭐⭐⭐⭐⭐（进阶必备）

---

📌 3. Google ADK适合企业级应用

Google出的东西，稳定性确实不错。

它提供了现成的智能体类型，比如顺序执行的和并行处理的。你不用从头搭建，直接调用就行。

但问题是自定义能力弱了点。如果业务需求比较特殊，可能会觉得束手束脚。

适合场景：企业级多智能体系统，对稳定性要求高的项目

推荐指数：⭐⭐⭐⭐（企业用户首选）

---

📌 4. CrewAI的角色设计很有意思

这个框架的思路很特别。

它不是单纯的技术堆砌，而是模拟人类团队协作。你要先定义角色，给每个智能体设定背景故事和目标，然后让它们像真实团队一样工作。

听起来有点玄，但用在业务流程自动化上效果意外的好。

适合场景：需要角色分工的业务流程

推荐指数：⭐⭐⭐⭐（有创意的产品）

---

📌 5. 其他框架一句话点评

Microsoft AutoGen：对话机制很灵活，适合做研究

LlamaIndex：数据检索能力强，RAG项目必备

Haystack：企业级搜索系统，检索质量高

MetaGPT：专门做代码生成，SOP驱动

SuperAGI：全生命周期管理，监控功能完善

Semantic Kernel：和微软技术栈集成好

Strands Agents：轻量级，部署简单

---

📌 6. 怎么选？给你几个实用建议

刚入门的朋友：先用LangChain，资料多，上手快

要做复杂系统：LangGraph + LangChain组合，灵活又强大

企业级部署：Google ADK或者SuperAGI，稳定性有保障

数据密集型应用：LlamaIndex做检索，配合其他框架做推理

快速原型：Strands Agents，轻量好用

---

📌 7. 选型决策矩阵

应用类型	推荐框架	关键考虑
简单RAG	LangChain	开发效率
复杂推理	LangGraph	状态管理
团队协作	CrewAI/Google ADK	角色设计
数据检索	LlamaIndex	检索质量
企业生产	Google ADK/SuperAGI	稳定性
快速原型	Strands Agents	灵活性

---

💭 写在最后

选择框架没有标准答案，关键看你的具体需求。

我建议先从小项目开始，用熟了再考虑换更复杂的。别一上来就追求最全的，那样反而容易踩坑。

你觉得哪个框架最适合你的项目？欢迎在评论区分享你的使用体验！

---

🔍 Q&A时间

Q: 这些框架学习成本高吗？ A: LangChain相对简单，一两周就能上手。LangGraph需要更多时间，但功能确实强大。

Q: 可以同时用多个框架吗？ A: 当然可以。很多项目都是组合使用，比如LlamaIndex做检索，LangGraph做推理。

Q: 哪个框架最适合初学者？ A: 推荐从LangChain开始，社区支持好，遇到问题容易找到解决方案。

---

📣 互动话题

你现在在用哪个AI智能体框架？遇到过什么坑？或者有什么好的使用技巧？

欢迎在评论区分享，我们一起交流学习！

觉得有用的话，记得点赞收藏，转发给需要的朋友！

---

Appendix C - Quick overview of Agentic Frameworks

附录C - 智能体框架快速概览

LangChain

LangChain

LangChain is a framework for developing applications powered by LLMs. Its core strength lies in its LangChain Expression Language (LCEL), which allows you to "pipe" components together into a chain. This creates a clear, linear sequence where the output of one step becomes the input for the next. It's built for workflows that are Directed Acyclic Graphs (DAGs), meaning the process flows in one direction without loops. LangChain是一个用于开发由LLM驱动的应用程序的框架。其核心优势在于LangChain表达式语言（LCEL），它允许您将组件"管道化"连接成一个链。这创建了一个清晰的线性序列，其中一个步骤的输出成为下一个步骤的输入。它专为有向无环图（DAG）的工作流程而构建，意味着流程单向流动且无循环。

Use it for: 使用场景：

• Simple RAG: Retrieve a document, create a prompt, get an answer from an LLM.
• 简单RAG：检索文档、创建提示词、从LLM获取答案。
• Summarization: Take user text, feed it to a summarization prompt, and return the output.
• 摘要：获取用户文本，将其输入摘要提示词，并返回输出。
• Extraction: Extract structured data (like JSON) from a block of text.
• 提取：从文本块中提取结构化数据（如JSON）。

Python

# A simple LCEL chain conceptually
# (This is not runnable code, just illustrates the flow)
chain = prompt | model | output_parse

LangGraph

LangGraph

LangGraph is a library built on top of LangChain to handle more advanced agentic systems. It allows you to define your workflow as a graph with nodes (functions or LCEL chains) and edges (conditional logic). Its main advantage is the ability to create cycles, allowing the application to loop, retry, or call tools in a flexible order until a task is complete. It explicitly manages the application state, which is passed between nodes and updated throughout the process. LangGraph是构建在LangChain之上的库，用于处理更高级的智能体系统。它允许您将工作流程定义为具有节点（函数或LCEL链）和边（条件逻辑）的图。其主要优势是能够创建循环，允许应用程序循环、重试或以灵活的顺序调用工具，直到任务完成。它显式管理应用程序状态，该状态在节点之间传递并在整个过程中更新。

Use it for: 使用场景：

• Multi-agent Systems: A supervisor agent routes tasks to specialized worker agents, potentially looping until the goal is met.
• 多智能体系统：监督智能体将任务路由到专门的工人智能体，可能循环直到目标达成。
• Plan-and-Execute Agents: An agent creates a plan, executes a step, and then loops back to update the plan based on the result.
• 计划-执行智能体：智能体创建计划，执行步骤，然后循环回根据结果更新计划。
• Human-in-the-Loop: The graph can wait for human input before deciding which node to go to next.
• 人在回路：图可以等待人工输入，然后再决定下一步转到哪个节点。

Feature	LangChain	LangGraph
Core Abstraction	Chain (using LCEL)	Graph of Nodes
核心抽象	链（使用LCEL）	节点图
Workflow Type	Linear (Directed Acyclic Graph)	Cyclical (Graphs with loops)
工作流程类型	线性（有向无环图）	循环（带循环的图）
State Management	Generally stateless per run	Explicit and persistent state object
状态管理	通常每次运行无状态	显式且持久的状态对象
Primary Use	Simple, predictable sequences	Complex, dynamic, stateful agents
主要用途	简单、可预测的序列	复杂、动态、有状态的智能体

Which One Should You Use?

应该选择哪一个？

• Choose LangChain when your application has a clear, predictable, and linear flow of steps. If you can define the process from A to B to C without needing to loop back, LangChain with LCEL is the perfect tool.
• 当您的应用程序具有清晰、可预测且线性的步骤流程时，选择LangChain。如果您可以定义从A到B到C的过程而无需循环返回，那么使用LCEL的LangChain是完美的工具。
• Choose LangGraph when you need your application to reason, plan, or operate in a loop. If your agent needs to use tools, reflect on the results, and potentially try again with a different approach, you need the cyclical and stateful nature of LangGraph.
• 当您需要应用程序进行推理、规划或循环操作时，选择LangGraph。如果您的智能体需要使用工具、反思结果并可能尝试不同的方法，您需要LangGraph的循环和有状态特性。

# Graph state
class State(TypedDict):
    topic: str
    joke: str
    story: str
    poem: str
    combined_output: str

# Nodes
def call_llm_1(state: State):
    """First LLM call to generate initial joke"""
    msg = llm.invoke(f"Write a joke about {state['topic']}")
    return {"joke": msg.content}

def call_llm_2(state: State):
    """Second LLM call to generate story"""
    msg = llm.invoke(f"Write a story about {state['topic']}")
    return {"story": msg.content}

def call_llm_3(state: State):
    """Third LLM call to generate poem"""
    msg = llm.invoke(f"Write a poem about {state['topic']}")
    return {"poem": msg.content}

def aggregator(state: State):
    """Combine the joke and story into a single output"""
    combined = f"Here's a story, joke, and poem about {state['topic']}!\n\n"
    combined += f"STORY:\n{state['story']}\n\n"
    combined += f"JOKE:\n{state['joke']}\n\n"
    combined += f"POEM:\n{state['poem']}"
    return {"combined_output": combined}

# Build workflow
parallel_builder = StateGraph(State)

# Add nodes
parallel_builder.add_node("call_llm_1", call_llm_1)
parallel_builder.add_node("call_llm_2", call_llm_2)
parallel_builder.add_node("call_llm_3", call_llm_3)
parallel_builder.add_node("aggregator", aggregator)

# Add edges to connect nodes
parallel_builder.add_edge(START, "call_llm_1")
parallel_builder.add_edge(START, "call_llm_2")
parallel_builder.add_edge(START, "call_llm_3")
parallel_builder.add_edge("call_llm_1", "aggregator")
parallel_builder.add_edge("call_llm_2", "aggregator")
parallel_builder.add_edge("call_llm_3", "aggregator")
parallel_builder.add_edge("aggregator", END)

parallel_workflow = parallel_builder.compile()

# Show workflow
display(Image(parallel_workflow.get_graph().draw_mermaid_png()))

# Invoke
state = parallel_workflow.invoke({"topic": "cats"})
print(state["combined_output"])

This code defines and runs a LangGraph workflow that operates in parallel. Its main purpose is to simultaneously generate a joke, a story, and a poem about a given topic and then combine them into a single, formatted text output. 此代码定义并运行一个并行操作的LangGraph工作流程。其主要目的是同时生成关于给定主题的笑话、故事和诗歌，然后将它们组合成一个格式化的文本输出。

Google's ADK

Google的ADK

Google's Agent Development Kit, or ADK, provides a high-level, structured framework for building and deploying applications composed of multiple, interacting AI agents. It contrasts with LangChain and LangGraph by offering a more opinionated and production-oriented system for orchestrating agent collaboration, rather than providing the fundamental building blocks for an agent's internal logic. Google的智能体开发套件（ADK）提供了一个高级、结构化的框架，用于构建和部署由多个交互AI智能体组成的应用程序。它与LangChain和LangGraph形成对比，通过提供更偏向意见和生产导向的系统来编排智能体协作，而不是提供智能体内部逻辑的基本构建块。

LangChain operates at the most foundational level, offering the components and standardized interfaces to create sequences of operations, such as calling a model and parsing its output. LangGraph extends this by introducing a more flexible and powerful control flow; it treats an agent's workflow as a stateful graph. Using LangGraph, a developer explicitly defines nodes, which are functions or tools, and edges, which dictate the path of execution. This graph structure allows for complex, cyclical reasoning where the system can loop, retry tasks, and make decisions based on an explicitly managed state object that is passed between nodes. It gives the developer fine-grained control over a single agent's thought process or the ability to construct a multi-agent system from first principles. LangChain在最基础的层面运行，提供组件和标准化接口来创建操作序列，例如调用模型和解析其输出。LangGraph通过引入更灵活和强大的控制流来扩展这一点；它将智能体的工作流程视为有状态图。使用LangGraph，开发人员显式定义节点（函数或工具）和边（决定执行路径）。这种图结构允许复杂的循环推理，系统可以循环、重试任务，并基于在节点之间传递的显式管理状态对象做出决策。它使开发人员能够对单个智能体的思维过程进行细粒度控制，或者从基本原理构建多智能体系统。

Google's ADK abstracts away much of this low-level graph construction. Instead of asking the developer to define every node and edge, it provides pre-built architectural patterns for multi-agent interaction. For instance, ADK has built-in agent types like SequentialAgent or ParallelAgent, which manage the flow of control between different agents automatically. It is architected around the concept of a "team" of agents, often with a primary agent delegating tasks to specialized sub-agents. State and session management are handled more implicitly by the framework, providing a more cohesive but less granular approach than LangGraph's explicit state passing. Therefore, while LangGraph gives you the detailed tools to design the intricate wiring of a single robot or a team, Google's ADK gives you a factory assembly line designed to build and manage a fleet of robots that already know how to work together. Google的ADK抽象了大部分低级图构建。它不要求开发人员定义每个节点和边，而是提供预构建的多智能体交互架构模式。例如，ADK具有内置的智能体类型，如SequentialAgent或ParallelAgent，它们自动管理不同智能体之间的控制流。它围绕智能体"团队"的概念构建，通常有一个主智能体将任务委托给专门的子智能体。状态和会话管理由框架更隐式地处理，提供比LangGraph显式状态传递更统一但粒度更小的方法。因此，虽然LangGraph为您提供了设计单个机器人或团队复杂布线的详细工具，但Google的ADK为您提供了一个工厂装配线，旨在构建和管理已经知道如何协同工作的机器人舰队。

from google.adk.agents import LlmAgent
from google.adk.tools import google_Search

dice_agent = LlmAgent(
   model="gemini-2.0-flash-exp", 
   name="question_answer_agent",
   description="A helpful assistant agent that can answer questions.",
   instruction="""Respond to the query using google search""",
   tools=[google_search],
)

This code creates a search-augmented agent. When this agent receives a question, it will not just rely on its pre-existing knowledge. Instead, following its instructions, it will use the Google Search tool to find relevant, real-time information from the web and then use that information to construct its answer. 此代码创建一个搜索增强的智能体。当此智能体收到问题时，它不会仅仅依赖其预先存在的知识。相反，按照其指令，它将使用Google搜索工具从网络查找相关的实时信息，然后使用该信息构建其答案。

Crew.AI Crew.AI

CrewAI offers an orchestration framework for building multi-agent systems by focusing on collaborative roles and structured processes. It operates at a higher level of abstraction than foundational toolkits, providing a conceptual model that mirrors a human team. Instead of defining the granular flow of logic as a graph, the developer defines the actors and their assignments, and CrewAI manages their interaction. CrewAI提供了一个编排框架，通过专注于协作角色和结构化流程来构建多智能体系统。它在比基础工具包更高的抽象级别上运行，提供了一个反映人类团队的概念模型。开发人员不是将逻辑的细粒度流定义为图，而是定义参与者及其分配，CrewAI管理它们的交互。

The core components of this framework are Agents, Tasks, and the Crew. An Agent is defined not just by its function but by a persona, including a specific role, a goal, and a backstory, which guides its behavior and communication style. A Task is a discrete unit of work with a clear description and expected output, assigned to a specific Agent. The Crew is the cohesive unit that contains the Agents and the list of Tasks, and it executes a predefined Process. This process dictates the workflow, which is typically either sequential, where the output of one task becomes the input for the next in line, or hierarchical, where a manager-like agent delegates tasks and coordinates the workflow among other agents. 该框架的核心组件是智能体、任务和团队。智能体不仅由其功能定义，还由其角色定义，包括特定角色、目标和背景故事，这指导其行为和沟通风格。任务是一个离散的工作单元，具有清晰的描述和预期输出，分配给特定的智能体。团队是包含智能体和任务列表的凝聚力单元，它执行预定义的过程。此过程决定工作流程，通常是顺序的（一个任务的输出成为下一个任务的输入）或分层的（类似管理器的智能体委托任务并协调其他智能体之间的工作流程）。

When compared to other frameworks, CrewAI occupies a distinct position. It moves away from the low-level, explicit state management and control flow of LangGraph, where a developer wires together every node and conditional edge. Instead of building a state machine, the developer designs a team charter. While Googlés ADK provides a comprehensive, production-oriented platform for the entire agent lifecycle, CrewAI concentrates specifically on the logic of agent collaboration and for simulating a team of specialists 与其他框架相比，CrewAI占据了一个独特的位置。它远离了LangGraph的低级、显式状态管理和控制流，在LangGraph中开发人员将每个节点和条件边连接在一起。开发人员不是构建状态机，而是设计团队章程。虽然Google的ADK为整个智能体生命周期提供了一个全面的、生产导向的平台，但CrewAI专门专注于智能体协作的逻辑和模拟专家团队。

@crew
def crew(self) -> Crew:
    """Creates the research crew"""
    return Crew(
        agents=self.agents,
        tasks=self.tasks,
        process=Process.sequential,
        verbose=True,
    )

This code sets up a sequential workflow for a team of AI agents, where they tackle a list of tasks in a specific order, with detailed logging enabled to monitor their progress. 此代码为AI智能体团队设置了一个顺序工作流程，他们按特定顺序处理任务列表，并启用详细日志记录以监控其进度。

Other agent development framework 其他智能体开发框架

Microsoft AutoGen: AutoGen is a framework centered on orchestrating multiple agents that solve tasks through conversation. Its architecture enables agents with distinct capabilities to interact, allowing for complex problem decomposition and collaborative resolution. The primary advantage of AutoGen is its flexible, conversation-driven approach that supports dynamic and complex multi-agent interactions. However, this conversational paradigm can lead to less predictable execution paths and may require sophisticated prompt engineering to ensure tasks converge efficiently. Microsoft AutoGen：AutoGen是一个以编排多个智能体通过对话解决任务为中心的框架。其架构使具有不同能力的智能体能够交互，允许复杂的问题分解和协作解决。AutoGen的主要优势是其灵活的、对话驱动的方法，支持动态和复杂的多智能体交互。然而，这种对话范式可能导致不太可预测的执行路径，并且可能需要复杂的提示工程来确保任务有效收敛。

LlamaIndex: LlamaIndex is fundamentally a data framework designed to connect large language models with external and private data sources. It excels at creating sophisticated data ingestion and retrieval pipelines, which are essential for building knowledgeable agents that can perform RAG. While its data indexing and querying capabilities are exceptionally powerful for creating context-aware agents, its native tools for complex agentic control flow and multi-agent orchestration are less developed compared to agent-first frameworks. LlamaIndex is optimal when the core technical challenge is data retrieval and synthesis. LlamaIndex：LlamaIndex本质上是一个数据框架，旨在将大型语言模型与外部和私有数据源连接。它擅长创建复杂的数据摄取和检索管道，这对于构建能够执行RAG的知识型智能体至关重要。虽然其数据索引和查询能力对于创建上下文感知智能体非常强大，但其用于复杂智能体控制流和多智能体编排的本机工具与智能体优先框架相比不太发达。当核心技术挑战是数据检索和合成时，LlamaIndex是最佳选择。

Haystack: Haystack is an open-source framework engineered for building scalable and production-ready search systems powered by language models. Its architecture is composed of modular, interoperable nodes that form pipelines for document retrieval, question answering, and summarization. The main strength of Haystack is its focus on performance and scalability for large-scale information retrieval tasks, making it suitable for enterprise-grade applications. A potential trade-off is that its design, optimized for search pipelines, can be more rigid for implementing highly dynamic and creative agentic behaviors. Haystack：Haystack是一个开源框架，专为构建由语言模型驱动的可扩展和生产就绪的搜索系统而设计。其架构由模块化、可互操作的节点组成，这些节点形成用于文档检索、问答和摘要的管道。Haystack的主要优势是其专注于大规模信息检索任务的性能和可扩展性，使其适用于企业级应用程序。一个潜在的权衡是，其针对搜索管道优化的设计对于实现高度动态和创造性的智能体行为可能更刚性。

MetaGPT: MetaGPT implements a multi-agent system by assigning roles and tasks based on a predefined set of Standard Operating Procedures (SOPs). This framework structures agent collaboration to mimic a software development company, with agents taking on roles like product managers or engineers to complete complex tasks. This SOP-driven approach results in highly structured and coherent outputs, which is a significant advantage for specialized domains like code generation. The framework's primary limitation is its high degree of specialization, making it less adaptable for general-purpose agentic tasks outside of its core design. MetaGPT：MetaGPT通过基于预定义的标准操作程序（SOP）集分配角色和任务来实现多智能体系统。此框架构建智能体协作以模拟软件开发公司，智能体承担产品经理或工程师等角色来完成复杂任务。这种SOP驱动的方法产生高度结构化和连贯的输出，这对于代码生成等专业领域是一个显著优势。该框架的主要限制是其高度专业化，使其在其核心设计之外的一般用途智能体任务中适应性较差。

SuperAGI: SuperAGI is an open-source framework designed to provide a complete lifecycle management system for autonomous agents. It includes features for agent provisioning, monitoring, and a graphical interface, aiming to enhance the reliability of agent execution. The key benefit is its focus on production-readiness, with built-in mechanisms to handle common failure modes like looping and to provide observability into agent performance. A potential drawback is that its comprehensive platform approach can introduce more complexity and overhead than a more lightweight, library-based framework. SuperAGI：SuperAGI是一个开源框架，旨在为自主智能体提供完整的生命周期管理系统。它包括智能体配置、监控和图形界面等功能，旨在提高智能体执行的可靠性。关键优势是其专注于生产就绪性，具有内置机制来处理常见故障模式（如循环）并提供对智能体性能的可观察性。一个潜在的缺点是其全面的平台方法可能比更轻量级的基于库的框架引入更多复杂性和开销。

Semantic Kernel: Developed by Microsoft, Semantic Kernel is an SDK that integrates large language models with conventional programming code through a system of "plugins" and "planners." It allows an LLM to invoke native functions and orchestrate workflows, effectively treating the model as a reasoning engine within a larger software application. Its primary strength is its seamless integration with existing enterprise codebases, particularly in .NET and Python environments. The conceptual overhead of its plugin and planner architecture can present a steeper learning curve compared to more straightforward agent frameworks. Semantic Kernel：由Microsoft开发，Semantic Kernel是一个SDK，通过"插件"和"规划器"系统将大型语言模型与传统编程代码集成。它允许LLM调用本机函数并编排工作流程，有效地将模型视为更大软件应用程序中的推理引擎。其主要优势是其与现有企业代码库的无缝集成，特别是在.NET和Python环境中。其插件和规划器架构的概念开销可能比更直接的智能体框架带来更陡峭的学习曲线。

Strands Agents: An AWS lightweight and flexible SDK that uses a model-driven approach for building and running AI agents. It is designed to be simple and scalable, supporting everything from basic conversational assistants to complex multi-agent autonomous systems. The framework is model-agnostic, offering broad support for various LLM providers, and includes native integration with the MCP for easy access to external tools. Its core advantage is its simplicity and flexibility, with a customizable agent loop that is easy to get started with. A potential trade-off is that its lightweight design means developers may need to build out more of the surrounding operational infrastructure, such as advanced monitoring or lifecycle management systems, which more comprehensive frameworks might provide out-of-the-box. Strands Agents：一个AWS轻量级灵活SDK，使用模型驱动方法构建和运行AI智能体。它设计简单且可扩展，支持从基本对话助手到复杂多智能体自治系统的所有内容。该框架是模型无关的，为各种LLM提供商提供广泛支持，并包括与MCP的本机集成以便轻松访问外部工具。其核心优势是简单性和灵活性，具有可自定义的智能体循环，易于入门。一个潜在的权衡是，其轻量级设计意味着开发人员可能需要构建更多周围的操作基础设施，例如高级监控或生命周期管理系统，而更全面的框架可能开箱即用。

Conclusion 结论

The landscape of agentic frameworks offers a diverse spectrum of tools, from low-level libraries for defining agent logic to high-level platforms for orchestrating multi-agent collaboration. At the foundational level, LangChain enables simple, linear workflows, while LangGraph introduces stateful, cyclical graphs for more complex reasoning. Higher-level frameworks like CrewAI and Google's ADK shift the focus to orchestrating teams of agents with predefined roles, while others like LlamaIndex specialize in data-intensive applications. This variety presents developers with a core trade-off between the granular control of graph-based systems and the streamlined development of more opinionated platforms. Consequently, selecting the right framework hinges on whether the application requires a simple sequence, a dynamic reasoning loop, or a managed team of specialists. Ultimately, this evolving ecosystem empowers developers to build increasingly sophisticated AI systems by choosing the precise level of abstraction their project demands. 智能体框架的格局提供了多样化的工具，从定义智能体逻辑的低级库到编排多智能体协作的高级平台。在基础层面，LangChain支持简单、线性的工作流程，而LangGraph引入了有状态的循环图以进行更复杂的推理。更高级的框架如CrewAI和Google的ADK将重点转移到编排具有预定义角色的智能体团队，而其他如LlamaIndex则专注于数据密集型应用程序。这种多样性为开发人员提供了基于图系统的细粒度控制与更偏向意见平台的简化开发之间的核心权衡。因此，选择正确的框架取决于应用程序是需要简单序列、动态推理循环还是受管理的专家团队。最终，这个不断发展的生态系统使开发人员能够通过选择项目所需的精确抽象级别来构建日益复杂的AI系统。

References 参考文献

1. LangChain, www.langchain.com/
2. LangChain，www.langchain.com/
3. LangGraph, www.langchain.com/langgraph
4. LangGraph，www.langchain.com/langgraph
5. Google's ADK, google.github.io/adk-docs/
6. Google的ADK，google.github.io/adk-docs/
7. Crew.AI, docs.crewai.com/en/introduc…
8. Crew.AI，docs.crewai.com/en/introduc…