Inspiration

In professional League of Legends, the draft phase is a high-stakes puzzle with 167+ champions, complex synergy interactions, and lane-specific counter matchups. Coaches have ~30 seconds per pick to process thousands of data points mentally. We asked: what if AI could augment those decisions in real-time?

DraftOracle was born from this challenge—building a system that transforms historical match data into actionable intelligence under time pressure.

What It Does

DraftOracle is an AI-powered drafting assistant that provides:

  • Pick Recommendations: Optimized suggestions based on synergy + counter + meta + player comfort
  • Ban Recommendations: Targeted bans that exploit opponent weaknesses
  • Draft Analysis: Win probability estimation with lane-by-lane matchup breakdowns
  • Real-Time WebSocket: Live updates during the pick/ban phase

How We Built It

Architecture

GRID API → Data Ingestion → PostgreSQL → Analysis Engines → FastAPI → Swagger UI

Backend Stack:

  • FastAPI for async REST endpoints and WebSocket connections
  • PostgreSQL + Redis for persistent storage and caching
  • Celery for background data processing tasks

Core Engines:

  1. SynergyEngine — Computes pairwise champion synergies using Wilson score intervals for statistical confidence:

$$\text{Synergy} = \text{WinRate}_{\text{together}} - \mathbb{E}[\text{WinRate}]$$

  1. CounterEngine — Analyzes matchups with phase-specific advantages (early/mid/late) using gold differential normalization

  2. DraftOptimizer — Combines all signals with configurable weights:

$$S_{\text{total}} = w_1 \cdot S_{\text{synergy}} + w_2 \cdot S_{\text{counter}} + w_3 \cdot S_{\text{meta}} + w_4 \cdot S_{\text{comfort}}$$

Development Environment:

  • Built entirely in PyCharm with type hints throughout
  • Structured logging via structlog for debugging
  • Pydantic schemas for request/response validation

Challenges We Faced

  1. Sparse Data Problem: Many champion pairs have <30 games together. We addressed this with Wilson confidence intervals that penalize low sample sizes.

  2. Phase-Specific Matchups: A champion winning lane ≠ winning the game. We introduced gold differentials at 15-minute and 25-minute marks to capture early vs. late game dynamics.

  3. Real-Time Constraints: Draft decisions happen fast. We optimized database queries with indexed lookups and Redis caching for sub-100ms response times.

What We Learned

  • Statistical rigor matters—simple win rates are misleading without confidence intervals
  • Domain expertise (understanding why Sylas counters Ahri) validates that the math is working
  • FastAPI's async architecture is perfect for real-time esports applications

What's Next

  • ML Embeddings: Learn latent champion representations via contrastive learning
  • Win Probability Predictor: Transformer-based model using draft sequences
  • Frontend Dashboard: Real-time visualization for coaching staff
Share this project:

Updates