bevy_rig 0.1.0

Bevy ECS primitives and systems for modeling providers, agents, tools, sessions, runs, and workflows on top of Rig.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use bevy_app::App;
use bevy_ecs::hierarchy::ChildOf;
use bevy_rig::prelude::*;

fn main() {
    let mut app = App::new();
    app.add_plugins(BevyRigPlugin);

    let (provider, agent) = {
        let world = app.world_mut();

        let provider = spawn_provider(
            world,
            ProviderSpec::new(ProviderKind::OpenAi, "openai"),
            ProviderCapabilities::text_tooling(),
        );

        let chat_model = spawn_model(
            world,
            provider,
            ModelSpec::new("gpt-4o-mini").with_family("gpt-4o"),
            ModelCapabilities::chat_with_tools(),
            128_000,
        )
        .expect("chat model should register");

        spawn_model(
            world,
            provider,
            ModelSpec::new("text-embedding-3-large").with_family("embedding"),
            ModelCapabilities::embeddings_only(),
            8_192,
        )
        .expect("embedding model should register");

        let agent = spawn_agent_from_model(world, "planner", chat_model)
            .expect("agent should bind to a registered model")
            .agent;

        (provider, agent)
    };

    let world = app.world();
    let model = world
        .get::<AgentModelRef>(agent)
        .expect("agent should have a model ref")
        .0;
    let model_spec = world.get::<ModelSpec>(model).expect("model spec");
    let provider_spec = world
        .get::<ProviderSpec>(
            world
                .get::<ChildOf>(model)
                .expect("model should be owned by provider")
                .parent(),
        )
        .expect("provider spec");
    let registry = world.resource::<ModelRegistry>();

    let qualified_name = format!("{}/{}", provider_spec.label, model_spec.name);
    let resolved = registry
        .resolve_qualified(&qualified_name)
        .expect("qualified model lookup should succeed");

    println!("Agent model: {qualified_name}");
    println!("Resolved entity matches: {}", resolved == model);

    for model_entity in registry.models_for_provider(provider) {
        let spec = world.get::<ModelSpec>(model_entity).expect("model spec");
        let capabilities = world
            .get::<ModelCapabilities>(model_entity)
            .expect("model capabilities");
        println!(
            "Provider model: {} (chat={}, embeddings={}, tools={})",
            spec.name, capabilities.completions, capabilities.embeddings, capabilities.tools
        );
    }
}