Rivet

Provides a Tauri-based desktop application with a visual node-and-edge graph editor that allows users to design AI workflows by connecting nodes representing LLM calls, data transformations, and control flow. The editor uses a React-based UI component system that renders nodes with configurable input/output ports, supports drag-and-drop connections, and maintains real-time synchronization with the underlying graph data model. Graph state is persisted to disk as JSON and can be loaded for editing or execution.

Core execution engine (@ironclad/rivet-core) that interprets and executes directed acyclic graphs (DAGs) of nodes with support for local execution, remote debugging, and embedded programmatic execution. The processor handles node scheduling, data flow between connected nodes, context propagation, and execution recording. It supports three execution modes: local (in-process), remote (with debugger attachment), and embedded (via NPM packages). Execution state is tracked through a ProcessContext object that maintains variable bindings, execution history, and node outputs.

Built-in nodes for common data processing tasks: JSON extraction (JSONPath queries), string manipulation (split, join, replace, regex), array operations (map, filter, reduce), and type conversion. These nodes operate on data flowing through the graph, enabling transformation of LLM outputs into structured formats. Nodes support chaining — output of one transformation node feeds into the next. Includes error handling for invalid JSON or malformed data.

Nodes for implementing conditional logic (if/else based on boolean expressions) and loops (for-each over arrays, while loops with conditions). If nodes evaluate a condition and route execution to different branches. Loop nodes iterate over array elements, executing a subgraph for each element and collecting results. Merge nodes combine outputs from multiple branches. Control flow is explicit in the graph structure, making execution paths visible.

Automatically records execution traces during graph execution, capturing node inputs, outputs, execution time, and errors. Traces are stored in the execution context and can be inspected through the debugger or exported for analysis. Includes timing information for performance profiling and error details for debugging. Traces can be filtered by node, time range, or error status. Integration with monitoring systems allows traces to be sent to external observability platforms.

Runtime type system that validates connections between nodes based on input/output port types. Each node declares input and output port types (string, number, object, array, etc.). The editor prevents invalid connections (e.g., connecting a string output to a number input) and provides type mismatch warnings. Type information is used for runtime validation and can inform UI decisions (e.g., showing only compatible nodes when creating connections).

Extensible architecture where nodes are registered plugins implementing a common interface (NodeDefinition, NodeImpl). The core library includes 40+ built-in nodes organized into categories: Chat/AI nodes (OpenAI, Anthropic, Ollama), Data Processing nodes (JSON extraction, string manipulation, array operations), Control Flow nodes (if/else, loops, merge), and MCP Integration nodes. Each node declares input/output port schemas, execution logic, and UI configuration. Custom nodes can be registered at runtime via the plugin system without modifying core code.

Unified interface for integrating multiple LLM providers (OpenAI, Anthropic, Ollama, custom endpoints) through a model abstraction layer. Each provider has dedicated integration code handling authentication, request formatting, and response parsing. Chat nodes accept a model identifier and configuration object specifying temperature, max tokens, and provider-specific parameters. The abstraction allows graphs to switch providers by changing a single configuration value without modifying node logic. Supports streaming responses and token counting for cost estimation.

Native integration with Model Context Protocol servers, allowing graphs to discover and call tools exposed by MCP servers through dedicated MCP Integration nodes. The system handles MCP server lifecycle (startup, shutdown), tool schema discovery, request formatting, and response parsing. Tools are exposed as callable nodes in the graph, enabling LLMs to invoke external tools (web search, file operations, database queries) as part of workflow execution. MCP servers can be local processes or remote endpoints.

Built-in testing framework (@ironclad/rivet/trivet) that enables parameterized testing of graphs using datasets. Tests are defined as JSON files with input/expected output pairs. The framework executes graphs against test datasets, compares actual outputs to expected values, and generates test reports. Integration with Gentrace allows recording test executions for monitoring and regression detection. Tests can be run from the desktop app, CLI, or programmatically via the Node.js API.

Enables attaching a debugger to a running graph execution, allowing pause/resume, breakpoint setting, and inspection of node outputs and context variables. The desktop app can connect to a remote graph execution (running in CLI or embedded mode) via WebSocket, displaying live execution state and allowing interactive debugging. Execution state is serialized and sent to the debugger, enabling inspection without stopping execution. Breakpoints can be set on specific nodes to pause execution before that node runs.

Command-line interface for executing Rivet graphs without the desktop app, enabling integration into CI/CD pipelines and containerized deployments. The CLI accepts a graph file, input variables, and configuration, executes the graph, and outputs results as JSON. Includes Dockerfile for containerizing graph execution, allowing graphs to be deployed as microservices. Supports batch execution of multiple test cases and integration with external orchestration systems (Kubernetes, AWS Lambda).

Serializes entire Rivet projects (graphs, datasets, settings, node configurations) to disk as JSON files, enabling version control via Git. Each graph is a separate JSON file with a schema defining nodes, connections, and metadata. Projects can be loaded, edited, and saved without losing information. Supports project-level settings (API keys, model configurations) that apply to all graphs. Graph versioning is implicit through Git history rather than explicit version numbers.

Built-in prompt editing interface within the desktop app that supports template variables (e.g., {{variable_name}}) for dynamic prompt construction. Variables are substituted at execution time from the graph context. The designer provides syntax highlighting, variable validation, and preview of rendered prompts with sample data. Supports conditional prompt sections and variable formatting (uppercase, lowercase, JSON encoding).