Skip to content

System Overview

Jump to bottom
Dmitrii Karataev edited this page Feb 26, 2026 · 2 revisions

System Overview

RocketRide Engine is a high-performance, modular data processing engine. This page describes its layered architecture, key modules, and how they fit together.

Architecture Layers

The engine is organized into four layers, from bottom to top:

┌─────────────────────────────────────────────────────────────┐
│  Applications                                               │
│  Chat UI  ·  Dropper UI  ·  VSCode Extension  ·  Engine CLI │
├─────────────────────────────────────────────────────────────┤
│  Client Libraries                                           │
│  TypeScript SDK  ·  Python SDK  ·  MCP Protocol Client      │
├─────────────────────────────────────────────────────────────┤
│  Engine Layer                                               │
│  Pipeline Orchestrator · AI/ML Modules · 50+ Nodes · Tika   │
├─────────────────────────────────────────────────────────────┤
│  Core Library (C++ apLib)                                   │
│  async · crypto · file · json · memory · network · string · │
│  threading                                                  │
└─────────────────────────────────────────────────────────────┘

Core Library (C++)

The foundation layer (packages/server/engine-core) provides low-level primitives: asynchronous I/O, cryptography, file system operations, JSON parsing, memory management, networking, string utilities, and threading. Written in C++17 and compiled via CMake.

Engine Layer

The engine layer (packages/server/engine-lib) builds on the core library to provide:

  • Pipeline Orchestrator -- loads pipeline JSON definitions, instantiates nodes, manages data flow between them, and handles lifecycle events.
  • Node Runtime -- hosts 50+ Python-based pipeline nodes for LLMs, vector stores, embeddings, document processing, and more.
  • AI/ML Modules (packages/ai) -- shared AI utilities and model integrations.
  • Tika Integration (packages/tika) -- Apache Tika for parsing documents (PDF, DOCX, XLSX, images, etc.).

Client Libraries

Three client libraries connect to the engine over WebSocket using the DAP (Debug Adapter Protocol):

Library Package Language
TypeScript SDK rocketride (npm) TypeScript/JavaScript
Python SDK rocketride (PyPI) Python 3.8+
MCP Client packages/client-mcp TypeScript

Clients accept http://, https://, ws://, or wss:// URIs. HTTP/HTTPS URIs are automatically upgraded to WebSocket.

Applications

  • Chat UI (apps/chat-ui) -- React web interface for chatting with pipelines.
  • Dropper UI (apps/dropper-ui) -- React web interface for drag-and-drop file ingestion.
  • VSCode Extension (apps/vscode) -- VSCode extension for building and testing pipelines.
  • Engine CLI (apps/engine) -- the main engine executable, runnable as a standalone pipeline runner or as a persistent service.

Communication Protocol

All client-to-engine communication uses WebSocket with the DAP (Debug Adapter Protocol) message format. The engine exposes a single WebSocket endpoint at /task/service on its configured port.

Build System

RocketRide uses a custom declarative JavaScript build system (./builder). It orchestrates builds across all modules -- C++, TypeScript, Python, and Java -- without relying on npm scripts. See Module Guide for per-module build commands.

Repository Structure

rocketride-server/
├── apps/                        # Runnable applications
│   ├── engine/                  # Engine executable (C++)
│   ├── chat-ui/                 # Chat web interface (React)
│   ├── dropper-ui/              # File dropper interface (React)
│   └── vscode/                  # VSCode extension
├── packages/                    # Reusable libraries
│   ├── server/
│   │   ├── engine-core/         # Core library (apLib, C++)
│   │   └── engine-lib/          # Engine library (engLib, C++)
│   ├── client-typescript/       # TypeScript SDK
│   ├── client-python/           # Python SDK
│   ├── client-mcp/              # MCP Protocol client
│   ├── ai/                      # AI/ML modules
│   ├── tika/                    # Tika integration
│   ├── java/                    # JDK & Maven tooling
│   ├── vcpkg/                   # C++ package manager
│   └── shared-ui/               # Shared React components
├── nodes/                       # Pipeline nodes (Python)
│   └── src/nodes/               # Individual node implementations
├── scripts/                     # Build system scripts
├── test/                        # Integration tests
└── testdata/                    # Test fixtures

Next Steps

Getting Started

Architecture

API Reference

Contributing

Governance

Clone this wiki locally