ceylon-runtime 0.1.1

A Rust-based agent mesh framework for building local and distributed AI agent systems
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

# Ceylon Runtime


A Rust-based agent mesh framework for building local and distributed AI agent systems.

[![Crates.io](https://img.shields.io/crates/v/ceylon-runtime.svg)](https://crates.io/crates/ceylon-runtime)
[![Documentation](https://docs.rs/ceylon-runtime/badge.svg)](https://docs.rs/ceylon-runtime)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Features


- **Agent Framework**: Build autonomous AI agents with a simple trait-based API
- **Local Mesh**: Connect multiple agents in a local mesh for inter-agent communication
- **LLM Integration**: Built-in support for various LLM providers (OpenAI, Ollama, Vertex AI, etc.)
- **Memory Backends**: Pluggable memory systems with in-memory, SQLite, and Redis support
- **Async-first**: Built on Tokio for high-performance async operations
- **Logging & Metrics**: Structured logging and metrics collection built-in

## Installation


Add to your `Cargo.toml`:

```toml
[dependencies]
ceylon-runtime = "0.1"
```

### Feature Flags


- `sqlite` - Enable SQLite memory backend
- `redis` - Enable Redis memory backend
- `full` - Enable all optional backends

```toml
[dependencies]
ceylon-runtime = { version = "0.1", features = ["sqlite", "redis"] }
```

## Quick Start


```rust
use ceylon_runtime::{Agent, AgentContext, LocalMesh, Message};
use async_trait::async_trait;

struct MyAgent {
    name: String,
}

#[async_trait]

impl Agent for MyAgent {
    fn name(&self) -> String {
        self.name.clone()
    }

    async fn on_message(&mut self, msg: Message, ctx: &mut AgentContext) -> ceylon_runtime::core::error::Result<()> {
        println!("Received: {:?}", msg);
        Ok(())
    }
}

#[tokio::main]

async fn main() -> anyhow::Result<()> {
    let agent = MyAgent { name: "my-agent".to_string() };
    let mut mesh = LocalMesh::new("my-mesh");
    mesh.add_agent(Box::new(agent));
    mesh.start().await?;
    Ok(())
}
```

## Using LLM Agents


```rust
use ceylon_runtime::{LlmAgent, LLMConfig, InMemoryBackend};

#[tokio::main]

async fn main() -> anyhow::Result<()> {
    let config = LLMConfig::ollama("llama3.2", None);
    let memory = InMemoryBackend::new();

    let agent = LlmAgent::new(
        "assistant",
        "You are a helpful assistant",
        config,
        memory,
    );

    // Add to mesh and use...
    Ok(())
}
```

## Core Components


| Component         | Description                                   |
| ----------------- | --------------------------------------------- |
| `Agent`           | Trait for defining agent behavior             |
| `LocalMesh`       | Local multi-agent coordination                |
| `LlmAgent`        | Pre-built agent with LLM capabilities         |
| `Memory`          | Trait for memory backends                     |
| `InMemoryBackend` | In-memory storage (default)                   |
| `SqliteBackend`   | SQLite persistent storage (feature: `sqlite`) |
| `RedisBackend`    | Redis distributed storage (feature: `redis`)  |

## Documentation


- [API Documentation](https://docs.rs/ceylon-runtime)
- [GitHub Repository](https://github.com/ceylonai/ceylon)

## License


This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

## Contributing


Contributions are welcome! Please feel free to submit a Pull Request.