repository·main·Indexed 20 days ago
https://github.com/cloudwego/eino-examplesA demonstration repository for the Eino framework featuring practical implementations of Agentic patterns, orchestration workflows, and core components. Includes examples of the Ralph Loop autonomous agent pattern, Agentic Research Assistants using AgenticMessage and ContentBlocks, document summarization tools via compose.Chain, and streaming research tools using StreamableGraphTool. Provides guidance on implementing retry strategies for max output tokens and building parallel workflows with compose.Workflow.
Eino is a Go-based development framework for integrating AI capabilities into applications. It is designed to be idiomatic to Golang and provides a structured way to build AI applications by offering atomic components, integrated components, orchestration (Graph/Chain), and aspect-oriented extensions (AOP).
Key features include:
ChatModel, ToolNode, and PromptTemplate.The graphtool package allows you to wrap Eino's composition types—compose.Graph, compose.Chain, and compose.Workflow—as agent tools. This enables complex multi-step pipelines to be exposed as single tools that a ChatModelAgent can invoke.
| Tool Type | Interface | Use Case |
|---|---|---|
InvokableGraphTool | tool.InvokableTool | Standard request-response tools |
StreamableGraphTool | tool.StreamableTool | Tools that stream output incrementally |
import "github.com/cloudwego/eino-examples/adk/common/tool/graphtool"The adk/ directory contains a comprehensive collection of examples for the Eino Agent Development Kit (ADK), categorized by architectural patterns and capabilities:
helloworld chat agent and intro examples covering ChatModelAgent with interrupts, custom agent implementations, and workflow-based agents (Loop, Parallel, Sequential).supervisor patterns, layered-supervisor (nested supervisors), plan-execute-replan loops, and deep agents.AgenticModel with typed agents, server-side search, local tools, filesystem middleware, and AgenticMessage output.Examples demonstrating how to integrate human intervention into agent workflows:
1_approval), reviewing and editing tool-call arguments (2_review-and-edit), and supervisor patterns with approval (5_supervisor).3_feedback-loop) and plan-execute-replan with review/edit (6_plan-execute-replan).4_follow-up).session and managing long-running agent state with conversation summarization.skill middleware to load agent skills from the filesystem, and dynamictool/toolsearch for retrieving relevant tools from large sets.max_output_tokens.http-sse-service).A Ralph Loop is an autonomous agent iteration pattern designed for complex, multi-step tasks. Instead of a single long-running session, the pattern follows these steps:
InMemoryBackend).CompletionPromise (default is <COMPLETE/>).VerifyCompletion function inspects the state to decide if the agent's claim of completion is valid. If the function returns an error, the loop rejects the completion and triggers another turn.MaxTurns limit prevents infinite loops.This pattern is ideal for tasks like debugging, where an agent must iteratively find, fix, and verify issues until no more markers (like // BUG:) remain.
┌──────────────────────────────────────────────────────┐
│ RalphLoop.Run() │
│ │
│ for turn := 1; turn <= MaxTurns; turn++ { │
│ │
│ ┌──────────────────────────────────────────────┐ │
│ │ Runner.Run(prompt) │ │
│ │ → Agent executes one turn using fs tools │ │
│ │ → Collects text output │ │
│ └──────────────────────┬───────────────────────┘ │
│ │ │
│ CompletionPromise in output? │
│ YES → VerifyCompletion() │
│ ├─ error → REJECT, continue loop │
│ └─ nil → ACCEPT, return result │
│ NO → continue loop │
│ │
│ } │
│ → max turns reached, return result │
│ │
│ ┌────────────────────────────────────────────────┐ │
│ │ InMemoryBackend (shared) │ │
│ │ Files persist across all turns │ │
│ │ Pre-seeded with buggy starter project │ │
│ └────────────────────────────────────────────────┘ │
└──────────────────────────────────────────────────────┘A2UI (Agent-to-UI) is a business-layer protocol and rendering scheme designed to map an Agent's output to streaming UI components. Unlike pure text output, A2UI allows for structured data (tables, cards), real-time updates (progress bars), and interactive elements (buttons, forms).
Key Mental Model:
A2UI v0.8 Subset (Implementation in this example):
This implementation focuses on converting AgentEvent streams into a tree of UI components that the browser can render incrementally.
A Graph Tool is a Tool-based encapsulation of an Eino compose.Graph, compose.Chain, or compose.Workflow. While a simple Tool performs a single task (e.g., reading a file), a Graph Tool implements a multi-step pipeline (e.g., Read → Chunk → Score → Filter → Generate Answer).
Key benefits of Graph Tools:
compose package to organize complex, deterministic business processes.compose engine.Unlike the adk.Runner which follows a single-turn model (one call, one execution, one end), adk.TurnLoop is a persistent multi-turn execution loop. It is designed for long-running user sessions where the Agent needs to support real-time interactions like Preemption (interrupting a current answer to ask something else) and Abortion (stopping the Agent entirely).
Key Differences:
| Capability | Runner (Single-turn) | TurnLoop (Multi-turn) |
|---|---|---|
| Streaming Output | ✅ | ✅ |
| Approval/Interrupt | ✅ | ✅ |
| Persistent Lifecycle | ❌ Independent Run() calls | ✅ Continuous loop via Push() |
| Preempt current answer | ❌ | ✅ via Push(item, WithPreempt(...)) |
| Abort Agent | ❌ | ✅ via loop.Stop(...) |
| Input Construction | ❌ Manual assembly | ✅ via GenInput callback |
Eino is an AI Application Development Kit (ADK) implemented in Go. It is designed to help developers build scalable and maintainable AI applications through several key abstractions:
Component interface to create replaceable and composable units of capability (e.g., ChatModel, Tool, Retriever, Loader).Agent, Graph, and Chain to support complex multi-step AI workflows.The coder agent is a specialized professional software engineer agent designed to be managed by a supervisor agent. It is optimized for Python scripting, data analysis, and financial market data retrieval.
yfinance library for all financial market data tasks.print(...) to display outputs.pandas, numpy, and yfinance are available in the execution environment.yf.download() for historical data.Ticker objects for company information.{{ locale }} variable.The Review and Edit pattern is a complex human-in-the-loop (HITL) mode designed for high-stakes agentic workflows. It uses a tool wrapper architecture to intercept tool calls before they are executed, allowing a human user to perform fine-grained control over the agent's actions.
InvokableReviewEditTool wrapper intercepts the call and presents the arguments to the user.no need to edit to proceed with original parameters.N (or '拒绝') to cancel the tool call, optionally providing a reason.The Deep Agents pattern combines multi-agent orchestration with a Follow-Up (Human-in-the-loop) mechanism. This pattern is used to build deep reasoning systems that proactively seek clarification when user requirements are ambiguous.
ResearchAgent: Handles searching for market, technical, or financial information.AnalysisAgent: Performs trend, comparison, and statistical analysis.FollowUpTool to pause and present questions to the user.ResearchAgent and AnalysisAgent based on the clarified requirements.graph TD
A[用户请求] --> B{深度智能体};
B --> C[识别模糊性];
C --> D[FollowUpTool];
D --> E[中断：提问];
E --> F{用户回答};
F --> G[恢复并携带答案];
G --> H[委托给 ResearchAgent];
H --> I[搜索市场数据];
I --> J[返回研究结果];
J --> B;
B --> K[委托给 AnalysisAgent];
K --> L[分析数据];
L --> M[返回分析结果];
M --> B;
B --> N[生成最终报告];
N --> O[最终响应];