# AI Research Radar: arXiv + Hugging Face Papers (`tendoyo/ai-research-radar`) Actor

One ranked, de-duplicated feed of new AI papers (arXiv) enriched with Hugging Face daily-paper upvotes, GitHub repos/stars and trending models. Filter by category, keyword, upvotes, 'has code'; incremental 'only new' monitoring; optional LLM digest (bring your own key).

- **URL**: https://apify.com/tendoyo/ai-research-radar.md
- **Developed by:** [Shuai Li](https://apify.com/tendoyo) (community)
- **Categories:** AI, News, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 papers

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 Research Radar – arXiv + Hugging Face daily papers + trending models

One **ranked, de-duplicated feed** of what is new in AI for your topic:

- **arXiv** (official API): new papers by category, keyword and date window.
- **Hugging Face daily papers**: community upvotes, GitHub repo and stars, project page, HF AI summary and keywords.
- **Hugging Face trending models**: by task (text-generation, image-text-to-text, ASR…), with licence, likes and downloads.

An arXiv paper that is also featured on HF becomes **one row** carrying both arXiv metadata and the HF community signals.

### Ranking

`radarScore = HF upvotes + √GitHub stars + 5 × keyword-in-title + 2 if code + recency bonus`. The formula is transparent and reproducible. You can also set `rankBy: newest`.

### Typical uses

- A weekly "what to read" digest for an AI team, sent to Slack or e-mail (`onlyNew: true` on a schedule).
- Tracking a niche such as `["speculative decoding", "KV cache"]` or `["tool use", "agent"]`.
- Scouting open-source releases (`onlyWithCode: true`) and trending open-weight models.

### Optional AI digest (bring your own key)

You get a headline, up to 5 themes and why they matter, must-read papers with practical takeaways, models to watch and a short Markdown digest. It works with any OpenAI-compatible endpoint.

### Pricing (pay per event)

- Paper: **$0.002**
- Trending model: **$0.002**
- AI digest: **$0.03** per run

### Sources & etiquette

arXiv metadata is CC0. The Actor waits at least 3 s between arXiv requests, as arXiv's API terms ask, and links to papers rather than redistributing PDFs. *Thank you to arXiv for use of its open access interoperability.* Hugging Face data comes from the public Hub API with no login. Model weights remain under each model's own licence.

### Try it in one click

These ready-made example tasks show real output. Open one, click **Try for free** and you get your own copy to edit and run:

- [Track new AI agent, tool-use and RAG research papers](https://apify.com/Tendoyo/ai-research-radar/examples/radar-agents-tool-use-rag)
- [Monitor new LLM reasoning and reinforcement learning papers](https://apify.com/Tendoyo/ai-research-radar/examples/radar-llm-reasoning-papers)

### Sample output

Real rows from a recent run (some fields trimmed). The full row schema is shown in the **Output** tab.

```json
[
  {
    "rank": 1,
    "radarScore": 140.41,
    "title": "Trajectory2Gym: Decision-Grounded Compositional Interaction Synthesis for Tool-Use Agents",
    "published": "2026-10-24",
    "hfUpvotes": 130,
    "githubRepo": "https://github.com/yihaohu0118/Trajectory2Gym",
    "githubStars": 2,
    "hfAiSummary": "Trajectory2Gym improves tool-use training by constructing interactions with compositional coverage and decision grounding rather than collecting successful traj…",
    "matchedKeywords": [
      "agent"
    ],
    "absUrl": "https://arxiv.org/abs/2610.33568",
    "hfUrl": "https://huggingface.co/papers/2610.33568"
  },
  {
    "rank": 2,
    "radarScore": 118,
    "title": "StreamVibe: Proactive Video Agents for Evolving User Intent",
    "published": "2026-10-26",
    "hfUpvotes": 110,
    "githubRepo": null,
    "githubStars": null,
    "hfAiSummary": "StreamVibe introduces a benchmark, streaming vision-language model, and hierarchical memory harness to enable proactive, intent-aware interaction with implicit…",
    "matchedKeywords": [
      "agent"
    ],
    "absUrl": "https://arxiv.org/abs/2610.34662",
    "hfUrl": "https://huggingface.co/papers/2610.34662"
  }
]
```

### How much does it cost?

You pay only for results (pay per event). There is no separate compute charge, and you can cap any run with **Max total charge**.

| Scenario | Cost |
|---|---|
| 20 papers + 5 trending models (one example run) | 25 × $0.002 = **$0.05** |
| Daily feed of the top 20 papers | 600 × $0.002 = **$1.20 / month** |
| Weekly AI digest on top (your own LLM key) | 4 × $0.03 = **+$0.12 / month** |

A tiny "Actor start" event (about $0.00005) is also charged once per run.

### Use it from your code or tools

Run it and get the results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/Tendoyo~ai-research-radar/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords": ["speculative decoding", "KV cache"], "daysBack": 7, "onlyNew": true}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("Tendoyo/ai-research-radar").call(run_input={"keywords": ["speculative decoding", "KV cache"], "daysBack": 7, "onlyNew": true})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

To get alerts, add a **Schedule** (for example daily at 07:00) with `onlyNew: true` where available. Then connect **Slack, e-mail, Google Sheets, Make, Zapier, n8n or a webhook** in the Integrations tab. It also works with AI agents through the Apify MCP server.

### FAQ

**How is this different from arXiv e-mail alerts?**
arXiv alerts list everything in a category. This Actor merges arXiv with Hugging Face community signals (upvotes, GitHub stars, code links), filters by your keywords, de-duplicates and ranks, so you read the 10 papers that matter.

**Can I send it to Slack every morning?**
Yes. Add a schedule with `onlyNew: true` and connect the Slack integration, or turn on the AI digest and post the Markdown digest.

**Can I see only papers with code?**
Set `onlyWithCode: true`.

**Do you redistribute PDFs?**
No. Rows contain metadata and links; PDFs stay on arXiv under their own licences.

### Support

Questions, bugs or a source you'd like added: open an issue on the Actor page or e-mail **youcanneverhacktendoyo@gmail.com**. Maintained by [Tendoyo](https://apify.com/Tendoyo).

# Actor input Schema

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

Which feeds to include: arxiv (official API), hfDaily (Hugging Face daily papers) and hfModels (trending models).

## `arxivCategories` (type: `array`):

e.g. cs.CL, cs.CV, cs.RO, stat.ML. Applies to arXiv only (HF daily papers have no categories).

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

Match in title / abstract / HF AI keywords. Multi-word phrases are matched exactly. Empty = everything.

## `daysBack` (type: `integer`):

How many days back to look, counting from today (UTC).

## `maxPapers` (type: `integer`):

Maximum number of ranked papers to output.

## `rankBy` (type: `string`):

radarScore = HF upvotes + sqrt(GitHub stars) + keyword and code bonuses + recency; newest = submission date.

## `maxArxivScan` (type: `integer`):

arXiv returns newest first; ranking happens over the scanned set.

## `minUpvotes` (type: `integer`):

> 0 effectively keeps only HF-featured papers.

## `onlyWithCode` (type: `boolean`):

Keep only papers that link to a GitHub repository.

## `modelTasks` (type: `array`):

HF pipeline tags, e.g. text-generation, image-text-to-text, text-to-image, automatic-speech-recognition.

## `maxModels` (type: `integer`):

Maximum number of trending Hugging Face models to output.

## `onlyNew` (type: `boolean`):

Ideal for a daily/weekly schedule -> Slack / e-mail / Notion.

## `llmEnrichment` (type: `boolean`):

Optional AI digest (headline, themes, must-reads, models to watch). Requires your own OpenAI-compatible key; charged once per run.

## `llmApiKey` (type: `string`):

Your API key for any OpenAI-compatible endpoint. Stored encrypted; only used when the AI option is on.

## `llmBaseUrl` (type: `string`):

Default https://api.openai.com/v1

## `llmModel` (type: `string`):

Default gpt-4o-mini

## `contactEmail` (type: `string`):

Optional e-mail added to the User-Agent so data providers can contact the operator, as their fair-use policies ask.

## Actor input object example

```json
{
  "sources": [
    "arxiv",
    "hfDailyPapers",
    "hfTrendingModels"
  ],
  "arxivCategories": [
    "cs.CL",
    "cs.AI",
    "cs.LG"
  ],
  "keywords": [
    "agent",
    "retrieval"
  ],
  "daysBack": 3,
  "maxPapers": 50,
  "rankBy": "radarScore",
  "maxArxivScan": 300,
  "minUpvotes": 0,
  "onlyWithCode": false,
  "modelTasks": [
    "text-generation"
  ],
  "maxModels": 20,
  "onlyNew": false,
  "llmEnrichment": false
}
```

# Actor output Schema

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

Ranked AI papers (arXiv + Hugging Face daily papers) and trending open models, plus the optional AI digest row.

## `runSummary` (type: `string`):

JSON stats for the run: items pushed, sources queried, charged events and warnings.

# 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 = {
    "arxivCategories": [
        "cs.CL",
        "cs.AI",
        "cs.LG"
    ],
    "keywords": [
        "agent",
        "retrieval"
    ],
    "modelTasks": [
        "text-generation"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tendoyo/ai-research-radar").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 = {
    "arxivCategories": [
        "cs.CL",
        "cs.AI",
        "cs.LG",
    ],
    "keywords": [
        "agent",
        "retrieval",
    ],
    "modelTasks": ["text-generation"],
}

# Run the Actor and wait for it to finish
run = client.actor("tendoyo/ai-research-radar").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 '{
  "arxivCategories": [
    "cs.CL",
    "cs.AI",
    "cs.LG"
  ],
  "keywords": [
    "agent",
    "retrieval"
  ],
  "modelTasks": [
    "text-generation"
  ]
}' |
apify call tendoyo/ai-research-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tendoyo/ai-research-radar"
        }
    }
}
```

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/KO1zcy6dgrJCnIWmb/builds/hxNkgKyFgnq6pLIVh/openapi.json