riceprompt-engine

YAML-native agent workflow execution engine, written in Rust.

You describe an agent workflow as a YAML file — nodes, edges, prompts, data
sources, MCP tools — and the engine parses it, resolves dependencies, and
executes the graph: making LLM calls, running scripts, querying databases,
calling MCP tools, iterating over data, and orchestrating multi-agent plans.

This engine powers RicePrompt — the visual
agent IDE where you build and run these workflows without writing YAML by hand.

[dependencies]
riceprompt-engine = "0.1"

Features

YAML-native — entire workflow (graph, prompts, data sources, providers)
in a single declarative file. See docs/FLOW_SPEC.md
for the authoritative spec.
Multi-provider LLM support — OpenAI, Anthropic, Gemini, DeepSeek, Qwen,
Zhipu, Moonshot, MiniMax, xAI, Huoshan, and any OpenAI-compatible endpoint.
Streaming, tool calling, structured output — first-class across providers.
Rich node types — generate, transform (Rhai scripting), iterator,
supervisor (multi-agent routing), subgraph, data_connector,
skill_set (progressive-disclosure knowledge bundles), mcp /
mcp_tools (Model Context Protocol).
Built-in data connectors — PostgreSQL, MySQL, MongoDB, Redis, Qdrant,
S3-compatible object storage, REST APIs.
Harness layer — workflow-level instructions (CLAUDE.md-style) injected
into every generate node, with persistent memory support.
Self-describing results — ExecutionResult can include the source YAML
so downstream tooling renders the topology + per-node results from one file.
Checkpoint / resume — pause and resume long-running workflows.

Quick start

A minimal three-node workflow:

version: "1.0"
name: "hello_world"

providers:
  openai:
    api_key: "${OPENAI_API_KEY}"

nodes:
  - id: start
    type: start

  - id: greet
    type: generate
    config:
      provider: openai
      model: gpt-4o-mini
      template: tpl_greet
      variables:
        name: "start.name"

  - id: response
    type: response
    config:
      output:
        greeting: "greet.output"

edges:
  - from: start
    to: greet
  - from: greet
    to: response

templates:
  tpl_greet:
    user_prompt: "Greet {{name}} warmly in one sentence."

Run it:

use riceprompt_engine::Engine;
use serde_json::json;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let yaml = std::fs::read_to_string("hello.yaml")?;
    let engine = Engine::builder().build()?;
    let result = engine.run_yaml(&yaml, json!({ "name": "Ada" })).await?;
    println!("{}", serde_json::to_string_pretty(&result)?);
    Ok(())
}

More runnable examples live under examples/.

Documentation

docs/FLOW_SPEC.md — authoritative YAML workflow spec
(node types, fields, providers, data sources, harness, skills, MCP).
A user-facing usage guide ("skill guide") will be published separately.

RicePrompt — visual agent IDE built on top
of this engine. Design workflows in a graph editor, run them in-browser,
and export the same YAML this engine consumes.

Project status

0.1.x — the API may change between minor versions while the spec
stabilizes. Pin an exact version if you need stability.

Contributing

Issues and PRs welcome. Please:

Run cargo fmt and cargo clippy --all-targets before submitting.
Add tests for new node types or provider behaviors.
For changes that touch the YAML surface, update docs/FLOW_SPEC.md in
the same PR.

License

Licensed under either of

Apache License, Version 2.0 (LICENSE-APACHE or
http://www.apache.org/licenses/LICENSE-2.0)
MIT license (LICENSE-MIT or
http://opensource.org/licenses/MIT)

at your option.

Unless you explicitly state otherwise, any contribution intentionally
submitted for inclusion in the work by you, as defined in the Apache-2.0
license, shall be dual licensed as above, without any additional terms or
conditions.

rp-engine