+| Chapter | Topic | Entry |
+| Chapter 1 | ChatModel and Message (Console) | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch01_chatmodel_agent_console.md |
+| Chapter 2 | Agent and Runner (Console multi-turn) | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch02_chatmodel_agent_runner_console.md |
+| Chapter 3 | Memory and Session (persistent conversation) | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch03_memory_session_jsonl.md |
+| Chapter 4 | Tools and file system access | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch04_tool_backend_filesystem.md |
+| Chapter 5 | Middleware pattern | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch05_middleware.md |
+| Chapter 6 | Callback and Trace (observability) | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch06_callback.md |
+| Chapter 7 | Interrupt/Resume | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch07_interrupt_resume.md |
+| Chapter 8 | Graph Tool (complex workflows) | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch08_graph_tool.md |
+| Chapter 9 | Skill (Console) | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch09_skill.md |
+| Final | A2UI (Web) | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch10_a2ui.md |
+
+
+## Final deliverable: an extensible end-to-end Agent application skeleton
+
+You can think of the final output of this Quickstart as a “pluggable application skeleton” that connects Eino’s key capabilities into a full loop:
+
+- Runtime: Runner drives execution, supporting streaming output and the event model
+- Tools: integrate file system/retrieval/workflows via Tool
+- Middleware: carry cross-cutting concerns like retries, approvals, and error handling via handler/middleware
+- Human-in-the-loop: interrupt/resume + checkpoint enable interactive flows like approval, missing-arg filling, and branch selection
+- Deterministic orchestration: compose (graph/chain/workflow) organizes complex business flows into maintainable, reusable execution graphs
+- UI delivery: map the Agent event stream to an incrementally renderable UI component tree with A2UI (SSE push)
+
+The boundary of A2UI is important: it is not part of the Eino framework itself; it is a business-layer UI protocol/rendering solution. This Quickstart uses it to demonstrate “how Agent capabilities can be delivered as a product”, and the details are defined by the final chapter.
+
+## Next explorations (from Quickstart to real business)
+
+- To systematically understand Eino’s component abstractions and usage: start from Chapter 1 and then fill in Tools/Graph/Callback/Interrupt step by step
+- To reuse larger-scale knowledge and instruction packs: integrate `eino-ext` skills and load them on demand via Skill middleware
+- To build an Agent into a business product: follow the final chapter (A2UI/Web) to connect event stream, state, and interaction, then replace it with your own UI form/protocol
diff --git a/content/en/docs/eino/quick_start/agent_llm_with_tools.md b/content/en/docs/eino/quick_start/agent_llm_with_tools.md
deleted file mode 100644
index e0e17f6981c..00000000000
--- a/content/en/docs/eino/quick_start/agent_llm_with_tools.md
+++ /dev/null
@@ -1,300 +0,0 @@
----
-Description: ""
-date: "2026-03-03"
-lastmod: ""
-tags: []
-title: Agent — Give Your LLM Hands
-weight: 2
----
-
-## What Is an Agent?
-
-An Agent is a system that perceives its environment and takes actions to achieve a goal. In AI applications, agents combine the language understanding of LLMs with tool execution, enabling them to autonomously complete complex tasks — a key form factor for how AI integrates into everyday work and life.
-
-> 💡
-> Example code snippets: [eino-examples/quickstart/todoagent](https://github.com/cloudwego/eino-examples/blob/master/quickstart/todoagent/main.go)
-
-## Core Components of an Agent
-
-In Eino, an agent typically consists of two core parts: a `ChatModel` and one or more `Tools`.
-
-### ChatModel
-
-`ChatModel` is the agent’s brain. It processes the user’s natural language input, understands intent, analyzes requirements, and decides whether a tool is needed. When tools are required, it selects the right tool with the right parameters and converts tool outputs back into natural-language responses.
-
-> More about ChatModel: [Eino: ChatModel Guide](/docs/eino/core_modules/components/chat_model_guide)
-
-### Tool
-
-`Tool` is the agent’s executor. Each tool has a clear function definition and parameter schema, allowing the `ChatModel` to call it accurately. Tools can wrap anything from simple data ops to sophisticated external service calls.
-
-> More about tools and ToolsNode: [Eino: ToolsNode Guide](/docs/eino/core_modules/components/tools_node_guide)
-
-## Implementing Tools
-
-Eino offers multiple ways to implement tools. We illustrate with a simple Todo management system.
-
-### Approach 1: Build with `NewTool`
-
-This is ideal for simpler tools: define tool metadata and a handler function.
-
-```go
-import (
- "context"
-
- "github.com/cloudwego/eino/components/tool"
- "github.com/cloudwego/eino/components/tool/utils"
- "github.com/cloudwego/eino/schema"
-)
-
-// Handler
-func AddTodoFunc(_ context.Context, params *TodoAddParams) (string, error) {
- // Mock
- return `{"msg": "add todo success"}`, nil
-}
-
-func getAddTodoTool() tool.InvokableTool {
- // Tool metadata
- 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,
- },
- }),
- }
-
- // Build with NewTool
- return utils.NewTool(info, AddTodoFunc)
-}
-```
-
-This approach is straightforward but has a drawback: parameter descriptions (`ParamsOneOf`) are separate from the actual parameter struct (`TodoAddParams`). Changes require updating both, risking inconsistency.
-
-### Approach 2: Build with `InferTool`
-
-This is more concise. Use struct tags to define parameter metadata so the description and struct share the same source.
-
-```go
-import (
- "context"
-
- "github.com/cloudwego/eino/components/tool/utils"
-)
-
-// Parameter struct
-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"`
-}
-
-// Handler
-func UpdateTodoFunc(_ context.Context, params *TodoUpdateParams) (string, error) {
- // Mock
- return `{"msg": "update todo success"}`, nil
-}
-
-// Build tool with InferTool
-updateTool, err := utils.InferTool(
- "update_todo", // tool name
- "Update a todo item, eg: content,deadline...", // description
- UpdateTodoFunc)
-```
-
-### Approach 3: Implement the Tool Interface
-
-For advanced scenarios, implement the `Tool` interface.
-
-```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": "Prepare Eino demo slides before 2024-12-10", "started_at": 1717401600, "deadline": 1717488000, "done": false}]}` , nil
-}
-```
-
-### Approach 4: Use Official Tools
-
-Beyond custom tools, Eino provides many well-tested, ready-to-use tools. For example, DuckDuckGo Search:
-
-```go
-import (
- "github.com/cloudwego/eino-ext/components/tool/duckduckgo"
-)
-
-
-// Create DuckDuckGo Search tool
-searchTool, err := duckduckgo.NewTool(ctx, &duckduckgo.Config{})
-```
-
-Using tools from `eino-ext` avoids reinvention and ensures reliability — they’re maintained and continuously improved.
-
-## Build an Agent with Chain
-
-`ToolsNode` is a core component for agents, managing tool invocation. It can host multiple tools and supports both synchronous (`Invoke`) and streaming (`Stream`) execution.
-
-To create a `ToolsNode`, provide a tool list configuration:
-
-```go
-import (
- "context"
-
- "github.com/cloudwego/eino/components/tool"
- "github.com/cloudwego/eino/compose"
-)
-
-conf := &compose.ToolsNodeConfig{
- Tools: []tool.BaseTool{tool1, tool2}, // tools can be InvokableTool or StreamableTool
-}
-toolsNode, err := compose.NewToolNode(context.Background(), conf)
-```
-
-Below is a complete agent example using OpenAI’s `ChatModel` and the Todo tools above:
-
-```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() {
- // Initialize tools
- todoTools := []tool.BaseTool{
- getAddTodoTool(), // NewTool
- updateTool, // InferTool
- &ListTodoTool{}, // Implement Tool interface
- searchTool, // Official tool
- }
-
- // Create and configure ChatModel
- chatModel, err := openai.NewChatModel(context.Background(), &openai.ChatModelConfig{
- Model: "gpt-4",
- APIKey: os.Getenv("OPENAI_API_KEY"),
- })
- if err != nil {
- log.Fatal(err)
- }
- // Bind tool infos to 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)
- }
-
-
- // Create tools node
- todoToolsNode, err := compose.NewToolNode(context.Background(), &compose.ToolsNodeConfig{
- Tools: todoTools,
- })
- if err != nil {
- log.Fatal(err)
- }
-
- // Build chain
- chain := compose.NewChain[[]*schema.Message, []*schema.Message]()
- chain.
- AppendChatModel(chatModel, compose.WithNodeName("chat_model")).
- AppendToolsNode(todoToolsNode, compose.WithNodeName("tools"))
-
- // Compile and run
- agent, err := chain.Compile(ctx)
- if err != nil {
- log.Fatal(err)
- }
-
- // Run example
- resp, err := agent.Invoke(ctx, []*schema.Message{
- {
- Role: schema.User,
- Content: "Add a TODO to learn Eino and search for the cloudwego/eino repo URL",
- },
- })
- if err != nil {
- log.Fatal(err)
- }
-
- // Print output
- for _, msg := range resp {
- fmt.Println(msg.Content)
- }
-}
-```
-
-This example assumes the `ChatModel` will decide to make tool calls when appropriate.
-
-## Other Ways to Build Agents
-
-Beyond Chain/Graph-based agents, Eino provides ready-made agent patterns.
-
-### ReAct Agent
-
-ReAct (Reasoning + Acting) combines deep reasoning with action through a think–act–observe loop. It’s well-suited for multi-step reasoning in complex tasks.
-
-> Learn more: [Eino: ReAct Agent Manual](/docs/eino/core_modules/flow_integration_components/react_agent_manual)
-
-### Multi Agent
-
-Multi-agent systems coordinate multiple agents, each with distinct responsibilities and expertise. Through interaction and collaboration, they can tackle complex tasks requiring multiple areas of knowledge.
-
-> Learn more: [Eino Tutorial: Host Multi-Agent](/docs/eino/core_modules/flow_integration_components/multi_agent_hosting)
-
-## Summary
-
-This article introduced core approaches to building agents with Eino. Using chains, tool calling, or ReAct patterns, you can flexibly construct AI agents to meet practical needs.
-
-Agents are a vital direction in AI — they understand user intent and take action by calling tools to accomplish complex tasks. As LLMs advance, agents will increasingly bridge AI and the real world. We hope Eino helps you build powerful, user-friendly agents and inspires new agent-driven applications.
-
-## Related Reading
-
-- Quick Start
- - [Build a Minimal LLM Application — ChatModel](/docs/eino/quick_start/simple_llm_application)
diff --git a/content/en/docs/eino/quick_start/chapter_01_chatmodel_and_message.md b/content/en/docs/eino/quick_start/chapter_01_chatmodel_and_message.md
new file mode 100644
index 00000000000..bc08710a458
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_01_chatmodel_and_message.md
@@ -0,0 +1,222 @@
+---
+Description: ""
+date: "2026-03-12"
+lastmod: ""
+tags: []
+title: "Chapter 1: ChatModel and Message (Console)"
+weight: 1
+---
+
+## Introduction to the Eino framework
+
+**What is Eino?**
+
+Eino is an AI application development framework in Go (Agent Development Kit) designed to help developers quickly build scalable and maintainable AI applications.
+
+**What problems does Eino solve?**
+
+1. **Model abstraction**: unify interfaces across different LLM providers (OpenAI, Ark, Claude, etc.), so switching models does not require changing business code
+2. **Capability composition**: provide replaceable, composable capability units through the Component interfaces (chat, tools, retrieval, etc.)
+3. **Orchestration framework**: offer orchestration abstractions such as Agent, Graph, and Chain to support complex multi-step AI workflows
+4. **Runtime support**: built-in streaming output, interrupt/resume, state management, and Callback-based observability
+
+**Main repositories of Eino:**
+
+- **eino** (this repo): the core library, defining interfaces, orchestration abstractions, and ADK
+- **eino-ext**: the extension library, providing concrete implementations of Components (OpenAI, Ark, Milvus, etc.)
+- **eino-examples**: the examples repo, including this Quickstart series
+
+---
+
+## ChatWithEino: an assistant that talks with Eino docs
+
+**What is ChatWithEino?**
+
+ChatWithEino is an intelligent assistant built with Eino. It helps developers learn Eino and write Eino code by accessing the Eino repository’s source code, comments, and examples, so it can provide accurate and up-to-date technical help.
+
+**Core capabilities:**
+
+- **Conversational interaction**: understand questions about Eino and respond clearly
+- **Code access**: read Eino source code/comments/examples and answer based on real implementations
+- **Persistent sessions**: support multi-turn conversations, remember context, and restore sessions across processes
+- **Tool calling**: perform operations such as file reading and code search
+
+**Architecture overview:**
+
+- **ChatModel**: communicate with LLM providers (OpenAI, Ark, Claude, etc.)
+- **Tool**: extend capabilities such as file system access and code search
+- **Memory**: persist conversation history
+- **Agent**: a unified execution framework that coordinates components
+
+## Quickstart series: build ChatWithEino from scratch
+
+This series walks you step by step: starting from the most basic ChatModel call, and progressively building a fully functional ChatWithEino Agent.
+
+**Learning path:**
+
+
+| Chapter | Topic | Core content | Capability gain |
+| Chapter 1 | ChatModel and Message | Understand the Component abstraction and implement a single-turn chat | Basic conversation |
+| Chapter 2 | Agent and Runner | Introduce execution abstractions and implement multi-turn chat | Session management |
+| Chapter 3 | Memory and Session | Persist chat history and support session recovery | Persistence |
+| Chapter 4 | Tools and file system | Add file access to read source code | Tool calling |
+| Chapter 5 | Middleware | Middleware mechanism and unified cross-cutting concerns | Extensibility |
+| Chapter 6 | Callback | Callbacks to observe the Agent execution process | Observability |
+| Chapter 7 | Interrupt and Resume | Interrupt and resume to support long-running tasks | Reliability |
+| Chapter 8 | Graph and Tool | Use Graph to orchestrate complex workflows | Complex orchestration |
+| Chapter 9 | A2UI | Integration from Agent to UI | Production-grade delivery |
+
+
+**Why design it this way?**
+
+Each chapter adds one core capability on top of the previous chapter, so you can:
+
+1. **Understand the role of each component**: features are introduced progressively instead of all at once
+2. **See the architecture evolve**: from simple to complex, and why each abstraction exists
+3. **Build practical skills**: every chapter comes with runnable code you can try hands-on
+
+---
+
+Goal of this chapter: understand Eino’s Component abstraction, call a ChatModel once with minimal code (with streaming output), and learn the basics 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 we need the Component interfaces
+
+Eino defines a set of Component interfaces (`ChatModel`, `Tool`, `Retriever`, `Loader`, etc.). Each interface describes one replaceable capability category:
+
+```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 implementations for OpenAI, Ark, Claude, Ollama, and more. Business code depends only on the interface, so switching models only changes construction logic.
+2. **Composable orchestration**: orchestration layers such as Agent, Graph, and Chain depend only on Component interfaces, not concrete implementations. You can swap OpenAI for Ark without changing orchestration code.
+3. **Mockable in tests**: interfaces make mocking natural; unit tests do not need real model calls.
+
+This chapter focuses on `ChatModel`. Later chapters will introduce Components such as `Tool` and `Retriever`.
+
+## schema.Message: the basic unit of 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) // second arg is ToolCalls
+schema.ToolMessage("tool result", "call_id")
+```
+
+**Role semantics:**
+
+- `system`: system instructions, typically placed at the beginning of messages
+- `user`: user input
+- `assistant`: model response
+- `tool`: tool call result (covered 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 (OpenAI by default; Ark is also supported)
+
+### Option A: OpenAI (default)
+
+```bash
+export OPENAI_API_KEY="..."
+export OPENAI_MODEL="gpt-4.1-mini" # OpenAI 2025 new model; gpt-4o / gpt-4o-mini also work
+# 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
+
+In `eino-examples/quickstart/chatwitheino`, run:
+
+```bash
+go run ./cmd/ch01 -- "Explain in one sentence what problem Eino’s Component design solves."
+```
+
+Example output (printed incrementally as the stream arrives):
+
+```
+[assistant] Eino’s Component design defines unified interfaces...
+```
+
+## What the entry code does
+
+In execution order:
+
+1. **Create a ChatModel**: choose 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()`, returning a `StreamReader[*Message]`
+4. **Print the result**: iterate `StreamReader` and print the assistant reply chunk by chunk
+
+Key code snippet (**note: simplified and not directly runnable; for the full code see** [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 boundaries for replaceable, composable, and testable capabilities
+- **Message**: the basic unit of conversation data, with semantics defined by roles
+- **ChatModel**: the most fundamental Component, providing `Generate` and `Stream`
+- **Implementation choice**: switch between OpenAI/Ark implementations 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 00000000000..ad2bd195ee6
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_02_chatmodelagent_runner_agentevent.md
@@ -0,0 +1,26 @@
+---
+Description: ""
+date: "2026-03-12"
+lastmod: ""
+tags: []
+title: "Chapter 2: ChatModelAgent, Runner, AgentEvent (Console multi-turn)"
+weight: 2
+---
+
+Goal of this chapter: introduce ADK execution abstractions (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)
+
+## Full tutorial
+
+This page is a website-friendly overview. For the full runnable walkthrough, see:
+
+- [ch02_chatmodel_agent_runner_console.md](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch02_chatmodel_agent_runner_console.md)
+
+## What you learn
+
+- Why “Agent” is a higher-level abstraction than “ChatModel”: it owns the interaction loop and tool routing.
+- What “Runner” does: it provides the runtime (streaming, events, interrupt/resume plumbing) for running an Agent.
+- How “AgentEvent” models the execution stream: user input, model output, tool calls, tool results, and lifecycle signals.
diff --git a/content/en/docs/eino/quick_start/chapter_03_memory_and_session.md b/content/en/docs/eino/quick_start/chapter_03_memory_and_session.md
new file mode 100644
index 00000000000..e90a0a8e990
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_03_memory_and_session.md
@@ -0,0 +1,28 @@
+---
+Description: ""
+date: "2026-03-12"
+lastmod: ""
+tags: []
+title: "Chapter 3: Memory and Session (persistent conversations)"
+weight: 3
+---
+
+Goal of this chapter: persist conversation history and support session recovery across processes.
+
+> ⚠️ Important note: **Memory, Session, and Store here are business-layer concepts**, not core Eino framework components.
+>
+> Eino focuses on “how to process messages”; “how to store messages” is entirely up to your application (DB/Redis/object storage/etc.). The implementation in this chapter is a simple reference you can replace.
+
+## Code location
+
+- Entry code: [cmd/ch03/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/cmd/ch03/main.go)
+
+## Full tutorial
+
+- [ch03_memory_session_jsonl.md](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch03_memory_session_jsonl.md)
+
+## What you learn
+
+- How to model “Session” as a stable ID and resume a conversation by reloading stored messages.
+- A simple storage format (JSONL) as a baseline for implementing your own persistence layer.
+- How to integrate persistence with the Agent/Runner loop without coupling it into Eino itself.
diff --git a/content/en/docs/eino/quick_start/chapter_04_tool_and_filesystem.md b/content/en/docs/eino/quick_start/chapter_04_tool_and_filesystem.md
new file mode 100644
index 00000000000..aff152a9b87
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_04_tool_and_filesystem.md
@@ -0,0 +1,33 @@
+---
+Description: ""
+date: "2026-03-12"
+lastmod: ""
+tags: []
+title: "Chapter 4: Tools and file system access"
+weight: 4
+---
+
+Goal of this chapter: add Tool capabilities so the Agent can access the file system.
+
+## Why Tools
+
+In Chapters 1–3, the Agent can only chat; it cannot perform real actions.
+
+Typical limitations without tools:
+
+- Only generates text responses
+- Cannot access external resources (files/APIs/databases)
+- Cannot execute real tasks (compute/query/modify)
+
+## Code location
+
+- Entry code: [cmd/ch04/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/cmd/ch04/main.go)
+
+## Full tutorial
+
+- [ch04_tool_backend_filesystem.md](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch04_tool_backend_filesystem.md)
+
+## What you learn
+
+- How to expose file reads as tools and let the model call them through the Agent.
+- How to keep tool boundaries explicit (inputs/outputs) so they are testable and observable.
diff --git a/content/en/docs/eino/quick_start/chapter_05_middleware.md b/content/en/docs/eino/quick_start/chapter_05_middleware.md
new file mode 100644
index 00000000000..d15b7f96640
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_05_middleware.md
@@ -0,0 +1,33 @@
+---
+Description: ""
+date: "2026-03-16"
+lastmod: ""
+tags: []
+title: "Chapter 5: Middleware (cross-cutting concerns)"
+weight: 5
+---
+
+Goal of this chapter: understand the middleware pattern and implement Tool error handling and ChatModel retry.
+
+## Why Middleware
+
+Once you add tools (Chapter 4), failures become normal in real-world systems:
+
+- Tool failures: file not found, invalid args, missing permissions, etc.
+- ChatModel failures: rate limits (429), network timeouts, temporary outages, etc.
+
+Middleware provides a single place to handle these cross-cutting concerns without scattering logic throughout your business code.
+
+## Code location
+
+- Entry code: [cmd/ch05/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/cmd/ch05/main.go)
+
+## Full tutorial
+
+- [ch05_middleware.md](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch05_middleware.md)
+
+## What you learn
+
+- How to wrap tool execution with consistent error handling.
+- How to add retry policies around ChatModel calls in a composable way.
+- How middleware keeps the Agent core clean and extensible.
diff --git a/content/en/docs/eino/quick_start/chapter_06_callback_and_trace.md b/content/en/docs/eino/quick_start/chapter_06_callback_and_trace.md
new file mode 100644
index 00000000000..397af7dae31
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_06_callback_and_trace.md
@@ -0,0 +1,23 @@
+---
+Description: ""
+date: "2026-03-12"
+lastmod: ""
+tags: []
+title: "Chapter 6: Callback and Trace (observability)"
+weight: 6
+---
+
+Goal of this chapter: understand the Callback mechanism and integrate tracing/observability for the Agent execution.
+
+## Code location
+
+- Entry code: [cmd/ch06/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/cmd/ch06/main.go)
+
+## Full tutorial
+
+- [ch06_callback.md](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch06_callback.md)
+
+## What you learn
+
+- How callbacks expose lifecycle hooks for key execution points (model calls, tool calls, streaming chunks).
+- How to build logging/metrics/tracing without coupling instrumentation into core logic.
diff --git a/content/en/docs/eino/quick_start/chapter_07_interrupt_resume.md b/content/en/docs/eino/quick_start/chapter_07_interrupt_resume.md
new file mode 100644
index 00000000000..fe5fdfa2924
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_07_interrupt_resume.md
@@ -0,0 +1,23 @@
+---
+Description: ""
+date: "2026-03-16"
+lastmod: ""
+tags: []
+title: "Chapter 7: Interrupt/Resume (human-in-the-loop)"
+weight: 7
+---
+
+Goal of this chapter: understand Interrupt/Resume and implement an approval flow so users can confirm before sensitive tool operations.
+
+## Code location
+
+- Entry code: [cmd/ch07/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/cmd/ch07/main.go)
+
+## Full tutorial
+
+- [ch07_interrupt_resume.md](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch07_interrupt_resume.md)
+
+## What you learn
+
+- How to pause an execution at a safe boundary and request user input.
+- How to resume from checkpoints to support long-running or approval-gated tasks.
diff --git a/content/en/docs/eino/quick_start/chapter_08_graph_tool.md b/content/en/docs/eino/quick_start/chapter_08_graph_tool.md
new file mode 100644
index 00000000000..e842eadb624
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_08_graph_tool.md
@@ -0,0 +1,24 @@
+---
+Description: ""
+date: "2026-03-12"
+lastmod: ""
+tags: []
+title: "Chapter 8: Graph Tool (complex workflows)"
+weight: 8
+---
+
+Goal of this chapter: understand the Graph Tool concept and build more complex workflows using the compose package.
+
+## Code location
+
+- Entry code: [cmd/ch08/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/cmd/ch08/main.go)
+- RAG implementation: [rag/rag.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/rag/rag.go)
+
+## Full tutorial
+
+- [ch08_graph_tool.md](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch08_graph_tool.md)
+
+## What you learn
+
+- How to decompose a complex task into a deterministic execution graph.
+- How to parallelize “chunking + retrieval” for large files and aggregate results back into a final answer.
diff --git a/content/en/docs/eino/quick_start/chapter_09_a2ui_protocol.md b/content/en/docs/eino/quick_start/chapter_09_a2ui_protocol.md
new file mode 100644
index 00000000000..3f1c4246564
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_09_a2ui_protocol.md
@@ -0,0 +1,24 @@
+---
+Description: ""
+date: "2026-03-16"
+lastmod: ""
+tags: []
+title: "Final: A2UI protocol (streaming UI components)"
+weight: 10
+---
+
+Goal of this chapter: implement the A2UI protocol and render the Agent output as a stream of UI components.
+
+## Important: A2UI’s boundary
+
+A2UI is not part of the Eino framework itself. It is a business-layer UI protocol/rendering approach. This chapter integrates A2UI into the Agent you built across previous chapters to provide an end-to-end, production-oriented example: model calls, tool calls, workflow orchestration, and finally delivering results as a more user-friendly UI.
+
+In real-world products, you can choose different UI forms depending on your product:
+
+- Web/App: custom components, tables, cards, charts
+- IM/office suite: message cards, interactive forms
+- CLI: plain text or TUI
+
+## Full tutorial
+
+- [ch10_a2ui.md](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch10_a2ui.md)
diff --git a/content/en/docs/eino/quick_start/chapter_09_skill_console.md b/content/en/docs/eino/quick_start/chapter_09_skill_console.md
new file mode 100644
index 00000000000..6f7558bcbfd
--- /dev/null
+++ b/content/en/docs/eino/quick_start/chapter_09_skill_console.md
@@ -0,0 +1,24 @@
+---
+Description: ""
+date: "2026-03-16"
+lastmod: ""
+tags: []
+title: "Chapter 9: Skill (Console)"
+weight: 9
+---
+
+Goal of this chapter: introduce the `skill` middleware so the Agent can discover and load reusable skill documents (`SKILL.md`) and use them on demand through tool calls.
+
+## Code location
+
+- Entry code: [cmd/ch09/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/cmd/ch09/main.go)
+- Sync script: [scripts/sync_eino_ext_skills.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/scripts/sync_eino_ext_skills.go)
+
+## Full tutorial
+
+- [ch09_skill.md](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch09_skill.md)
+
+## What you learn
+
+- How “progressive disclosure” works for skills (index → load on demand).
+- How to integrate skills into an Agent without permanently inflating prompt context.
diff --git a/content/en/docs/eino/quick_start/simple_llm_application.md b/content/en/docs/eino/quick_start/simple_llm_application.md
deleted file mode 100644
index 219c8c1a97c..00000000000
--- a/content/en/docs/eino/quick_start/simple_llm_application.md
+++ /dev/null
@@ -1,207 +0,0 @@
----
-Description: ""
-date: "2026-01-20"
-lastmod: ""
-tags: []
-title: Building a Simple LLM Application
-weight: 1
----
-
-This guide will help you quickly get started using Eino framework's ChatModel to build a simple LLM application. We will demonstrate how to use ChatModel through implementing a "Programmer Encouragement Assistant" example.
-
-> 💡
-> Code snippets from the examples in this article can be found at: [eino-examples/quickstart/chat](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chat)
-
-## **ChatModel Introduction**
-
-ChatModel is Eino framework's abstraction for conversational large models, providing a unified interface to interact with different large model services (such as OpenAI, Ollama, etc.).
-
-> For more detailed component introduction, see: [Eino: ChatModel Guide](/docs/eino/core_modules/components/chat_model_guide)
-
-## **Message Structure and Usage**
-
-In Eino, conversations are represented through `schema.Message`, which is Eino's abstract definition of a conversation message. Each Message contains the following important fields:
-
-- `Role`: The role of the message, which can be:
- - `system`: System instruction, used to set the model's behavior and role
- - `user`: User input
- - `assistant`: Model's reply
- - `tool`: Tool call result
-- `Content`: The specific content of the message
-
-## **Implementing the Programmer Encouragement Assistant**
-
-Let's learn how to use ChatModel by implementing a Programmer Encouragement Assistant. This assistant can not only provide technical advice but also offer psychological support when programmers feel discouraged.
-
-### Creating Conversation Templates and Generating Messages
-
-Eino provides powerful templating functionality for building messages to input to the large model:
-
-1. Template rendering, supporting three template formats:
-
- - FString: Python-style simple string formatting (e.g., "Hello, {name}!")
- - Jinja2: Jinja2-style templates supporting rich expressions (e.g., "Hello, {{name}}!")
- - GoTemplate: Go's built-in text/template format (e.g., "Hello, {{.name}}!")
-2. Message placeholders: Support inserting a group of messages (such as conversation history)
-
-```go
-// optional=false means required message list, will error if corresponding variable not found in template input
-schema.MessagesPlaceholder("chat_history", false)
-```
-
-> For more detailed component introduction, see: [Eino: ChatTemplate Guide](/docs/eino/core_modules/components/chat_template_guide)
-
-Below is the complete code for creating and using conversation templates with FString format + message placeholders:
-
-```go
-// eino-examples/quickstart/chat/template.go
-
-import (
- "context"
-
- "github.com/cloudwego/eino/components/prompt"
- "github.com/cloudwego/eino/schema"
-)
-
-// Create template using FString format
-template := prompt.FromMessages(schema.FString,
- // System message template
- schema.SystemMessage("You are a {role}. You need to respond in a {style} tone. Your goal is to help programmers maintain a positive and optimistic mindset, providing technical advice while also caring about their mental health."),
-
- // Insert needed conversation history (leave empty for new conversations)
- schema.MessagesPlaceholder("chat_history", true),
-
- // User message template
- schema.UserMessage("Question: {question}"),
-)
-
-// Use template to generate messages
-messages, err := template.Format(context.Background(), map[string]any{
- "role": "Programmer Encouragement Assistant",
- "style": "positive, warm, and professional",
- "question": "My code keeps throwing errors, I feel so frustrated, what should I do?",
- // Conversation history (simulating two rounds of conversation history in this example)
- "chat_history": []*schema.Message{
- schema.UserMessage("Hello"),
- schema.AssistantMessage("Hey! I'm your Programmer Encouragement Assistant! Remember, every excellent programmer grows through debugging. How can I help you?", nil),
- schema.UserMessage("I feel like the code I write is terrible"),
- schema.AssistantMessage("Every programmer goes through this stage! What's important is that you're constantly learning and improving. Let's look at the code together, I believe through refactoring and optimization, it will get better. Remember, Rome wasn't built in a day, code quality improves through continuous improvement.", nil),
- },
-})
-```
-
-### Creating a ChatModel
-
-ChatModel is one of the most core components in the Eino framework, providing a unified interface for interacting with various large language models. Eino currently supports the following large language model implementations:
-
-- OpenAI: Supports GPT-3.5/GPT-4 and other models (also supports Azure-provided OpenAI services)
-- Ollama: Supports locally deployed open-source models
-- Ark: Model services on Volcano Engine (e.g., ByteDance's Doubao model)
-- More models are being added
-
-> For supported models, see: [Eino: Ecosystem Integration](/docs/eino/ecosystem_integration)
-
-Below we demonstrate how to create and use ChatModel using OpenAI and Ollama as examples:
-
-#### **OpenAI (choose either this or Ollama below)**
-
-```go
-// eino-examples/quickstart/chat/openai.go
-
-import (
- "os"
-
- "github.com/cloudwego/eino-ext/components/model/openai"
-)
-
-chatModel, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
- Model: "gpt-4o", // Model version to use
- APIKey: os.Getenv("OPENAI_API_KEY"), // OpenAI API key
-})
-```
-
-> For detailed information about OpenAI ChatModel, see: [ChatModel - OpenAI](https://github.com/cloudwego/eino-ext/blob/main/components/model/openai/README.md)
-
-#### **Ollama (choose either this or OpenAI above)**
-
-Ollama supports running open-source models locally, suitable for scenarios with data privacy requirements or offline usage needs.
-
-```go
-// eino-examples/quickstart/chat/ollama.go
-
-import (
- "github.com/cloudwego/eino-ext/components/model/ollama"
-)
-
-
-chatModel, err := ollama.NewChatModel(ctx, &ollama.ChatModelConfig{
- BaseURL: "http://localhost:11434", // Ollama service address
- Model: "llama2", // Model name
-})
-```
-
-> For detailed information about Ollama ChatModel, see: [ChatModel - Ollama](https://github.com/cloudwego/eino-ext/blob/main/components/model/ollama/README.md)
-
-Eino provides a unified ChatModel abstraction for large models and offers ready-to-use implementations of various LLMs. Therefore, business code can focus on writing business logic without worrying about model implementation details. When model implementations are updated, they won't affect core business logic, meaning developers can easily switch between different models without modifying large amounts of code.
-
-### Running the ChatModel
-
-After obtaining the ChatModel input messages and the initialized ChatModel instance through the previous two steps, you can start trying to run the ChatModel. Eino ChatModel provides two running modes: output complete message (generate) and output message stream (stream):
-
-```go
-// eino-examples/quickstart/chat/generate.go
-
-/*** create messages
-* messages, err := xxx
-*/
-
-/*** create chat model
-* chatModel, err := xxx
-*/
-
-result, err := chatModel.Generate(ctx, messages)
-streamResult, err := chatModel.Stream(ctx, messages)
-```
-
-In practical applications, there are many scenarios that need streaming responses. The main scenario is "improving user experience": the stream running mode allows ChatModel to provide typewriter-like output, giving users model responses earlier.
-
-Here's how Eino handles streaming output:
-
-```go
-// eino-examples/quickstart/chat/stream.go
-
-import (
- "io"
- "log"
-
- "github.com/cloudwego/eino/schema"
-)
-
-func reportStream(sr *schema.StreamReader[*schema.Message]) {
- defer sr.Close()
-
- i := 0
- for {
- message, err := sr.Recv()
- if err == io.EOF { // Streaming output ended
- return
- }
- if err != nil {
- log.Fatalf("recv failed: %v", err)
- }
- log.Printf("message[%d]: %+v\n", i, message)
- i++
- }
-}
-```
-
-For the complete implementation, see: [eino-examples/quickstart/chat/main.go](https://github.com/cloudwego/eino-examples/blob/main/quickstart/chat/main.go)
-
-## **Summary**
-
-This example demonstrated how to build an LLM application using the Eino framework through a Programmer Encouragement Assistant case. From creating a ChatModel to using message templates to actual conversation implementation, you should now have a basic understanding of the Eino framework. Whether you choose OpenAI, Ollama, or other model implementations, Eino provides a unified and simple way to use them. We hope this example helps you quickly start building your own LLM applications.
-
-## **Related Reading**
-
-- Quick Start
- - [Agent - Give LLMs Hands](/docs/eino/quick_start/agent_llm_with_tools)
diff --git a/content/zh/docs/eino/Cookbook.md b/content/zh/docs/eino/Cookbook.md
index d8268d94759..db3b6c8f616 100644
--- a/content/zh/docs/eino/Cookbook.md
+++ b/content/zh/docs/eino/Cookbook.md
@@ -1,6 +1,6 @@
---
Description: ""
-date: "2026-03-02"
+date: "2026-03-16"
lastmod: ""
tags: []
title: Cookbook
diff --git a/content/zh/docs/eino/FAQ.md b/content/zh/docs/eino/FAQ.md
index d062f4d4b96..5f4b47f5f00 100644
--- a/content/zh/docs/eino/FAQ.md
+++ b/content/zh/docs/eino/FAQ.md
@@ -142,7 +142,7 @@ eino-ext 支持的多模态输入输出场景，可以查阅 [https://www.cloudw
eino-ext 部分 module 报错 undefined: schema.NewParamsOneOfByOpenAPIV3 等问题，升级报错的 eino-ext module 到最新版本即可。
-如果 schema 改造比较复杂，可以使用现有的 OpenAPI 3.0 → JSONSchema 转换工具方法辅助转换。
+如果 schema 改造比较复杂，可以参考上面的 Discussion #397，使用其中的 JSONSchema 转换工具方法辅助转换。
# Q: Eino-ext 提供的 ChatModel 有哪些模型是支持 Response API 形式调用嘛？
diff --git a/content/zh/docs/eino/core_modules/chain_and_graph_orchestration/stream_programming_essentials.md b/content/zh/docs/eino/core_modules/chain_and_graph_orchestration/stream_programming_essentials.md
index 39ef62359a2..9c7025c0804 100644
--- a/content/zh/docs/eino/core_modules/chain_and_graph_orchestration/stream_programming_essentials.md
+++ b/content/zh/docs/eino/core_modules/chain_and_graph_orchestration/stream_programming_essentials.md
@@ -101,7 +101,7 @@ Collect 和 Transform 两种流式范式，目前只在编排场景有用到。
上面的 Concat message stream 是 Eino 框架自动提供的能力，即使不是 message，是任意的 T，只要满足特定的条件，Eino 框架都会自动去做这个 StreamReader[T] 到 T 的转化，这个条件是：**在编排中，当一个组件的上游输出是 StreamReader[T]，但是组件只提供了 T 作为输入的业务接口时，框架会自动将 StreamReader[T] concat 成 T，再输入给这个组件。**
> 💡
-> 框架自动将 StreamReader[T] concat 成 T 的过程，可能需要用户提供一个 Concat function。详见 [Eino: 编排的设计理念](/zh/docs/eino/core_modules/chain_and_graph_orchestration/orchestration_design_principles) 中关于“合并帧”的章节。
+> 框架自动将 StreamReader[T] concat 成 T 的过程，可能需要用户提供一个 Concat function。详见 [Eino: 编排的设计理念](/zh/docs/eino/core_modules/chain_and_graph_orchestration/orchestration_design_principles#share-FaVnd9E2foy4fAxtbTqcsgq3n5f) 中关于“合并帧”的章节。
另一方面，考虑一个相反的例子。还是 React Agent，这次是一个更完整的编排示意图：
diff --git a/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/Backend_Ark_Agentkit_Sandbox.md b/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/Backend_Ark_Agentkit_Sandbox.md
index b80be13db1c..68e9eac2d4c 100644
--- a/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/Backend_Ark_Agentkit_Sandbox.md
+++ b/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/Backend_Ark_Agentkit_Sandbox.md
@@ -1,6 +1,6 @@
---
Description: ""
-date: "2026-03-10"
+date: "2026-03-16"
lastmod: ""
tags: []
title: Ark Agentkit Sandbox
diff --git "a/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/Backend_\346\234\254\345\234\260\346\226\207\344\273\266\347\263\273\347\273\237.md" "b/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/Backend_\346\234\254\345\234\260\346\226\207\344\273\266\347\263\273\347\273\237.md"
index 356d445ddd8..4f1b07ab907 100644
--- "a/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/Backend_\346\234\254\345\234\260\346\226\207\344\273\266\347\263\273\347\273\237.md"
+++ "b/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/Backend_\346\234\254\345\234\260\346\226\207\344\273\266\347\263\273\347\273\237.md"
@@ -1,6 +1,6 @@
---
Description: ""
-date: "2026-03-10"
+date: "2026-03-12"
lastmod: ""
tags: []
title: 本地文件系统
@@ -218,6 +218,10 @@ absPath, _ := filepath.Abs("./relative/path")
### 常见问题
+**Q: 为什么运行 grep 命令报错 ripgrep (rg) is not installed or not in PATH. Please install it: ****[https://github.com/BurntSushi/ripgrep#installation](https://github.com/BurntSushi/ripgrep#installation)**
+
+local 的 Grep 命令默认依赖** ripgrep **指令，如系统没有预装 ripgrep 则需要通过文档安装 ripgrep
+
**Q: GrepRaw 支持正则吗？**
支持正则匹配，GrepRaw 底层使用的是 ripgrep 命令做的 Grep 操作
diff --git a/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/_index.md b/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/_index.md
index e108aabe972..498bbcfd721 100644
--- a/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/_index.md
+++ b/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_FileSystem/_index.md
@@ -1,6 +1,6 @@
---
Description: ""
-date: "2026-03-02"
+date: "2026-03-12"
lastmod: ""
tags: []
title: FileSystem
diff --git a/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_Skill.md b/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_Skill.md
index beaa5fa0857..5e7acbdaa83 100644
--- a/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_Skill.md
+++ b/content/zh/docs/eino/core_modules/eino_adk/Eino_ADK_ChatModelAgentMiddleware/Middleware_Skill.md
@@ -1,6 +1,6 @@
---
Description: ""
-date: "2026-03-10"
+date: "2026-03-16"
lastmod: ""
tags: []
title: Skill
@@ -50,7 +50,7 @@ type FrontMatter struct {
+| 章节 | 主题 | 入口 |
+| 第一章 | ChatModel 与 Message（Console） | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch01_chatmodel_agent_console.md |
+| 第二章 | Agent 与 Runner（Console 多轮） | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch02_chatmodel_agent_runner_console.md |
+| 第三章 | Memory 与 Session（持久化对话） | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch03_memory_session_jsonl.md |
+| 第四章 | Tool 与文件系统访问 | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch04_tool_backend_filesystem.md |
+| 第五章 | Middleware（中间件模式） | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch05_middleware.md |
+| 第六章 | Callback 与 Trace（可观测性） | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch06_callback.md |
+| 第七章 | Interrupt/Resume（中断与恢复） | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch07_interrupt_resume.md |
+| 第八章 | Graph Tool（复杂工作流） | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch08_graph_tool.md |
+| 第九章 | Skill（Console） | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch09_skill.md |
+| 最终章 | A2UI（Web） | https://github.com/cloudwego/eino-examples/blob/main/quickstart/chatwitheino/docs/ch10_a2ui.md |
+
+
+## 最终交付：一个可扩展的端到端 Agent 应用骨架
+
+你可以把这个 Quickstart 的最终产物理解为一套“可插拔的应用骨架”，它把 Eino 的关键能力连成闭环：
+
+- 运行时：Runner 驱动执行，支持流式输出与事件模型
+- 工具层：通过 Tool 接入文件系统/检索/工作流等能力
+- 中间件：用 handler/middleware 承载重试、审批、错误处理等横切能力
+- 人机协作：interrupt/resume + checkpoint 支持审批、补参、分支选择等交互式流程
+- 确定性编排：compose（graph/chain/workflow）把复杂业务流程组织为可维护、可复用的执行图
+- UI 交付：用 A2UI 把 Agent 的事件流映射为可增量渲染的 UI 组件树（SSE 推送）
+
+其中 A2UI 的边界需要明确：它不是 Eino 框架本身的一部分，而是业务层的 UI 协议/渲染方案。本 Quickstart 用它来展示“Agent 能力如何以产品形态呈现给用户”，具体实现与协议细节以最终章为准。
+
+## 下一步探索（从 Quickstart 到真实业务）
+
+- 想系统理解 Eino 的组件抽象与用法：从第一章的 Component 入门开始，再按章节逐步补齐 Tool/Graph/Callback/Interrupt 等能力
+- 想复用更大规模的知识与指令：对接 `eino-ext` 的 skills，并通过 Skill 中间件按需加载
+- 想把 Agent 做成业务产品：参考最终章（A2UI/Web）把事件流、状态与交互打通，再替换为你自己的 UI 形态与协议
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 2694ed87a92..00000000000
--- 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 00000000000..e961e52b1be
--- /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。
+
+**学习路径：**
+
+