Paladin Feature Flags

Paladin uses Cargo feature flags to enable fine-grained control over compiled dependencies and functionality. This allows you to build minimal, focused binaries for specific use cases while reducing compile times and binary sizes.

See also the Crate Map & Feature Flags reference for per-crate flag tables, the crate dependency graph, and copy-paste consumer profiles.

Table of Contents

• Overview
• Available Feature Flags
• Default Configuration
• Usage Examples
• Build Comparison
• Feature Dependencies
• Best Practices

Overview

Philosophy

Feature flags in Paladin follow these principles:

1. Core Framework Always Available - Paladin agents, Battalion orchestration, Garrison memory, Arsenal tools, and Herald formatters are always compiled
2. Provider Choice - Choose which LLM providers to support (OpenAI, Anthropic, DeepSeek)
3. Subsystem Opt-In - Enable only the subsystems you need (web servers, content processing, notifications)
4. Infrastructure Selection - Pick storage/queue adapters (Redis, S3/MinIO, Qdrant)
5. Testing Flexibility - Enable integration tests only when needed

Default vs. Full

Available Feature Flags

LLM Provider Flags

Subsystem Flags

Storage & Queue Flags

Special Build Flags

CLI Flags

Build the paladin-cli binary with:

cargo build --bin paladin-cli --features cli

Testing Flags

Convenience Flags

Default Configuration

Current Default (as of v0.5.0):

[dependencies]
paladin-ai = "0.5"

This enables only:

• ✅ llm-openai - OpenAI LLM provider
• ✅ Core framework (always available)

Previous Default (before v0.5.0):

# Old default - no longer applies
default = ["redis-queue", "s3-storage", "openai-embeddings"]

See migration-guide.md for migration guidance.

Usage Examples

Minimal Build (Core Only)

No external LLM providers, storage, or queues:

[dependencies]
paladin-ai = { version = "0.5", default-features = false }

Use case: Custom LLM integrations, library embedding, edge deployments

Single Provider Builds

OpenAI Only (default):

[dependencies]
paladin-ai = "0.5"
# Or explicitly:
paladin-ai = { version = "0.5", features = ["llm-openai"] }

Anthropic Only:

[dependencies]
paladin-ai = { version = "0.5", default-features = false, features = ["llm-anthropic"] }

DeepSeek Only:

[dependencies]
paladin-ai = { version = "0.5", default-features = false, features = ["llm-deepseek"] }

Multi-Provider Builds

All LLM Providers:

[dependencies]
paladin-ai = { version = "0.5", default-features = false, features = ["llm-all"] }

OpenAI + Anthropic:

[dependencies]
paladin-ai = { version = "0.5", default-features = false, features = ["llm-openai", "llm-anthropic"] }

Orchestration Platform Build

Agents + web API + Redis queue + S3 storage:

[dependencies]
paladin-ai = { version = "0.5", features = ["web-server", "redis-queue", "s3-storage"] }

Content Processing Build

Content ingestion + processing + all providers:

[dependencies]
paladin-ai = { version = "0.5", features = ["llm-all", "content-processing", "qdrant", "s3-storage"] }

Full Development Build

All features enabled:

[dependencies]
paladin-ai = { version = "0.5", features = ["full"] }

Or use the CLI:

cargo build --features full
cargo test --features full

Production API Server

Web server + notifications + OpenAI + storage:

[dependencies]
paladin-ai = { version = "0.5", features = ["web-server", "notifications", "redis-queue", "s3-storage"] }

Build Comparison

Binary Size Comparison

*Approximate values for release builds on x86_64 Linux. Actual values vary by system.

Compile Time Optimization

Fast iteration (core only):

cargo build --no-default-features
cargo test --lib --no-default-features

Full testing (all features):

cargo test --features full

Feature Dependencies

Dependency Tree

full
├── llm-all
│   ├── llm-openai
│   ├── llm-anthropic
│   └── llm-deepseek
├── content-processing
│   ├── pdf-extract
│   ├── scraper
│   ├── tiktoken-rs
│   └── rss
├── web-server
│   ├── actix-web
│   └── axum
├── notifications
│   ├── lettre
│   └── handlebars
├── vision
├── redis-queue
│   └── redis
├── s3-storage
│   └── rust-s3
├── openai-embeddings
└── qdrant
    └── qdrant-client

Conditional Compilation Examples

In Your Code:

// Always available (core framework)
use paladin::core::platform::container::paladin::Paladin;
use paladin::application::services::paladin::paladin_builder::PaladinBuilder;

// Conditionally compiled
#[cfg(feature = "llm-openai")]
use paladin::infrastructure::adapters::llm::openai_adapter::OpenAIAdapter;

#[cfg(feature = "redis-queue")]
use paladin::infrastructure::adapters::queue::redis::RedisQueueAdapter;

#[cfg(feature = "web-server")]
use paladin::infrastructure::web::server::start_web_server;

Best Practices

1. Start Minimal, Add as Needed

Begin with default features, add others only when required:

# Start here
[dependencies]
paladin-ai = "0.5"

# Add features as needed
paladin-ai = { version = "0.5", features = ["redis-queue"] }

2. Use full for Development Only

Enable all features during development, but specify exact features for production:

[dependencies]
# Production - explicit features
paladin-ai = { version = "0.5", features = ["llm-anthropic", "s3-storage"] }

[dev-dependencies]
# Development - all features
paladin-ai = { version = "0.5", features = ["full"] }

3. Document Feature Requirements

If your application requires specific features, document them:

//! # Example Application
//!
//! **Required Features:**
//! ```toml
//! paladin-ai = { version = "0.5", features = ["llm-openai", "redis-queue", "s3-storage"] }
//! ```

4. Test with Multiple Feature Combinations

Use CI to test critical combinations:

# .github/workflows/ci.yml
strategy:
  matrix:
    features:
      - "--no-default-features"
      - ""  # default
      - "--features full"

See .github/workflows/ for Paladin's complete feature matrix testing.

5. Feature-Gate Examples

Add feature requirements to example documentation:

//! # Redis Queue Example
//!
//! **Required Cargo Features:**
//! ```toml
//! paladin-ai = { version = "0.5", features = ["redis-queue"] }
//! ```
//!
//! Run with: `cargo run --example redis_queue --features redis-queue`

Migration Guide

If you're upgrading from a version before the feature flag reorganization, see migration-guide.md for detailed migration instructions.

CI/CD Integration

GitHub Actions

name: CI
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        features:
          - ""                              # default
          - "--no-default-features"         # core only
          - "--features full"               # all features
          - "--features llm-anthropic"      # specific provider
    steps:
      - uses: actions/checkout@v4
      - uses: actions-rs/toolchain@v1
        with:
          toolchain: stable
      - name: Test
        run: cargo test ${{ matrix.features }}

Docker Multi-Stage Builds

# Builder with only needed features
FROM rust:1.75 as builder
WORKDIR /app
COPY . .
RUN cargo build --release --features "llm-openai,redis-queue,s3-storage"

# Runtime image
FROM debian:bookworm-slim
COPY --from=builder /app/target/release/paladin /usr/local/bin/
CMD ["paladin"]

Support

For issues or questions about feature flags:

• Documentation: Configuration Guide
• Migration: Migration Guide
• Issues: GitHub Issues
• Discussions: GitHub Discussions