AgentReady API Docs

import requests
from typing import Optional

class AgentReady:
    """AgentReady API client for Python."""

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base = "https://agentready.cloud/api/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        }

    def _post(self, endpoint: str, data: dict) -> dict:
        r = requests.post(f"{self.base}{endpoint}", headers=self.headers, json=data)
        r.raise_for_status()
        return r.json()

    # ── Tool #1: TokenCut ──
    def tokencut(self, text: str, level: str = "standard") -> str:
        """Compress text to save 40-60% tokens. Returns compressed text."""
        data = self._post("/tools/tokencut", {"text": text, "level": level})
        return data["data"]["compressed_text"]

    # ── Tool #2: MD Converter ──
    def md_convert(self, url: str, **kwargs) -> dict:
        """Convert URL to clean Markdown. Returns {markdown, metadata, stats}."""
        return self._post("/tools/md-converter", {"url": url, **kwargs})["data"]

    # ── Tool #3: Sitemap Generator ──
    def sitemap(self, domain: str, max_pages: int = 100) -> dict:
        """Crawl domain and generate sitemap with scores."""
        return self._post("/tools/sitemap-generator", {
            "domain": domain, "max_pages": max_pages
        })["data"]

    # ── Tool #4: LLMO Auditor ──
    def llmo_audit(self, url: str) -> dict:
        """Audit a page for AI/LLM readiness. Returns scores + recommendations."""
        return self._post("/tools/llmo-auditor", {"url": url})["data"]

    # ── Tool #5: Structured Data ──
    def structured_data(self, url: str) -> dict:
        """Analyze structured data and get Schema.org recommendations."""
        return self._post("/tools/structured-data", {"url": url})["data"]

    # ── Tool #6: Robots.txt ──
    def robots_txt(self, domain: str) -> dict:
        """Analyze robots.txt for AI bot compatibility."""
        return self._post("/tools/robots-txt", {"domain": domain})["data"]

    # ── Tool #7: Image Proxy ──
    def image_proxy(self, image_url: str, mode: str = "resize", **kwargs) -> dict:
        """Process image: resize, describe, or analyze."""
        return self._post("/tools/image-proxy", {
            "image_url": image_url, "mode": mode, **kwargs
        })["data"]


# ─── Usage Examples ───
ar = AgentReady("ar_your_api_key_here")

# Compress text before sending to GPT-4 → save 40-60%
compressed = ar.tokencut("Your long article text here...")

# Convert a webpage to Markdown for RAG
page = ar.md_convert("https://example.com/blog/post")
print(page["markdown"])

# Crawl an entire domain for a knowledge base
sitemap = ar.sitemap("example.com", max_pages=50)
for p in sitemap["pages"]:
    print(f"{p['url']} — score: {p['score']}")

# Audit your site for AI readiness
audit = ar.llmo_audit("https://yoursite.com")
print(f"Overall score: {audit['overall_score']}/100")

# Check if AI bots can crawl your site
robots = ar.robots_txt("yoursite.com")
for bot in robots["bot_analysis"]:
    print(f"{bot['bot']}: {'✅' if bot['allowed'] else '❌'}")

# Analyze structured data
sd = ar.structured_data("https://yoursite.com")
print(f"Has structured data: {sd['has_structured_data']}")

# Resize image for GPT-4 Vision
img = ar.image_proxy("https://example.com/photo.jpg", mode="resize", max_width=512)
print(f"Optimized: {img['proxy_url']}")

class AgentReady {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.base = "https://agentready.cloud/api/v1";
  }

  async _post(endpoint, data) {
    const res = await fetch(`${this.base}${endpoint}`, {
      method: "POST",
      headers: {
        "Authorization": `Bearer ${this.apiKey}`,
        "Content-Type": "application/json"
      },
      body: JSON.stringify(data),
    });
    if (!res.ok) throw new Error(`API error: ${res.status}`);
    return res.json();
  }

  // Tool #1: TokenCut — compress text to save 40-60% tokens
  async tokencut(text, level = "standard") {
    const r = await this._post("/tools/tokencut", { text, level });
    return r.data.compressed_text;
  }

  // Tool #2: MD Converter — URL to clean Markdown
  async mdConvert(url, opts = {}) {
    const r = await this._post("/tools/md-converter", { url, ...opts });
    return r.data;
  }

  // Tool #3: Sitemap Generator — crawl domain
  async sitemap(domain, maxPages = 100) {
    const r = await this._post("/tools/sitemap-generator", {
      domain, max_pages: maxPages
    });
    return r.data;
  }

  // Tool #4: LLMO Auditor — AI readiness audit
  async llmoAudit(url) {
    const r = await this._post("/tools/llmo-auditor", { url });
    return r.data;
  }

  // Tool #5: Structured Data — analyze Schema.org
  async structuredData(url) {
    const r = await this._post("/tools/structured-data", { url });
    return r.data;
  }

  // Tool #6: Robots.txt — AI bot compatibility
  async robotsTxt(domain) {
    const r = await this._post("/tools/robots-txt", { domain });
    return r.data;
  }

  // Tool #7: Image Proxy — resize/describe/analyze images
  async imageProxy(imageUrl, mode = "resize", opts = {}) {
    const r = await this._post("/tools/image-proxy", {
      image_url: imageUrl, mode, ...opts
    });
    return r.data;
  }
}

// ─── Usage ───
const ar = new AgentReady("ar_your_api_key_here");

// Compress before sending to LLM
const compressed = await ar.tokencut("Long article text...");

// Convert page to Markdown
const page = await ar.mdConvert("https://example.com/blog/post");
console.log(page.markdown);

// Full site audit
const audit = await ar.llmoAudit("https://yoursite.com");
console.log(`Score: ${audit.overall_score}/100`);