How to Add Verified News Intelligence to TradingAgents

pip install polaris-news

export POLARIS_API_KEY=pr_live_xxx

from polaris_news import PolarisClient

client = PolarisClient()

def get_polaris_news(ticker: str, category: str = "markets"):
    """Fetch verified intelligence instead of raw news."""

    # Search for briefs related to this ticker
    results = client.search(
        query=ticker,
        category=category,
        limit=10
    )

    # Format for TradingAgents news analyst
    intelligence = []
    for brief in results.briefs:
        intelligence.append({
            "headline": brief.headline,
            "summary": brief.summary,
            "confidence": brief.confidence,
            "bias_score": brief.bias_score,
            "source_count": brief.source_count,
            "category": brief.category,
            "published_at": brief.published_at,
            "counter_argument": brief.counter_argument,
            "entities": getattr(brief, "entities", [])
        })

    return intelligence

def get_bias_comparison(topic: str):
    """Compare outlet framing for sentiment calibration."""

    comparison = client.compare_sources(topic=topic)

    return {
        "topic": comparison.topic,
        "source_analyses": comparison.source_analyses,
        "polaris_analysis": comparison.polaris_analysis,
        "polaris_brief": comparison.polaris_brief
    }

import httpx

API_KEY = "pr_live_xxx"
BASE = "https://api.thepolarisreport.com"

def get_forecast(topic: str, depth: str = "standard"):
    """Get structured predictions with confidence and invalidation criteria."""

    resp = httpx.post(
        f"{BASE}/api/v1/forecast",
        headers={"X-API-Key": API_KEY},
        json={"topic": topic, "depth": depth}
    )
    forecast = resp.json()

    return {
        "executive_summary": forecast["executive_summary"],
        "trend": forecast.get("trend"),
        "predictions": [
            {
                "prediction": p["prediction"],
                "confidence": p["confidence"],
                "timeframe": p.get("timeframe"),
                "invalidated_if": p.get("invalidated_if")
            }
            for p in forecast.get("predictions", [])
        ],
        "signals_to_watch": forecast.get("signals_to_watch", []),
        "wildcards": forecast.get("wildcards", [])
    }

def verify_claim(claim: str):
    """Fact-check a claim against verified intelligence."""

    resp = httpx.post(
        f"{BASE}/api/v1/verify",
        headers={"X-API-Key": API_KEY},
        json={"claim": claim}
    )
    result = resp.json()

    return {
        "verdict": result["verdict"],  # supported, contradicted, partially_supported, unverifiable
        "confidence": result["confidence"],
        "evidence": result.get("evidence", []),
        "counter_arguments": result.get("counter_arguments", []),
        "sources_checked": result.get("sources_checked", 0)
    }

# Example: before acting on a rumor
verification = verify_claim("NVIDIA is facing GPU supply constraints")
if verification["verdict"] == "supported" and verification["confidence"] > 0.7:
    # Proceed with trade logic
    pass

def create_watchlist(name: str, entities: list, webhook_url: str):
    """Watch entities and get webhook alerts on new intelligence."""

    # Create watchlist
    resp = httpx.post(
        f"{BASE}/api/v1/watchlists",
        headers={"X-API-Key": API_KEY},
        json={"name": name}
    )
    watchlist = resp.json()

    # Add watch items
    for entity in entities:
        httpx.post(
            f"{BASE}/api/v1/watchlists/{watchlist['id']}/items",
            headers={"X-API-Key": API_KEY},
            json={
                "item_type": "entity",
                "value": entity,
                "notify": "webhook",
                "callback_url": webhook_url
            }
        )

    return watchlist

# Watch key entities for your portfolio
create_watchlist(
    name="Trading Portfolio",
    entities=["NVIDIA", "TSMC", "OpenAI", "Federal Reserve"],
    webhook_url="https://your-agent.example.com/webhook"
)

import httpx
from polaris_news import PolarisClient
from tradingagents.graph.trading_graph import TradingAgentsGraph
from tradingagents.default_config import DEFAULT_CONFIG

API_KEY = "pr_live_xxx"
BASE = "https://api.thepolarisreport.com"
polaris = PolarisClient()

def enhanced_analysis(ticker: str):
    """Full Polaris-enhanced trading analysis."""

    # 1. Get verified intelligence
    news = polaris.search(query=ticker, category="markets", limit=10)

    # 2. Check bias across outlets
    bias = polaris.compare_sources(topic=ticker)

    # 3. Get forward-looking predictions
    forecast = httpx.post(
        f"{BASE}/api/v1/forecast",
        headers={"X-API-Key": API_KEY},
        json={"topic": f"{ticker} stock price", "depth": "standard"}
    ).json()

    # 4. Verify any specific claims
    verification = None
    if news.briefs:
        top_claim = news.briefs[0].headline
        verification = httpx.post(
            f"{BASE}/api/v1/verify",
            headers={"X-API-Key": API_KEY},
            json={"claim": top_claim}
        ).json()

    return {
        "intelligence": news,
        "bias_analysis": bias,
        "forecast": forecast,
        "verification": verification
    }

# Run analysis
analysis = enhanced_analysis("NVDA")

# Feed into TradingAgents
ta = TradingAgentsGraph(debug=True, config=DEFAULT_CONFIG.copy())
_, decision = ta.propagate("NVDA", "2026-03-20")