mubit-sdk (Rust)

Canonical Rust SDK for MuBit. Durable memory + continual learning for AI agents.

Full documentation: https://docs.mubit.ai

Install

cargo add mubit-sdk

Two Layers

The SDK offers two integration depths. Start at the top and drop down only when you need more control.

Admin and low-level storage ops still live under client.auth and client.core for clarity.

Learn (Closed-Loop Memory)

The learn module provides explicit methods for closed-loop memory. Unlike Python/JS, Rust does not use monkey-patching — call enrich_messages() before your LLM call and record() after.

use mubit_sdk::learn::{LearnSession, LearnConfig};
use serde_json::json;

let session = LearnSession::new(
    LearnConfig::from_env()
        .agent_id("my-agent")
        .inject_lessons(true)
        .auto_reflect(true)
).await;

let messages = vec![
    json!({"role": "user", "content": "Fix the auth bug"}),
];

// Enrich with lessons before LLM call
let enriched = session.enrich_messages(&messages).await;

// Make your LLM call with enriched messages...

// Record the interaction
session.record("response text", "gpt-4o", 1500.0).await;

// End run (triggers reflection)
session.end().await;

Key config: inject_lessons, injection_position, max_token_budget, auto_reflect, cache_ttl_seconds, fail_open.

Client Helpers

Quickstart

use mubit_sdk::{Client, ClientConfig, RecallOptions, RememberOptions};
use std::env;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let api_key = env::var("MUBIT_API_KEY")?;
    let client = Client::new(
        ClientConfig::default()
            .run_id("sdk-rust-demo")
            .api_key(api_key),
    )?;

    let mut remember = RememberOptions::new(
        "Checkpoint before replaying recovery after token signer rotation.",
    );
    remember.run_id = Some("sdk-rust-demo".to_string());
    remember.intent = Some("lesson".to_string());
    remember.lesson_type = Some("success".to_string());
    client.remember(remember).await?;

    let mut recall = RecallOptions::new("What should I do before replaying recovery?");
    recall.run_id = Some("sdk-rust-demo".to_string());
    recall.entry_types = vec!["lesson".to_string(), "rule".to_string()];
    let answer = client.recall(recall).await?;

    println!("{}", answer["final_answer"]);
    Ok(())
}

Methods by Use Case

Helper calls take typed option structs instead of raw serde_json::Value payload bags.

The Learning Loop

1. remember()         → ingest facts, traces, lessons into MuBit
2. reflect()          → LLM extracts lessons from run evidence
                         (auto-promotes recurring lessons: run → session → global)
3. get_context()      → retrieve relevant lessons for the next LLM call
4. record_outcome()   → reinforce what worked, adjust confidence scores

With LearnSession, steps 1 and 3 are handled by record() and enrich_messages(). With helpers, you orchestrate them yourself.

Exact References

use mubit_sdk::{ArchiveOptions, Client, ClientConfig, DereferenceOptions};

let client = Client::new(ClientConfig::default().run_id("sdk-rust-demo"))?;

let mut archive = ArchiveOptions::new(
    "--- a/query.py\n+++ b/query.py\n@@ ...",
    "patch_fragment",
);
archive.run_id = Some("sdk-rust-demo".to_string());
archive.labels = vec!["django".to_string(), "retry".to_string()];
let archived = client.archive(archive).await?;

let mut dereference = DereferenceOptions::new(
    archived["reference_id"].as_str().unwrap_or_default(),
);
dereference.run_id = Some("sdk-rust-demo".to_string());
let exact = client.dereference(dereference).await?;
println!("{}", exact["evidence"]["content"]);

Managed MuBit resources

For teams and hosted deployments, configure agents declaratively as Projects + Agent Cards with versioned prompts and skills. Full guide: Projects, Agents, Skills, Prompts.

Managed resources are accessed directly on Client with serde_json::json! payloads — typed option structs (like RememberOptions) exist only for the 17 high-level helpers.

Projects

use serde_json::json;

let resp = client.create_project(json!({
    "name": "triage-demo",
    "description": "Customer-support triage pilot",
})).await?;
let project_id = resp["project"]["project_id"].as_str().unwrap();

let projects = client.list_projects(json!({})).await?;

Agent Definitions

client.create_agent_definition(json!({
    "project_id": project_id,
    "agent_id": "triage",
    "role": "customer triage agent",
    "system_prompt_content": "You are a concise, empathetic triage agent...",
})).await?;

Prompt version lifecycle

Every agent has exactly one active prompt version and any number of candidate versions awaiting review.

// Manual edit — activates immediately.
client.set_prompt(json!({
    "agent_id": "triage",
    "content": "...",
    "activate": true,
})).await?;

// Ask the control plane to propose a candidate from recent outcomes.
let resp = client.optimize_prompt(json!({
    "agent_id": "triage",
    "project_id": project_id,
})).await?;
let candidate_id = resp["candidate"]["version_id"].as_str().unwrap();

// Diff + approve.
let diff = client.get_prompt_diff(json!({
    "agent_id": "triage",
    "version_a_id": active_version_id,
    "version_b_id": candidate_id,
})).await?;

client.activate_prompt_version(json!({
    "agent_id": "triage",
    "version_id": candidate_id,
})).await?;

See Prompt Optimization Lifecycle for the full capture → optimize → review → activate workflow.

Skills

Same lifecycle — create_skill, optimize_skill, activate_skill_version, get_skill_diff all accept json!{...} payloads and return the same version shape as prompts.

Examples

Public adoption scenarios:

cargo run --example 01_remember_recall --features public-examples
cargo run --example 13_learn_module_smoke --features public-examples

Internal smoke tests for wire-level verification live under examples/internal/.

Related

• Full documentation: https://docs.mubit.ai
• SDK methods reference: https://docs.mubit.ai/sdk/sdk-methods
• API reference (HTTP + gRPC): https://docs.mubit.ai/api-reference/control-http
• GitHub: https://github.com/mubit-ai/ricedb