Eino: Components

LLM application development differs from traditional app development primarily due to two core capabilities:

• Semantic text processing: understanding and generating human language, handling relationships within unstructured content.
• Intelligent decision-making: reasoning from context and making appropriate action decisions.

These capabilities lead to three major application patterns:

1. Direct conversation: process user input and produce responses.
2. Knowledge processing: semantically process, store, and retrieve textual documents.
3. Tool calling: reason from context and call appropriate tools.

These patterns summarize common LLM app scenarios and provide a basis for abstraction and standardization. Eino abstracts these into reusable components.

Mapping components to patterns:

Conversation components:

1. Template and parameter preparation for LLM interaction: ChatTemplate

   • See Eino: ChatTemplate Guide

2. Direct LLM interaction: ChatModel

   • See Eino: ChatModel Guide

Text semantics components:

1. Document acquisition and processing: Document.Loader, Document.Transformer

   • See Document Loader Guide and Document Transformer Guide

2. Semantic embedding of documents: Embedding

   • See Embedding Guide

3. Indexing and storage of embeddings: Indexer

   • See Indexer Guide

4. Retrieval of semantically related documents: Retriever

   • See Retriever Guide

Decision and execution components:

1. Tool-enabled decision making for LLMs: ToolsNode

   • See ToolsNode Guide

Custom logic:

1. User-defined business logic: Lambda

   • See Lambda Guide

Components provide application capabilities — the bricks and mortar of LLM app construction. Eino’s component abstractions follow these principles:

1. Modularity and standardization: unify common capabilities into clear modules with well-defined boundaries for flexible composition.
2. Extensibility: keep interfaces minimally constraining so developers can implement custom components easily.
3. Reusability: package common capabilities and implementations as ready-to-use tooling.

These abstractions establish consistent development paradigms, reduce cognitive load, and improve collaboration efficiency, letting developers focus on business logic instead of reinventing the wheel.