> ## Documentation Index
> Fetch the complete documentation index at: https://docs.blobhub.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Components

> Understanding the executable nodes that power BlobHub workflows.

**Components** (sometimes called Processors or Nodes) are the fundamental executable blocks inside a Workflow Definition. Each component adheres to a specific **Interface** (e.g., `genai.chat.openai`) which dictates its input ports, output ports, routing logic, and functional behavior.

Below is an overview of the supported taxonomy of component interfaces natively powered by BlobHub.

## Component Taxonomy

### Flow Control (`flow.*`)

These handle the fundamental initiation and termination of the logic loop.

* `flow.start`: The absolute entry point of the execution.
* `flow.end`: A terminal endpoint resolving the execution gracefully.
* `flow.goto`: A redirect node pointing to another discrete location.

```mermaid theme={null}
graph LR
    Start([flow.start]) --> Component
    Component --> End([flow.end])
```

### Data Variables (`data.*`)

Static blocks providing statically typed constants injected dynamically into the runtime graph.

* `data.integer`: Hardcodes a number.
* `data.message`: Hardcodes a rich semantic AI message prompt.
* `data.messages`: Hardcodes conversation history arrays.

### Logic (`logic.*`)

Control branching, data manipulation, and programming logic.

* `logic.code`: Escapes the interface into raw Python sandboxes (See [Code Component](./component-code)).
* `logic.generic_provider`: Injects generic authenticated API blocks.
* `logic.for`: Loops over input arrays.
* `logic.sleep`: Pauses execution dynamically.
* `logic.insert`: Injects dynamic text strings into payload templates.

```mermaid theme={null}
graph TD
    Data[data.message] --> Loop{logic.for}
    Loop --> |Next Item| Process[logic.code]
    Process --> Loop
    Loop --> |Complete| End([flow.end])
```

### Generative AI Chat (`genai.chat.*`)

High-level native integrations to industry-leading Large Language Models.

* `genai.chat.openai`: Connects to OpenAI models (GPT-4o, etc).
* `genai.chat.anthropic`: Connects to Anthropic (Claude 3.5 Sonnet, etc).
* `genai.chat.gemini`: Connects to Google Gemini integrations.
* `genai.chat`: Abstract router delegating to arbitrary endpoints based on payloads.

### Generative AI Agents (`genai.agent.*`)

Recursive execution loops allowing LLMs to invoke tools autonomously.

* `genai.agent.basic`: Implements a standard reasoning and execution (ReAct) agent looping wrapper mapping tools natively to workflow functions.

```mermaid theme={null}
graph TD
    Input --> Agent{genai.agent.basic}
    Agent --> |Reasoning| LLM[LLM Engine]
    Agent --> |Tool Call| Tool[External Database]
    Tool --> Agent
    Agent --> |Final Answer| Output
```

### Vector Database (`database.vector.*`)

Semantic search integrations natively wired to external retrieval-augmented generation (RAG) providers.

* `database.vector.pinecone`: Direct Pinecone ingestion and search.
* `database.vector.ingest`: Abstract interface pushing embeddings.
* `database.vector.retrieve`: Abstract interface pulling similarity searches.

### The Web (`web.*`)

Fetching, scraping, and dynamically parsing the actual internet.

* `web.scrape`: General HTML fetching.
* `web.scrape.firecrawl`: Sophisticated headless browser scraping via Firecrawl.
* `web.search`: General SERP queries.
* `web.search.tavily`: Web synthesis and targeted searching via Tavily.

### Text Processing (`text.*`)

Splitting and parsing text.

* `text.chunk`: Breaks down giant documents into smaller token-ready vectors for database storage.
* `text.render_template`: Parses Jinja templates with dynamic arguments.