# AI SDK Release Radar (`serendy/ai-sdk-release-radar`) Actor

Track OpenAI, LangChain and LlamaIndex SDK updates. Get evidence-backed breaking-change, deprecation and migration reports in JSON and English, with no API key required.

- **URL**: https://apify.com/serendy/ai-sdk-release-radar.md
- **Developed by:** [Luqian Lin](https://apify.com/serendy) (community)
- **Categories:** Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 complete dependency analyses

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 SDK Release Radar

Know what changed before you upgrade your AI stack. Track **OpenAI, LangChain and LlamaIndex** Python SDKs and turn official release notes into an English upgrade review with structured JSON, source links and clear evidence boundaries.

Check a single dependency or a team’s dependency list. Schedule recurring runs and connect the output to GitHub Actions, n8n, Make, Zapier or your own automation through Apify’s API and native webhooks.

### What you get

- Latest stable versions from public PyPI metadata.
- Release notes between your installed version and the latest stable version.
- Breaking-change, deprecated-API, removed-feature and migration signals, with quoted official evidence.
- A risk level, update highlights and practical next steps for each dependency.
- A coverage check against PyPI’s published stable versions. Missing release notes produce **unknown** overall risk, rather than a reassuring guess.
- One JSON dataset row per unique dependency, a full JSON report and a readable English Markdown report.

**No API key or LLM subscription is required.** The MVP uses transparent, deterministic evidence rules, not a generative AI model. The name refers to the AI SDKs it monitors. Official release statements and rule-based inferences are labeled separately. It does not read or modify your application code.

### Quick start

1. Keep the example input for a first run, or replace `currentVersion` with the exact version installed in your project.
2. Click **Start**.
3. Open the **Dependency risk table**, **Full JSON report** or **English upgrade report** in the run’s Output tab.

```json
{
  "dependencies": [
    {"package": "openai", "currentVersion": "3.34.0"},
    {"package": "langchain", "currentVersion": "1.4.4"},
    {"package": "llama-index-core", "currentVersion": "0.14.24"}
  ]
}
```

The example versions are real published versions checked on October 19, 2026. Latest versions and results change over time.

#### Supported packages

| Package | Repository selection | Notes |
|---|---|---|
| `openai` | Automatic | Official OpenAI Python SDK |
| `langchain` | Automatic | Only matching `langchain==` releases |
| `langchain-core` | Automatic | Only matching `langchain-core==` releases |
| `langchain-openai` | Automatic | Matching package tags; the package is maintained in the LangChain repository |
| `llama-index-core` | Automatic | Only the core package’s section in shared release notes |
| `llama-index` | Automatic | Requires an explicit `llama-index` section; otherwise the report is partial |
| Other public Python packages | Supply `repository` | Must link the repository from PyPI metadata and use `v1.2.3`, `1.2.3` or `package==1.2.3` GitHub release tags |

```json
{
  "dependencies": [
    {
      "package": "openai",
      "repository": "openai/openai-python",
      "currentVersion": "3.34.0"
    }
  ]
}
```

`repository` also accepts `https://github.com/owner/repository`. Use public PyPI package names and exact, published stable versions. Version ranges, private repositories, prerelease/dev versions and local-version suffixes are not supported. Maximum: **20 input dependencies per run**. Exact duplicate entries are analyzed once.

### Understand the report

| Field | Meaning |
|---|---|
| `status` | `success`, `partial`, `error` or `skipped` |
| `riskLevel` | `none` for no update; `low`, `medium` or `high` for complete release coverage; `unknown` when evidence is missing or a source fails |
| `observedRiskLevel` | Risk suggested by available notes; does not override `unknown` when coverage is incomplete |
| `findings[].basis` | `official_statement` for a quoted release statement; `rule_inference` for a major-version heuristic |
| `findings[].evidence` | Source URL, exact source excerpt and section, where available |
| `coverage` | Number of expected and reviewed versions, completeness and missing versions |
| `billable` | Whether the persisted report qualifies for an analysis event; actual charges are recorded by Apify, separately |
| `retrievedAt` | UTC timestamp of this source check |

The official statement label applies to the quoted text. Categorization, potential impact and upgrade advice are rules-based interpretations. A major-version change is a heuristic, not proof that an API broke. `low` means no explicit risk signals were found in the reviewed notes; it does **not** mean a verified safe upgrade.

#### Example output

This shortened excerpt is from a live public-source check on October 19, 2026:

```json
{
  "package": "llama-index-core",
  "currentVersion": "0.14.24",
  "latestVersion": "0.14.25",
  "status": "success",
  "riskLevel": "high",
  "analysisEngine": "evidence-rules-v1",
  "llmUsed": false,
  "coverage": {
    "complete": true,
    "expectedVersions": 1,
    "analyzedVersions": 1,
    "missingVersions": []
  },
  "billable": true
}
```

The full output also contains findings, source excerpts, recommendations, release notes, source URLs and retrieval timestamps. Export the dataset as JSON, CSV or Excel through Apify; JSON preserves nested evidence best.

### Pricing

The launch price is **$0.005 per complete dependency analysis** ($5 per 1,000 analyses), including checks that confirm no update is available. The live **Pricing** tab is authoritative. There is no monthly Actor rental or LLM surcharge.

- A complete analysis requires verified public version metadata and, when an update exists, release notes for every non-yanked stable target version in the checked window.
- Errors, incomplete coverage and budget-skipped dependencies do not trigger `dependency-analysis` events.
- There is no startup charge or automatic per-dataset-row charge. Results are persisted before the custom analysis events are charged.
- Set **Max cost per run** to control spending. An input of three complete dependencies costs $0.015 at the launch price. A report with missing historical notes is returned without an analysis-event charge.
- Platform execution costs for your own development/test runs and builds are governed by your Apify account plan. Standard Store runs include platform usage in the event price. Standby mode is not supported.

### Schedule and integrate

Save the input as an **Apify Task**, then create an **Apify Schedule** for a daily or weekly check. Keep `currentVersion` aligned with your project’s installed pin; the Actor does not change it automatically.

Resurrecting a run with an existing report repairs any missing output and does not issue another analysis event. Start a fresh run to request a new source check.

Use a native Apify webhook for `ACTOR.RUN.SUCCEEDED` to notify your automation, then fetch the run’s default dataset or `REPORT` record. A successful run may contain per-dependency error rows, so inspect `status` and `coverage.complete` before routing an upgrade alert.

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("Serendy/ai-sdk-release-radar").call(run_input={
    "dependencies": [{"package": "openai", "currentVersion": "3.34.0"}]
})
for result in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(result["package"], result["status"], result["riskLevel"])
```

Never put API tokens in a public issue, report or source file. Apify supplies its run credentials automatically in the cloud.

### Limits and troubleshooting

- **Incomplete coverage:** This MVP reads up to 300 recent GitHub releases per repository. Older upgrades, packages without version-specific notes and missing package sections return partial reports without analysis charges. Check a smaller upgrade window or read the missing versions manually.
- **Rate limit:** Public GitHub API limits apply per egress IP. The Actor returns `rate_limited` and does not charge that dependency. Retry later or schedule less frequently.
- **Source unavailable:** Transient network and server failures have bounded retries. Retry the run later. Other dependencies can still complete.
- **Unknown current version / ahead of latest:** Check `pip show PACKAGE` and enter its exact published stable version.
- **Repository mismatch:** Use the official repository linked from the package’s PyPI project metadata. This prevents release notes from unrelated projects entering your report.
- **Budget reached:** Increase the run’s maximum charge or submit fewer dependencies. Skipped dependencies are not charged.

This tool cannot guarantee compatibility or discover every undocumented breaking change. It excludes prerelease and yanked target releases, does not resolve your transitive dependency tree and does not execute packages. Review source evidence and run your application tests before upgrading.

### Data and support

The Actor reads public metadata and release notes from PyPI and GitHub. Your dependency list and generated reports are stored in your run’s Apify storage under your account’s retention settings. There is no external analytics service or LLM provider in the Actor.

For help, open an issue in the Actor’s Apify Store **Issues** tab with the package, version, error code and a redacted input. Do not include credentials or private code.

# Actor input Schema

## `dependencies` (type: `array`):

Use package and currentVersion. Optional repository accepts owner/repo or a GitHub repository URL. For other Python packages, supply the repository linked in their PyPI metadata. Current versions must be published stable versions. Change the examples to the versions installed in your project.

## Actor input object example

```json
{
  "dependencies": [
    {
      "package": "openai",
      "currentVersion": "3.34.0"
    },
    {
      "package": "langchain",
      "currentVersion": "1.4.4"
    },
    {
      "package": "llama-index-core",
      "currentVersion": "0.14.24"
    }
  ]
}
```

# Actor output Schema

## `dependencies` (type: `string`):

No description

## `report` (type: `string`):

No description

## `markdown` (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 = {
    "dependencies": [
        {
            "package": "openai",
            "currentVersion": "3.34.0"
        },
        {
            "package": "langchain",
            "currentVersion": "1.4.4"
        },
        {
            "package": "llama-index-core",
            "currentVersion": "0.14.24"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("serendy/ai-sdk-release-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 = { "dependencies": [
        {
            "package": "openai",
            "currentVersion": "3.34.0",
        },
        {
            "package": "langchain",
            "currentVersion": "1.4.4",
        },
        {
            "package": "llama-index-core",
            "currentVersion": "0.14.24",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("serendy/ai-sdk-release-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 '{
  "dependencies": [
    {
      "package": "openai",
      "currentVersion": "3.34.0"
    },
    {
      "package": "langchain",
      "currentVersion": "1.4.4"
    },
    {
      "package": "llama-index-core",
      "currentVersion": "0.14.24"
    }
  ]
}' |
apify call serendy/ai-sdk-release-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,serendy/ai-sdk-release-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/VfPcoRar5UxbEJ5w2/builds/UD2ejxrFm57POOv0y/openapi.json