+| Chapter | Topic | What you build | Capability |
+| Chapter 1 | ChatModel and Message | Understand the Component abstraction, implement a single-turn chat | Basic chat |
+| Chapter 2 | Agent and Runner | Introduce the execution abstraction, implement multi-turn chat | Session management |
+| Chapter 3 | Memory and Session | Persist chat history and support session recovery | Persistence |
+| Chapter 4 | Tool and filesystem | Add file-access capability and read source code | Tool calling |
+| Chapter 5 | Middleware | Middleware mechanism to handle cross-cutting concerns | Extensibility |
+| Chapter 6 | Callback | Callback mechanism to observe Agent execution | Observability |
+| Chapter 7 | Interrupt and Resume | Interrupt/resume for long-running tasks | Reliability |
+| Chapter 8 | Graph and Tool | Use Graph to orchestrate complex workflows | Advanced orchestration |
+| Chapter 9 | A2UI | Integration from Agent to UI | Production readiness |
+
+
+**Why this design?**
+
+Each chapter adds one core capability on top of the previous one, so you can:
+
+1. **Understand each component’s role**: Introduce features gradually instead of all at once
+2. **See how the architecture evolves**: From simple to complex, and why each abstraction exists
+3. **Build practical skills**: Every chapter includes runnable code for hands-on practice
+
+---
+
+Goal of this chapter: understand Eino’s Component abstraction, call a ChatModel with minimal code (with streaming output), and learn the basic usage of `schema.Message`.
+
+## Code Location
+
+- Entry code: [cmd/ch01/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/cmd/ch01/main.go)
+
+## Why a Component Interface?
+
+Eino defines a set of Component interfaces (`ChatModel`, `Tool`, `Retriever`, `Loader`, etc.). Each interface describes a replaceable capability:
+
+```go
+type BaseChatModel interface {
+ Generate(ctx context.Context, input []*schema.Message, opts ...Option) (*schema.Message, error)
+ Stream(ctx context.Context, input []*schema.Message, opts ...Option) (
+ *schema.StreamReader[*schema.Message], error)
+}
+```
+
+**Benefits of interfaces:**
+
+1. **Replaceable implementations**: `eino-ext` provides OpenAI, Ark, Claude, Ollama, and more. Business code depends only on the interface; switching models only changes construction.
+2. **Composable orchestration**: Agent/Graph/Chain depend only on Component interfaces, not implementations. Replace OpenAI with Ark without changing orchestration code.
+3. **Mock-friendly testing**: Interfaces are easy to mock; unit tests do not need real model calls.
+
+This chapter focuses only on `ChatModel`. Later chapters will introduce `Tool`, `Retriever`, and more.
+
+## schema.Message: The Basic Unit of a Conversation
+
+`Message` is the basic structure for conversation data in Eino:
+
+```go
+type Message struct {
+ Role RoleType // system / user / assistant / tool
+ Content string // text content
+ ToolCalls []ToolCall // only assistant messages may have this
+ // ...
+}
+```
+
+Common constructors:
+
+```go
+schema.SystemMessage("You are a helpful assistant.")
+schema.UserMessage("What is the weather today?")
+schema.AssistantMessage("I don't know.", nil) // the second argument is ToolCalls
+schema.ToolMessage("tool result", "call_id")
+```
+
+**Role semantics:**
+
+- `system`: system instruction, usually first in the message list
+- `user`: user input
+- `assistant`: model response
+- `tool`: tool execution result (used in later chapters)
+
+## Prerequisites
+
+### Get the Code
+
+```bash
+git clone https://github.com/cloudwego/eino-examples.git
+cd eino-examples/quickstart/chatwitheino
+```
+
+- Go version: Go 1.21+ (see `go.mod`)
+- A callable ChatModel (default: OpenAI; Ark is also supported)
+
+### Option A: OpenAI (Default)
+
+```bash
+export OPENAI_API_KEY="..."
+export OPENAI_MODEL="gpt-4.1-mini" # OpenAI model (2025), or gpt-4o / gpt-4o-mini, etc.
+# Optional:
+# OPENAI_BASE_URL (proxy or compatible service)
+# OPENAI_BY_AZURE=true (use Azure OpenAI)
+```
+
+### Option B: Ark
+
+```bash
+export MODEL_TYPE="ark"
+export ARK_API_KEY="..."
+export ARK_MODEL="..."
+# Optional: ARK_BASE_URL
+```
+
+## Run
+
+From `examples/quickstart/chatwitheino`:
+
+```bash
+go run ./cmd/ch01 -- "In one sentence, what problem does Eino’s Component design solve?"
+```
+
+Example output (streaming print):
+
+```
+[assistant] Eino’s Component design defines unified interfaces...
+```
+
+## What the Entry Code Does
+
+In execution order:
+
+1. **Create the ChatModel**: select OpenAI or Ark based on the `MODEL_TYPE` environment variable
+2. **Build input messages**: `SystemMessage(instruction)` + `UserMessage(query)`
+3. **Call Stream**: all ChatModel implementations must support `Stream()`, which returns `StreamReader[*Message]`
+4. **Print output**: iterate over the `StreamReader` and print assistant chunks
+
+Key snippet (note: this is a simplified excerpt and not directly runnable; see the full code in [cmd/ch01/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/cmd/ch01/main.go)):
+
+```go
+// Build input
+messages := []*schema.Message{
+ schema.SystemMessage(instruction),
+ schema.UserMessage(query),
+}
+
+// Call Stream (all ChatModels must implement this)
+stream, err := cm.Stream(ctx, messages)
+if err != nil {
+ log.Fatal(err)
+}
+defer stream.Close()
+
+for {
+ chunk, err := stream.Recv()
+ if errors.Is(err, io.EOF) {
+ break
+ }
+ if err != nil {
+ log.Fatal(err)
+ }
+ fmt.Print(chunk.Content)
+}
+```
+
+## Summary
+
+- **Component interfaces**: define replaceable, composable, and testable capability boundaries
+- **Message**: the basic unit of conversation data, with semantics defined by role
+- **ChatModel**: the fundamental Component, providing `Generate` and `Stream`
+- **Implementation choice**: switch between OpenAI/Ark via env/config without changing business code
diff --git a/content/en/docs/eino/quick_start/chapter_02_chatmodelagent_runner_agentevent.md b/content/en/docs/eino/quick_start/chapter_02_chatmodelagent_runner_agentevent.md
new file mode 100644
index 0000000000..589f34575c
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_02_chatmodelagent_runner_agentevent.md
@@ -0,0 +1,309 @@
+---
+Description: ""
+date: "2026-03-12"
+lastmod: ""
+tags: []
+title: "Chapter 2: ChatModelAgent, Runner, and AgentEvent (Console Multi-Turn)"
+weight: 2
+---
+
+Goal of this chapter: introduce the ADK execution abstraction (Agent + Runner) and implement a multi-turn conversation in a console program.
+
+## Code Location
+
+- Entry code: [cmd/ch02/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/cmd/ch02/main.go)
+
+## Prerequisites
+
+Same as Chapter 1: configure a working ChatModel (OpenAI or Ark).
+
+## Run
+
+From `examples/quickstart/chatwitheino`:
+
+```bash
+go run ./cmd/ch02
+```
+
+After you see the prompt, type questions (empty line to exit):
+
+```
+you> Hi — what is an Agent in Eino?
+...
+you> Summarize it in one sentence
+...
+```
+
+## Key Concepts
+
+### From Component to Agent
+
+In Chapter 1 we learned **Components**: replaceable, composable capability units in Eino:
+
+- `ChatModel`: call an LLM
+- `Tool`: execute specific tasks
+- `Retriever`: retrieve information
+- `Loader`: load data
+
+**Relationship between Components and Agents:**
+
+- **A Component is not a complete AI app**: it is just a capability unit that must be organized/orchestrated/executed
+- **An Agent is a complete AI app**: it encapsulates business logic and can run directly
+- **Agents use Components internally**: the most fundamental are `ChatModel` (conversation) and `Tool` (actions)
+
+**Why do we need Agents?**
+
+If you only had Components, you would need to build a lot yourself:
+
+- manage conversation history
+- orchestrate call flow (when to call the model, when to call tools)
+- handle streaming output
+- implement interrupt/resume
+- ...
+
+**What does an Agent provide?**
+
+- **A complete runtime framework**: `Runner` uniformly manages execution
+- **A standard event-stream output**: `Run() -> AsyncIterator[*AgentEvent]`, enabling streaming, interrupt, and resume
+- **Extensibility**: add tools, middleware, interrupts, etc.
+- **Out of the box**: once created, an Agent can run without caring about internals
+
+**This chapter’s example:**
+
+`ChatModelAgent` is the simplest Agent. Internally it only uses `ChatModel`, but it already provides the full Agent runtime shape. Later chapters add `Tool` and more capabilities.
+
+### Agent Interface
+
+`Agent` is the core interface in ADK and defines the basic behavior of an agent:
+
+```go
+type Agent interface {
+ Name(ctx context.Context) string
+ Description(ctx context.Context) string
+
+ // Run executes the Agent and returns an event stream.
+ Run(ctx context.Context, input *AgentInput, options ...AgentRunOption) *AsyncIterator[*AgentEvent]
+}
+```
+
+**Responsibilities:**
+
+- `Name()` / `Description()`: identify the Agent
+- `Run()`: execute the Agent, take input messages, and return an event stream
+
+**Design ideas:**
+
+- **Unified abstraction**: all Agents (ChatModelAgent, WorkflowAgent, SupervisorAgent, etc.) implement this interface
+- **Event-driven**: the execution is emitted as `AsyncIterator[*AgentEvent]` to support streaming responses
+- **Extensibility**: adding tools/middleware/interrupts later does not change the interface
+
+### ChatModelAgent
+
+`ChatModelAgent` is an implementation of the Agent interface built on a ChatModel:
+
+```go
+agent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
+ Name: "Ch02ChatModelAgent",
+ Description: "A minimal ChatModelAgent with in-memory multi-turn history.",
+ Instruction: instruction,
+ Model: cm,
+})
+```
+
+**ChatModel vs ChatModelAgent: what’s the difference?**
+
+
> 💡
-> Skill Middleware 仅提供了如上图所示的加载 SKILL.md 能力，如果 Skill 本身需要读取文件、执行脚本等，需要用户另外为 agent 配置相关能力。
+> Skill Middleware 仅提供了如上图所示的加载 SKILL.md 能力，如果 Skill 需要 agent 具备读取文件、执行脚本等能力，需要用户另外为 agent 配置。
diff --git a/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_ToolReduction.md b/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_ToolReduction.md
index 309c9ab004..fae42a03c9 100644
--- a/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_ToolReduction.md
+++ b/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_ToolReduction.md
@@ -1,6 +1,6 @@
---
Description: ""
-date: "2026-03-09"
+date: "2026-03-12"
lastmod: ""
tags: []
title: Reduction
diff --git a/content/zh/docs/eino/core_modules/eino_adk/adk_agent_callback.md b/content/zh/docs/eino/core_modules/eino_adk/adk_agent_callback.md
index 1088b50d6f..90b1d677e6 100644
--- a/content/zh/docs/eino/core_modules/eino_adk/adk_agent_callback.md
+++ b/content/zh/docs/eino/core_modules/eino_adk/adk_agent_callback.md
@@ -1,6 +1,6 @@
---
Description: ""
-date: "2026-03-10"
+date: "2026-03-12"
lastmod: ""
tags: []
title: Agent Callback
diff --git a/content/zh/docs/eino/ecosystem_integration/_index.md b/content/zh/docs/eino/ecosystem_integration/_index.md
index ca3673709a..1dcb09ae79 100644
--- a/content/zh/docs/eino/ecosystem_integration/_index.md
+++ b/content/zh/docs/eino/ecosystem_integration/_index.md
@@ -11,9 +11,9 @@ weight: 6
### ChatModel
-- openai: [ChatModel - OpenAI](https://github.com/cloudwego/eino-ext/blob/main/components/model/openai/README_zh.md)
-- ark: [ChatModel - ARK](https://github.com/cloudwego/eino-ext/blob/main/components/model/ark/README_zh.md)
-- ollama: [ChatModel - Ollama](https://github.com/cloudwego/eino-ext/blob/main/components/model/ollama/README_zh.md)
+- openai: [OpenAI](/zh/docs/eino/ecosystem_integration/chat_model/agentic_model_openai)
+- ark: [ARK](/zh/docs/eino/ecosystem_integration/chat_model/agentic_model_ark)
+- 更多组件请见：[ChatModel 组件列表](/zh/docs/eino/ecosystem_integration/chat_model)
### Document
diff --git a/content/zh/docs/eino/quick_start/_index.md b/content/zh/docs/eino/quick_start/_index.md
index 78ae777d85..b2f99f8978 100644
--- a/content/zh/docs/eino/quick_start/_index.md
+++ b/content/zh/docs/eino/quick_start/_index.md
@@ -19,7 +19,7 @@ Eino 提供了多种面向 AI 应用开发场景的组件抽象，同时也提
AI 的应用中，最基础的场景就是 prompt + chat model 的场景，这也是互联网上各类 AI 应用平台提供的最重要的功能。你可以定义 `System Prompt` 来约束大模型的回答逻辑，比如 “你在扮演一个 XXX 角色” 等等。这个示例中，你可以用 Eino 的 `PromptTemplate` 组件 和 `ChatModel` 组件来构建一个角色扮演应用。
-- [实现一个最简 LLM 应用-ChatModel](/zh/docs/eino/quick_start/simple_llm_application)
+- [第一章：ChatModel 与 Message（Console）](/zh/docs/eino/quick_start/chapter_01_chatmodel_and_message)
### 示例：创建一个 Agent
@@ -31,7 +31,7 @@ AI 的应用中，最基础的场景就是 prompt + chat model 的场景，这
在这个示例中，我们将使用 react agent 来构建一个可以和现实世界交互的智能体。
-- [Agent-让大模型拥有双手](/zh/docs/eino/quick_start/agent_llm_with_tools)
+- [第四章：Tool 与文件系统访问](/zh/docs/eino/quick_start/chapter_04_tool_and_filesystem)
## 下一步探索
diff --git a/content/zh/docs/eino/quick_start/agent_llm_with_tools.md b/content/zh/docs/eino/quick_start/agent_llm_with_tools.md
deleted file mode 100644
index 2694ed87a9..0000000000
--- a/content/zh/docs/eino/quick_start/agent_llm_with_tools.md
+++ /dev/null
@@ -1,300 +0,0 @@
----
-Description: ""
-date: "2026-03-03"
-lastmod: ""
-tags: []
-title: Agent-让大模型拥有双手
-weight: 2
----
-
-## **Agent 是什么**
-
-Agent（智能代理）是一个能够感知环境并采取行动以实现特定目标的系统。在 AI 应用中，Agent 通过结合大语言模型的理解能力和预定义工具的执行能力，可以自主地完成复杂的任务。是未来 AI 应用到生活生产中主要的形态。
-
-> 💡
-> 本文中示例的代码片段详见：[eino-examples/quickstart/todoagent](https://github.com/cloudwego/eino-examples/blob/master/quickstart/todoagent/main.go)
-
-## **Agent 的核心组成**
-
-在 Eino 中，要实现 Agent 主要需要两个核心部分：ChatModel 和 Tool。
-
-### **ChatModel**
-
-ChatModel 是 Agent 的大脑，它通过强大的语言理解能力来处理用户的自然语言输入。当用户提出请求时，ChatModel 会深入理解用户的意图，分析任务需求，并决定是否需要调用特定的工具来完成任务。在需要使用工具时，它能够准确地选择合适的工具并生成正确的参数。不仅如此，ChatModel 还能将工具执行的结果转化为用户易于理解的自然语言回应，实现流畅的人机对话。
-
-> 更详细的 ChatModel 的信息，可以参考： [Eino: ChatModel 使用说明](/zh/docs/eino/core_modules/components/chat_model_guide)
-
-### **Tool**
-
-Tool 是 Agent 的执行器，提供了具体的功能实现。每个 Tool 都有明确的功能定义和参数规范，使 ChatModel 能够准确地调用它们。Tool 可以实现各种功能，从简单的数据操作到复杂的外部服务调用都可以封装成 Tool。
-
-> 更详细关于 Tool 和 ToolsNode 的信息，可参考： [Eino: ToolsNode 使用说明](/zh/docs/eino/core_modules/components/tools_node_guide)
-
-## **Tool 的实现方式**
-
-在 Eino 中，我们提供了多种方式来实现 Tool。下面通过一个待办事项（Todo）管理系统的例子来说明。
-
-### **方式一：使用 NewTool 构建**
-
-这种方式适合简单的工具实现，通过定义工具信息和处理函数来创建 Tool：
-
-```go
-import (
- "context"
-
- "github.com/cloudwego/eino/components/tool"
- "github.com/cloudwego/eino/components/tool/utils"
- "github.com/cloudwego/eino/schema"
-)
-
-// 处理函数
-func AddTodoFunc(_ context.Context, params *TodoAddParams) (string, error) {
- // Mock处理逻辑
- return `{"msg": "add todo success"}`, nil
-}
-
-func getAddTodoTool() tool.InvokableTool {
- // 工具信息
- info := &schema.ToolInfo{
- Name: "add_todo",
- Desc: "Add a todo item",
- ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
- "content": {
- Desc: "The content of the todo item",
- Type: schema.String,
- Required: true,
- },
- "started_at": {
- Desc: "The started time of the todo item, in unix timestamp",
- Type: schema.Integer,
- },
- "deadline": {
- Desc: "The deadline of the todo item, in unix timestamp",
- Type: schema.Integer,
- },
- }),
- }
-
- // 使用NewTool创建工具
- return utils.NewTool(info, AddTodoFunc)
-}
-```
-
-这种方式虽然直观，但存在一个明显的缺点：需要在 ToolInfo 中手动定义参数信息（ParamsOneOf），和实际的参数结构（TodoAddParams）是分开定义的。这样不仅造成了代码的冗余，而且在参数发生变化时需要同时修改两处地方，容易导致不一致，维护起来也比较麻烦。
-
-### **方式二：使用 InferTool 构建**
-
-这种方式更加简洁，通过结构体的 tag 来定义参数信息，就能实现参数结构体和描述信息同源，无需维护两份信息：
-
-```go
-import (
- "context"
-
- "github.com/cloudwego/eino/components/tool/utils"
-)
-
-// 参数结构体
-type TodoUpdateParams struct {
- ID string `json:"id" jsonschema:"description=id of the todo"`
- Content *string `json:"content,omitempty" jsonschema:"description=content of the todo"`
- StartedAt *int64 `json:"started_at,omitempty" jsonschema:"description=start time in unix timestamp"`
- Deadline *int64 `json:"deadline,omitempty" jsonschema:"description=deadline of the todo in unix timestamp"`
- Done *bool `json:"done,omitempty" jsonschema:"description=done status"`
-}
-
-// 处理函数
-func UpdateTodoFunc(_ context.Context, params *TodoUpdateParams) (string, error) {
- // Mock处理逻辑
- return `{"msg": "update todo success"}`, nil
-}
-
-// 使用 InferTool 创建工具
-updateTool, err := utils.InferTool(
- "update_todo", // tool name
- "Update a todo item, eg: content,deadline...", // tool description
- UpdateTodoFunc)
-```
-
-### **方式三：实现 Tool 接口**
-
-对于需要更多自定义逻辑的场景，可以通过实现 Tool 接口来创建：
-
-```go
-import (
- "context"
-
- "github.com/cloudwego/eino/components/tool"
- "github.com/cloudwego/eino/schema"
-)
-
-type ListTodoTool struct {}
-
-func (lt *ListTodoTool) Info(ctx context.Context) (*schema.ToolInfo, error) {
- return &schema.ToolInfo{
- Name: "list_todo",
- Desc: "List all todo items",
- ParamsOneOf: schema.NewParamsOneOfByParams(map[string]*schema.ParameterInfo{
- "finished": {
- Desc: "filter todo items if finished",
- Type: schema.Boolean,
- Required: false,
- },
- }),
- }, nil
-}
-
-func (lt *ListTodoTool) InvokableRun(ctx context.Context, argumentsInJSON string, opts ...tool.Option) (string, error) {
- // Mock调用逻辑
- return `{"todos": [{"id": "1", "content": "在2024年12月10日之前完成Eino项目演示文稿的准备工作", "started_at": 1717401600, "deadline": 1717488000, "done": false}]}`, nil
-}
-```
-
-### **方式四：使用****官方封装的工具**
-
-除了自己实现工具，我们还提供了许多开箱即用的工具。这些工具经过充分测试和优化，可以直接集成到你的 Agent 中。以 duckduckgo Search 工具为例：
-
-```go
-import (
- "github.com/cloudwego/eino-ext/components/tool/duckduckgo"
-)
-
-
-// 创建 duckduckgo Search 工具
-searchTool, err := duckduckgo.NewTool(ctx, &duckduckgo.Config{})
-```
-
-使用 eino-ext 提供的工具不仅能避免重复开发的工作量，还能确保工具的稳定性和可靠性。这些工具都经过充分测试和持续维护，可以直接集成到项目中使用。
-
-## **用 Chain 构建 Agent**
-
-在构建 Agent 时，ToolsNode 是一个核心组件，它负责管理和执行工具调用。ToolsNode 可以集成多个工具，并提供统一的调用接口。它支持同步调用（Invoke）和流式调用（Stream）两种方式，能够灵活地处理不同类型的工具执行需求。
-
-要创建一个 ToolsNode，你需要提供一个工具列表配置：
-
-```go
-import (
- "context"
-
- "github.com/cloudwego/eino/components/tool"
- "github.com/cloudwego/eino/compose"
-)
-
-conf := &compose.ToolsNodeConfig{
- Tools: []tool.BaseTool{tool1, tool2}, // 工具可以是 InvokableTool 或 StreamableTool
-}
-toolsNode, err := compose.NewToolNode(context.Background(), conf)
-```
-
-下面是一个完整的 Agent 示例，它使用 OpenAI 的 ChatModel 并结合了上述的 Todo 工具:
-
-```go
-import (
- "context"
- "fmt"
- "log"
- "os"
-
- "github.com/cloudwego/eino-ext/components/model/openai"
- "github.com/cloudwego/eino/components/tool"
- "github.com/cloudwego/eino/compose"
- "github.com/cloudwego/eino/schema"
-)
-
-func main() {
- // 初始化 tools
- todoTools := []tool.BaseTool{
- getAddTodoTool(), // NewTool 构建
- updateTool, // InferTool 构建
- &ListTodoTool{}, // 实现Tool接口
- searchTool, // 官方封装的工具
- }
-
- // 创建并配置 ChatModel
- chatModel, err := openai.NewChatModel(context.Background(), &openai.ChatModelConfig{
- Model: "gpt-4",
- APIKey: os.Getenv("OPENAI_API_KEY"),
- })
- if err != nil {
- log.Fatal(err)
- }
- // 获取工具信息并绑定到 ChatModel
- toolInfos := make([]*schema.ToolInfo, 0, len(todoTools))
- for _, tool := range todoTools {
- info, err := tool.Info(ctx)
- if err != nil {
- log.Fatal(err)
- }
- toolInfos = append(toolInfos, info)
- }
- err = chatModel.BindTools(toolInfos)
- if err != nil {
- log.Fatal(err)
- }
-
-
- // 创建 tools 节点
- todoToolsNode, err := compose.NewToolNode(context.Background(), &compose.ToolsNodeConfig{
- Tools: todoTools,
- })
- if err != nil {
- log.Fatal(err)
- }
-
- // 构建完整的处理链
- chain := compose.NewChain[[]*schema.Message, []*schema.Message]()
- chain.
- AppendChatModel(chatModel, compose.WithNodeName("chat_model")).
- AppendToolsNode(todoToolsNode, compose.WithNodeName("tools"))
-
- // 编译并运行 chain
- agent, err := chain.Compile(ctx)
- if err != nil {
- log.Fatal(err)
- }
-
- // 运行示例
- resp, err := agent.Invoke(ctx, []*schema.Message{
- {
- Role: schema.User,
- Content: "添加一个学习 Eino 的 TODO，同时搜索一下 cloudwego/eino 的仓库地址",
- },
- })
- if err != nil {
- log.Fatal(err)
- }
-
- // 输出结果
- for _, msg := range resp {
- fmt.Println(msg.Content)
- }
-}
-```
-
-这个示例有一个假设，也就是 ChatModel 一定会做出 tool 调用的决策。
-
-## **使用其他方式构建 Agent**
-
-除了上述使用 Chain/Graph 构建的 agent 之外，Eino 还提供了常用的 Agent 模式的封装。
-
-### **ReAct Agent**
-
-ReAct（Reasoning + Acting）Agent 结合了推理和行动能力，通过思考-行动-观察的循环来解决复杂问题。它能够在执行任务时进行深入的推理，并根据观察结果调整策略，特别适合需要多步推理的复杂场景。
-
-> 更详细的 react agent 可以参考： [Eino: React Agent 使用手册](/zh/docs/eino/core_modules/flow_integration_components/react_agent_manual)
-
-### **Multi Agent**
-
-Multi Agent 系统由多个协同工作的 Agent 组成，每个 Agent 都有其特定的职责和专长。通过 Agent 间的交互与协作，可以处理更复杂的任务，实现分工协作。这种方式特别适合需要多个专业领域知识结合的场景。
-
-> 更详细的 multi agent 可以参考： [Eino Tutorial: Host Multi-Agent ](/zh/docs/eino/core_modules/flow_integration_components/multi_agent_hosting)
-
-## **总结**
-
-介绍了使用 Eino 框架构建 Agent 的基本方法。通过 Chain、Tool Calling 和 ReAct 等不同方式，我们可以根据实际需求灵活地构建 AI Agent。
-
-Agent 是 AI 技术发展的重要方向。它不仅能够理解用户意图，还能主动采取行动，通过调用各种工具来完成复杂任务。随着大语言模型能力的不断提升，Agent 将在未来扮演越来越重要的角色，成为连接 AI 与现实世界的重要桥梁。我们期待 Eino 能为用户带来更强大、易用的 agent 构建方案，推动更多基于 Agent 的应用创新。
-
-## **关联阅读**
-
-- 快速开始
- - [实现一个最简 LLM 应用-ChatModel](/zh/docs/eino/quick_start/simple_llm_application)
diff --git a/content/zh/docs/eino/quick_start/chapter_01_chatmodel_and_message.md b/content/zh/docs/eino/quick_start/chapter_01_chatmodel_and_message.md
new file mode 100644
index 0000000000..e961e52b1b
--- /dev/null
+++ b/content/zh/docs/eino/quick_start/chapter_01_chatmodel_and_message.md
@@ -0,0 +1,222 @@
+---
+Description: ""
+date: "2026-03-12"
+lastmod: ""
+tags: []
+title: 第一章：ChatModel 与 Message（Console）
+weight: 1
+---
+
+## Eino 框架简介
+
+**Eino 是什么？**
+
+Eino 是一个 Go 语言实现的 AI 应用开发框架（Agent Development Kit），旨在帮助开发者快速构建可扩展、可维护的 AI 应用。
+
+**Eino 解决什么问题？**
+
+1. **模型抽象**：统一不同 LLM 提供商的接口（OpenAI、Ark、Claude 等），切换模型无需修改业务代码
+2. **能力组合**：通过 Component 接口实现可替换、可组合的能力单元（对话、工具、检索等）
+3. **编排框架**：提供 Agent、Graph、Chain 等编排抽象，支持复杂的多步骤 AI 工作流
+4. **运行时支持**：内置流式输出、中断与恢复、状态管理、Callback 可观测性等能力
+
+**Eino 的主要仓库：**
+
+- **eino**（本仓库）：核心库，定义接口、编排抽象和 ADK
+- **eino-ext**：扩展库，提供各类 Component 的具体实现（OpenAI、Ark、Milvus 等）
+- **eino-examples**：示例代码库，包含本 quickstart 系列
+
+---
+
+## ChatWithEino：与 Eino 文档对话的智能助手
+
+**ChatWithEino 是什么？**
+
+ChatWithEino 是一个基于 Eino 框架构建的智能助手，能够帮助开发者学习 Eino 框架并编写 Eino 代码。它通过访问 Eino 仓库的源码、注释和示例，为用户提供最准确、最及时的技术支持。
+
+**核心能力：**
+
+- **对话交互**：理解用户关于 Eino 的问题，提供清晰的解答
+- **代码访问**：直接读取 Eino 源码、注释和示例，基于真实实现回答问题
+- **持久化会话**：支持多轮对话，记住上下文，可跨进程恢复会话
+- **工具调用**：能够执行文件读取、代码搜索等操作
+
+**技术架构：**
+
+- **ChatModel**：与大语言模型通信（OpenAI、Ark、Claude 等）
+- **Tool**：文件系统访问、代码搜索等能力扩展
+- **Memory**：对话历史持久化存储
+- **Agent**：统一的执行框架，协调各组件协同工作
+
+## Quickstart 文档系列：从零构建 ChatWithEino
+
+本系列文档通过循序渐进的方式，带你从最基础的 ChatModel 调用开始，逐步构建一个功能完整的 ChatWithEino Agent。
+
+**学习路径：**
+
+