Agent Orchestration

Multi-domain AI agent orchestration system with RAG (Retrieval-Augmented Generation) capabilities for specialized knowledge domains.

Overview

This project provides a scalable framework for building domain-specific AI agents that can answer questions, provide guidance, and assist with technical tasks across multiple knowledge areas. The system uses advanced RAG techniques with vector databases, graph databases, and code analysis to provide accurate, context-aware responses.

Current Status

In Development - Docker domain implementation in progress

MCP Server Integration

The agent orchestration framework can be used as an MCP (Model Context Protocol) server with Claude Desktop, allowing Claude to query domain-specific agents directly from the chat interface.

Quick Setup

1. Install dependencies:

pip install -e .
pip install mcp

2. Configure Claude Desktop by adding to ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "agent-orchestration": {
      "command": "python3",
      "args": ["-m", "agent_orchestration.mcp_server"],
      "env": {
        "PYTHONPATH": "/path/to/agent_orchestration/src"
      }
    }
  }
}

3. Restart Claude Desktop and ask questions like:
   • "How do I optimize BuildKit caching?"
   • "What domains are available in the agent system?"
   • "Which domain would handle questions about DevContainers?"

For detailed setup instructions, see MCP_SETUP.md

Architecture

For detailed architecture documentation, see docs/ARCHITECTURE.md

Multi-Domain Design

The system is designed to support multiple specialized knowledge domains, each with its own:

• Domain-specific documentation and knowledge base
• Specialized AI agents trained on domain expertise
• Custom retrieval and ranking strategies
• Domain-specific tools and integrations

First Domain: Docker

Docker expertise serves as our inaugural domain, demonstrating the full capabilities of the system:

Expertise Areas:

• BuildKit: Build optimization, caching strategies, multi-stage builds
• Docker Bake & Buildx: Multi-platform builds, build coordination
• DevContainers: Development environment configuration
• Multi-Stage Optimization: Build performance and image size optimization

Documentation Location: docs/domains/docker/

Technology Stack

Core RAG & Vector Database:

• ChromaDB for vector storage and similarity search
• LlamaIndex for RAG pipeline orchestration
• Sentence Transformers for embeddings

Search & Graph Storage:

• Elasticsearch for full-text search
• Neo4j for knowledge graph relationships

Code Analysis:

• Tree-sitter for AST parsing
• Pygments for syntax highlighting

CLI/TUI Framework:

• Typer for command-line interface
• Rich for terminal output formatting
• Trogon for auto-generated TUI
• Textual for terminal UI components

Project Structure

agent_orchestration/
├── src/
│   └── agent_orchestration/
│       ├── cli/           # Command-line interface
│       ├── core/          # Core RAG and agent logic
│       ├── domains/       # Domain-specific implementations
│       └── utils/         # Shared utilities
├── docs/
│   ├── domains/
│   │   └── docker/        # Docker domain documentation
│   ├── ARCHITECTURE.md    # Multi-domain architecture design
│   ├── IMPLEMENTATION_GUIDE.md
│   ├── INDEX.md
│   ├── SUBDOMAIN_ARCHITECTURE.md
│   └── TOOLING_GUIDE.md
├── tests/
├── pixi.toml             # Environment management (pixi + uv)
├── pyproject.toml        # Python project configuration
└── docker-bake.hcl       # Multi-platform Docker builds

Development Setup

Prerequisites

• Python 3.13+
• Pixi for environment management
• Docker with BuildKit support

Quick Start

1. Clone the repository:

git clone https://github.com/rmanaloto-tastytrade/agent-orchestration.git
cd agent-orchestration

2. Install dependencies:

pixi install

3. Run quality checks:

pixi run check-all

Available Commands

Development Workflow:

pixi run init         # Initialize uv project
pixi run sync         # Sync dependencies
pixi run install      # Install all extras

Code Quality:

pixi run lint         # Run ruff linter (no fixes)
pixi run lint-fix     # Run ruff linter with fixes
pixi run format       # Format code with ruff
pixi run format-check # Check code formatting
pixi run typing       # Run mypy type checking

Security:

pixi run security     # Run bandit security scanner
pixi run safety-check # Check for known vulnerabilities

Testing:

pixi run test         # Run pytest
pixi run test-verbose # Run pytest with verbose output
pixi run test-cov     # Run pytest with coverage report
pixi run test-watch   # Run pytest in watch mode

Docker:

pixi run docker-build     # Build all targets
pixi run docker-build-dev # Build dev target (arm64)
pixi run docker-check     # Validate Bake configuration
pixi run docker-lint      # Lint Dockerfile with hadolint

Documentation:

pixi run docs-build   # Build documentation
pixi run docs-serve   # Serve documentation locally

Cleanup:

pixi run clean        # Remove cache and build artifacts
pixi run clean-all    # Remove all generated files

Roadmap

Phase 1: Docker Domain (Current)

• ✅ Project structure and infrastructure setup
• ✅ Documentation migration
• ⏳ Core RAG implementation
• ⏳ Docker-specific agents
• ⏳ CLI interface

Phase 2: Additional Domains

• Kubernetes orchestration
• CI/CD pipelines (GitHub Actions, GitLab CI)
• Cloud infrastructure (AWS, Azure, GCP)
• Programming language ecosystems (Python, Go, Rust)

Phase 3: Advanced Features

• Multi-domain query routing
• Cross-domain knowledge integration
• Interactive learning and feedback
• Performance optimization
• API server for integration

Credits

Created with cookiecutter and the cookiecutter-pytask-project template.

License

MIT License - see LICENSE for details.

Contact

Author: Ray Manaloto Email: [email protected] GitHub: https://github.com/rmanaloto-tastytrade/agent-orchestration