rp-engine - GitLite

KO | EN

gitlite — search

#python #ai #golang #android #rust #docker #macos #nodejs #java #windows #cli #mcp #openai #open-source

rp-engine

(★ 1,224)

YAML-native agent workflow execution engine, written in Rust

File Explorer

Download Latest Version (.zip)

- FLOW_SPEC.md
- run_demo.rs
- test_frontend_yaml.rs
- test_harness.rs
- test_harness_writeback.rs
- test_mcp.rs
- test_providers.rs
- test_search.rs
- test_skill_set.rs
- test_tool_calling.rs
- ut_advanced.rs
- ut_runner.rs
- - builder.rs
  - engine.rs
  - evomap.rs
  - executor.rs
  - graph.rs
  - mod.rs
  - stream_handler.rs
- - evaluator.rs
  - lexer.rs
  - mod.rs
  - parser.rs
- - checkpoint.rs
  - data_connector.rs
  - generate.rs
  - iterator.rs
  - mcp.rs
  - mod.rs
  - response.rs
  - skill_set.rs
  - start.rs
  - subgraph_runner.rs
  - supervisor.rs
  - transform.rs
  - workflow_node.rs
- - anthropic.rs
  - content.rs
  - deepseek.rs
  - embedding.rs
  - embedding_dashscope.rs
  - embedding_openai.rs
  - gemini.rs
  - huoshan.rs
  - minimax.rs
  - mod.rs
  - model_registry.rs
  - moonshot.rs
  - openai.rs
  - openai_compatible.rs
  - providers.json
  - qwen.rs
  - streaming.rs
  - xai.rs
  - zhipu.rs
- - edge.rs
  - mod.rs
  - node.rs
  - template.rs
  - workflow.rs
- - execution_state.rs
  - mod.rs
- error.rs
- lib.rs
- - conditional.yaml
  - linear.yaml
  - loop.yaml
  - parallel.yaml
  - TaskPlanner.yaml
- integration_tests.rs
- test_multimodal.rs
.gitignore
Cargo.toml
LICENSE-APACHE
LICENSE-MIT
README.md

# Installation Guide

1. Get the code

git clone https://github.com/jieyefriic/rp-engine

Downloads the entire project code from GitHub to your computer.

cd rp-engine

Moves into the project folder you just downloaded.

2. Rust

Medium Recommended

Prerequisites

Git Needed to download the project code from GitHub.
Rust (rustup) Installing via rustup also installs cargo.

cargo build --release

Compiles the Rust project.

cargo run

Builds and then immediately runs the program.

✅ If cargo build finishes without errors, it worked. The executable is created under target/.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# 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](https://riceprompt.app)** — the visual
agent IDE where you build and run these workflows without writing YAML by hand.

```toml
[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`](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:

```yaml
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:

```rust
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/`](examples/).

## Documentation

- [`docs/FLOW_SPEC.md`](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.

## Related

- **[RicePrompt](https://riceprompt.app)** — 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](LICENSE-APACHE) or
  <http://www.apache.org/licenses/LICENSE-2.0>)
- MIT license ([LICENSE-MIT](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.