# AI Tool Momentum Index (`lsso/ai-tool-momentum-index`) Actor

Which AI tools are taking off right now? Ranks GitHub trending repos, Hugging Face trending models and Spaces, or your own list, 0-100 on star velocity, HF trending, npm/PyPI download growth and Hacker News buzz. Hype flags, since-last-run changes, JSON + HTML report.

- **URL**: https://apify.com/lsso/ai-tool-momentum-index.md
- **Developed by:** [Haidong Nan](https://apify.com/lsso) (community)
- **Categories:** AI, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 tool profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## 📈 AI Tool Momentum Index: which AI tools are taking off right now

**Stars and likes tell you how big a tool already is. Momentum tells you what is growing *this week*.** This Actor scans GitHub trending repos and Hugging Face trending models and Spaces (or your own list of tools), and ranks every tool with a transparent **0–100 momentum score** built from how fast attention is growing: GitHub star velocity, Hugging Face trending and fresh-model downloads, npm and PyPI download growth, and Hacker News coverage.

- ✅ **One ranked list across GitHub, Hugging Face, npm and PyPI**, AI tools only by default
- ✅ **Momentum, not size**: stars gained per day, growth rate, downloads of models in their first weeks, week-over-week package growth
- ✅ **Hype check**: flags models with thousands of likes but almost no downloads, and star spikes with suspiciously few forks
- ✅ **Packages found automatically**: a GitHub repo is linked to its npm / PyPI package only when the package points back to that repo (no name guessing)
- ✅ **Track your own list**: repos, models, Spaces, npm and PyPI packages. Schedule it and every run also shows the **change since your last run**
- ✅ **HTML report + clean JSON**, ready for Sheets, a newsletter, a dashboard or an AI agent
- ✅ **Fair billing**: everything found is scored for free, you pay only for the top N tools returned

### 🎯 Who is it for?

- **Developers and tech leads**: spot the agent frameworks, inference engines and models your team will be asked about next month.
- **VCs, analysts and scouts**: open-source traction signals before they show up in funding news.
- **Newsletter writers and creators**: "the 10 fastest-rising AI tools this week" in one run.
- **DevRel and marketing teams**: track your project against competitors every day.

### 🚀 Quick start

1. Leave **What to do** on *Discover what is trending now*.
2. Optionally add **keywords** such as `agent`, `mcp`, `video` or `coding`.
3. Click **Start**. Open the **HTML report** in the Storage tab, or download the dataset as JSON, CSV or Excel.

### ⬇️ Input examples

This week's trending AI tools on GitHub and Hugging Face:

```json
{ "mode": "trending", "githubPeriod": "weekly", "maxItems": 50 }
```

Only agent tools, from Python and TypeScript repos:

```json
{ "mode": "trending", "sources": ["github"], "githubLanguages": ["python", "typescript"], "keywords": ["agent"] }
```

Track your own list (schedule it daily to get the change since the last run):

```json
{ "mode": "track", "tools": ["vllm-project/vllm", "ollama/ollama", "hf:Qwen/Qwen3-8B", "npm:@anthropic-ai/sdk", "pypi:langchain"] }
```

### ⬆️ Output (one item per tool)

```json
{
  "rank": 1,
  "kind": "github",
  "id": "alibaba/open-code-review",
  "name": "open-code-review",
  "description": "Secure, fast, efficient, battle-tested at Alibaba's scale...",
  "url": "https://github.com/alibaba/open-code-review",
  "momentumScore": 45,
  "tier": "exploding",
  "signals": ["GitHub: +9,833 stars in 7 days (40,479 total)"],
  "scoreComponents": { "githubVelocity": 35, "githubGrowth": 10, "hfTrending": 0, "hfAdoption": 0, "downloadsGrowth": 0, "hackerNews": 0 },
  "qualityFlags": [],
  "github": { "stars": 40479, "forks": 2912, "starsInPeriod": 9833, "period": "weekly", "starsPerDay": 1404.7, "language": "Go" }
}
```

Hugging Face items carry `huggingFace` (likes, trending score, downloads in the last 30 days, task, created date). Packages carry `npm` or `pypi` (downloads last week, previous week or monthly average, growth). The key-value store also has `OUTPUT` (top 10, exploding tools, flagged tools) and `REPORT` (the HTML report).

**Tiers:** `exploding` (45+), `rising` (30–44), `steady` (15–29), `quiet` (under 15).

### 🧮 How the score works

| Component | Max | What it measures |
|---|---|---|
| GitHub velocity | 35 | Stars gained per day (log scale, 1,000/day = max) |
| GitHub growth | 10 | Stars gained relative to the repo's size |
| Hugging Face trending | 25 | Hub trending score (halved when likes have no downloads behind them) |
| Hugging Face adoption | 20 | Downloads in the last 30 days, weighted towards models under 60 days old |
| Package growth | 20 | npm week-over-week or PyPI week vs monthly average, only when volume is real |
| Hacker News | 10 | Points of stories linking to or naming the tool |

Every component is returned with each tool, so you can re-weight it yourself.

### 💵 Pricing

**Free from October 9, 2026.** Until then the old pay-per-event prices still apply ($0.02 per tool returned, $0.10 per report). After that date you pay only Apify's normal platform usage for your own runs, typically a few cents.

### 🤖 Use it from AI agents (MCP)

Add this URL as an MCP server in Claude, Cursor or any MCP client and ask *"Which AI tools gained the most momentum this week?"*:

```
https://mcp.apify.com?tools=lsso/ai-tool-momentum-index
```

### ❓ FAQ

**Where does the data come from?** GitHub's public trending page and REST API, the Hugging Face Hub API, the npm downloads API, PyPI Stats and the official Hacker News search API (Algolia). No logins, no private data.

**Do I need a GitHub token?** No. Trending mode works without one. In **track** mode, a token (read-only public access is enough) lets the Actor measure star velocity for many repos, because GitHub allows only 60 anonymous requests per hour. The token is used only for this run. GitHub lists only the newest 40,000 stargazers of a repo, so for repos with more than 40,000 stars the velocity comes from the change since your previous run (schedule the Actor; the first run shows 0 for them).

**Why does a famous model score lower than a new one?** The index measures growth, not size. A model with 10 million downloads that is no longer trending scores below a two-week-old model that everyone is trying.

**What does the "check" flag mean?** A pattern that often means inflated popularity, e.g. a model with thousands of likes and almost no downloads. The tool is still listed; the flag tells you to look twice.

**How fresh is it?** Every run fetches live data. GitHub trending updates several times a day, Hugging Face trending continuously.

### 📝 Changelog

- **1.2** (2026-09-25): Becoming free (from October 9, 2026); Hugging Face data now comes only from the official API (the mirror fallback was removed); report links are restricted to http(s).
- **1.1** (2026-09-24): Hugging Face mirror fallback, much lower memory use for popular repos (small npm lookups), 20-second request timeouts, repos with dots in the name (e.g. `vercel/next.js`) now link to their packages, star losses no longer produce negative scores, clearer message when the charge limit is too low.
- **1.0** (2026-09-24): First release: GitHub trending + Hugging Face models and Spaces, track mode for repos, models, Spaces, npm and PyPI, momentum score with components, hype flags, since-last-run changes, HTML report.

# Actor input Schema

## `mode` (type: `string`):

**trending**: scan GitHub trending repos and Hugging Face trending models and Spaces, then score them. **track**: score your own list (repos, models, Spaces, npm or PyPI packages). Schedule it to get the change since your last run.

## `tools` (type: `array`):

Only for **track**. One per line: `ollama/ollama` or a GitHub URL, `hf:Qwen/Qwen3-8B`, `space:org/name`, `npm:openai`, `pypi:vllm`. Hugging Face, npm and PyPI URLs also work.

## `sources` (type: `array`):

Only for **trending**. Default: all three.

## `githubPeriod` (type: `string`):

Only for **trending**: which GitHub trending list to read. Stars gained in this period drive the GitHub part of the score.

## `githubLanguages` (type: `array`):

Optional, e.g. `python`, `typescript`, `rust`. Each language adds its own trending list. Empty = all languages.

## `hfLimit` (type: `integer`):

Only for **trending**: how many trending Hugging Face models and Spaces to read (each list).

## `aiOnly` (type: `boolean`):

Drop GitHub trending repos that are not about AI (Hugging Face items are always kept).

## `keywords` (type: `array`):

Keep only tools whose name or description contains one of these, e.g. `agent`, `mcp`, `video`, `coding`.

## `maxItems` (type: `integer`):

Everything found is scored for free; you pay only for the top N tools returned.

## `hnDays` (type: `integer`):

How far back to count Hacker News stories and points for each tool.

## `githubToken` (type: `string`):

Optional, read-only public access is enough. Raises GitHub's limit from 60 to 5,000 requests/hour so **track** mode can measure star velocity for many repos. Never stored or shared.

## Actor input object example

```json
{
  "mode": "trending",
  "tools": [
    "vllm-project/vllm",
    "ollama/ollama",
    "hf:Qwen/Qwen3-8B",
    "npm:@anthropic-ai/sdk",
    "pypi:langchain"
  ],
  "sources": [
    "github",
    "hf-models",
    "hf-spaces"
  ],
  "githubPeriod": "weekly",
  "githubLanguages": [],
  "hfLimit": 40,
  "aiOnly": true,
  "keywords": [],
  "maxItems": 50,
  "hnDays": 7
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "tools": [
        "vllm-project/vllm",
        "ollama/ollama",
        "hf:Qwen/Qwen3-8B",
        "npm:@anthropic-ai/sdk",
        "pypi:langchain"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lsso/ai-tool-momentum-index").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "tools": [
        "vllm-project/vllm",
        "ollama/ollama",
        "hf:Qwen/Qwen3-8B",
        "npm:@anthropic-ai/sdk",
        "pypi:langchain",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("lsso/ai-tool-momentum-index").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "tools": [
    "vllm-project/vllm",
    "ollama/ollama",
    "hf:Qwen/Qwen3-8B",
    "npm:@anthropic-ai/sdk",
    "pypi:langchain"
  ]
}' |
apify call lsso/ai-tool-momentum-index --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lsso/ai-tool-momentum-index"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/6qPoAsVu0efbjAlMz/builds/ige7dIL7pd7qtUFW8/openapi.json