> ## Documentation Index
> Fetch the complete documentation index at: https://densumesh-broccoli-27.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Broccoli

> A robust, type-safe message queue system for Rust applications

# Broccoli

A robust message queue system for Rust applications, designed as a Rust alternative to [Celery](https://docs.celeryq.dev/). Broccoli provides asynchronous message processing with type safety, configurable retry strategies, and support for multiple message brokers.

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Get up and running with Broccoli in minutes
  </Card>

  <Card title="Installation" icon="download" href="/installation">
    Add Broccoli to your Rust project
  </Card>

  <Card title="Brokers" icon="server" href="/brokers/overview">
    Learn about supported message brokers
  </Card>

  <Card title="API Reference" icon="code" href="/api/queue">
    Explore the complete API documentation
  </Card>
</CardGroup>

## Features

<CardGroup cols={2}>
  <Card title="Type-safe messaging" icon="shield-check">
    Leverage Rust's type system for compile-time message validation
  </Card>

  <Card title="Multiple brokers" icon="database">
    Support for Redis, RabbitMQ, and SurrealDB backends
  </Card>

  <Card title="Configurable retries" icon="rotate">
    Built-in retry strategies for failed message handling
  </Card>

  <Card title="Connection pooling" icon="layer-group">
    Efficient resource management with connection pools
  </Card>

  <Card title="Message scheduling" icon="clock">
    Schedule messages for delayed or future delivery
  </Card>

  <Card title="Concurrent processing" icon="bolt">
    Process messages with configurable worker concurrency
  </Card>
</CardGroup>

## Quick example

```rust theme={null}
use broccoli_queue::{queue::BroccoliQueue, brokers::broker::BrokerMessage};
use serde::{Serialize, Deserialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
struct JobPayload {
    id: String,
    task_name: String,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize the queue with Redis
    let queue = BroccoliQueue::builder("redis://localhost:6379")
        .pool_connections(5)
        .failed_message_retry_strategy(Default::default())
        .build()
        .await?;

    // Publish a message
    let job = JobPayload {
        id: "job-1".to_string(),
        task_name: "process_data".to_string(),
    };
    
    queue.publish("jobs", None, &job, None).await?;

    // Process messages
    queue.process_messages("jobs", Some(2), None, |message: BrokerMessage<JobPayload>| async move {
        println!("Processing: {:?}", message.payload);
        Ok(())
    }).await?;

    Ok(())
}
```

## Why Broccoli?

If you're familiar with Celery but want to leverage Rust's performance and type safety, Broccoli provides:

* **Rust performance** - Native async/await with Tokio runtime
* **Type safety** - Compile-time message validation with serde
* **Multiple brokers** - Choose Redis, RabbitMQ, or SurrealDB based on your needs
* **Simple API** - Builder pattern for easy configuration

## Current status

Broccoli is under active development. Current broker support:

| Broker    | Status      |
| --------- | ----------- |
| Redis     | ✅ Available |
| RabbitMQ  | ✅ Available |
| SurrealDB | ✅ Available |
| Kafka     | 🚧 Planned  |