1
┌─────────────────────────────────────────┐
2
│         ADK / Flow / Compose            │  ← Upper-layer orchestration
3
├─────────────────────────────────────────┤
4
│  ChatModel │ Retriever │ Parser │ ...   │  ← Component interfaces
5
├─────────────────────────────────────────┤
6
│  OpenAI │ ARK │ VikingDB │ PDF │ HTML   │  ← Concrete implementations
7
└─────────────────────────────────────────┘

1
Three major component categories:
2
  Model:    A/B routing (ABRouter) / HTTP logging (CurlRT)
3
  Retriever: Multi-Query (rewrite query) / Router (multi-data-source routing)
4
  Parser:   TextParser → ExtParser → CustomParser (dispatch by extension)
5

6
Core pattern: All implement a unified interface → freely pluggable in any orchestration

1
100% of user requests
2
  ├─ 90% → GPT-4o (main, stable)
3
  └─ 10% → DeepSeek (experiment, observe)

1
import "github.com/cloudwego/eino-examples/components/model/abtest"
2

3
// Prepare two candidate models
4
gpt4o, _ := openai.NewChatModel(ctx, &openai.ChatModelConfig{...})
5
deepseek, _ := openai.NewChatModel(ctx, &openai.ChatModelConfig{
6
    BaseURL: "https://api.deepseek.com/v1",  // Point to DeepSeek
7
    Model:   "deepseek-chat",
8
})
9

10
// Router: A/B split based on the last digit of userID
11
router := abtest.NewABRouterChatModel(func(
12
    ctx context.Context, in []*schema.Message, _ ...model.Option,
13
) (string, model.BaseChatModel, error) {
14
    // Extract userID from context (in a real project, from the request context)
15
    userID, _ := ctx.Value("userID").(string)
16
    if userID != "" && userID[len(userID)-1] < '5' {  // 50% of traffic
17
        return "deepseek", deepseek, nil  // Experiment group
18
    }
19
    return "gpt4o", gpt4o, nil            // Control group
20
})
21

22
// Used exactly the same as a normal ChatModel!
23
msg, _ := router.Generate(ctx, messages)

1
client := &http.Client{
2
    Transport: httptransport.NewCurlRT(
3
        http.DefaultTransport,          // Base Transport (the one that actually sends requests)
4
        httptransport.WithLogger(log.Default()),
5
        httptransport.WithPrintAuth(false),              // ⚠️ API Key redacted (not printed by default)
6
        httptransport.WithMaskHeaders([]string{"X-API-KEY"}),
7
        httptransport.WithStreamLogging(true),            // Log streaming responses too
8
        httptransport.WithMaxStreamLogBytes(8192),
9
    ),
10
}
11

12
// Inject into ChatModel — logs are printed automatically on subsequent calls
13
chatModel, _ := openai.NewChatModel(ctx, &openai.ChatModelConfig{
14
    HTTPClient: client,
15
})

1
[curl request] curl -X POST 'https://api.openai.com/v1/chat/completions' \
2
  -H 'Content-Type: application/json' \
3
  -H 'Authorization: <redacted>' \
4
  --data '{"model":"gpt-4o","messages":[{"role":"user","content":"hello"}]}'

1
[curl response] HTTP/1.1 200
2
{"id":"chatcmpl-xxx","choices":[{"message":{"role":"assistant","content":"Hello! How can I help?"}}]}

1
User input: "How to improve code quality"
2
The actual titles of relevant docs in the vector store are:
3
  "Unit Testing Best Practices"
4
  "Code Review Process Guidelines"
5
  "Static Analysis Tool Configuration Guide"

1
User input: "tourist attraction" (too vague)
2
    ↓ LLM auto-rewrites
3
Variant 1: "best tourist attractions for families"     ← from the "family" angle
4
Variant 2: "outdoor sightseeing spots recommendations"  ← from the "outdoor" angle
5
Variant 3: "popular travel destinations and landmarks"  ← from the "famous attractions" angle
6
    ↓ Retrieve from the same vector store separately
7
Result 1: [doc_a, doc_b]
8
Result 2: [doc_b, doc_d]     →  FusionFunc merges and dedupes → [doc_a, doc_b, doc_c, doc_d, doc_e, doc_f]
9
Result 3: [doc_c, doc_e, doc_f]

1
import "github.com/cloudwego/eino/flow/retriever/multiquery"
2

3
mqr, _ := multiquery.NewRetriever(ctx, &multiquery.Config{
4
    RewriteHandler: func(ctx context.Context, query string) ([]string, error) {
5
        out, _ := llm.Generate(ctx, []*schema.Message{
6
            schema.SystemMessage("Generate 3 rewritten search queries, one per line."),
7
            schema.UserMessage(query),
8
        })
9
        return strings.Split(out.Content, "\n"), nil
10
    },
11
    MaxQueriesNum: 3,        // Generate at most 3 variants
12
    OrigRetriever: vk,        // Underlying vector retrieval engine
13
})
14

15
docs, _ := mqr.Retrieve(ctx, "tourist attraction")
16
// docs contains the merged results from all variants

1
Your system has three vector stores:
2
  product_vdb  → stores product info (name, price, specs)
3
  review_vdb   → stores user reviews (ratings, review text)
4
  faq_vdb      → stores FAQs (Q&A pairs)
5

6
User asks "How much does this product cost?" → search product_vdb
7
User asks "Is this product good?" → search review_vdb
8
User asks "How to return it?"      → search faq_vdb

1
rr, _ := router.NewRetriever(ctx, &router.Config{
2
    Retrievers: map[string]retriever.Retriever{
3
        "product":  productRetriever,   // Product vector store
4
        "review":   reviewRetriever,    // Review vector store
5
        "faq":      faqRetriever,       // FAQ vector store
6
    },
7
    Router: func(ctx context.Context, query string) ([]string, error) {
8
        var targets []string
9
        // Route to different engines by keyword
10
        if strings.Contains(query, "price") || strings.Contains(query, "specs") {
11
            targets = append(targets, "product")
12
        }
13
        if strings.Contains(query, "review") || strings.Contains(query, "good") {
14
            targets = append(targets, "review")
15
        }
16
        if strings.Contains(query, "return") || strings.Contains(query, "how") {
17
            targets = append(targets, "faq")
18
        }
19
        if len(targets) == 0 {
20
            targets = []string{"product", "review", "faq"}  // Fallback: search all
21
        }
22
        return targets, nil
23
    },
24
    FusionFunc: nil,  // nil = default RRF (Reciprocal Rank Fusion) fusion
25
})

1
import "github.com/cloudwego/eino/components/document/parser"
2

3
textParser := parser.TextParser{}
4
docs, _ := textParser.Parse(ctx, strings.NewReader("hello world"))

1
extParser, _ := parser.NewExtParser(ctx, &parser.ExtParserConfig{
2
    Parsers: map[string]parser.Parser{
3
        ".html": htmlParser,     // → Use CSS Selector to extract body content
4
        ".pdf":  pdfParser,      // → Use PDF parsing engine to extract text
5
    },
6
    FallbackParser: textParser,  // Unknown format → read as plain text
7
})
8

9
file, _ := os.Open("./testdata/test.html")
10
docs, _ := extParser.Parse(ctx, file, parser.WithURI(filePath))
11
// ↑ WithURI must be passed — ExtParser determines the format by the file path suffix

1
// A/B test routing
2
"github.com/cloudwego/eino-examples/components/model/abtest"
3

4
// HTTP transport logging
5
"github.com/cloudwego/eino-examples/components/model/httptransport"
6

7
// Retriever augmentation
8
"github.com/cloudwego/eino/flow/retriever/multiquery"   // Multi-Query
9
"github.com/cloudwego/eino/flow/retriever/router"        // Router
10

11
// Document parser
12
"github.com/cloudwego/eino/components/document/parser"         // Parser interface, TextParser, ExtParser
13
"github.com/cloudwego/eino-ext/components/document/parser/html" // HTML
14
"github.com/cloudwego/eino-ext/components/document/parser/pdf"  // PDF

1
┌──────────────────────────────────────────────────┐
2
│  ADK layer (Intro Notes §1~§7)                           │
3
│  ChatModelAgent, Runner, Middleware, Interrupt   │
4
├──────────────────────────────────────────────────┤
5
│  Flow layer (Appendix 1: Flow Module)                    │
6
│  react.NewAgent, host.NewMultiAgent              │
7
├──────────────────────────────────────────────────┤
8
│  Compose layer (Intro Notes §6.4)                        │
9
│  Graph, Chain, Workflow, Branch, ProcessState    │
10
├──────────────────────────────────────────────────┤
11
│  Component layer (this appendix)                                   │
12
│  ChatModel, Retriever, Parser, Tool              │
13
└──────────────────────────────────────────────────┘

1
Model:
2
  ABRouter = traffic distributor (A/B testing / cost optimization / canary release)
3
  CurlRT   = HTTP debugger (cURL-style logs + automatic API Key redaction)
4

5
Retriever:
6
  MultiQuery = use LLM to rewrite query → search same store from multiple angles → merge and dedupe
7
  Router     = analyze query content → dispatch to different stores → fuse results
8

9
Parser:
10
  TextParser → ExtParser (map by extension) → CustomParser (WrapImplSpecificOptFn)