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

# iBlueprint node types: AI, data, logic, and human

> Every node type available in iBlueprint Blueprints: what each one does, when to use it, and example configurations for the most common nodes.

iBlueprint Blueprints are built from nodes, and each node type is designed for a specific kind of work. Choosing the right node type keeps your Blueprint readable and ensures you get the right behavior from the execution engine. The sections below group node types by purpose so you can find the right one quickly.

<Tabs>
  <Tab title="AI / LLM">
    These nodes call AI models to generate, transform, or analyse content. They are the core of most Blueprints.

    <AccordionGroup>
      <Accordion title="prompt — Text generation" icon="message" defaultOpen={true}>
        The `prompt` node sends a message to a language model and returns the generated text. Use it any time you need the model to write, summarise, classify, extract, translate, or reason over text.

        **Example configuration**

        ```json theme={null}
        {
          "model": "gpt-4o",
          "systemPrompt": "You are a helpful assistant that writes concise summaries.",
          "userPrompt": "Summarise the following article in three bullet points:\n\n{{article_text}}"
        }
        ```

        | Field          | Description                                                            |
        | -------------- | ---------------------------------------------------------------------- |
        | `model`        | The model to use, e.g. `gpt-4o`, `claude-3-5-sonnet`, `gemini-1.5-pro` |
        | `systemPrompt` | Sets the model's persona and constraints                               |
        | `userPrompt`   | The actual request sent to the model; supports `{{variables}}`         |

        <Tip>
          Use `{{previousNode.output}}` in `userPrompt` to feed the result of the previous node directly into your prompt.
        </Tip>
      </Accordion>

      <Accordion title="image_generation — Generate images from text" icon="image">
        The `image_generation` node sends a text prompt to an image model (such as DALL·E or Stable Diffusion) and returns a generated image. Use it to create illustrations, product mockups, or visual assets on the fly.

        **Key config fields:** `prompt`, `model`, `size`, `quality`, `n` (number of images).
      </Accordion>

      <Accordion title="image_editing — Edit or transform existing images" icon="pen-to-square">
        The `image_editing` node takes an input image and applies model-guided edits based on a text instruction. Use it to retouch photos, apply styles, or modify regions of an image.

        **Key config fields:** `image` (URL or base64), `instruction`, `model`, `mask`.
      </Accordion>

      <Accordion title="image_variations — Generate variants of an image" icon="clone">
        The `image_variations` node produces alternative versions of a source image while preserving its overall composition. Use it to explore creative directions or generate multiple options.

        **Key config fields:** `image`, `n`, `size`, `model`.
      </Accordion>

      <Accordion title="vision — Analyse images with a multimodal model" icon="eye">
        The `vision` node passes one or more images to a multimodal model alongside a text prompt. Use it to describe images, extract text from screenshots, or answer questions about visual content.

        **Key config fields:** `images` (array of URLs or base64), `prompt`, `model`.
      </Accordion>

      <Accordion title="ocr — Extract text from images" icon="text">
        The `ocr` node runs optical character recognition on an image and returns the extracted text. Use it to digitise scanned documents, receipts, or screenshots before feeding the text into a `prompt` node.

        **Key config fields:** `image`, `language`.
      </Accordion>

      <Accordion title="speech_to_text — Transcribe audio" icon="microphone">
        The `speech_to_text` node transcribes an audio file into text. Use it to process voice recordings, meeting audio, or podcast episodes before running downstream analysis.

        **Key config fields:** `audio` (URL or base64), `model`, `language`.
      </Accordion>

      <Accordion title="text_to_speech — Convert text to audio" icon="volume-high">
        The `text_to_speech` node synthesises spoken audio from a text string. Use it to build audio summaries, voice interfaces, or accessibility features.

        **Key config fields:** `text`, `voice`, `model`, `speed`.
      </Accordion>

      <Accordion title="video_analysis — Understand video content" icon="video">
        The `video_analysis` node sends a video (or keyframes) to a multimodal model for analysis. Use it to summarise video content, detect events, or extract structured information from recordings.

        **Key config fields:** `video` (URL), `prompt`, `model`.
      </Accordion>

      <Accordion title="data_extraction — Pull structured data from text" icon="table">
        The `data_extraction` node instructs a model to extract structured fields from unstructured text and return them as JSON. Use it to parse emails, reports, or any free-form document into a schema you define.

        **Key config fields:** `input`, `schema` (JSON Schema), `model`.
      </Accordion>
    </AccordionGroup>
  </Tab>

  <Tab title="Data">
    Data nodes connect your Blueprint to external data sources — APIs, databases, files, and cloud storage.

    <AccordionGroup>
      <Accordion title="api — Make HTTP requests" icon="globe" defaultOpen={true}>
        The `api` node makes an HTTP request to any REST endpoint and returns the response. Use it to fetch live data, post to third-party services, or call your own backend from within a Blueprint.

        **Example configuration**

        ```json theme={null}
        {
          "method": "POST",
          "url": "https://api.example.com/v1/analyse",
          "headers": {
            "Authorization": "Bearer {{api_key}}",
            "Content-Type": "application/json"
          },
          "body": {
            "text": "{{input_text}}"
          }
        }
        ```

        | Field     | Description                                                 |
        | --------- | ----------------------------------------------------------- |
        | `method`  | HTTP verb: `GET`, `POST`, `PUT`, `PATCH`, or `DELETE`       |
        | `url`     | Full URL; supports `{{variables}}` in path and query string |
        | `headers` | Key-value pairs; use variables for secrets                  |
        | `body`    | Request body (JSON); supports `{{variables}}`               |

        <Warning>
          Do not hardcode API keys in the `headers` field. Store them as Blueprint environment variables and reference them with `{{variable_name}}` instead.
        </Warning>
      </Accordion>

      <Accordion title="data — Pass static or transformed data" icon="database">
        The `data` node lets you inject a fixed JSON value or transform an existing value into the chain. Use it to provide seed data, reshape an upstream response, or create a reference object other nodes can read.

        **Key config fields:** `value` (any JSON), `transform` (optional expression).
      </Accordion>

      <Accordion title="cloud-drive — Read files from cloud storage" icon="cloud">
        The `cloud-drive` node retrieves a file from a connected cloud storage provider (such as Google Drive or Dropbox) and makes its content available downstream. Use it to process documents, spreadsheets, or images stored in your team's cloud drive.

        **Key config fields:** `connectionId`, `fileId`, `outputFormat` (`text` | `base64` | `url`).
      </Accordion>
    </AccordionGroup>
  </Tab>

  <Tab title="Logic">
    Logic nodes control the flow of execution and let you run custom code inside a Blueprint.

    <AccordionGroup>
      <Accordion title="conditional — Branch on a condition" icon="code-branch" defaultOpen={true}>
        The `conditional` node evaluates a boolean expression and routes execution down one of two paths. Use it to skip steps, handle error states, or apply different transformations based on the data flowing through the chain.

        **Key config fields:** `condition` (JavaScript expression), `truePath`, `falsePath`.

        <Note>
          Because Blueprints use linear chains, the `conditional` node selects which of its two output sub-chains to execute rather than creating a fork that rejoins later.
        </Note>
      </Accordion>

      <Accordion title="function — Run custom JavaScript" icon="code">
        The `function` node executes a snippet of JavaScript (or TypeScript) you write directly in the editor. Use it when you need logic that no built-in node covers — data transformation, string manipulation, or complex calculations.

        **Key config fields:** `code` (JavaScript function body), `timeout`.

        The function receives the previous node's output as its first argument and must return a value:

        ```javascript theme={null}
        // Example: extract the first word from the upstream output
        const words = input.split(' ');
        return { firstWord: words[0], wordCount: words.length };
        ```
      </Accordion>
    </AccordionGroup>
  </Tab>

  <Tab title="Integrations">
    Integration nodes connect your Blueprint to external platforms and protocol servers.

    <AccordionGroup>
      <Accordion title="mcp — Connect to an MCP server" icon="plug" defaultOpen={true}>
        The `mcp` node connects to a [Model Context Protocol](https://modelcontextprotocol.io) server and calls one of its tools. Use it to give your Blueprint access to context from external systems — file systems, databases, search indices, or any MCP-compatible service.

        **Key config fields:** `connectionId`, `tool`, `arguments`.
      </Accordion>

      <Accordion title="webhook — Emit an event to an external URL" icon="webhook">
        The `webhook` node sends an HTTP POST to a URL you specify, typically to notify an external system that a step has completed. Use it to trigger Zapier automations, Slack notifications, or any webhook-compatible service.

        **Key config fields:** `url`, `headers`, `payload`.
      </Accordion>

      <Accordion title="integration — Connect a pre-built integration" icon="link">
        The `integration` node uses a saved connection from your integrations library to call a supported third-party service. Use it instead of the `api` node when iBlueprint has a native integration for the service you need, as it handles authentication automatically.

        **Key config fields:** `integrationId`, `action`, `parameters`.
      </Accordion>
    </AccordionGroup>
  </Tab>

  <Tab title="Human">
    Human nodes pause execution and require input or approval from a person before the Blueprint continues.

    <AccordionGroup>
      <Accordion title="human — Collect human input" icon="person" defaultOpen={true}>
        The `human` node pauses the Blueprint and presents a form to a specified user or role. Execution resumes only after a human submits the requested input. Use it for data collection, content review, or any step where automation alone is not sufficient.

        **Key config fields:** `prompt` (instructions shown to the reviewer), `fields` (array of form fields), `assignee`.
      </Accordion>

      <Accordion title="human_checkpoint — Require approval to continue" icon="circle-check">
        The `human_checkpoint` node pauses execution and asks a designated approver to review the current state and either approve or reject. If rejected, execution stops. Use it for compliance gates, quality checks, or spend approvals.

        **Key config fields:** `message`, `approvers`, `timeout`.
      </Accordion>

      <Accordion title="approval_gate — Multi-party approval" icon="shield-check">
        The `approval_gate` node requires approval from multiple users or a quorum before proceeding. Use it for high-stakes decisions that need more than one sign-off.

        **Key config fields:** `approvers`, `requiredCount`, `message`, `timeout`.
      </Accordion>

      <Accordion title="document — Generate a structured document" icon="file-lines">
        The `document` node assembles a formatted document (PDF, Markdown, or HTML) from a template and the data flowing through the chain. Use it to produce contracts, reports, proposals, or any structured output that needs to be stored or sent.

        **Key config fields:** `template`, `format`, `data`.
      </Accordion>

      <Accordion title="process_step — Model a business process step" icon="diagram-project">
        The `process_step` node represents a manual task within a larger business process. It records that a defined step must be completed by a human operator and tracks its completion status. Use it when integrating Blueprints into structured SOPs or audit workflows.

        **Key config fields:** `name`, `description`, `assignee`, `dueDate`.
      </Accordion>
    </AccordionGroup>
  </Tab>

  <Tab title="Agent">
    Agent nodes orchestrate autonomous AI agents that can plan, use tools, and complete multi-step goals.

    <AccordionGroup>
      <Accordion title="agent — Run a single autonomous agent" icon="robot" defaultOpen={true}>
        The `agent` node runs an AI agent that can call tools, reason over results, and iterate until it achieves its goal. Use it when the task cannot be expressed as a fixed sequence of steps and requires dynamic decision-making.

        **Key config fields:** `goal`, `model`, `tools`, `maxIterations`.
      </Accordion>

      <Accordion title="agent_team — Coordinate multiple agents" icon="users">
        The `agent_team` node runs a group of specialised agents that collaborate to complete a shared goal. Use it for complex research, multi-domain analysis, or tasks that benefit from parallel expertise.

        **Key config fields:** `goal`, `agents`, `supervisor`, `maxIterations`.
      </Accordion>

      <Accordion title="goal — Define a high-level objective" icon="bullseye">
        The `goal` node describes a high-level objective and lets the engine decompose it into sub-tasks automatically. Use it as the entry point for agent-driven Blueprints where the exact steps are not predetermined.

        **Key config fields:** `description`, `successCriteria`, `model`.
      </Accordion>
    </AccordionGroup>
  </Tab>
</Tabs>