Red Hat Learning Paths

An AI-powered learning platform that discovers and organizes Red Hat educational content into personalized learning journeys for system administrators and developers.

🚀 Quick Start

Get the application running in just a few commands:

# Clone the repository
git clone <repository-url>
cd redhat-learning-paths

# Set up the environment
bash scripts/setup.sh

# Build and deploy with Podman
bash scripts/deploy.sh

# Access the application
open http://localhost:30000

📋 Table of Contents

• Features
• Architecture
• Prerequisites
• Installation
• Usage
• API Documentation
• Development
• Testing
• Deployment
• Contributing
• License

✨ Features

🤖 AI-Powered Recommendations

• Ollama Integration: Uses local LLM for intelligent content categorization
• Personalized Paths: Generates learning paths tailored to your skill level
• Smart Filtering: Prioritizes Red Hat official content and certifications

🎯 Learning Tracks

• Administrator Track: System administration, infrastructure, and operations
  • Technical Overview → DO080 → DO180 → DO280 → EX280 → DO380 → EX380
  • Virtualization: DO316/EX316/DO336/EX336
• Developer Track: Application development and cloud-native technologies
  • DO188 → EX188 → DO288 → EX288
  • Specializations: AI/ML, Service Mesh, Microservices, DevOps Pipelines

🔍 Multi-Source Search

• Red Hat Official: Documentation, training, and certification resources
• Google: Technical articles and community content
• YouTube: Video tutorials and workshops
• Udemy: Comprehensive courses and hands-on labs

🐧 Red Hat Technologies Focus

• OpenShift: Container platform and Kubernetes management
• RHEL: Enterprise Linux administration and automation
• Podman: Daemonless container engine
• Ansible: Automation and configuration management

🏗️ Architecture

graph TB
    subgraph "Frontend (React 18)"
        A[Search Interface]
        B[Results Display]
        C[Learning Paths]
    end
    
    subgraph "Backend (FastAPI)"
        D[Search API]
        E[Path Generator]
        F[Content Categorizer]
    end
    
    subgraph "AI Engine"
        G[Ollama LLM]
    end
    
    subgraph "Data Layer"
        H[PostgreSQL]
        I[pgvector]
    end
    
    subgraph "Search Sources"
        J[Google]
        K[YouTube]
        L[Udemy]
        M[Red Hat]
    end
    
    A --> D
    D --> E
    D --> F
    E --> G
    F --> G
    D --> H
    H --> I
    D --> J
    D --> K
    D --> L
    D --> M

Loading

📦 Prerequisites

Required

• Podman 4.0+ (for containerization)
• Git (for version control)
• curl (for health checks)

Optional (for development)

• Python 3.9+ with pip
• Node.js 18+ with npm
• PostgreSQL 15+ (if running locally)

System Requirements

• Memory: 4GB minimum, 8GB recommended
• Storage: 10GB free space
• CPU: 2 cores minimum, 4 cores recommended

🛠️ Installation

Option 1: Quick Setup (Recommended)

# Run the automated setup script
bash scripts/setup.sh

# Deploy the application
bash scripts/deploy.sh

Option 2: Manual Setup

1. Build Container Images

# Build backend image
cd backend
podman build -t redhat-learning-paths-backend:latest -f Containerfile .

# Build frontend image
cd ../frontend
podman build -t redhat-learning-paths-frontend:latest -f Containerfile .

2. Deploy with Podman

# Create and start the pod
podman play kube podman-pod.yaml

# Check status
podman pod ps
podman ps --pod

3. Verify Installation

# Check frontend
curl http://localhost:30000/health

# Check backend API
curl http://localhost:30001/health

# Check Ollama
curl http://localhost:30003

🎯 Usage

Basic Search

1. Open the Application

   http://localhost:30000
   

2. Search for Technologies

   • Enter search terms like "OpenShift", "RHEL", "Podman"
   • Use filters for track (Administrator/Developer) and level (Beginner/Intermediate/Advanced)

3. View Results

   • Browse categorized search results
   • Explore AI-generated learning paths
   • Follow structured progressions

Example Queries

Query	Expected Results
OpenShift	Container platform docs, training courses, certification paths
RHEL administration	System administration guides, DO080, RH124, RH134 courses
Podman containers	Container engine documentation, tutorials, best practices
Ansible automation	Automation guides, DO374, DO447 training materials

Learning Path Example

Search: "OpenShift" Generated Path (Administrator Track - Beginner):

1. Foundation (2 weeks)

   • Learn container basics
   • Understand Kubernetes concepts
   • Resources: DO180 course materials

2. Hands-on Practice (3 weeks)

   • Deploy applications on OpenShift
   • Practice with oc CLI
   • Resources: OpenShift tutorials, labs

3. Certification Prep (3 weeks)

   • Prepare for EX280 exam
   • Practice scenarios
   • Resources: Red Hat training, practice exams

📚 API Documentation

Base URL

http://localhost:30001

Authentication

Currently no authentication required. Future versions will include user authentication.

Endpoints

Search Learning Resources

POST /search
Content-Type: application/json

{
  "query": "OpenShift",
  "track": "all|administrator|developer",
  "level": "all|beginner|intermediate|advanced"
}

Response:

{
  "query": "OpenShift",
  "results": [
    {
      "title": "OpenShift Documentation",
      "url": "https://docs.openshift.com",
      "description": "Official OpenShift documentation",
      "source": "redhat",
      "relevance_score": 0.95,
      "track": "administrator",
      "level": "intermediate"
    }
  ],
  "learning_paths": [
    {
      "track": "administrator",
      "level": "beginner",
      "estimated_duration": "6-8 weeks",
      "prerequisites": ["Basic Linux knowledge"],
      "steps": [
        {
          "title": "Container Basics",
          "description": "Learn containerization fundamentals",
          "duration": "2 weeks"
        }
      ]
    }
  ],
  "total_results": 25,
  "processing_time": 2.3
}

Get Learning Tracks

GET /tracks

Health Check

GET /health

Available Models

GET /models

For detailed API documentation, visit: http://localhost:30001/docs

🔧 Development

Local Development Setup

Backend Development

cd backend

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -r requirements.txt

# Set environment variables
export DATABASE_URL="postgresql://postgres:password@localhost:5432/redhat_learning_paths"
export OLLAMA_BASE_URL="http://localhost:11434"

# Run development server
uvicorn main:app --reload --host 0.0.0.0 --port 8000

Frontend Development

cd frontend

# Install dependencies
npm install

# Set environment variables
echo "REACT_APP_API_URL=http://localhost:8000" > .env.local

# Start development server
npm start

Database Setup

# Start PostgreSQL with Podman
podman run -d --name postgres-dev \
  -e POSTGRES_DB=redhat_learning_paths \
  -e POSTGRES_USER=postgres \
  -e POSTGRES_PASSWORD=password \
  -p 5432:5432 \
  postgres:15-alpine

# Initialize database
cd backend
python database.py

Ollama Setup

# Start Ollama
podman run -d --name ollama-dev \
  -p 11434:11434 \
  -v ollama_data:/root/.ollama \
  ollama/ollama:latest

# Download model
podman exec ollama-dev ollama pull llama3.1

Development Tools

Code Formatting

# Backend (Python)
cd backend
black .
isort .
flake8 .

# Frontend (JavaScript)
cd frontend
npm run lint
npm run lint:fix

Database Migrations

cd backend
# Create migration
alembic revision --autogenerate -m "Description"

# Apply migration
alembic upgrade head

🧪 Testing

Backend Tests

cd backend

# Install test dependencies
pip install pytest pytest-cov pytest-asyncio

# Run all tests
pytest

# Run with coverage
pytest --cov=. --cov-report=html

# Run specific test file
pytest test_main.py -v

Frontend Tests

cd frontend

# Run unit tests
npm test

# Run with coverage
npm test -- --coverage --watchAll=false

# Run E2E tests
npx playwright test

# Run E2E tests with UI
npx playwright test --ui

Integration Tests

# Start the full application
bash scripts/deploy.sh

# Run E2E tests against running application
cd frontend
PLAYWRIGHT_BASE_URL=http://localhost:30000 npx playwright test

Test Coverage Goals

• Backend: 80% minimum coverage
• Frontend: 70% minimum coverage
• E2E: Core user flows covered

🚀 Deployment

Production Deployment

1. Environment Configuration

# Create production environment file
cat > .env.production << EOF
DATABASE_URL=postgresql://user:password@db-host:5432/redhat_learning_paths
OLLAMA_BASE_URL=http://ollama-host:11434
OLLAMA_MODEL=llama3.1
ENVIRONMENT=production
DEBUG=false
EOF

2. Build Production Images

# Build with production optimizations
bash scripts/build.sh

# Tag for registry
podman tag redhat-learning-paths-backend:latest registry.example.com/redhat-learning-paths-backend:v1.0.0
podman tag redhat-learning-paths-frontend:latest registry.example.com/redhat-learning-paths-frontend:v1.0.0

# Push to registry
podman push registry.example.com/redhat-learning-paths-backend:v1.0.0
podman push registry.example.com/redhat-learning-paths-frontend:v1.0.0

3. Deploy to Production

# Update pod configuration for production
# Edit podman-pod.yaml with production images and settings

# Deploy
podman play kube podman-pod.yaml

# Verify deployment
curl -f http://production-host:30000/health
curl -f http://production-host:30001/health

Kubernetes Deployment

Convert Podman pod to Kubernetes:

# Generate Kubernetes manifests
podman generate kube redhat-learning-paths > k8s-deployment.yaml

# Deploy to Kubernetes
kubectl apply -f k8s-deployment.yaml

Monitoring and Logging

Health Checks

# Application health
curl http://localhost:30000/health
curl http://localhost:30001/health

# Container health
podman healthcheck run redhat-learning-paths-frontend
podman healthcheck run redhat-learning-paths-backend

Logs

# Pod logs
podman pod logs redhat-learning-paths

# Individual container logs
podman logs redhat-learning-paths-frontend
podman logs redhat-learning-paths-backend
podman logs redhat-learning-paths-postgres
podman logs redhat-learning-paths-ollama

Backup and Recovery

Database Backup

# Backup database
podman exec redhat-learning-paths-postgres pg_dump -U postgres redhat_learning_paths > backup.sql

# Restore database
podman exec -i redhat-learning-paths-postgres psql -U postgres redhat_learning_paths < backup.sql

Data Volumes

# Backup volumes
podman volume export postgres-data > postgres-data-backup.tar
podman volume export ollama-data > ollama-data-backup.tar

# Restore volumes
podman volume import postgres-data < postgres-data-backup.tar
podman volume import ollama-data < ollama-data-backup.tar

🤝 Contributing

We welcome contributions to the Red Hat Learning Paths project! Please read our Contributing Guidelines for details.

Development Process

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Make your changes
4. Add tests for new functionality
5. Run the test suite (npm test and pytest)
6. Commit your changes (git commit -m 'Add amazing feature')
7. Push to the branch (git push origin feature/amazing-feature)
8. Open a Pull Request

Code Standards

• Python: Follow PEP 8, use Black for formatting
• JavaScript: Follow ESLint configuration, use Prettier
• Commits: Use conventional commit messages
• Documentation: Update README for new features

Issue Reporting

Please use GitHub Issues to report bugs or request features. Include:

• Environment: OS, Podman version, browser
• Steps to Reproduce: Detailed reproduction steps
• Expected Behavior: What should happen
• Actual Behavior: What actually happens
• Screenshots: If applicable

📄 License

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

🙏 Acknowledgments

• Red Hat: For excellent documentation and training resources
• Ollama: For making local LLM inference accessible
• Podman: For secure, daemonless containerization
• FastAPI: For the high-performance Python web framework
• React: For the powerful frontend framework
• Community: All the developers and contributors

📞 Support

• Documentation: Project Wiki
• Issues: GitHub Issues
• Discussions: GitHub Discussions
• Security: See SECURITY.md for reporting security issues

🗺️ Roadmap

Version 1.1

• User authentication and profiles
• Bookmarking and progress tracking
• Enhanced learning path customization
• Integration with Red Hat Learning Subscription

Version 1.2

• Offline mode support
• Mobile application
• Advanced analytics dashboard
• Community learning paths

Version 2.0

• Multi-language support
• Integration with Red Hat Certification system
• Advanced AI recommendations
• Enterprise deployment features

---

Made with ❤️ for the Red Hat community

Powered by Ollama AI • Containerized with Podman • Built for learning