Build a Multi-Tenant AI Answer-Engine-Optimization (AEO/GEO) Platform

npm install @usenaive-sdk/server

import { Naive } from "@usenaive-sdk/server";
 
const naive = new Naive({ apiKey: process.env.NAIVE_API_KEY! });

// One Account Kit per tier. Connecting a CMS is gated by default for tenant users.
const starterKit = await naive.accountKits.create({
  name: "AEO Starter",
  primitives_config: {
    llm: { enabled: true },
  },
  connections_config: {
    mode: "allowlist",
    toolkits: ["webflow", "wordpress"], // the only CMSs a brand may connect
    // requiresApproval defaults on for connecting — we keep it on
  },
});
 
const growthKit = await naive.accountKits.create({
  name: "AEO Growth",
  primitives_config: { llm: { enabled: true } },
  connections_config: { mode: "allowlist", toolkits: ["webflow", "wordpress", "contentful"] },
});

await naive.plans.upsert({
  key: "starter",
  name: "AEO Starter",
  accountKitId: starterKit.id,      // assigned to the tenant on subscribe
  stripePriceId: "price_starter",   // your Stripe price (optional)
  quotas: { aeo: 100, seo: 500 },   // calls per period
  period: "month",
});
 
await naive.plans.upsert({
  key: "growth",
  name: "AEO Growth",
  accountKitId: growthKit.id,
  stripePriceId: "price_growth",
  quotas: { aeo: 1000, seo: 5000 },
  period: "month",
});

async function onboardBrand(dbBrand: { id: string; email: string; name: string; planKey: "starter" | "growth" }) {
  // 1. Provision the isolation boundary
  const brand = await naive.users.create({
    external_id: dbBrand.id,        // your DB row id — stable, your source of truth
    email: dbBrand.email,
    label: dbBrand.name,
  });
 
  // 2. Subscribe — assignKit (default true) applies the plan's Account Kit to the brand
  await naive.forUser(brand.id).billing.setSubscription({
    planKey: dbBrand.planKey,
    status: "active",
    stripeCustomerId: "cus_...",        // from your Stripe webhook
    stripeSubscriptionId: "sub_...",
    currentPeriodEnd: "2026-07-01T00:00:00Z",
    assignKit: true,
  });
 
  return brand; // brand.id → the handle you scope every future call with
}

const brand = naive.forUser(brandId);

const brand = naive.forUser(brandId);
 
// What does ChatGPT actually say for a high-intent buyer query?
const chatgpt = await brand.aeo.llmResponses("chatgpt", {
  user_prompt: "best project management software for agencies 2026",
  model_name: "gpt-4o-mini",
});
 
const answer = chatgpt.results[0];
console.log(answer.response);        // the model's full answer
console.log(answer.cited_domains);   // e.g. ["asana.com", "linear.app", "notion.so"]
console.log(answer.cited_urls);      // the exact pages it cited

const engines = ["chatgpt", "claude", "gemini", "perplexity"] as const;
const modelByEngine = {
  chatgpt: "gpt-4o-mini",
  claude: "claude-3-5-haiku-latest",
  gemini: "gemini-2.0-flash",
  perplexity: "sonar",
} as const;
 
const audits = await Promise.all(
  engines.map((engine) =>
    brand.aeo.llmResponses(engine, {
      user_prompt: "best project management software for agencies 2026",
      model_name: modelByEngine[engine], // each engine expects its own model id — list with GET .../{engine}/models
    }),
  ),
);

const mentions = await brand.aeo.llmMentions("search", {
  keyword: "project management software for agencies",
  target: [{ domain: "yourbrand.com" }, { domain: "asana.com" }, { domain: "notion.so" }],
});
 
const me = mentions.results.find((r) => r.target === "yourbrand.com");
console.log(me?.mention_count);   // how often we appear in LLM answers
console.log(me?.llm_platforms);   // which engines mention us
console.log(me?.cited_urls);      // which of our pages get cited

const volume = await brand.aeo.aiKeywords({
  keywords: ["project management for agencies", "agency resource planning tool"],
});
// volume.results → [{ keyword, ai_search_volume, competition }, ...]

const brand = naive.forUser(brandId);
 
// Who ranks for the query today? These are the pages LLMs are likely to cite.
const serp = await brand.seo.serpCompetitors(["project management software for agencies"]);
 
// Real search demand + difficulty for the topic cluster
const overview = await brand.seo.labs("google", "keyword-overview", {
  keywords: ["project management for agencies"],
  location_code: 2840, // US
});
 
// Why do the cited domains win? Audit their backlink authority.
const authority = await brand.seo.backlinksSummary("asana.com");
console.log(authority.results[0].total_referring_domains, authority.results[0].rank);

const brand = naive.forUser(brandId);
 
const plan = await brand.llm.chat({
  model: "anthropic/claude-sonnet-4.6",
  models: ["anthropic/claude-sonnet-4.6", "openai/gpt-5.2"], // OpenRouter fallback chain
  provider: { sort: "throughput", data_collection: "deny" },  // OpenRouter routing
  messages: [
    {
      role: "system",
      content:
        "You are an AEO strategist. Given how AI answer engines respond and the SERP/backlink data, " +
        "produce an answer-optimized article plan that maximizes the chance of being cited by LLMs.",
    },
    {
      role: "user",
      content: JSON.stringify({
        query: "best project management software for agencies 2026",
        chatgpt_answer: answer.response,
        cited_domains: answer.cited_domains,
        serp_competitors: serp.results,
        our_mentions: me,
      }),
    },
  ],
  // OpenRouter structured outputs — the body is forwarded as-is
  response_format: {
    type: "json_schema",
    json_schema: {
      name: "aeo_brief",
      strict: true,
      schema: {
        type: "object",
        additionalProperties: false,
        properties: {
          title: { type: "string" },
          target_question: { type: "string" },
          tl_dr_answer: { type: "string", description: "A direct 2-sentence answer LLMs can lift verbatim" },
          headings: { type: "array", items: { type: "string" } },
          faqs: {
            type: "array",
            items: {
              type: "object",
              additionalProperties: false,
              properties: { q: { type: "string" }, a: { type: "string" } },
              required: ["q", "a"],
            },
          },
        },
        required: ["title", "target_question", "tl_dr_answer", "headings", "faqs"],
      },
    },
  },
});
 
const brief = JSON.parse(plan.choices[0].message.content);
console.log("credits used:", plan.credits_used);

const usage = await naive.forUser(brandId).billing.usage();
// { plan: "starter", status: "active", period: "month",
//   quotas: { aeo: 100, seo: 500 }, usage: { aeo: 100, seo: 213 } }

import { NaiveError } from "@usenaive-sdk/server";
 
async function auditWithinQuota(brandId: string, prompt: string) {
  try {
    return await naive.forUser(brandId).aeo.llmResponses("chatgpt", {
      user_prompt: prompt,
      model_name: "gpt-4o-mini",
    });
  } catch (err) {
    if (err instanceof NaiveError && err.code === "rate_limited") {
      // The brand hit their plan quota. Stop the agent; prompt an upgrade.
      return { quotaExceeded: true };
    }
    throw err;
  }
}

await naive.forUser(brandId).billing.setSubscription({ planKey: "growth", status: "active", assignKit: true });
// Higher quotas + the Growth kit's larger CMS allowlist, atomically.

import { isPendingApproval } from "@usenaive-sdk/server";
 
const brand = naive.forUser(brandId);
 
// Agent attempts to connect the brand's Webflow — gated by default
const res = await brand.connections.connect("webflow", {
  callbackUrl: "https://yourapp.com/oauth/done",
});
 
if (isPendingApproval(res)) {
  // Nothing happened yet. Surface res.approval_id to the brand's admin.
  console.log("CMS connect awaiting approval:", res.approval_id);
 
  // A human approves (from your dashboard, or the operator key):
  await brand.approvals.approve(res.approval_id);
 
  // The API replays the frozen connect and returns the hosted redirect
  const resolved = await brand.approvals.get(res.approval_id);
  // resolved.status === "executed" → resolved.result holds the redirectUrl
} else {
  // Un-gated path: send the brand admin to res.redirectUrl to finish OAuth
}

const tools = await brand.connections.tools("webflow");
// → the exact tool slugs + arg schemas Webflow exposes
 
// Then execute the publish tool the catalog reports, with the structured brief
await brand.connections.execute("webflow", "<PUBLISH_TOOL_SLUG>", {
  title: brief.title,
  body: renderArticle(brief), // your renderer turns the brief into HTML/markdown
});

import { Naive, isPendingApproval, NaiveError } from "@usenaive-sdk/server";
 
const naive = new Naive({ apiKey: process.env.NAIVE_API_KEY! });
 
// One-time: policy + plans
const starterKit = await naive.accountKits.create({
  name: "AEO Starter",
  primitives_config: { llm: { enabled: true } },
  connections_config: { mode: "allowlist", toolkits: ["webflow", "wordpress"] },
});
await naive.plans.upsert({
  key: "starter",
  name: "AEO Starter",
  accountKitId: starterKit.id,
  quotas: { aeo: 100, seo: 500 },
  period: "month",
});
 
// Per brand: provision + subscribe (applies the plan's Account Kit)
export async function onboardBrand(b: { id: string; email: string; name: string }) {
  const brand = await naive.users.create({ external_id: b.id, email: b.email, label: b.name });
  await naive.forUser(brand.id).billing.setSubscription({
    planKey: "starter",
    status: "active",
    assignKit: true,
  });
  return brand.id;
}
 
// Per cycle: audit → ground → write → (publish via approved CMS)
export async function runAeoCycle(brandId: string, query: string) {
  const brand = naive.forUser(brandId);
 
  try {
    const chatgpt = await brand.aeo.llmResponses("chatgpt", { user_prompt: query, model_name: "gpt-4o-mini" });
    const answer = chatgpt.results[0];
 
    const mentions = await brand.aeo.llmMentions("search", {
      keyword: query,
      target: [{ domain: "yourbrand.com" }],
    });
    const serp = await brand.seo.serpCompetitors([query]);
 
    const plan = await brand.llm.chat({
      model: "anthropic/claude-sonnet-4.6",
      models: ["anthropic/claude-sonnet-4.6", "openai/gpt-5.2"],
      messages: [
        { role: "system", content: "You are an AEO strategist. Output an answer-optimized article plan." },
        { role: "user", content: JSON.stringify({ query, answer: answer.response, cited: answer.cited_domains, serp: serp.results, mentions: mentions.results }) },
      ],
      response_format: { type: "json_schema", json_schema: { name: "aeo_brief", strict: true, schema: BRIEF_SCHEMA } },
    });
 
    return { brief: JSON.parse(plan.choices[0].message.content), creditsUsed: plan.credits_used };
  } catch (err) {
    if (err instanceof NaiveError && err.code === "rate_limited") return { quotaExceeded: true };
    throw err;
  }
}
 
// On demand: connect the brand's CMS (freezes for approval)
export async function connectCms(brandId: string, cms: string) {
  const brand = naive.forUser(brandId);
  const res = await brand.connections.connect(cms, { callbackUrl: "https://yourapp.com/oauth/done" });
  if (isPendingApproval(res)) return { status: "pending", approvalId: res.approval_id };
  return { status: "ready", redirectUrl: res.redirectUrl };
}

naive cron create "0 9 * * 1" \
  "Re-audit AI answer-engine visibility for every active brand. Compare mention share vs last week. Draft an answer-optimized brief for any query where we lost a citation." \
  --name "Weekly AEO audit"

const kit = naive.forUser(brandId).agentTools();
// kit.tools  → tool-use definitions, filtered by the brand's kit + plan
// kit.handle(name, input) → dispatcher, AccountKit-gated and quota-metered server-side