This note was generated with AI assistance, but the code-reading order should be fine (all examples use the official Eino examples; personally, I find the official tutorials a bit hard to follow).

In principle, I think the appendices are just for reference — you can skim them and look things up when needed.

Appendix 3: Lambda Writing, Debugging Tools, and Visualization

📂 Source repo: github.com/cloudwego/eino-examples↗
📖 Series docs: Intro Notes | Agentic Advanced | Appendix 1 Flow | Appendix 2 Components | Appendix 3 Tools

📁 Code root: components/lambda/, devops/
📖 Prerequisites: Lambda is the most flexible node type in Compose orchestration; debugging and visualization are essential tools for development and troubleshooting.

At a Glance: The Relationship Between the Three Tools

1
Development stage                               Production stage
2
────────                              ────────
3
Write business logic with Lambda
4
    ↓
5
Orchestrate nodes with Graph/Chain
6
    ↓
7
Visualize (Mermaid)                      Debug (Devops)
8
View topology structure                  Test via graphical UI
9
    ↓
10
Confirm structure is correct            Confirm logic is correct
11
    ↓
12
    Commit code → run in production

📇 Quick-Reference Card for This Appendix

1
Four ways to create a Lambda:
2
  InvokableLambda(fn)                     ← Simplest
3
  InvokableLambdaWithOption(fn)           ← Needs custom params
4
  AnyLambda(invoke, stream, collect, transform) ← All modes
5
  ToList[T]()                             ← Type conversion T→[]T
6

7
Debugging: devops.Init(ctx) → Chain/Graph.Compile → test via graphical UI
8
Visualization: NewMermaidGenerator(dir) → Compile(WithGraphCompileCallbacks(gen))

1. The Complete Guide to Writing Lambda Nodes

📁 components/lambda/lambda.go
📖 Official docs: https://www.cloudwego.io/zh/docs/eino/core_modules/components/lambda_guide/↗

1.1 What is a Lambda

A Lambda is the “all-purpose node” in Compose orchestration — you can wrap any Go function as a node in a Graph/Chain:

1
Built-in Graph nodes: ChatModel, ToolsNode, ChatTemplate  ← provided by the framework
2
Lambda node:          any function you write              ← provided by yourself

1.2 Lambda Decision Tree

1
What do you need?
2
│
3
├─ Simplest: ctx+input → output
4
│   └─→ compose.InvokableLambda(fn)
5
│
6
├─ Need custom params
7
│   └─→ compose.InvokableLambdaWithOption(fn)
8
│
9
├─ Need streaming (Stream/Transform)
10
│   └─→ compose.AnyLambda(invoke, stream, collect, transform)
11
│
12
├─ Only type conversion T → []T
13
│   └─→ compose.ToList[T]()
14
│
15
└─ Parse JSON returned by ChatModel
16
    └─→ compose.MessageParser(parser)

1.3 Four Creation Methods

Method 1: InvokableLambda (Simplest)

1
lambda := compose.InvokableLambda(
2
    func(ctx context.Context, input string) (output string, err error) {
3
        return strings.ToUpper(input), nil
4
    },
5
)

Method 2: InvokableLambdaWithOption (with custom params)

1
type Options struct { Field1 string }
2
type MyOption func(*Options)
3

4
lambda := compose.InvokableLambdaWithOption(
5
    func(ctx context.Context, input string, opts ...MyOption) (output string, err error) {
6
        o := &Options{}
7
        for _, opt := range opts { opt(o) }
8
        return "", nil
9
    },
10
)

Method 3: AnyLambda (Full-featured: Invoke/Stream/Collect/Transform)

1
lambda, _ := compose.AnyLambda(
2
    func(ctx context.Context, input string, opts ...MyOption) (output string, err error) { return "", nil },
3
    func(ctx context.Context, input string, opts ...MyOption) (output *schema.StreamReader[string], err error) { return nil, nil },
4
    func(ctx context.Context, input *schema.StreamReader[string], opts ...MyOption) (output string, err error) { return "", nil },
5
    func(ctx context.Context, input *schema.StreamReader[string], opts ...MyOption) (output *schema.StreamReader[string], err error) { return nil, nil },
6
)

Method 4: ToList (Type-Conversion Lambda)

1
// ChatModel returns *schema.Message; bridge when downstream needs []*schema.Message
2
chain.AppendLambda(compose.ToList[*schema.Message]())

1.4 Using Lambda in Chain and Graph

1
// Chain
2
chain := compose.NewChain[string, string]()
3
chain.AppendLambda(
4
    compose.InvokableLambda(func(ctx context.Context, input string) (string, error) {
5
        return input + " processed", nil
6
    }),
7
    compose.WithNodeName("step1"),
8
)
9

10
// Graph
11
graph := compose.NewGraph[string, *MyStruct]()
12
graph.AddLambdaNode("node1",
13
    compose.InvokableLambda(func(ctx context.Context, input string) (*MyStruct, error) {
14
        return &MyStruct{ID: 1}, nil
15
    }),
16
    compose.WithStatePreHandler(func(ctx context.Context, input string, state *myState) (string, error) {
17
        return input, nil  // Read/write State before node execution
18
    }),
19
)

1.5 Special-Type Lambda: MessageParser

Parse the Content (JSON string) of a *schema.Message into a Go struct:

1
parser := schema.NewMessageJSONParser[*MyStruct](&schema.MessageJSONParseConfig{
2
    ParseFrom: schema.MessageParseFromContent,
3
})
4
parserLambda := compose.MessageParser(parser)
5

6
chain := compose.NewChain[*schema.Message, *MyStruct]()
7
chain.AppendLambda(parserLambda)

2. Eino Devops Debugging Tool

📁 devops/debug/

2.1 Start the Debugging Service

1
import (
2
    "github.com/cloudwego/eino-ext/devops"
3
    "os/signal"
4
    "syscall"
5
)
6

7
func main() {
8
    err := devops.Init(ctx)  // 1. Start the HTTP debug UI
9

10
    chain.RegisterSimpleChain(ctx)     // 2. Register your Chain/Graph
11
    graph.RegisterSimpleGraph(ctx)
12

13
    sigs := make(chan os.Signal, 1)   // 3. Block and wait
14
    signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
15
    <-sigs
16
}

💡 devops.Init(ctx) only needs to be called once. The registered Chain/Graph will appear in the dropdown menu of the debug UI.

2.2 Debugging Tip for Any-Type Input

When the Graph’s input type is map[string]any, type annotations are needed:

1
{
2
    "name": {
3
        "_value": "alice",
4
        "_eino_go_type": "string"
5
    },
6
    "score": {
7
        "_value": "99",
8
        "_eino_go_type": "int"
9
    }
10
}

3. Visualization Tool: Mermaid Diagram Generation

📁 devops/visualize/mermaid.go

3.1 Basic Usage

1
import "github.com/cloudwego/eino-examples/devops/visualize"
2

3
gen := visualize.NewMermaidGenerator("output/dir")  // Specify the output directory
4

5
runner, _ := g.Compile(context.Background(),
6
    compose.WithGraphCompileCallbacks(gen),
7
    compose.WithGraphName("MyGraph"),
8
)

Output files: output/dir/MyGraph (Markdown) + MyGraph.png (automatically rendered topology diagram).

3.2 Visualization Rules

Node type	Mermaid shape
START / END	`([START])` `([END])` stadium/rounded rectangle
Normal node	`[node name<br/>(component type)]` box
Lambda node	`(node name<br/>(Lambda))` rounded box
Nested subgraph	`subgraph ... end` subgraph box
Branch	`{"branch"}` diamond

3.3 Image Generation Strategy

Prefer mmdc (Mermaid CLI): mmdc -i input.mmd -o output.png
Fallback to chromedp: headless browser renders SVG → screenshot saved as PNG

4. Lambda Quick Reference Table

Type	Creation function	Required params	Common options
Pure-function Lambda	`compose.InvokableLambda(fn)`	fn	—
Option-bearing Lambda	`compose.InvokableLambdaWithOption(fn)`	fn	Custom Option
Full-mode Lambda	`compose.AnyLambda(invoke, stream, collect, transform)`	4 functions	Custom Option
List wrapper	`compose.ToList[T]()`	— (generic)	—
Message parser	`compose.MessageParser(parser)`	schema.MessageJSONParser	—

Common import paths

1
// Lambda
2
"github.com/cloudwego/eino/compose"  // InvokableLambda, AnyLambda, ToList, MessageParser
3
"github.com/cloudwego/eino/schema"   // NewMessageJSONParser, MessageParseFromContent
4

5
// Debugging
6
"github.com/cloudwego/eino-ext/devops"  // Init
7

8
// Visualization
9
"github.com/cloudwego/eino-examples/devops/visualize"  // NewMermaidGenerator

Full Series Document Index

Document	Content	Position
Intro Notes	ADK intro + Middleware + Interrupt + Compose overview	🌱 Intro
Agentic Advanced	AgenticModel / AgenticMessage / Typed system / truncation retry	🌿 Advanced
Appendix 1: Flow Module	Flow module: ReAct / Multi-Agent / state graph / Manus / Deer-Go	🌳 Deep
Appendix 2: Components Module	Component module: A/B routing / HTTP logging / retrieval augmentation / document parsing	🔧 Components
Appendix 3: Lambda and Debugging Tools	Lambda writing / Devops debugging / Mermaid visualization	🛠️ Tools

📇 Quick-Reference Card for This Appendix

1
Lambda:     InvokableLambda (ctx+T→T) → AppendLambda / AddLambdaNode
2
Debugging:  devops.Init → Compile → test via graphical UI
3
Visualization: NewMermaidGenerator → WithGraphCompileCallbacks → + .png
4
MessageParser:  ChatModel JSON output → Go struct (type-safe handling)

📂 Source repo: github.com/cloudwego/eino-examples↗
📖 Keep reading:
Intro Notes — Eino ADK from Hello World to Compose orchestration
Agentic Advanced — Responses API / AgenticMessage / Typed generics
Appendix 1: Flow Module — ReAct Agent / Multi-Agent / state graph
Appendix 2: Components Module — A/B routing / HTTP logging / retrieval augmentation / document parsing
Appendix 3: Lambda and Debugging Tools — Lambda writing / Devops / Mermaid visualization ← You are here

Thanks for reading! Follow me if you'd like~

Eino Study Notes — Appendix 3

Mon Jul 20 2026

941 words · 8 minutes

Notes Go Learning eino AI