Competitor-Intel Report as JSON From One MCP Call

"""
Build a one-call competitor-intel report as structured JSON.
Combines Google SERP positions + Reddit mentions + YouTube presence.
Every datapoint carries a source url and a captured_at timestamp,
because raw counts are commodity; provenance and freshness are the value.

Requires: pip install requests
Set SCAVIO_API_KEY in your environment.
"""

import os
import json
from datetime import datetime, timezone

import requests

API_KEY = os.environ["SCAVIO_API_KEY"]
BASE = "https://api.scavio.dev/api/v1"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}

COMPETITOR = "Acme Analytics"


def now_iso():
    return datetime.now(timezone.utc).isoformat()


def post(path, body):
    resp = requests.post(f"{BASE}{path}", headers=HEADERS, json=body, timeout=60)
    resp.raise_for_status()
    return resp.json()


def google_positions(competitor):
    data = post("/google", {"query": competitor, "light_request": False})
    captured_at = now_iso()
    rows = []
    for i, item in enumerate(data.get("organic", []), start=1):
        rows.append({
            "position": item.get("position", i),
            "title": item.get("title"),
            "source_url": item.get("link"),
            "captured_at": captured_at,
        })
    kg = data.get("knowledge_graph") or {}
    return {
        "organic": rows,
        "knowledge_graph": kg or None,
        "questions": data.get("questions", []),
        "related_searches": data.get("related_searches", []),
        "captured_at": captured_at,
    }


def reddit_mentions(competitor):
    data = post("/reddit/search", {"query": competitor, "sort": "new"})
    captured_at = now_iso()
    threads = []
    for t in data.get("threads", []):
        threads.append({
            "title": t.get("title"),
            "score": t.get("score"),
            "subreddit": t.get("subreddit"),
            "source_url": t.get("url") or t.get("permalink"),
            "captured_at": captured_at,
        })
    return {"threads": threads, "captured_at": captured_at}


def youtube_presence(competitor):
    data = post("/youtube/search", {"search": competitor})
    captured_at = now_iso()
    videos = []
    for v in data.get("videos", []):
        videos.append({
            "title": v.get("title"),
            "channel": v.get("channel"),
            "views": v.get("views"),
            "source_url": v.get("link") or v.get("url"),
            "captured_at": captured_at,
        })
    return {"videos": videos, "captured_at": captured_at}


def build_report(competitor):
    return {
        "competitor": competitor,
        "generated_at": now_iso(),
        "sources": {
            "google": google_positions(competitor),
            "reddit": reddit_mentions(competitor),
            "youtube": youtube_presence(competitor),
        },
    }


if __name__ == "__main__":
    report = build_report(COMPETITOR)
    print(json.dumps(report, indent=2, ensure_ascii=False))

/**
 * Build a one-call competitor-intel report as structured JSON.
 * Combines Google SERP positions + Reddit mentions + YouTube presence.
 * Every datapoint carries a source url and a captured_at timestamp,
 * because raw counts are commodity; provenance and freshness are the value.
 *
 * Node 18+ (built-in fetch). Set SCAVIO_API_KEY in your environment.
 */

const API_KEY = process.env.SCAVIO_API_KEY;
const BASE = "https://api.scavio.dev/api/v1";
const HEADERS = {
  Authorization: `Bearer ${API_KEY}`,
  "Content-Type": "application/json",
};

const COMPETITOR = "Acme Analytics";

const nowIso = () => new Date().toISOString();

async function post(path, body) {
  const resp = await fetch(`${BASE}${path}`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify(body),
  });
  if (!resp.ok) throw new Error(`${resp.status} ${await resp.text()}`);
  return resp.json();
}

async function googlePositions(competitor) {
  const data = await post("/google", { query: competitor, light_request: false });
  const capturedAt = nowIso();
  const organic = (data.organic || []).map((item, i) => ({
    position: item.position ?? i + 1,
    title: item.title,
    source_url: item.link,
    captured_at: capturedAt,
  }));
  return {
    organic,
    knowledge_graph: data.knowledge_graph || null,
    questions: data.questions || [],
    related_searches: data.related_searches || [],
    captured_at: capturedAt,
  };
}

async function redditMentions(competitor) {
  const data = await post("/reddit/search", { query: competitor, sort: "new" });
  const capturedAt = nowIso();
  const threads = (data.threads || []).map((t) => ({
    title: t.title,
    score: t.score,
    subreddit: t.subreddit,
    source_url: t.url || t.permalink,
    captured_at: capturedAt,
  }));
  return { threads, captured_at: capturedAt };
}

async function youtubePresence(competitor) {
  const data = await post("/youtube/search", { search: competitor });
  const capturedAt = nowIso();
  const videos = (data.videos || []).map((v) => ({
    title: v.title,
    channel: v.channel,
    views: v.views,
    source_url: v.link || v.url,
    captured_at: capturedAt,
  }));
  return { videos, captured_at: capturedAt };
}

async function buildReport(competitor) {
  const [google, reddit, youtube] = await Promise.all([
    googlePositions(competitor),
    redditMentions(competitor),
    youtubePresence(competitor),
  ]);
  return {
    competitor,
    generated_at: nowIso(),
    sources: { google, reddit, youtube },
  };
}

buildReport(COMPETITOR)
  .then((report) => console.log(JSON.stringify(report, null, 2)))
  .catch((err) => {
    console.error(err);
    process.exit(1);
  });