DEV Community: connerlambden

Detecting AI-authored news at corpus scale from a single MCP call

connerlambden — Tue, 21 Apr 2026 15:04:16 +0000

There's a growing crisis inside news feeds: AI-generated content, slop, and opinion-masked-as-reporting are all appearing faster than human review systems can flag them. Most "AI detection" tools work per-document and return a single binary probability with no supporting evidence. That's not enough for someone who has to actually decide what to read, publish, or cite.

I put the opposite approach behind an MCP server - a continuous, corpus-scale, per-article ai_authorship_probability score, plus 30 other framing dimensions, all queryable in plain English from Claude or Cursor.

The core dimension

Helium MCP scores every article it ingests across 3.2M+ articles and 5,000+ sources on:

ai_authorship_probability - explicit model estimate that the article was LLM-generated
credibility - sourcing density, named-source ratio, evidence-citation patterns
sensationalism - headline-vs-body amplification, superlative density
overconfidence - hedge-language vs declarative-certainty ratio
opinion_vs_fact - opinion language vs declarative-fact language ratio
oversimplification - single-cause reduction of complex causation
begging_the_question - conclusion assumed in the framing
scapegoating - actor-blaming vs structural-explanation patterns
covering_responses - whether the criticized parties get space to respond
...22 more

The point is not that any one score is a verdict. The point is that you can now triangulate. A high AI-authorship probability paired with low sourcing density and high sensationalism is a very different signal from high AI-authorship in a meticulously-sourced explainer - and a scoring pipeline that only returns one number cannot tell them apart.

Setup

# In Cursor or Claude Desktop MCP config:
npx mcp-remote https://heliumtrades.com/mcp

Free. No signup. No API key. Remote server.

Asking the question

In Claude, I asked:

Using Helium, show me the most AI-suspicious recent articles across the corpus, and cross-reference against their credibility and sensationalism scores.

Claude called search_articles, filtered by the top decile of ai_authorship_probability, joined against per-source metadata, and returned a ranked list with the four relevant scores side-by-side. The top of the list was dominated by low-credibility, high-sensationalism sources - which is what you'd expect. But the more interesting result was a small cohort in the middle of the pack: high AI-authorship, high credibility, moderate sensationalism. Those are almost certainly human-edited AI drafts - the category that a single-axis detector would miss entirely.

Why 31 dimensions, not one

The one-number-detector fails in two ways:

False negatives from human editing. A human editor can smooth an LLM draft enough to drop a binary detector score below threshold, but framing artifacts (overconfidence pattern, opinion-vs-fact ratio, coverage-of-responses) survive. Multi-dim signal catches them.
False positives from LLM-like human writing. Academic-style prose is often flagged as AI-generated by single-axis detectors. But the sourcing-density and citation-evidence axes in a 31-dim score are the difference between a grad student and an LLM - and they show up cleanly in the schema.

Example use cases

Newsroom standards editors - a daily cron job that flags high-AI-authorship articles in your freelance submissions bucket, weighted by credibility score, before an editor ever opens them.

Fact-checkers - when triaging a viral claim, pull the source's recent-window scores on ai_authorship_probability, credibility, and overconfidence. A source that has drifted toward AI authorship and away from sourced evidence is a different trust situation than one that has been stable.

Journalism-school instructors - assign students to pull 10 articles from a single publication across a decade, graph the ai_authorship_probability and credibility trend lines, and write a piece on what changed.

AI-safety researchers - the full 31-dimension scored corpus is a ready-made dataset for studying how LLM-generated news content is spreading through mainstream feeds.

Live example

Here's a real query I ran in Claude:

Helium: Show me how AI-authorship probability has moved for tech-news sources over the last year, correlated with credibility.

Claude used the MCP tools, ran the query across the Helium corpus, and returned a tidy summary showing that several mid-tier aggregator sources have seen a meaningful upward shift in ai_authorship_probability over the last 12 months, while their credibility score drifted down. That's a reportable trend. The reporter didn't have to build a scraper, didn't have to maintain a classifier, didn't have to write SQL - they asked a question in English.

What to do

If you work anywhere near news - as a reader, a writer, an editor, a researcher, or someone building AI-news workflows - try it:

npx mcp-remote https://heliumtrades.com/mcp

Then ask Claude the question you've been asking Google and failing to get a structured answer from. The 31-dim schema is there, the corpus is populated, and the tool calls are free.

Full tool list, full schema, full source: github.com/connerlambden/helium-mcp.

If you find the schema missing something important, open an issue or reach out. The axes were picked empirically across 3.2M articles, but the space of things-worth-measuring about a news article is larger than what's in the schema today - and I'd rather know.

31 dimensions of news bias, queryable from Claude in plain English

connerlambden — Sun, 19 Apr 2026 22:21:30 +0000

The problem

Most "news bias" tools collapse a story into a single number on a left-right axis. That's useful for a thumbnail, but it's the wrong granularity for almost any real workflow - a newsroom standards editor, a fact-checker triaging a viral claim, a journalism-school instructor teaching framing, an AI safety researcher building a misinformation classifier.

What those workflows actually need is structured, multi-dimensional, queryable framing data. So I built it and put it behind an MCP server that any AI assistant can call.

The schema

Helium MCP scores every article on 31 dimensions. A non-exhaustive sample:

liberal_conservative - the standard left-right axis (kept for compatibility)
credibility - sourcing density, named-source ratio, evidence-citation pattern
opinion_vs_fact - opinion language vs declarative-fact language ratio
scapegoating - actor-blaming patterns vs structural-explanation patterns
covering_responses - whether the article gives space to the people/orgs being criticized
fearful - emotional valence, threat language
sensationalism - headline-vs-body amplification, superlative density
overconfidence - hedge language vs declarative certainty
intelligence - reading level, conceptual density
begging_the_question - assumes the conclusion in the framing
oversimplification - reduces complex causation to single factors
ai_authorship_probability - explicit estimate that the article was LLM-generated
... 19 more

The key thing is that every dimension is operationalized - it's not just "vibes" labeling, each one is computed from features in the text.

The corpus

3.2M+ articles
5,000+ sources
Updated continuously
Sources span global mainstream, US partisan, business press, tech press, regional, and long-tail / hyperlocal

The MCP interface

Helium MCP exposes this via three main tools you can call from any AI assistant:

get_source_bias(source) - aggregate scores across a source's recent corpus
get_bias_from_url(url) - score a single article on demand
search_balanced_news(query) - synthesize multi-source coverage of an event with structured outcomes

Setup (one line)

Add to your mcp.json in Cursor or Claude Desktop:

{
  "mcpServers": {
    "helium": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://heliumtrades.com/mcp"]
    }
  }
}

Free, no signup, no API key.

A real example

In Claude, I asked: "Show me the bias profile for CNN's recent corpus using Helium."

Real output (445 articles analyzed):

Liberal/Conservative:  -2   (slightly left)
Credibility:           15   (moderate-high)
Fearful:                4
Intelligence:          11
Covering Responses:     9   (gives space to the criticized)
Opinion:                5
Overconfidence:         8

The value of seeing it as 31 numbers (and not 1) is that you can ask follow-up questions like "For these same articles, are the high-credibility ones more or less likely to be high-overconfidence?" - and the agent can compute the correlation in-place.

Use cases this unlocks

For a newsroom standards editor: triage incoming wire/syndication content by ai_authorship_probability before it goes through your editorial pipeline.

For a fact-checker: rank a list of suspect URLs by credibility (low) and overconfidence (high) - the combination is a strong indicator of claims worth investigating.

For a journalism instructor: show students how the same event was framed across 10 sources, with structured scapegoating / covering_responses / opinion_vs_fact scores attached.

For an AI safety researcher: the schema is essentially a deployed multi-criterion eval pipeline applied to news rather than to LLM outputs - useful as an empirical reference for how multi-criterion eval criteria interact with each other in production (Goodhart, distribution shift, taxonomy choice).

For anyone building an AI agent that consumes news: structured per-source/per-article framing metadata is the missing primary key for reasoning about source reliability programmatically.

The bigger point

In a world where readers query LLMs more than they visit homepages, the value of an individual article goes down and the value of structured, queryable, per-article metadata goes up. The schema above is one open attempt at what that metadata layer should look like.

If you have ideas for dimensions that should be added (or critiques of the existing ones), I'd love to hear them - the methodology is open.

Caveats

This is not a substitute for human editorial judgment. Bias scoring is hard, the schema can be wrong, and there are distribution-shift / Goodhart concerns with any operationalized criterion. Use it as a triage layer, not a verdict.

How I screen for ratio spread opportunities in 30 seconds with an MCP server

connerlambden — Sun, 19 Apr 2026 22:05:52 +0000

The setup

A "ratio spread" in options trading is when you sell N options at one strike and buy M options at another, where N != M. The classic 1x2 put ratio spread (sell 1 ATM put, buy 2 OTM puts) is a favorite of vol traders because it lets you express a view that downside skew is overpriced and gives you positive convexity if the market really crashes.

The hard part is finding candidates. Skew mispricings are the kind of thing you used to need a Bloomberg terminal + a custom IV-surface model + an analyst to surface. With a free remote MCP server I built called Helium MCP, you can do it in 30 seconds inside Claude Desktop or Cursor.

What the MCP exposes

Helium MCP is a thin wrapper over a per-symbol ML options pricing model. For any contract, it returns:

predicted_price - Helium's model fair value
prob_itm - probability of expiring in the money
options_data_date - freshness of the chain snapshot

The model is trained per-symbol on each ticker's own historical options data, so it makes different (and sometimes wildly different) calls than a generic Black-Scholes fit.

Setup (one line)

Add to your mcp.json in Cursor or Claude Desktop:

{
  "mcpServers": {
    "helium": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://heliumtrades.com/mcp"]
    }
  }
}

That's it. Free, no signup.

Finding a ratio-spread candidate

Inside Cursor, I asked the agent: "Pull AAPL option prices from Helium for May 15 expiry across $180/$195/$200/$205 strikes."

Real output, just now:

get_option_price('AAPL', 200, '2026-05-15', 'call')   ->  $20.64,  prob_itm 0.52
get_option_price('AAPL', 205, '2026-05-15', 'call')   ->  $20.69,  prob_itm 0.52
get_option_price('AAPL', 195, '2026-05-15', 'put')    ->  $0.06,   prob_itm 0.01
get_option_price('AAPL', 180, '2026-05-15', 'put')    ->  $0.02,   prob_itm 0.01

Look at the puts. The model thinks AAPL has effectively 1% probability of finishing below $195 by mid-May. The market is paying actual money for those puts (and a lot more for the deeper OTM ones - that's the skew).

If you believe the model, the deep OTM put side is the overpriced side. That's a textbook setup for a 1x2 put ratio spread:

Sell 1 near-ATM put (collect the rich premium the market is offering for a bearish view)
Buy 2 deep OTM puts (cheap insurance + tail-side convexity)

If the market chops sideways or rallies (the model's base case), all the puts expire worthless and you keep the credit. If the market crashes hard, the 2 long puts catch up to and exceed the 1 short put.

The point isn't this specific trade

The point is that screening this kind of structural mispricing went from "needs an institutional setup" to "ask Claude in plain English" the day MCP made it possible to expose model APIs to LLMs.

The same workflow applies to:

Calendar spread arbitrage (compare term-structure of Helium IV vs market IV)
Diagonal spreads (mix the two)
Volatility compression candidates - Helium MCP has a get_top_trading_strategies endpoint that returns a daily-ranked long-vol vs short-vol screen with explicit bull/bear cases:

"Market IV (~30%) above Helium IV (~26-27%) across maturities - favoring volatility compression. Skew is mostly tail-priced..."

The bigger picture

ML option pricing was an institutional moat for two decades. With MCP, the marginal cost of querying an ML option pricing model from inside an LLM is zero. That changes who can run a structured options screen.

Helium MCP also exposes 31-dimension structured bias scoring across 3.2M+ news articles (5,000+ sources) - useful for the news/narrative side of trading - but that's a topic for another post.

Caveats

This is not trading advice. Helium's model can be wrong. Per-symbol regression models can overfit. Always size positions appropriately and validate against your own framework.

How to Give Your AI Assistant Real-Time Market Intelligence

connerlambden — Tue, 14 Apr 2026 21:15:15 +0000

MCP (Model Context Protocol) lets AI assistants call external tools. I built a remote MCP server called Helium that gives any MCP-compatible AI assistant access to real-time financial intelligence — market data, ML-powered options pricing, news bias analysis, and more.

The interesting part isn't the financial data itself (there are plenty of market APIs). It's what happens when you combine structured financial data with an LLM's reasoning.

Setup (30 seconds)

Add one line to your AI assistant's MCP config:

Cursor / Windsurf:

{"mcpServers":{"helium":{"url":"https://heliumtrades.com/mcp"}}}

Claude Desktop:

{"mcpServers":{"helium":{"command":"npx","args":["mcp-remote","https://heliumtrades.com/mcp"]}}}

No API key. Nothing to install. Free tier.

What it does

Helium exposes 10 tools through MCP:

1. Market Intelligence (`get_ticker`)

Ask "What's the outlook for NVDA?" and get:

AI-generated bull and bear cases
5 probability-weighted scenarios (e.g., 38% chance of mean-reversion, 25% upside on AI headlines, 10% tail risk on export shock)
Each scenario includes falsifiability criteria — what would prove it wrong

2. ML Options Pricing (`get_top_trading_strategies`)

The model computes independent fair values for every listed options contract. For each ticker, it returns:

Strategies ranked by expected value
Backtested win rates (e.g., short vol calls on AAPL: 61% win rate, avg +$8.40/trade over 39 historical trades)
Full Greeks for every contract

A single call returns ~355KB of structured data.

3. Balanced News Synthesis (`search_balanced_news`)

Aggregates 3.2M+ articles from 5,000+ sources. Instead of one take, it shows where sources agree vs. diverge on any topic.

4. Multi-Dimensional Bias Scoring (`get_all_source_biases`)

Scores news sources across 15+ dimensions — not just left/right:

Prescriptiveness: Does the outlet tell you what to think, or just report?
Sensationalism: Framing intensity
Fearful framing: How much fear-based language is used
Integrity: Factual rigor
Plus: dovish/hawkish, libertarian/authoritarian, and more

5. Historical Options Data (`get_historical_options_data`)

Full historical chains with ML pricing baked in. A single SPY request returns ~30MB of every contract with the model's theoretical value.

Why MCP matters for this

The key insight is that MCP eliminates the build step. Instead of building a custom financial app, you add one config line and ask questions in natural language. The AI handles parsing 355KB of structured options data and pulling out what's relevant.

This pattern — domain-specific intelligence delivered through MCP — is how I think a lot of specialized AI tools will work going forward.

Links

Happy to answer questions about the implementation or the MCP protocol in general.

Search Scientific Papers from Any AI Tool — Introducing BGPT MCP

connerlambden — Tue, 17 Feb 2026 04:50:13 +0000

If you work with scientific literature — whether you're a researcher, bioinformatician, or building AI-powered tools — you know the pain of searching for papers programmatically. PubMed's API is clunky. Semantic Scholar doesn't give you experimental details. And scraping is fragile.

BGPT MCP solves this by giving any AI tool direct access to a curated database of scientific papers, complete with raw experimental data extracted from full-text studies.

What is MCP?

Model Context Protocol (MCP) is an open standard that lets AI assistants connect to external tools and data sources. Think of it as "USB-C for AI" — one protocol, many tools.

If you use Cursor, Claude Desktop, Cline, Windsurf, or any MCP-compatible client, you can connect to BGPT with a single line of config.

What Does BGPT MCP Do?

BGPT provides a search_papers tool that searches a curated database of scientific papers. Unlike typical search APIs, BGPT extracts raw experimental data from full-text papers. Each result includes:

Title, DOI, and authors
Methods — actual experimental procedures used
Results — quantitative findings extracted from the paper
Quality scores — automated assessment of study rigor
25+ metadata fields — journal, year, sample size, organism, and more

This is the kind of structured data that used to require hours of manual extraction.

Quick Start (2 minutes)

For Cursor IDE

Add this to your MCP settings:

{
  "mcpServers": {
    "bgpt": {
      "url": "https://bgpt.pro/mcp/sse"
    }
  }
}

That's it. No API keys needed for your first 50 searches.

For Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "bgpt": {
      "url": "https://bgpt.pro/mcp/sse"
    }
  }
}

For Any MCP Client

BGPT uses Server-Sent Events (SSE) transport. Point your client to:

https://bgpt.pro/mcp/sse

Example Queries

Once connected, just ask your AI assistant naturally:

"Search for papers on CRISPR gene editing efficiency in human cells"
"Find studies comparing immunotherapy response rates in melanoma"
"What papers exist on transformer models for protein structure prediction?"

The AI will call the search_papers tool and return structured results you can immediately work with.

Why This Matters

If you're building research tools, literature review pipelines, or AI agents that need scientific context, BGPT MCP gives you:

No infrastructure — it's a remote server, nothing to install
Structured data — not just abstracts, but methods and results
Quality scores — filter for rigorous studies automatically
Works everywhere — any MCP-compatible AI tool

Pricing

50 free searches per network (no account needed)
$0.01 per result after that with an API key

Get your API key at bgpt.pro/mcp.

DEV Community: connerlambden

Detecting AI-authored news at corpus scale from a single MCP call

The core dimension

Setup

Asking the question

Why 31 dimensions, not one

Example use cases

Live example

What to do

31 dimensions of news bias, queryable from Claude in plain English

The problem

The schema

The corpus

The MCP interface

Setup (one line)

A real example

Use cases this unlocks

The bigger point

Caveats

Links

How I screen for ratio spread opportunities in 30 seconds with an MCP server

The setup

What the MCP exposes

Setup (one line)

Finding a ratio-spread candidate

The point isn't this specific trade

The bigger picture

Caveats

Links

How to Give Your AI Assistant Real-Time Market Intelligence

Setup (30 seconds)

What it does

1. Market Intelligence (get_ticker)

2. ML Options Pricing (get_top_trading_strategies)

3. Balanced News Synthesis (search_balanced_news)

4. Multi-Dimensional Bias Scoring (get_all_source_biases)

5. Historical Options Data (get_historical_options_data)

Why MCP matters for this

Links

Search Scientific Papers from Any AI Tool — Introducing BGPT MCP

What is MCP?

What Does BGPT MCP Do?

Quick Start (2 minutes)

For Cursor IDE

For Claude Desktop

For Any MCP Client

Example Queries

Why This Matters

Pricing

Links

1. Market Intelligence (`get_ticker`)

2. ML Options Pricing (`get_top_trading_strategies`)

3. Balanced News Synthesis (`search_balanced_news`)

4. Multi-Dimensional Bias Scoring (`get_all_source_biases`)

5. Historical Options Data (`get_historical_options_data`)