Rig

📑 Docs   •   🌐 Website   •   🤝 Contribute   •   ✍🏽 Blogs   •  

Rig is a Rust library for building LLM applications, and rig, a terminal coding agent built on it that you extend with Bevy plugins.

The coding agent

rig-cli is not on crates.io yet. Until the next release, install the last release, 0.46.0, whose rig crate carries the launcher:

cargo install rig

This README describes main. 0.46.0 keeps its plugin list in plugins.toml, and its guide is on its tag. Or install main from a checkout (--force replaces a rig installed by another crate):

git clone https://github.com/0xPlaygrounds/rig && cd rig
cargo install --locked --force --path crates/rig-cli

Then:

1. rig builds the agent, which takes several minutes the first time, and opens it.
2. /login signs in with a ChatGPT plan or saves a provider's API key. Or export a key, such as OPENAI_API_KEY, before starting rig.
3. /model picks a model. A local Ollama or llama.cpp server is listed once OLLAMA_API_BASE_URL or LLAMACPP_API_BASE_URL names it, or its key variable is set.
4. Type a prompt and press Enter. /help lists the commands.
5. rig -p "fix the failing test" answers one prompt without the terminal view.

rig update updates rig (how). The agent guide also says what is per home and what is per project.

• Everything is a plugin. The agent is a Bevy app; its tools, commands, sessions, sign-in and terminal view are each a plugin, turned on or off in settings.toml, so any of them can be removed, replaced or added to.
• It rebuilds itself. /reload rebuilds the agent with your plugin crates and restarts it in the same session, and keeps the old build running if the new one does not compile. rig update reinstalls rig with cargo; /update does it from the agent and restarts on it. Both arrive with the next release: 0.46.0 updates by installing again.
• Scriptable. rig -p --json and rig --json drive it over pipes; rig help-agents is the protocol.
• More when you want it. Subagents are an optional plugin, and the tools work on remote hosts over ssh or any command.

The agent guide covers the keys, sessions, compaction, plugins and files, and the plugin guide shows how to write a tool, command or panel. The agent needs Rust 1.97.1 or newer and runs on Linux and macOS.

The library

cargo add rig

use rig::prelude::*;
use rig::providers::openai::{self, OpenAI};

#[tokio::main]
async fn main() -> Result<(), anyhow::Error> {
    // The client reads `OPENAI_API_KEY` and builds the models it serves.
    let model = OpenAI::from_env()?.completion(openai::GPT_6_1_SOL);
    let comedian = AgentBuilder::new(model)
        .preamble("You are a comedian here to entertain the user using humour and jokes.")
        .build();

    let response = comedian.prompt("Entertain me!").await?;
    println!("{}", response.output());
    Ok(())
}

The example also needs tokio, with the macros and rt-multi-thread features that #[tokio::main] uses, and anyhow (cargo add tokio --features macros,rt-multi-thread and cargo add anyhow).

• 20+ model providers and 10+ vector stores, each under one interface
• Agents with tools, multi-turn streaming and typed hooks
• Completion, embedding, transcription, audio and image generation
• GenAI semantic conventions for OpenTelemetry
• Recording and replay of an agent's effects (rig-cassette)
• Browser WASM (wasm32-unknown-unknown) for the core and the agent runtime (target support)

More in examples/, the docs and the API reference.

Crates

The rig crate re-exports rig-core, and each companion crate behind a feature.

Crate	Feature	What it is
rig-core	always	Provider-neutral messages, completion and embedding models, tool contracts, the conversation type, vector-store contracts, and the providers
rig-agent	agent (default)	The agent builder, prompting and streaming, hooks, the tool registry and the serializable AgentRun
rig-memory	memory	Windows, compaction, and saving, resuming and forking conversations
rig-cassette	cassette	Effect logs: recording, replay and checkpoints

The coding agent's crates are not facade features. Depend on them directly.

This is the beginning of the README. Read the rest at the original. Read the full README ↗