Universal Bot - Enterprise AI Automation Framework

Enterprise-grade AI automation framework integrating AWS Bedrock, PDMT templating, and AssetGen content generation into a unified, production-ready platform.

🚀 Overview

Universal Bot is a comprehensive AI-powered automation framework that combines cutting-edge technologies from production systems:

• AWS Bedrock Integration: Enterprise-grade AI model orchestration with Claude Opus 4.1, Sonnet 4, and more
• PDMT Templating: Deterministic, reproducible content generation with quality gates
• AssetGen Engine: Automated educational and marketing content creation
• MCP Protocol: Native Model Context Protocol support for AI assistants
• Production-Ready: 85%+ test coverage, property testing, and comprehensive validation

🏗️ Core Technologies

AWS Bedrock Runtime

• Connection Pooling: Enterprise-grade connection management with retry logic
• Model Orchestra: Claude Opus 4.1, Sonnet 4, Llama, Titan multi-model support
• Token Management: Automatic usage tracking and cost optimization
• Streaming: Real-time response streaming for interactive applications
• Metrics: Comprehensive observability with latency and success tracking

PDMT (Pragmatic Deterministic MCP Templating)

• Zero-Temperature Generation: Reproducible outputs with deterministic templates
• Quality Gates: PMAT enforcement with coverage, complexity, and SATD detection
• Todo Validation: Actionability scoring and dependency analysis
• MCP Native: Full Model Context Protocol support via PMCP SDK

AssetGen Content Engine

• Multi-Format Generation: Quizzes, labs, blog posts, marketing content
• Platform-Specific: MailChimp, LinkedIn, Discord, Bluesky optimized content
• Meta-Aware Validation: Automatic detection and removal of transcript artifacts
• GitHub Integration: Automated publishing pipeline with issue tracking

📦 Key Features

AI Model Integration

• ✅ AWS Bedrock Runtime: Production-ready with retry logic and pooling
• ✅ Multi-Model Support: Claude, Llama, Titan, Jurassic orchestration
• ✅ Token Optimization: Automatic counting and cost tracking
• ✅ Streaming Responses: Real-time token generation

Content Generation

• ✅ Educational Materials: Automated quiz, lab, and reflection creation
• ✅ Marketing Content: Platform-specific for MailChimp, LinkedIn, Discord
• ✅ Blog Generation: Technical blogs with Zola/Hugo support
• ✅ Transcription Processing: Whisper.cpp integration

Quality Assurance

• ✅ Property Testing: 100+ property tests ensuring robustness
• ✅ Coverage Tracking: 85%+ test coverage with reporting
• ✅ Validation Pipeline: Multi-stage validation with quality gates
• ✅ CI/CD Integration: GitHub Actions and self-hosted runners

🏗️ Architecture

universal-bot/
├── core/                    # Core Rust components
│   ├── bedrock/            # AWS Bedrock client implementation
│   │   ├── client.rs       # Connection pooling & retry logic
│   │   ├── models.rs       # Model configuration & selection
│   │   └── metrics.rs      # Token usage & cost tracking
│   ├── pdmt/               # Template engine
│   │   ├── engine.rs       # Handlebars-based generation
│   │   ├── validators.rs   # Todo validation & scoring
│   │   └── quality.rs      # Quality gate enforcement
│   └── providers/          # AI provider abstractions
│       ├── bedrock.rs      # AWS Bedrock provider
│       └── mcp.rs          # MCP protocol provider
├── generators/             # Content generation modules
│   ├── quiz/              # Quiz generation with validation
│   ├── blog/              # Blog post generation
│   ├── marketing/         # Multi-platform marketing
│   └── educational/       # Labs, reflections, key terms
├── validators/            # Validation components
│   ├── content.rs        # Meta-aware content validation
│   ├── quality.rs        # Quality gate checks
│   └── structure.rs      # Course structure validation
└── integrations/         # External integrations
    ├── github/          # GitHub API & Actions
    ├── aws/             # S3, Bedrock services
    └── mcp/             # Model Context Protocol

🛠️ Prerequisites

Required

• Rust 1.75+ (latest stable)
• AWS Account with Bedrock access
• 8GB RAM minimum
• 2GB disk space

Optional

• Node.js 18+ (for TypeScript integrations)
• Docker (for containerized deployment)
• GitHub account (for CI/CD)

📦 Installation

From crates.io

[dependencies]
universal-bot-core = "1.0"

From source

# Clone the repository
git clone https://github.com/paiml/universal-bot
cd universal-bot

# Install dependencies
make install

# Configure AWS credentials
aws configure

# Run tests to verify setup
make test

# Start the bot
cargo run --bin universal-bot

📁 Repository Structure

universal-bot-rust/
│
├── 📦 core/                        # The 80% - Universal AI Brain
│   ├── src/
│   │   ├── bedrock/               # AWS Bedrock client & models
│   │   │   ├── client.rs         # Connection management
│   │   │   ├── models.rs         # Model orchestration
│   │   │   └── streaming.rs      # Real-time responses
│   │   │
│   │   ├── conversation/         # Conversation engine
│   │   │   ├── pipeline.rs      # Message processing
│   │   │   ├── state.rs         # State machines
│   │   │   └── context.rs       # Memory management
│   │   │
│   │   ├── plugins/              # Extension system
│   │   │   ├── traits.rs        # Plugin interfaces
│   │   │   ├── registry.rs      # Plugin management
│   │   │   └── builtin/         # Core plugins
│   │   │
│   │   └── lib.rs               # Public API
│   │
│   ├── examples/                 # Runnable demonstrations
│   │   ├── basic_conversation.rs
│   │   ├── multi_model_chat.rs
│   │   ├── stream_conversation.rs
│   │   └── plugin_demo.rs
│   │
│   └── Cargo.toml               # Dependencies
│
├── 📚 adapters/                   # The 20% - Platform Theory
│   ├── discord_theory.md        # Discord architecture (no code)
│   ├── slack_theory.md          # Slack patterns (conceptual)
│   ├── web_api_theory.md        # REST endpoints (theory)
│   └── integration_patterns.md  # General adapter design
│
├── 🎓 course/                    # Video course materials
│   ├── module_1/                # Foundation videos
│   ├── module_2/                # Core engine videos
│   ├── module_3/                # Advanced patterns
│   ├── module_4/                # Plugin architecture
│   └── module_5/                # Platform theory
│
├── 📖 docs/                      # Documentation
│   ├── architecture.md          # System design
│   ├── bedrock_setup.md        # AWS configuration
│   ├── rust_patterns.md        # Rust best practices
│   └── deployment.md           # Production guide
│
├── 🧪 tests/                     # Test suite
│   ├── integration/             # End-to-end tests
│   └── unit/                    # Component tests
│
└── 🔧 scripts/                   # Utility scripts
    ├── setup.sh                 # Environment setup
    ├── test.sh                  # Run all tests
    └── deploy.sh                # Deployment helper

💡 Key Concepts Visualized

The Message Pipeline

Think of messages flowing through a factory assembly line:

     Raw Input                  Enriched                   Routed
         │                         │                         │
         ▼                         ▼                         ▼
    ┌─────────┐             ┌─────────┐              ┌─────────┐
    │ Sanitize│ ──────────► │ Context │ ───────────► │  Model  │
    └─────────┘             └─────────┘              └─────────┘
                                                           │
                                                           ▼
    ┌─────────┐             ┌─────────┐              ┌─────────┐
    │ Display │ ◄────────── │ Format  │ ◄──────────  │   AI    │
    └─────────┘             └─────────┘              └─────────┘
     Final Output             Structured               Response

The Plugin System

Like LEGO blocks with standardized connectors:

pub trait BotPlugin {
    async fn process(&self, input: Message) -> Result<Message>;
    fn capabilities(&self) -> Vec<Capability>;
}

// Any plugin can connect if it fits the trait
impl BotPlugin for WeatherPlugin { ... }
impl BotPlugin for DatabasePlugin { ... }
impl BotPlugin for CustomPlugin { ... }

🧪 Testing

# Run all tests
make test

# Run specific test suite
cargo test --package universal-bot-core

# Run property tests
cargo test --features property-testing

# Run integration tests
cargo test --test integration

# Generate coverage report
make coverage

# Run linting and formatting
make lint
cargo fmt --check
cargo clippy -- -D warnings

🚀 Example: Your First Universal Bot

use universal_bot::{BotCore, BedrockConfig, Message};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize the universal brain
    let config = BedrockConfig::from_env()?;
    let bot = BotCore::new(config).await?;
    
    // Process a message (platform-agnostic)
    let input = Message::text("Hello, what can you do?");
    let response = bot.process(input).await?;
    
    println!("🤖 {}", response.content);
    
    // This same bot core could connect to:
    // - Discord (with adapter)
    // - Slack (with adapter)
    // - Web API (with adapter)
    // - Any platform (with adapter)
    
    Ok(())
}

🎓 Course Philosophy

Why 80/20?

• 80% Universal: The AI logic, conversation management, and business logic remain constant
• 20% Specific: Only the platform connection changes

Why Rust?

• Memory Safety: No null pointer exceptions in production
• Performance: Near C++ speed with high-level abstractions
• Concurrency: True parallel processing with Tokio
• Type Safety: Catch errors at compile time, not runtime

Why AWS Bedrock?

• Multi-Model: Access to Claude, Llama, and more
• Enterprise Ready: Built for production scale
• Streaming: Real-time token generation
• Managed: No model hosting headaches

🤝 Community & Support

Get Help

• 💬 Discord Server: Join our community
• 🐛 Issues: Report bugs
• 💡 Discussions: Share ideas

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Office Hours

• Tuesdays: 2 PM EST - Rust basics
• Thursdays: 3 PM EST - AWS Bedrock deep dive
• Fridays: 1 PM EST - Architecture review

📈 Progress Tracking

Track your learning journey:

- [x] Module 1: Foundation
- [x] Module 2: Core Engine
- [ ] Module 3: Advanced AI
- [ ] Module 4: Plugins
- [ ] Module 5: Platform Theory
- [ ] Final Project: Custom Bot Brain

🏆 Certification Path

Complete all modules and build a custom bot brain to earn:

• Certificate of Completion
• Portfolio Project for GitHub
• LinkedIn Badge for your profile
• Community Recognition as a Universal Bot Architect

📊 Success Metrics

What Success Looks Like

Week 1: "I can connect to AWS Bedrock from Rust"
Week 2: "I built a conversation engine"
Week 3: "My bot uses multiple AI models"
Week 4: "I created custom plugins"
Week 5: "I understand how to adapt this anywhere"
Final:  "I have a production-ready AI brain"

🔮 Beyond the Course

Where This Leads

• Senior Positions: Architect-level thinking
• Startup Ready: Build AI products quickly
• Open Source: Contribute to major projects
• Consulting: Help others modernize their bots

Next Steps After Completion

1. Build a production bot for a real use case
2. Create your own platform adapter
3. Contribute plugins to the community
4. Teach others the 80/20 approach

📝 License

This project is licensed under the MIT License - see LICENSE file for details.

🙏 Acknowledgments

• AWS Bedrock Team for the powerful AI platform
• Rust Community for the amazing ecosystem
• Tokio Project for async runtime excellence
• You for choosing to think differently about bots

🧠 Stop Building Bots. Start Building Brains. 🧠

The future isn't platform-specific. It's universally intelligent.

Start Course • Watch Videos • Join Community