Overview

View as Markdown

Nodes are the building blocks of a RocketRide pipeline. A pipeline is a directed graph, and each node is one component that does one job: call a model, embed text, query a vector store, parse a document, or run a tool. You wire nodes together and the engine runs them.

This page explains how a node is structured on disk and how the runtime loads and executes it, then catalogs every node that ships with the toolchain, grouped by type.

Anatomy of a node

Each built-in node is a directory under nodes/src/nodes/<name>/. A node is its service manifest plus an implementation and its documentation:

nodes/src/nodes/llm_openai/
  services.json     # the manifest: identity, class type, capabilities, config schema
  IGlobal.py        # node-level lifecycle: config validation, dependency loading
  IInstance.py      # per-instance behaviour: what the node does each invocation
  *_client.py       # provider/client implementation detail
  requirements.txt  # Python dependencies, installed on demand
  <name>.svg        # canvas icon
  README.md         # co-located documentation (rendered as this node's page)

The services.json manifest is the contract the engine reads. Its key fields:

Field	Purpose
title	Display name on the canvas and in this catalog.
protocol	The node's URL scheme, e.g. llm_openai://.
classType	The kind of work the node does (llm, store, tool, …). Governs how it wires into the graph.
capabilities	Flags that change engine behaviour, e.g. invoke.
register	How the engine registers the node: filter (transforms data in the graph) or endpoint (an edge connector).
node / path	The runtime (python) and module (nodes.llm_openai) the engine instantiates.
prefix	Prefix swapped when converting between URLs and module paths.
description	Prose shown in the editor.
config	The configuration schema: the fields a pipeline author fills in.

A node's public contract is its classType, config schema, and the input/output lanes it supports. The pipeline JSON reference documents how a node is referenced from a .pipe file (id, provider, config, input).

How the runtime runs a node

1. Discovery & registration. On startup the engine scans every services*.json and registers a factory keyed by protocol/prefix. The register value decides whether the node is a filter in the graph or an endpoint connector at its edge.
2. Instantiation. When a pipeline references a provider, the engine instantiates the implementation named by node and path. IGlobal runs once per node definition (it validates config and loads requirements.txt on demand); IInstance carries the per-invocation behaviour.
3. Wiring. The classType determines how the node connects. Data nodes exchange data through lanes; agent, tool, llm, and memory nodes participate in control connections (see Agents & tools).
4. Execution. The engine drives the graph from sources to targets, passing each node's output along its lanes. capabilities flags toggle engine features such as invoke. See the execution model for how data flows.

Because behaviour lives in provider + config, swapping which model or store a pipeline uses is a config edit, not a code change.

Node types

126 nodes across 21 types. Every node declares a class type in its manifest; the catalog below is grouped by it.

Sources

Bring data into a pipeline: webhooks, chat, file and database readers, and cloud connectors.

Node	Description
Chat	A user interface component that provides a web-based chat experience.
Drag & Drop	A user interface component that provides a web-based dropper experience.
Telegram Bot	A Telegram Bot source node that receives messages from users via the Telegram Bot API.
Tools	A source component that transfers no data: it exists to host tool nodes.
Webhook	A user interface component that provides a web-based chat experience.
Webhook	A source component that listens for incoming HTTP requests and accepts uploaded documents or data from external systems or processes.

LLMs

Call large language models for generation, chat, summarization, and reasoning across many providers.

Node	Description
Amazon Bedrock	A component that connects to Amazon Bedrock, providing access to a range of foundation models from leading AI providers through a unified AWS interface.
Anthropic	A component that integrates with Anthropic's Claude models for natural language understanding and generation.
Baidu Qianfan	A component that connects to Baidu Qianfan ERNIE large language models through Qianfan's OpenAI-compatible chat-completions API.
Deepseek	A component that connects to DeepSeek’s large language models for advanced natural language processing.
Gemini	A component that connects to Gemini models for advanced natural language processing.
GMI Cloud	A component that connects to GMI Cloud's large language models for advanced natural language processing.
Kimi (Moonshot)	A component that connects to Moonshot AI's Kimi large language models for advanced natural language processing.
MiniMax	A component that connects to MiniMax's large language models for advanced natural language processing.
Mistral AI	A component that connects to Mistral AI's advanced language models for natural language processing.
Ollama	A component that integrates with locally-hosted language models through Ollama.
OpenAI	A component that connects to OpenAI's latest GPT models for advanced natural language processing.
OpenAI-Compatible API	A component that connects to any OpenAI-compatible API endpoint for language model inference.
Perplexity	A component that connects to Perplexity AI's Sonar models for advanced natural language processing with real-time web search capabilities.
Qwen	A component that connects to Alibaba Cloud's Qwen large language models via the DashScope API.
xAI	A component that integrates with xAI's Grok language models for intelligent text generation and analysis.

Vision & Image

Analyze and transform images: vision models, OCR, thumbnails, cleanup, and accessibility descriptions.

Node	Description
Accessibility Describe	An accessibility-focused image analysis node that generates scene descriptions optimized for blind and visually impaired users.
Cleanup	A component that processes an image, cleans it up for OCR tasks by converting to gray scale, removing noise, deskewing, and enhancing contrast.
Gemini Vision	A component that connects to Google Gemini's vision-capable models for image analysis, OCR, visual understanding, and scene description.
Mistral Vision	A component that connects to Mistral AI's vision-capable models for image analysis, OCR, and visual understanding tasks.
OCR	A component that extracts machine-readable text from images and scanned documents using optical character recognition.
Ollama Vision	A component that connects to locally-hosted open-source vision models through Ollama for image analysis, description, and visual understanding tasks.
OpenAI Vision	A component that connects to OpenAI's vision-capable models for image analysis, OCR, visual understanding, and scene description.
Thumbnail	A processing component that creates thumbnails from input images.

Audio

Work with audio: transcription, text-to-speech, and playback.

Node	Description
Player	The Audio Player component plays audio through the system’s default audio output device, including the audio track from video content.
Text To Speech	Converts incoming text into speech using Kokoro-82M (local KPipeline or --modelserver KokoroLoader).
Transcribe	The Audio transcribe component recieves audio or video and transcribes into text.

Video

Process video: frame extraction, embeddings, and video understanding.

Node	Description
Frame Grabber	A component that extracts frames from video files and outputs them as image data.
TwelveLabs	Sends a video to TwelveLabs along with instructions and returns the generated text response.

Text

Operate on text: summarization, extraction, named-entity recognition, and anonymization.

Node	Description
Anomaly Detector	A pipeline monitoring component that detects anomalies in numeric output values using statistical methods.
Anonymize	A filter component that identifies and masks sensitive information in text data.
Answers to Documents	An adapter component that turns model/agent answers into embeddable documents.
Currency Convert (Explicit)	An opt-in currency converter for the audit-grade financial extraction suite.
Data Extractor	A component that processes unstructured or semi-structured text and extracts structured data in a tabular format.
Dictionary	A processing component that analyzes documents to extract a dictionary of key terms and phrases.
Fact Extractor	The extraction brain.
Named Entity Recognition	A text processing component that identifies and extracts named entities from text using state-of-the-art transformer models.
Normalize Facts	A deterministic fact normalizer for the audit-grade financial extraction suite.
Prompt	A transformation component that takes multiple inputs and merges them into a single question with a configurable prompt.
Question	A transformation component that takes input text and encapsulates it as a Question object without modification.
Schema Validate	A guard node for the audit-grade financial extraction suite.
Summarization: LLM	A processing component that analyzes document content to extract concise summaries, key points, and named entities.

Embeddings

Turn text, images, or video into vectors for semantic search and retrieval.

Node	Description
Image	A processing component that generates vector embeddings from image content using advanced computer vision models.
OpenAI (Embedding)	A component that transforms text into numerical vector representations using advanced embedding models.
Transformer	A component that transforms text into numerical vector representations using advanced embedding models.
Video	A processing component that generates vector embeddings from video content by extracting frames at configurable intervals and encoding them using vision models such as CLIP.

Rerank

Reorder retrieved results by relevance to a query.

Node	Description
Cohere Rerank	A reranking component powered by Cohere's Rerank API that improves search quality by reordering retrieved documents based on their relevance to a given query.

Search

Query external search providers and the web.

Node	Description
Exa Search	A direct Exa web search node.

Vector Stores

Store and query embeddings for retrieval: Qdrant, Pinecone, Milvus, Chroma, and more.

Node	Description
Astra DB	A vector database component for Astra DB, enabling efficient storage and retrieval of vector embeddings.
Chroma	A vector database component for Chroma, enabling efficient storage and retrieval of vector embeddings.
Elasticsearch	A vector database component for Elasticsearch, enabling efficient storage and retrieval of vector embeddings.
Elasticsearch	A vector database component for Elasticsearch, enabling efficient storage and retrieval of vector embeddings.
File System	File system node.
Milvus	A vector database component for Milvus, enabling efficient storage, indexing, and retrieval of vector embeddings.
MongoDB Atlas	A vector database component for MongoDB Atlas, enabling efficient storage and retrieval of vector embeddings using MongoDB's native vector search capabilities.
OpenSearch	An OpenSearch node that supports classic BM25 search and vector search for ingestion and retrieval workflows.
Pinecone	A component that connects to the Pinecone vector database for storing and retrieving high-dimensional embeddings.
PostgreSQL (pgvector)	A component that enhances PostgreSQL with vector similarity search capabilities through the pgvector extension.
Qdrant	A vector database component for Qdrant, enabling efficient storage and retrieval of vector embeddings.
RocketRide Vector	A RocketRide-managed vector store backed by PostgreSQL + pgvector.
Weaviate	A component that stores vector embeddings in a Weaviate instance for semantic search and retrieval.

Databases

Read from and write to relational and graph databases.

Node	Description
Aparavi AQL	Queries the Aparavi data governance platform using AQL (Aparavi Query Language).
ClickHouse	A ClickHouse component that answers natural-language questions by translating them into SQL and executing them against the database, returning rows as a table, text, or structured answers.
MySQL	A processing component that takes structured table data and inserts it into a MySQL database.
PostgreSQL	A processing component that takes structured table data and inserts it into a PostgreSQL database.
RocketRide SQL	A RocketRide-managed relational database.

Memory

Persist and recall conversational or working state across runs.

Node	Description
Memory (Internal)	Run-scoped keyed memory store exposed as agent tools.
Persistent Memory	A persistent cross-session memory node that retains data across pipeline invocations.

Agents

Autonomous nodes that plan and call tools to accomplish a goal.

Node	Description
CrewAI Agent	Standalone single-agent CrewAI node.
CrewAI Agent	Standalone single-agent CrewAI node.
CrewAI Manager	Multi-agent manager using CrewAI hierarchical process.
CrewAI Subagent	Managed CrewAI sub-agent.
Deep Agent	Single-agent execution using Deep Agents.
Deep Agent	Single-agent execution using Deep Agents.
DeepAgent Subagent	Managed Deep Agent subagent.
LangChain	Single-agent execution using LangChain.
LlamaIndex	Single-agent execution using LlamaIndex's ReAct loop.
RocketRide Wave	Wave-planning agent built natively on the RocketRide architecture.

Tools

Capabilities an agent or pipeline can invoke: HTTP, shell, code execution, and external APIs.

Node	Description
Apify	Exposes Apify Actors as agent tools.
Bland AI	Make and manage AI-powered phone calls via Bland AI.
Chart (Chart.js)	Generates Chart.js v4 chart configurations from data using the pipeline LLM.
Cognee	Persistent semantic memory backed by a Cognee server, exposed as three agent tools.
Daytona	Gives agents an isolated Daytona cloud sandbox for running code and shell commands.
DeepL	Exposes DeepL translation and AI rephrasing as agent tools.
Exa Search	Exposes Exa semantic web search as an agent tool.
Firecrawl	Exposes Firecrawl web-scraping operations as agent tools.
Git	Exposes local Git repository operations as agent tools.
GitHub	Exposes GitHub repository operations as agent tools.
HTTP Request	Makes HTTP requests to any API endpoint, like curl for agents.
LaserData Memory	Durable, shared agent memory exposed as tools, backed by LaserData (Apache Iggy) via the Laser SDK.
MCP Client	Connects to the Butterbase MCP server and exposes its backend tools for agent tool-calling.
Oura	Exposes Oura Ring health data as read-only agent tools.
Pipedrive	Exposes the Pipedrive CRM REST API v1 as agent tools.
Pipeline Tool	Exposes an inline pipeline as an agent tool.
Python	Executes Python code in a restricted in-process sandbox via exec().
Slack	Exposes Slack workspace operations as agent tools.
Tavily	Exposes Tavily real-time web search as an agent tool.
v0 by Vercel	A component that connects to Vercel's v0 API to generate React + Tailwind CSS UI components from natural-language prompts.
xTrace Memory	Long-term, shared agent memory exposed as tools, backed by xTrace Memory Manager.

Preprocessors

Prepare and chunk data before embedding or model calls.

Node	Description
Code	A specialized component designed to parse and tokenize source code.
General Text	A preprocessing component that segments large bodies of text into intelligently sized chunks for downstream processing.
LLM	A processing component that analyzes document content to extract concise summaries, key points, and named entities and to divide a document for storage into a vector database.

Data

Extract, shape, and route structured data within the pipeline.

Node	Description
Guild.ai	Run Guild.ai agents from a RocketRide pipeline or an agent.
LlamaParse	A document parsing component that uses LlamaParse to extract text and structured data from various document formats including PDFs, images, Word documents, Excel spreadsheets, and other formats.
Reducto	A parsing component that uses Reducto to extract text and structured data from various document formats including PDFs, images, and other document types.

Guardrails

Validate and constrain inputs and outputs for safety and policy.

Node	Description
Guardrails	A comprehensive input/output guardrails filter for AI safety.

Outputs

Send results out of the pipeline: responses, files, and external systems.

Node	Description
Local Text Output	A target component that writes data to the file system.
Text Output	A target component that writes data to the file system.

Infrastructure

Plumbing that supports execution rather than transforming data.

Node	Description
Remote Processing	A transport component that forwards data to a remote machine or processing node.
Response	A component that returns processed answers back to the requesting client.

Graph Databases

Graph Databases nodes.

Node	Description
ArangoDB	A processing component that connects to an ArangoDB multi-model database.
FalkorDB	A processing component that connects to a FalkorDB graph database.
HydraDB	A database/tool node for HydraDB, a managed graph + memory store.
Neo4J	A processing component that connects to a Neo4J graph database.
RocketRide Graph	A RocketRide-managed graph database backed by PostgreSQL + Apache AGE.

Other

Nodes that do not fall into a single category above.

Node	Description
Core	A combined configuration that bundles a preprocessor, embedding model, vector store, and LLM into a single selectable unit.
Fingerprinter	A processing component that generates a unique fingerprint (hash) of a document's content.
IBM Watson
Parse/Process/Embed	This component combines document parsing, text preprocessing, and embedding generation in a single node.
Parser	A document parsing component that extracts rich content from a wide variety of document types.
Vectorizer	An internal filter that chunks incoming text, computes embeddings via the configured embedding component, and writes the resulting documents to the vector store.