Struct LocalMesh 

pub struct LocalMesh { /* private fields */ }

Implementations

impl LocalMesh

pub fn new(name: impl Into<String>) -> Self

Examples found in repository

examples/mesh_architecture.rs (line 80)

async fn main() -> Result<()> {
    // 1. Create the Mesh (wrapped in Arc for sharing)
    let mesh = Arc::new(LocalMesh::new("main_mesh"));

    // 2. Create Agents with reference to mesh
    let completion = Arc::new(Notify::new());

    let worker = Box::new(WorkerAgent { mesh: mesh.clone() });
    let manager = Box::new(ManagerAgent {
        mesh: mesh.clone(),
        completion_notify: completion.clone(),
    });

    // 3. Register Agents
    mesh.add_agent(worker).await?;
    mesh.add_agent(manager).await?;

    // 4. Start Mesh
    mesh.start().await?;

    // Wait for the interaction to complete
    println!("Waiting for interaction to complete...");
    // Timeout after 5 seconds
    tokio::select! {
        _ = completion.notified() => {
            println!("Interaction completed successfully!");
        }
        _ = tokio::time::sleep(Duration::from_secs(5)) => {
            println!("Timeout waiting for interaction.");
        }
    }

    // 5. Stop Mesh
    mesh.stop().await?;

    Ok(())
}

examples/llm_multi_agent_mesh.rs (line 226)

async fn main() -> Result<()> {
    println!("=== Ceylon Runtime - LLM Multi-Agent Mesh Example ===\n");
    println!("This example demonstrates two LLM agents communicating via LocalMesh:");
    println!("  1. Researcher Agent - Researches a given topic");
    println!("  2. Summarizer Agent - Summarizes the research findings\n");

    // 1. Create the Mesh
    let mesh = Arc::new(LocalMesh::new("llm_mesh"));

    // 2. Create completion notifier
    let completion = Arc::new(Notify::new());

    // 3. Create LLM-powered agents
    let researcher = match ResearcherAgent::new(mesh.clone()) {
        Ok(agent) => agent,
        Err(e) => {
            eprintln!("Failed to create Researcher agent: {}", e);
            eprintln!("Make sure Ollama is running and gemma3:latest is available.");
            return Err(e);
        }
    };

    let summarizer = match SummarizerAgent::new(completion.clone()) {
        Ok(agent) => agent,
        Err(e) => {
            eprintln!("Failed to create Summarizer agent: {}", e);
            eprintln!("Make sure Ollama is running and gemma3:latest is available.");
            return Err(e);
        }
    };

    let coordinator = CoordinatorAgent {
        mesh: mesh.clone(),
        topic: "The benefits of Rust programming language for system development".to_string(),
    };

    // 4. Register agents with the mesh
    mesh.add_agent(Box::new(researcher)).await?;
    mesh.add_agent(Box::new(summarizer)).await?;
    mesh.add_agent(Box::new(coordinator)).await?;

    println!("✓ All agents registered successfully\n");

    // 5. Start the mesh (this triggers on_start for all agents)
    mesh.start().await?;

    // 6. Wait for the workflow to complete
    println!("Waiting for multi-agent workflow to complete...\n");
    tokio::select! {
        _ = completion.notified() => {
            println!("Multi-agent workflow completed successfully!");
        }
        _ = tokio::time::sleep(Duration::from_secs(120)) => {
            println!("Timeout waiting for workflow completion.");
        }
    }

    // 7. Stop the mesh
    mesh.stop().await?;

    println!("\n=== Example finished ===");
    Ok(())
}

pub fn request_queue(&self) -> Arc<RequestQueue>

Get the request queue (for sharing with agent wrappers)

impl LocalMesh

pub async fn broadcast( &self, message: Message, exclude: Option<&str>, ) -> Result<Vec<Result<()>>>

Broadcast a message to all agents in the mesh

pub async fn submit(&self, target: &str, payload: String) -> Result<String>

Submit a request (fire-and-forget). Returns request ID.

pub fn get_pending(&self) -> Vec<MeshRequest>

Get pending requests

pub fn has_pending(&self) -> bool

Check if there are pending requests

pub fn get_results(&self) -> Vec<MeshResult>

Get available results (removes them from queue)

pub fn peek_results(&self) -> Vec<MeshResult>

Peek at results without removing

pub async fn send_reminders(&self, older_than_secs: f64) -> Result<Vec<String>>

Send reminders for stale requests

pub async fn wait_for( &self, request_id: &str, timeout_secs: f64, reminder_interval_secs: f64, ) -> Result<MeshResult>

Wait for a specific result with auto-reminders

pub async fn collect_results( &self, reminder_interval_secs: f64, ) -> Vec<MeshResult>

Collect all results, blocking until all pending complete

Trait Implementations

impl Mesh for LocalMesh

fn start<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Start the mesh and all registered agents.

fn stop<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stop the mesh and all agents.

fn add_agent<'life0, 'async_trait>( &'life0 self, agent: Box<dyn Agent + 'static>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Add an agent to the mesh.

fn send<'life0, 'life1, 'async_trait>( &'life0 self, message: Message, target: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Send a message to a specific agent by name.