Add comprehensive Docker integration with multi-environment support, monitoring, and deployment tools

.dockerignore

@@ -0,0 +1,88 @@
+# Git
+.git
+.gitignore
+.gitattributes
+
+# Python
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env
+pip-log.txt
+pip-delete-this-directory.txt
+.tox
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.log
+.git
+.mypy_cache
+.pytest_cache
+.hypothesis
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Project specific
+logs/*
+!logs/.gitkeep
+data/*
+!data/.gitkeep
+models/*
+!models/.gitkeep
+*.csv
+*.json
+*.pkl
+*.h5
+*.pth
+
+# Documentation
+docs/
+*.md
+!README.md
+
+# Tests
+tests/
+pytest.ini
+
+# Docker
+Dockerfile
+docker-compose.yml
+.dockerignore
+
+# Jupyter
+.ipynb_checkpoints
+*.ipynb
+
+# Temporary files
+tmp/
+temp/
+*.tmp
+*.temp 

Dockerfile

@@ -0,0 +1,51 @@
+# Use Python 3.11 slim image for smaller size
+FROM python:3.11-slim
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Set work directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    libffi-dev \
+    libssl-dev \
+    curl \
+    wget \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt && \
+    pip install --no-cache-dir jupyter jupyterlab
+
+# Copy the entire project
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p logs data models
+
+# Set permissions
+RUN chmod +x demo.py finrl_demo.py docker-entrypoint.sh
+
+# Expose port for potential web interface
+EXPOSE 8000 8888
+
+# Set entrypoint
+ENTRYPOINT ["/app/docker-entrypoint.sh"]
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD python -c "import sys; sys.exit(0)" || exit 1
+
+# Default command
+CMD ["python", "-m", "agentic_ai_system.main"] 

README.md

@@ -25,7 +25,7 @@ paperswithcode_id: null
 
 # Algorithmic Trading System
 
-A comprehensive algorithmic trading system with synthetic data generation, comprehensive logging, extensive testing capabilities, and FinRL reinforcement learning integration.
+A comprehensive algorithmic trading system with synthetic data generation, comprehensive logging, extensive testing capabilities, FinRL reinforcement learning integration, and full Docker support.
 
 ## Features
 
@@ -44,6 +44,16 @@ A comprehensive algorithmic trading system with synthetic data generation, compr
 - **TensorBoard Integration**: Training progress visualization and monitoring
 - **Comprehensive Evaluation**: Performance metrics including Sharpe ratio and total returns
 
+### Docker Integration
+- **Multi-Environment Support**: Development, production, and testing environments
+- **Container Orchestration**: Docker Compose for easy service management
+- **Monitoring Stack**: Prometheus and Grafana for system monitoring
+- **Development Tools**: Jupyter Lab integration for interactive development
+- **Automated Testing**: Containerized test execution with coverage reporting
+- **Resource Management**: CPU and memory limits for production deployment
+- **Health Checks**: Built-in health monitoring for all services
+- **Backup Services**: Automated backup and data persistence
+
 ### Synthetic Data Generation
 - **Realistic Market Data**: Generate OHLCV data using geometric Brownian motion
 - **Multiple Frequencies**: Support for 1min, 5min, 1H, and 1D data
@@ -65,6 +75,25 @@ A comprehensive algorithmic trading system with synthetic data generation, compr
 
 ## Installation
 
+### Option 1: Docker (Recommended)
+
+1. Clone the repository:
+```bash
+git clone https://github.com/ParallelLLC/algorithmic_trading.git
+cd algorithmic_trading
+```
+
+2. Build and run with Docker:
+```bash
+# Build the image
+docker build -t algorithmic-trading .
+
+# Run the trading system
+docker run -p 8000:8000 algorithmic-trading
+```
+
+### Option 2: Local Installation
+
 1. Clone the repository:
 ```bash
 git clone https://github.com/ParallelLLC/algorithmic_trading.git
@@ -76,6 +105,128 @@ cd algorithmic_trading
 pip install -r requirements.txt
 ```
 
+## Docker Usage
+
+### Quick Start
+
+```bash
+# Build and start development environment
+./scripts/docker-build.sh dev
+
+# Build and start production environment
+./scripts/docker-build.sh prod
+
+# Run tests in Docker
+./scripts/docker-build.sh test
+
+# Stop all containers
+./scripts/docker-build.sh stop
+```
+
+### Development Environment
+
+```bash
+# Start development environment with Jupyter Lab
+docker-compose -f docker-compose.dev.yml up -d
+
+# Access services:
+# - Jupyter Lab: http://localhost:8888
+# - Trading System: http://localhost:8000
+# - TensorBoard: http://localhost:6006
+```
+
+### Production Environment
+
+```bash
+# Start production environment with monitoring
+docker-compose -f docker-compose.prod.yml up -d
+
+# Access services:
+# - Trading System: http://localhost:8000
+# - Grafana: http://localhost:3000 (admin/admin)
+# - Prometheus: http://localhost:9090
+```
+
+### Custom Commands
+
+```bash
+# Run a specific command in the container
+./scripts/docker-build.sh run 'python demo.py'
+
+# Run FinRL training
+./scripts/docker-build.sh run 'python finrl_demo.py'
+
+# Run backtesting
+./scripts/docker-build.sh run 'python -m agentic_ai_system.main --mode backtest'
+
+# Show logs
+./scripts/docker-build.sh logs trading-system
+```
+
+### Docker Compose Services
+
+#### Development (`docker-compose.dev.yml`)
+- **trading-dev**: Jupyter Lab environment with hot reload
+- **finrl-training-dev**: FinRL training with TensorBoard
+- **testing**: Automated test execution
+- **linting**: Code quality checks
+
+#### Production (`docker-compose.prod.yml`)
+- **trading-system**: Main trading system with resource limits
+- **monitoring**: Prometheus metrics collection
+- **grafana**: Data visualization dashboard
+- **backup**: Automated backup service
+
+#### Standard (`docker-compose.yml`)
+- **trading-system**: Basic trading system
+- **finrl-training**: FinRL training service
+- **backtesting**: Backtesting service
+- **development**: Development environment
+
+### Docker Features
+
+#### Health Checks
+All services include health checks to ensure system reliability:
+```yaml
+healthcheck:
+  test: ["CMD", "python", "-c", "import sys; sys.exit(0)"]
+  interval: 30s
+  timeout: 10s
+  retries: 3
+  start_period: 40s
+```
+
+#### Resource Management
+Production services include resource limits:
+```yaml
+deploy:
+  resources:
+    limits:
+      memory: 2G
+      cpus: '1.0'
+    reservations:
+      memory: 512M
+      cpus: '0.5'
+```
+
+#### Volume Management
+Persistent data storage with named volumes:
+- `trading_data`: Market data and configuration
+- `trading_logs`: System logs
+- `trading_models`: Trained models
+- `prometheus_data`: Monitoring metrics
+- `grafana_data`: Dashboard configurations
+
+#### Logging
+Structured logging with rotation:
+```yaml
+logging:
+  driver: "json-file"
+  options:
+    max-size: "10m"
+    max-file: "3"
+```
+
 ## Configuration
 
 The system is configured via `config.yaml`:
@@ -121,6 +272,23 @@ logging:
   enable_file: true
   max_file_size_mb: 10
   backup_count: 5
+
+# FinRL configuration
+finrl:
+  algorithm: 'PPO'
+  learning_rate: 0.0003
+  batch_size: 64
+  buffer_size: 1000000
+  gamma: 0.99
+  tensorboard_log: 'logs/finrl_tensorboard'
+  training:
+    total_timesteps: 100000
+    eval_freq: 10000
+    save_best_model: true
+    model_save_path: 'models/finrl_best/'
+  inference:
+    use_trained_model: false
+    model_path: 'models/finrl_best/best_model'
 ```
 
 ## Usage
@@ -172,6 +340,15 @@ pytest --cov=agentic_ai_system --cov-report=html
 pytest tests/test_synthetic_data_generator.py
 ```
 
+### Docker Testing
+```bash
+# Run all tests in Docker
+./scripts/docker-build.sh test
+
+# Run tests with coverage
+docker run --rm -v $(pwd):/app algorithmic-trading:latest pytest --cov=agentic_ai_system --cov-report=html
+```
+
 ## System Architecture
 
 ### Components
@@ -182,6 +359,7 @@ pytest tests/test_synthetic_data_generator.py
 4. **ExecutionAgent**: Executes trading orders with broker simulation
 5. **Orchestrator**: Coordinates the entire trading workflow
 6. **LoggerConfig**: Manages comprehensive logging throughout the system
+7. **FinRLAgent**: Reinforcement learning agent for advanced trading strategies
 
 ### Data Flow
 
@@ -189,266 +367,167 @@ pytest tests/test_synthetic_data_generator.py
 Synthetic Data Generator → Data Ingestion → Strategy Agent → Execution Agent
                               ↓
                          Logging System
+                              ↓
+                    FinRL Agent (Optional)
 ```
 
-## Synthetic Data Generation
-
-### Features
-- **Geometric Brownian Motion**: Realistic price movement simulation
-- **OHLCV Data**: Complete market data with open, high, low, close, and volume
-- **Market Scenarios**: Different market conditions for testing
-- **Configurable Parameters**: Adjustable volatility, trend, and noise levels
-
-### Usage Examples
-
-```python
-from agentic_ai_system.synthetic_data_generator import SyntheticDataGenerator
+### Docker Architecture
 
-# Initialize generator
-generator = SyntheticDataGenerator(config)
-
-# Generate OHLCV data
-data = generator.generate_ohlcv_data(
-    symbol='AAPL',
-    start_date='2024-01-01',
-    end_date='2024-12-31',
-    frequency='1min'
-)
-
-# Generate tick data
-tick_data = generator.generate_tick_data(
-    symbol='AAPL',
-    duration_minutes=60,
-    tick_interval_ms=1000
-)
-
-# Generate market scenarios
-crash_data = generator.generate_market_scenarios('crash')
-volatile_data = generator.generate_market_scenarios('volatile')
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Development   │    │   Production    │    │    Monitoring   │
+│   Environment   │    │   Environment   │    │     Stack       │
+├─────────────────┤    ├─────────────────┤    ├─────────────────┤
+│ • Jupyter Lab   │    │ • Trading Sys   │    │ • Prometheus    │
+│ • Hot Reload    │    │ • Resource Mgmt │    │ • Grafana       │
+│ • TensorBoard   │    │ • Health Checks │    │ • Metrics       │
+│ • Testing       │    │ • Logging       │    │ • Dashboards    │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
 ```
 
-## Logging System
-
-### Log Files
-- `logs/trading_system.log`: General system logs
-- `logs/trading.log`: Trading-specific logs
-- `logs/performance.log`: Performance metrics
-- `logs/errors.log`: Error logs
+## Monitoring and Observability
 
-### Log Levels
-- **DEBUG**: Detailed debugging information
-- **INFO**: General information about system operation
-- **WARNING**: Warning messages for potential issues
-- **ERROR**: Error messages for failed operations
-- **CRITICAL**: Critical system failures
+### Prometheus Metrics
+- Trading performance metrics
+- System resource usage
+- Error rates and response times
+- Custom business metrics
 
-### Usage Examples
+### Grafana Dashboards
+- Real-time trading performance
+- System health monitoring
+- Historical data analysis
+- Alert management
 
-```python
-import logging
-from agentic_ai_system.logger_config import setup_logging, get_logger
+### Health Checks
+- Service availability monitoring
+- Dependency health verification
+- Automatic restart on failure
+- Performance degradation detection
 
-# Setup logging
-setup_logging(config)
+## Deployment
 
-# Get logger for specific module
-logger = get_logger(__name__)
+### Local Development
+```bash
+# Start development environment
+./scripts/docker-build.sh dev
 
-# Log messages
-logger.info("Trading signal generated")
-logger.warning("High volatility detected")
-logger.error("Order execution failed", exc_info=True)
+# Access Jupyter Lab
+open http://localhost:8888
 ```
 
-## FinRL Integration
-
-### Overview
-The system now includes FinRL (Financial Reinforcement Learning) integration, providing state-of-the-art reinforcement learning capabilities for algorithmic trading. The FinRL agent can learn optimal trading strategies through interaction with a simulated market environment.
-
-### Supported Algorithms
-- **PPO (Proximal Policy Optimization)**: Stable policy gradient method
-- **A2C (Advantage Actor-Critic)**: Actor-critic method with advantage estimation
-- **DDPG (Deep Deterministic Policy Gradient)**: Continuous action space algorithm
-- **TD3 (Twin Delayed DDPG)**: Improved version of DDPG with twin critics
+### Production Deployment
+```bash
+# Deploy to production
+./scripts/docker-build.sh prod
 
-### Trading Environment
-The custom trading environment provides:
-- **Action Space**: Discrete actions (0=Buy, 1=Hold, 2=Sell)
-- **Observation Space**: OHLCV data + technical indicators + portfolio state
-- **Reward Function**: Portfolio return-based rewards
-- **Transaction Costs**: Realistic trading fees and slippage
-- **Position Limits**: Maximum position constraints
+# Monitor system health
+open http://localhost:3000  # Grafana
+open http://localhost:9090  # Prometheus
+```
 
-### Usage Examples
+### Cloud Deployment
+The Docker setup is compatible with:
+- **AWS ECS/Fargate**: For serverless container deployment
+- **Google Cloud Run**: For scalable containerized applications
+- **Azure Container Instances**: For managed container deployment
+- **Kubernetes**: For orchestrated container management
 
-#### Basic FinRL Training
-```python
-from agentic_ai_system.finrl_agent import FinRLAgent, FinRLConfig
-import pandas as pd
+### Environment Variables
+```bash
+# Development
+LOG_LEVEL=DEBUG
+PYTHONDONTWRITEBYTECODE=1
 
-# Create configuration
-config = FinRLConfig(
-    algorithm="PPO",
-    learning_rate=0.0003,
-    batch_size=64,
-    total_timesteps=100000
-)
+# Production
+LOG_LEVEL=INFO
+PYTHONUNBUFFERED=1
+```
 
-# Initialize agent
-agent = FinRLAgent(config)
+## Troubleshooting
 
-# Train the agent
-training_result = agent.train(
-    data=market_data,
-    total_timesteps=100000,
-    eval_freq=10000
-)
+### Common Docker Issues
 
-# Generate predictions
-predictions = agent.predict(test_data)
+#### Build Failures
+```bash
+# Clean build cache
+docker system prune -a
 
-# Evaluate performance
-evaluation = agent.evaluate(test_data)
-print(f"Total Return: {evaluation['total_return']:.2%}")
+# Rebuild without cache
+docker build --no-cache -t algorithmic-trading .
 ```
 
-#### Using Configuration File
-```python
-from agentic_ai_system.finrl_agent import create_finrl_agent_from_config
-
-# Create agent from config file
-agent = create_finrl_agent_from_config('config.yaml')
+#### Container Startup Issues
+```bash
+# Check container logs
+docker logs algorithmic-trading
 
-# Train and evaluate
-agent.train(market_data)
-results = agent.evaluate(test_data)
+# Check container status
+docker ps -a
 ```
 
-#### Running FinRL Demo
+#### Volume Mount Issues
 ```bash
-# Run the complete FinRL demo
-python finrl_demo.py
+# Check volume permissions
+docker run --rm -v $(pwd):/app algorithmic-trading:latest ls -la /app
 
-# This will:
-# 1. Generate synthetic training and test data
-# 2. Train a FinRL agent
-# 3. Evaluate performance
-# 4. Generate trading predictions
-# 5. Create visualization plots
+# Fix volume permissions
+chmod -R 755 data logs models
 ```
 
-### Configuration
-FinRL settings can be configured in `config.yaml`:
+### Performance Optimization
 
+#### Resource Tuning
 ```yaml
-finrl:
-  algorithm: 'PPO'  # PPO, A2C, DDPG, TD3
-  learning_rate: 0.0003
-  batch_size: 64
-  buffer_size: 1000000
-  gamma: 0.99
-  tensorboard_log: 'logs/finrl_tensorboard'
-  training:
-    total_timesteps: 100000
-    eval_freq: 10000
-    save_best_model: true
-    model_save_path: 'models/finrl_best/'
-  inference:
-    use_trained_model: false
-    model_path: 'models/finrl_best/best_model'
+# Adjust resource limits in docker-compose.prod.yml
+deploy:
+  resources:
+    limits:
+      memory: 4G  # Increase for heavy workloads
+      cpus: '2.0' # Increase for CPU-intensive tasks
 ```
 
-### Model Management
-```python
-# Save trained model
-agent.save_model('models/my_finrl_model')
-
-# Load pre-trained model
-agent.load_model('models/my_finrl_model')
-
-# Continue training
-agent.train(more_data, total_timesteps=50000)
-```
-
-### Performance Monitoring
-- **TensorBoard Integration**: Monitor training progress
-- **Evaluation Metrics**: Total return, Sharpe ratio, portfolio value
-- **Trading Statistics**: Buy/sell signal analysis
-- **Visualization**: Price charts with trading signals
-
-### Advanced Features
-- **Multi-timeframe Support**: Train on different data frequencies
-- **Feature Engineering**: Automatic technical indicator calculation
-- **Risk Management**: Built-in position and drawdown limits
-- **Backtesting**: Comprehensive backtesting capabilities
-- **Hyperparameter Tuning**: Easy configuration for different algorithms
-
-## Testing
-
-### Test Structure
-```
-tests/
-├── __init__.py
-├── test_synthetic_data_generator.py
-├── test_strategy_agent.py
-├── test_execution_agent.py
-├── test_data_ingestion.py
-├── test_integration.py
-├── test_finrl_agent.py
+#### Logging Optimization
+```yaml
+# Reduce log verbosity in production
+logging:
+  driver: "json-file"
+  options:
+    max-size: "5m"   # Smaller log files
+    max-file: "2"    # Fewer log files
 ```
 
-### Test Categories
-- **Unit Tests**: Test individual components in isolation
-- **Integration Tests**: Test complete workflows
-- **Performance Tests**: Test system performance and scalability
-- **Error Handling Tests**: Test error conditions and edge cases
-- **Slow RL Tests**: RL agent training tests are marked as `@pytest.mark.slow` and use minimal timesteps for speed. These are skipped by default unless explicitly run.
+## Contributing
 
-### Running Specific Tests
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Ensure all tests pass (including Docker tests)
+5. Submit a pull request
 
+### Development Workflow
 ```bash
-# Run all fast tests (default)
-pytest
-
-# Run slow RL tests (FinRL agent training)
-pytest -m slow
+# Start development environment
+./scripts/docker-build.sh dev
 
-# Run tests with coverage
-pytest --cov=agentic_ai_system --cov-report=html
+# Make changes and test
+./scripts/docker-build.sh test
 
-# Run tests in parallel
-pytest -n auto
+# Run linting
+docker-compose -f docker-compose.dev.yml run linting
 
-# Run tests with verbose output
-pytest -v
+# Commit and push
+git add .
+git commit -m "Add new feature"
+git push origin feature-branch
 ```
 
-## Performance Monitoring
-
-The system includes comprehensive performance monitoring:
-
-- **Execution Time Tracking**: Monitor workflow execution times
-- **Trade Statistics**: Track successful vs failed trades
-- **Performance Metrics**: Calculate returns and drawdowns
-- **Resource Usage**: Monitor memory and CPU usage
-
-## Error Handling
-
-The system includes robust error handling:
-
-- **Graceful Degradation**: System continues operation despite component failures
-- **Error Logging**: Comprehensive error logging with stack traces
-- **Fallback Mechanisms**: Automatic fallback to synthetic data when CSV files are missing
-- **Validation**: Data validation at multiple levels
+## License
 
-## Contributing
+This project is licensed under the Apache License, Version 2.0 - see the LICENSE file for details.
 
-1. Fork the repository
-2. Create a feature branch
-3. Add tests for new functionality
-4. Ensure all tests pass
-5. Submit a pull request
+## About
 
-## License
+A comprehensive, production-ready algorithmic trading system with real-time market data streaming, multi-symbol trading, advanced technical analysis, robust risk management capabilities, and full Docker containerization support.
 
-This project is licensed under the Apache License, Version 2.0 - see the [LICENSE](LICENSE) file for details. 
+[Medium Article](https://medium.com/@edwinsalguero/data-pipeline-design-in-an-algorithmic-trading-system-ac0d8109c4b9) 

docker-compose.dev.yml

@@ -0,0 +1,73 @@
+version: '3.8'
+
+services:
+  # Development environment with hot reload
+  trading-dev:
+    build: .
+    container_name: trading-dev
+    ports:
+      - "8888:8888"  # Jupyter Lab
+      - "8000:8000"  # Trading system
+      - "6006:6006"  # TensorBoard
+    volumes:
+      - .:/app
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - ./models:/app/models
+      - ./config.yaml:/app/config.yaml:ro
+    environment:
+      - PYTHONPATH=/app
+      - LOG_LEVEL=DEBUG
+      - PYTHONDONTWRITEBYTECODE=1
+    command: ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root", "--NotebookApp.token=''"]
+    restart: unless-stopped
+    stdin_open: true
+    tty: true
+
+  # FinRL training with TensorBoard
+  finrl-training-dev:
+    build: .
+    container_name: finrl-training-dev
+    ports:
+      - "6006:6006"  # TensorBoard
+    volumes:
+      - .:/app
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - ./models:/app/models
+      - ./config.yaml:/app/config.yaml:ro
+    environment:
+      - PYTHONPATH=/app
+      - LOG_LEVEL=DEBUG
+    command: ["python", "finrl_demo.py"]
+    restart: "no"
+
+  # Testing service
+  testing:
+    build: .
+    container_name: trading-testing
+    volumes:
+      - .:/app
+      - ./data:/app/data
+      - ./logs:/app/logs
+    environment:
+      - PYTHONPATH=/app
+      - LOG_LEVEL=DEBUG
+    command: ["pytest", "-v", "--cov=agentic_ai_system", "--cov-report=html"]
+    restart: "no"
+
+  # Linting and code quality
+  linting:
+    build: .
+    container_name: trading-lint
+    volumes:
+      - .:/app
+    environment:
+      - PYTHONPATH=/app
+    command: ["sh", "-c", "pip install flake8 black isort mypy && flake8 agentic_ai_system && black --check agentic_ai_system && isort --check-only agentic_ai_system"]
+    restart: "no"
+
+volumes:
+  data:
+  logs:
+  models: 

docker-compose.prod.yml

@@ -0,0 +1,102 @@
+version: '3.8'
+
+services:
+  # Production trading system
+  trading-system:
+    build: .
+    container_name: algorithmic-trading-prod
+    ports:
+      - "8000:8000"
+    volumes:
+      - trading_data:/app/data
+      - trading_logs:/app/logs
+      - trading_models:/app/models
+      - ./config.yaml:/app/config.yaml:ro
+    environment:
+      - PYTHONPATH=/app
+      - LOG_LEVEL=INFO
+      - PYTHONUNBUFFERED=1
+    command: ["python", "-m", "agentic_ai_system.main", "--mode", "live"]
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import sys; sys.exit(0)"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    deploy:
+      resources:
+        limits:
+          memory: 2G
+          cpus: '1.0'
+        reservations:
+          memory: 512M
+          cpus: '0.5'
+    logging:
+      driver: "json-file"
+      options:
+        max-size: "10m"
+        max-file: "3"
+
+  # Monitoring service
+  monitoring:
+    image: prom/prometheus:latest
+    container_name: trading-monitoring
+    ports:
+      - "9090:9090"
+    volumes:
+      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml:ro
+      - prometheus_data:/prometheus
+    command:
+      - '--config.file=/etc/prometheus/prometheus.yml'
+      - '--storage.tsdb.path=/prometheus'
+      - '--web.console.libraries=/etc/prometheus/console_libraries'
+      - '--web.console.templates=/etc/prometheus/consoles'
+      - '--storage.tsdb.retention.time=200h'
+      - '--web.enable-lifecycle'
+    restart: unless-stopped
+
+  # Grafana for visualization
+  grafana:
+    image: grafana/grafana:latest
+    container_name: trading-grafana
+    ports:
+      - "3000:3000"
+    volumes:
+      - grafana_data:/var/lib/grafana
+      - ./monitoring/grafana/dashboards:/etc/grafana/provisioning/dashboards:ro
+      - ./monitoring/grafana/datasources:/etc/grafana/provisioning/datasources:ro
+    environment:
+      - GF_SECURITY_ADMIN_PASSWORD=admin
+      - GF_USERS_ALLOW_SIGN_UP=false
+    restart: unless-stopped
+    depends_on:
+      - monitoring
+
+  # Backup service
+  backup:
+    build: .
+    container_name: trading-backup
+    volumes:
+      - trading_data:/app/data:ro
+      - trading_logs:/app/logs:ro
+      - trading_models:/app/models:ro
+      - backup_data:/backup
+    environment:
+      - PYTHONPATH=/app
+    command: ["python", "-c", "import shutil; import os; from datetime import datetime; timestamp = datetime.now().strftime('%Y%m%d_%H%M%S'); shutil.make_archive(f'/backup/trading_backup_{timestamp}', 'zip', '/app/data'); shutil.make_archive(f'/backup/models_backup_{timestamp}', 'zip', '/app/models'); print('Backup completed')"]
+    restart: "no"
+
+volumes:
+  trading_data:
+    driver: local
+  trading_logs:
+    driver: local
+  trading_models:
+    driver: local
+  prometheus_data:
+    driver: local
+  grafana_data:
+    driver: local
+  backup_data:
+    driver: local 

docker-compose.yml

@@ -0,0 +1,81 @@
+version: '3.8'
+
+services:
+  # Main trading system
+  trading-system:
+    build: .
+    container_name: algorithmic-trading
+    ports:
+      - "8000:8000"
+    volumes:
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - ./models:/app/models
+      - ./config.yaml:/app/config.yaml:ro
+    environment:
+      - PYTHONPATH=/app
+      - LOG_LEVEL=INFO
+    command: ["python", "-m", "agentic_ai_system.main", "--mode", "live", "--duration", "300"]
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "python", "-c", "import sys; sys.exit(0)"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+
+  # FinRL training service
+  finrl-training:
+    build: .
+    container_name: finrl-training
+    volumes:
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - ./models:/app/models
+      - ./config.yaml:/app/config.yaml:ro
+    environment:
+      - PYTHONPATH=/app
+      - LOG_LEVEL=INFO
+    command: ["python", "finrl_demo.py"]
+    restart: "no"
+    depends_on:
+      - trading-system
+
+  # Backtesting service
+  backtesting:
+    build: .
+    container_name: backtesting
+    volumes:
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - ./config.yaml:/app/config.yaml:ro
+    environment:
+      - PYTHONPATH=/app
+      - LOG_LEVEL=INFO
+    command: ["python", "-m", "agentic_ai_system.main", "--mode", "backtest", "--start-date", "2024-01-01", "--end-date", "2024-12-31"]
+    restart: "no"
+    depends_on:
+      - trading-system
+
+  # Development service with Jupyter
+  development:
+    build: .
+    container_name: trading-dev
+    ports:
+      - "8888:8888"
+    volumes:
+      - ./data:/app/data
+      - ./logs:/app/logs
+      - ./models:/app/models
+      - ./config.yaml:/app/config.yaml:ro
+      - .:/app
+    environment:
+      - PYTHONPATH=/app
+      - LOG_LEVEL=DEBUG
+    command: ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root", "--NotebookApp.token=''"]
+    restart: unless-stopped
+
+volumes:
+  data:
+  logs:
+  models: 

docker-entrypoint.sh

@@ -0,0 +1,77 @@
+#!/bin/bash
+set -e
+
+# Function to wait for dependencies
+wait_for_dependencies() {
+    echo "Waiting for dependencies to be ready..."
+    sleep 5
+}
+
+# Function to initialize directories
+init_directories() {
+    echo "Initializing directories..."
+    mkdir -p /app/data
+    mkdir -p /app/logs
+    mkdir -p /app/models
+    chmod 755 /app/data /app/logs /app/models
+}
+
+# Function to generate synthetic data if needed
+generate_data_if_needed() {
+    if [ ! -f "/app/data/synthetic_market_data.csv" ]; then
+        echo "Generating synthetic market data..."
+        python -c "
+from agentic_ai_system.synthetic_data_generator import SyntheticDataGenerator
+import yaml
+
+with open('/app/config.yaml', 'r') as f:
+    config = yaml.safe_load(f)
+
+generator = SyntheticDataGenerator(config)
+data = generator.generate_ohlcv_data(
+    symbol='AAPL',
+    start_date='2024-01-01',
+    end_date='2024-12-31',
+    frequency='1min'
+)
+data.to_csv('/app/data/synthetic_market_data.csv', index=True)
+print('Synthetic data generated successfully')
+"
+    else
+        echo "Synthetic data already exists"
+    fi
+}
+
+# Function to run health check
+health_check() {
+    echo "Running health check..."
+    python -c "
+import sys
+from agentic_ai_system.logger_config import setup_logging
+try:
+    setup_logging({})
+    print('Health check passed')
+except Exception as e:
+    print(f'Health check failed: {e}')
+    sys.exit(1)
+"
+}
+
+# Main execution
+main() {
+    echo "Starting Algorithmic Trading System..."
+    
+    # Initialize
+    init_directories
+    wait_for_dependencies
+    generate_data_if_needed
+    health_check
+    
+    echo "System initialized successfully"
+    
+    # Execute the main command
+    exec "$@"
+}
+
+# Run main function with all arguments
+main "$@" 

scripts/docker-build.sh

@@ -0,0 +1,162 @@
+#!/bin/bash
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Function to print colored output
+print_status() {
+    echo -e "${BLUE}[INFO]${NC} $1"
+}
+
+print_success() {
+    echo -e "${GREEN}[SUCCESS]${NC} $1"
+}
+
+print_warning() {
+    echo -e "${YELLOW}[WARNING]${NC} $1"
+}
+
+print_error() {
+    echo -e "${RED}[ERROR]${NC} $1"
+}
+
+# Function to build the Docker image
+build_image() {
+    print_status "Building Docker image..."
+    docker build -t algorithmic-trading:latest .
+    if [ $? -eq 0 ]; then
+        print_success "Docker image built successfully"
+    else
+        print_error "Failed to build Docker image"
+        exit 1
+    fi
+}
+
+# Function to run tests in Docker
+run_tests() {
+    print_status "Running tests in Docker..."
+    docker run --rm -v $(pwd):/app algorithmic-trading:latest pytest -v
+    if [ $? -eq 0 ]; then
+        print_success "Tests passed"
+    else
+        print_error "Tests failed"
+        exit 1
+    fi
+}
+
+# Function to start development environment
+start_dev() {
+    print_status "Starting development environment..."
+    docker-compose -f docker-compose.dev.yml up -d
+    print_success "Development environment started"
+    print_status "Jupyter Lab available at: http://localhost:8888"
+    print_status "Trading system available at: http://localhost:8000"
+    print_status "TensorBoard available at: http://localhost:6006"
+}
+
+# Function to start production environment
+start_prod() {
+    print_status "Starting production environment..."
+    docker-compose -f docker-compose.prod.yml up -d
+    print_success "Production environment started"
+    print_status "Trading system available at: http://localhost:8000"
+    print_status "Grafana available at: http://localhost:3000 (admin/admin)"
+    print_status "Prometheus available at: http://localhost:9090"
+}
+
+# Function to stop all containers
+stop_all() {
+    print_status "Stopping all containers..."
+    docker-compose -f docker-compose.yml down
+    docker-compose -f docker-compose.dev.yml down
+    docker-compose -f docker-compose.prod.yml down
+    print_success "All containers stopped"
+}
+
+# Function to clean up Docker resources
+cleanup() {
+    print_status "Cleaning up Docker resources..."
+    docker system prune -f
+    docker volume prune -f
+    print_success "Cleanup completed"
+}
+
+# Function to show logs
+show_logs() {
+    local service=${1:-trading-system}
+    print_status "Showing logs for $service..."
+    docker-compose logs -f $service
+}
+
+# Function to run a specific command in the container
+run_command() {
+    local command="$1"
+    print_status "Running command: $command"
+    docker run --rm -v $(pwd):/app algorithmic-trading:latest $command
+}
+
+# Function to show help
+show_help() {
+    echo "Usage: $0 [COMMAND]"
+    echo ""
+    echo "Commands:"
+    echo "  build       Build the Docker image"
+    echo "  test        Run tests in Docker"
+    echo "  dev         Start development environment"
+    echo "  prod        Start production environment"
+    echo "  stop        Stop all containers"
+    echo "  cleanup     Clean up Docker resources"
+    echo "  logs [SVC]  Show logs for a service (default: trading-system)"
+    echo "  run CMD     Run a specific command in the container"
+    echo "  help        Show this help message"
+    echo ""
+    echo "Examples:"
+    echo "  $0 build"
+    echo "  $0 dev"
+    echo "  $0 logs"
+    echo "  $0 run 'python demo.py'"
+}
+
+# Main script logic
+case "${1:-help}" in
+    build)
+        build_image
+        ;;
+    test)
+        build_image
+        run_tests
+        ;;
+    dev)
+        build_image
+        start_dev
+        ;;
+    prod)
+        build_image
+        start_prod
+        ;;
+    stop)
+        stop_all
+        ;;
+    cleanup)
+        cleanup
+        ;;
+    logs)
+        show_logs $2
+        ;;
+    run)
+        if [ -z "$2" ]; then
+            print_error "No command specified"
+            show_help
+            exit 1
+        fi
+        build_image
+        run_command "$2"
+        ;;
+    help|*)
+        show_help
+        ;;
+esac