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

# Node Types

> LLM, Router, Function, and Human nodes for building agent graphs

## Overview

Nodes are the building blocks of Aden agents. Each node type serves a specific purpose in the agent graph.

| Node Type | Purpose | When to Use |
| - | - | - |
| **LLM** | Language model inference | Text generation, classification, extraction |
| **Router** | Control flow decisions | Branching logic, conditional paths |
| **Function** | Custom code execution | API calls, data transformation, business logic |
| **Human** | Human intervention | Approvals, complex decisions, quality checks |

## LLM Node

Executes a language model call with structured inputs and outputs.

### Configuration

```json theme={null}
{
  "id": "analyze_sentiment",
  "type": "llm",
  "model": "claude-sonnet-4-5-20250929",
  "prompt": "Analyze the sentiment of this text: {{text}}",
  "system": "You are a sentiment analysis expert.",
  "output_schema": {
    "type": "object",
    "properties": {
      "sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"]},
      "confidence": {"type": "number", "minimum": 0, "maximum": 1}
    },
    "required": ["sentiment", "confidence"]
  },
  "temperature": 0.3,
  "max_tokens": 500
}
```

### Parameters

| Parameter | Type | Required | Description |
| - | - | - | - |
| `model` | string | Yes | LLM model identifier |
| `prompt` | string | Yes | Prompt template with `{{variable}}` placeholders |
| `system` | string | No | System message for the LLM |
| `output_schema` | object | No | JSON schema for structured output |
| `temperature` | number | No | Sampling temperature (0-2) |
| `max_tokens` | number | No | Maximum tokens to generate |
| `tools` | array | No | Tools the LLM can call |

### Tool Calling

LLM nodes can call tools/functions:

```json theme={null}
{
  "id": "research_agent",
  "type": "llm",
  "model": "claude-sonnet-4-5-20250929",
  "prompt": "Research this topic: {{topic}}",
  "tools": [
    {"name": "web_search", "description": "Search the web"},
    {"name": "read_file", "description": "Read a file from disk"}
  ]
}
```

## Router Node

Routes execution flow based on conditions or LLM decisions.

### Conditional Routing

Route based on output values from previous nodes:

```json theme={null}
{
  "id": "priority_router",
  "type": "router",
  "conditions": [
    {"path": "urgent_handler", "when": "priority == 'high'"},
    {"path": "normal_handler", "when": "priority == 'medium'"},
    {"path": "low_priority_queue", "when": "priority == 'low'"},
    {"path": "default_handler", "default": true}
  ]
}
```

### LLM-Decided Routing

Let the LLM choose the path:

```json theme={null}
{
  "id": "intent_router",
  "type": "router",
  "strategy": "llm",
  "model": "claude-haiku-4-5-20251001",
  "prompt": "Which handler should process this request? {{request}}",
  "paths": [
    {"name": "billing", "description": "Billing and payment questions"},
    {"name": "technical", "description": "Technical support issues"},
    {"name": "sales", "description": "Sales and pricing inquiries"}
  ]
}
```

### Weighted Routing

Probabilistic routing for A/B testing:

```json theme={null}
{
  "id": "ab_router",
  "type": "router",
  "strategy": "weighted",
  "weights": [
    {"path": "variant_a", "weight": 0.8},
    {"path": "variant_b", "weight": 0.2}
  ]
}
```

## Function Node

Executes custom Python code.

### Basic Function

```json theme={null}
{
  "id": "send_email",
  "type": "function",
  "handler": "tools.email.send",
  "inputs": ["recipient", "subject", "body"],
  "timeout": "30s"
}
```

### Implementation

```python theme={null}
# tools/email.py
async def send(ctx, recipient: str, subject: str, body: str):
    """Send an email via the configured SMTP server."""
    smtp = ctx.tools.get("smtp_client")
    result = await smtp.send(
        to=recipient,
        subject=subject,
        body=body
    )
    return {"sent": True, "message_id": result.id}
```

### Parameters

| Parameter | Type | Required | Description |
| - | - | - | - |
| `handler` | string | Yes | Python function path |
| `inputs` | array | No | Required input fields |
| `timeout` | string | No | Execution timeout |
| `retry` | object | No | Retry configuration |

## Human Node

Pauses execution for human input.

### Basic Configuration

```json theme={null}
{
  "id": "manager_approval",
  "type": "human",
  "prompt": "Approve refund of ${{amount}} for {{customer}}?",
  "options": ["approve", "reject", "escalate"],
  "timeout": "24h",
  "escalation": "auto_reject"
}
```

### Parameters

| Parameter | Type | Required | Description |
| - | - | - | - |
| `prompt` | string | Yes | Question/instructions for the human |
| `options` | array | No | Predefined response options |
| `timeout` | string | No | Time limit for human response |
| `escalation` | string | No | Action on timeout: `auto_approve`, `auto_reject`, `escalate` |
| `assignee` | string | No | Specific user/role to notify |

See [Human-in-the-Loop](/building/human-in-the-loop) for advanced patterns.

## Node Context

All nodes receive a context object:

```python theme={null}
class NodeContext:
    # Input from previous node
    input: dict

    # Shared memory store
    memory: MemoryStore

    # LLM client
    llm: LLMClient

    # Tool registry
    tools: ToolRegistry

    # Run metadata
    metadata: RunMetadata
```

### Using Context in Functions

```python theme={null}
async def my_function(ctx):
    # Read from memory
    user_data = await ctx.memory.get("user_profile")

    # Call LLM
    response = await ctx.llm.complete(
        model="claude-haiku-4-5-20251001",
        prompt="Summarize: " + ctx.input["text"]
    )

    # Use tools
    result = await ctx.tools.call("web_search", query="...")

    # Write to memory
    await ctx.memory.set("summary", response.text)

    return {"summary": response.text}
```

## Next Steps

<CardGroup cols={2}>
  <Card title="Edge Configuration" icon="arrow-right" href="/building/edges">
    Connect nodes with success, failure, and conditional edges
  </Card>

  <Card title="Human-in-the-Loop" icon="user" href="/building/human-in-the-loop">
    Configure human intervention patterns
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.