Open Source AI Radar：用三轴评分追踪 GitHub 新兴开源 AI 项目

Discover what is becoming important before everyone else does.

Open Source AI Radar is a continuously updated intelligence platform that discovers, analyzes, scores, and tracks emerging open-source AI projects on GitHub.

Unlike traditional star-count leaderboards, Radar uses three-axis scoring (Impact, Velocity, Health) to find projects that are becoming important — not just ones that already are.

Live Radar | API Docs | RSS

Tracking 9,080 repos · 76% auto-classified into 11 AI categories · 38.7M stars tracked · Updated 2026-10-09 19:28 UTC

Features

• Automated Discovery — Four-layer discovery: topics, keywords, trending activity, plus free-text name/description search (most popular AI repos ship without topics) across 11 categories
• Three-Axis Scoring — Impact (40%) + Velocity (35%) + Health (25%) with historical tracking
• Health Intelligence — Freshness, release cadence, issue load, community shape, bus factor (maintainer count), license safety
• Tier-Based Processing — Smart scheduling: high-value repos processed more frequently
• Rate-Limit-Aware — Adaptive API client that stays within GitHub limits
• Crash-Safe Scheduler — Queue-based processing with persistent cursor; no work lost on failure
• Anomaly Detection — Detects unusual growth patterns and breaking changes
• Breakout Detection — Identifies projects entering breakout territory
• Why Trending — Explains why a project is trending with specific metrics
• Weekly Reports — Auto-generated intelligence summaries with social media drafts
• Static Website — 9,000+ project pages, search, filter, explore rankings, side-by-side comparison, and weekly digest archive
• SEO Optimized — OpenGraph, Twitter Cards, JSON-LD structured data, sitemap
• RSS Feed — Subscribe to trending discoveries
• API Endpoints — JSON API for programmatic access
• Badges — Dynamic SVG badges for project READMEs

Show Your Project's Score

If your repo is tracked, grab a live badge for your README:

![AI Radar Score](https://erbharatmalhotra.github.io/open-source-ai-radar/api/badges/OWNER__REPO/score.svg)

More badges (velocity, stars) and the full docs: api-docs page.

Want your project tracked? Open a submission — reviewed within a few days.

Explore

• Weekly Digests — browsable archive of weekly intelligence
• Compare Projects — side-by-side radar score comparison
• llms.txt — machine-readable dataset guide for AI agents

Quick Start

# Install
uv sync

# Discover repos (finds new AI projects on GitHub)
uv run radar discover --limit 100

# Import to database
uv run radar import-json

# Process: snapshot + score all repos
uv run radar process

# Classify into categories
uv run radar classify

# View rankings
uv run radar top

# Check status
uv run radar status

How It Works

GitHub API  ->  Discovery  ->  SQLite DB  ->  Scoring  ->  Exports  ->  Website
    ^                                                              |
    +---------- Rate-Limit-Aware Scheduler (tier-based) -----------+

Pipeline Stages

1. Discovery — Searches GitHub for repos matching 11 AI categories (topics, keywords, trending, free-text name/description)
2. Import — Stores repo metadata in SQLite with deduplication
3. Classification — Assigns repos to categories using topic matching
4. Snapshot — Fetches current metrics (stars, forks, contributors, releases)
5. Scoring — Computes Impact/Velocity/Health scores and Radar Score
6. Analysis — Detects anomalies, breakouts, and explains why projects are trending
7. Export — Generates JSON, CSV, RSS, project pages, and API endpoints
8. Deploy — Builds static website with Astro and deploys to GitHub Pages

Tier-Based Processing

The scheduler automatically distributes workload based on project importance:

Live per-tier counts: uv run radar scheduler-stats or the status page. Each workflow run stays within GitHub's 1,000 GraphQL points/hour budget.

Three-Axis Scoring

Every repository receives three independent scores (0-100):

The Radar Score is: Impact x 0.40 + Velocity x 0.35 + Health x 0.25

Weights are configurable in config/scoring_weights.yml.

Categories

Categories are configurable in config/categories.yml.

CLI Commands

Core Pipeline

Analysis & Reports

Data & Export

Scale & Monitoring

Automated Workflows

All workflows run automatically via GitHub Actions:

Rate Limit Strategy

GitHub GITHUB_TOKEN provides 1,000 GraphQL points/hour. Each workflow run uses ~350 points (35% budget), leaving headroom for retries and discovery.

DISCOVER (2x/day):  ~120 GraphQL calls (search queries)
PROCESS (4x/day):   ~350 GraphQL calls (repo snapshots)
DEPLOY:             No API calls (build only)
WEEKLY REPORT:      ~50 GraphQL calls (analysis)

See docs/ARCHITECTURE.md for detailed rate limit analysis.

Configuration

Categories (config/categories.yml)

Define which topics and keywords map to each category. Each category has:

• topics — GitHub repository topics (high precision)
• keywords — Search terms for broader discovery
• sub_categories — Sub-category labels

Scoring Weights (config/scoring_weights.yml)

weights:
  impact: 0.40
  velocity: 0.35
  health: 0.25

Scale Settings (config/scale.yml)

tiers:
  1:
    min_stars: 1000
    interval_hours: 24     # daily
  2:
    min_stars: 100
    interval_hours: 72     # every 3 days
  3:
    min_stars: 10
    interval_hours: 168    # weekly
  4:
    min_stars: 0
    interval_hours: 720    # monthly

batch:
  size: 700                # max repos per run
  max_api_calls: 800       # budget per run

rate_limit:
  hourly_budget: 1000      # GITHUB_TOKEN limit
  safety_threshold: 0.80   # use 80% max

All timing and thresholds are configurable — no code changes needed.

AI Provider (AI_PROVIDER env var)

AI_PROVIDER=rule      # Rule-based only (default, free)
AI_PROVIDER=github    # GitHub Models
AI_PROVIDER=openai    # OpenAI API
AI_PROVIDER=local     # Local model (Ollama)

Website

Built with Astro, deployed to GitHub Pages:

SEO: OpenGraph tags, Twitter Cards, JSON-LD structured data, auto-generated sitemap.

API

Full reference: API docs.

Project Structure

open-source-ai-radar/
+-- src/radar/               # Core Python package
|   +-- github/              # GraphQL + REST API client
|   +-- discovery/           # Layered discovery engine + telemetry
|   +-- scoring/             # Three-axis scoring + snapshots + trends
|   +-- analysis/            # Classification, anomalies, breakouts
|   +-- processing/          # Change detection for incremental runs
|   +-- reports/             # Weekly reports, RSS, social drafts
|   +-- api/                 # Endpoints + badge generation
|   +-- scale/               # Scheduler, rate limiter, retention
|   +-- storage/             # SQLite + JSON storage
|   +-- cli.py               # CLI entry point
+-- config/                  # categories.yml, scoring_weights.yml, scale.yml
+-- data/                    # SQLite DB + JSON exports (gitignored)
+-- web/                     # Astro website
+-- scripts/                 # export.py
+-- docs/                    # Architecture and scaling docs
+-- .github/workflows/       # 4 automation workflows
+-- tests/                   # Unit tests (50+)

Development

# Install dependencies
uv sync

# Run tests
uv run pytest tests/ -v

# Lint
uv run ruff check src/ tests/

# Build website
cd web && npm run build

# Full pipeline (local)
uv run radar discover --limit 50
uv run radar import-json
uv run radar classify
uv run radar process --limit 50
uv run python scripts/export.py

Documentation

• docs/ARCHITECTURE.md — System design, data flow, rate limits
• docs/SCALING.md — Roadmap from 5K to 500K repositories

License

MIT