Rivet

Provides a Tauri-based desktop application with a visual node-and-edge graph editor for designing LLM workflows without code. The editor implements a graph data model where nodes represent computational units (LLM calls, data transforms, control flow) and edges represent data flow between them. Users drag nodes onto a canvas, configure node parameters through UI panels, and connect outputs to inputs. The graph is serialized to JSON for persistence and execution.

Executes serialized graph definitions through a graph processor engine that traverses nodes in dependency order, manages execution state, and handles both local (in-process) and remote (debugger-connected) execution. The processor implements a process context that tracks variable bindings, execution history, and node outputs. Local execution runs graphs directly in Node.js or browser; remote execution connects to a debugger for step-through debugging and inspection.

Integrated prompt design tool for crafting and testing LLM prompts before using them in graphs. The prompt designer provides a text editor with syntax highlighting, variable interpolation (using {{variable}} syntax), and a preview pane showing how prompts render with sample data. Designed prompts can be exported as graph nodes.

Command-line interface and server mode enabling Rivet graphs to run in production environments without the desktop IDE. The CLI can execute graphs directly from the command line, passing inputs via arguments or stdin. Server mode runs Rivet as an HTTP server exposing graphs as REST API endpoints, enabling integration with existing applications.

Enables step-through debugging of graph execution by connecting the desktop IDE to a running graph execution (local or remote). The debugger allows pausing execution at nodes, inspecting variable values, stepping through execution, and modifying execution state. Debugger connection is established via WebSocket or HTTP, allowing debugging of graphs running on remote servers.

Provides a Node.js-specific package (@ironclad/rivet-node) for embedding Rivet graph execution directly into Node.js applications. Applications import the package, load a graph definition, and execute it programmatically with input data. The package provides APIs for graph loading, execution, and result retrieval, enabling Rivet graphs to be used as a library within larger applications.

Abstracts LLM interactions through a provider-agnostic interface supporting OpenAI, Anthropic, and other models. Chat nodes in the graph accept a model identifier and configuration (temperature, max tokens, system prompt) and route calls to the appropriate provider's API. The abstraction handles provider-specific differences in API contracts, token counting, and response formats, normalizing them to a common interface.

Provides specialized node types for implementing conditional logic (if/else), loops (for, while), and parallel execution within graphs. These nodes evaluate expressions or conditions at runtime and route execution to different downstream nodes based on results. Loop nodes iterate over arrays or ranges, executing a subgraph for each iteration and collecting results. Parallel nodes execute multiple branches concurrently and merge outputs.

Integrates with Model Context Protocol servers to expose external tools and resources as callable functions within LLM nodes. MCP nodes in the graph connect to MCP servers (local or remote), discover available tools, and allow LLM nodes to invoke them with automatic schema-based argument marshaling. Responses from tools are returned to the LLM for further processing.

Provides nodes for common data manipulation tasks: JSON parsing/serialization, string operations (split, join, replace), array operations (map, filter, reduce), object manipulation, and type conversions. These nodes operate on graph data flowing between LLM calls and other processing steps. Transformations are configured through node UI panels or expression language for custom logic.

Built-in testing framework for validating graph behavior through test cases. Tests define input datasets, expected outputs, and assertions. The framework executes graphs against test data, compares actual outputs to expected values, and generates test reports. Tests can be run in the desktop IDE or via CLI for CI/CD integration.

Automatically records all graph executions, capturing node inputs, outputs, execution order, and timing. Recordings are stored as structured logs and can be replayed to inspect execution state at any point. Integrates with Gentrace for observability and cost tracking across LLM calls.

Extensible plugin architecture allowing developers to create custom node types and register them with Rivet. Plugins implement a standard interface defining node inputs, outputs, configuration, and execution logic. Plugins can be loaded from npm packages or local files and are available in the node palette for use in graphs.

Manages Rivet projects as collections of graphs, datasets, and configuration. Projects are serialized to JSON files for version control and sharing. Datasets are collections of test inputs and expected outputs used for testing and batch processing. Project structure includes graph definitions, dataset definitions, and project settings (API keys, model configurations).