Оптимизация для ChatGPT, Perplexity и YandexGPT

User-agent: GPTBot
Allow: /
Crawl-delay: 2

User-agent: ChatGPT-User
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: ClaudeBot
Allow: /

User-agent: Google-Extended
Allow: /

User-agent: Applebot-Extended
Allow: /

User-agent: cohere-ai
Allow: /

User-agent: CCBot
Disallow: /

User-agent: *
Allow: /

Sitemap: https://example.com/sitemap.xml

// composables/useGeoMeta.ts
export function useGeoMeta(options: {
  title: string
  description: string
  datePublished: string
  dateModified: string
  author?: string
}) {
  useHead({
    meta: [
      // Стандартные SEO-мета
      { name: 'description', content: options.description },
      { name: 'author', content: options.author || 'AI Portal' },

      // Open Graph — для ChatGPT и Perplexity
      { property: 'og:title', content: options.title },
      { property: 'og:description', content: options.description },
      { property: 'og:type', content: 'article' },

      // Даты — критично для AI-поисковиков
      {
        property: 'article:published_time',
        content: new Date(options.datePublished).toISOString(),
      },
      {
        property: 'article:modified_time',
        content: new Date(options.dateModified).toISOString(),
      },
    ],
  })

  // Schema.org JSON-LD
  useSchemaOrg([
    defineArticle({
      headline: options.title,
      description: options.description,
      datePublished: options.datePublished,
      dateModified: options.dateModified,
      author: {
        name: options.author || 'AI Portal',
      },
    }),
  ])
}

// utils/generateFaqSchema.ts
interface FaqItem {
  question: string
  answer: string
}

export function generateFaqSchema(items: FaqItem[]) {
  return {
    '@context': 'https://schema.org',
    '@type': 'FAQPage',
    'mainEntity': items.map(item => ({
      '@type': 'Question',
      'name': item.question,
      'acceptedAnswer': {
        '@type': 'Answer',
        'text': item.answer,
      },
    })),
  }
}

// Использование в Nuxt-компоненте
// <script setup>
// const faqSchema = generateFaqSchema([
//   {
//     question: "Что такое GEO?",
//     answer: "GEO — оптимизация контента для AI-поисковиков."
//   },
// ])
// useHead({
//   script: [{
//     type: 'application/ld+json',
//     innerHTML: JSON.stringify(faqSchema),
//   }]
// })
// </script>

import httpx
import asyncio
from dataclasses import dataclass

@dataclass
class VisibilityResult:
    platform: str
    query: str
    cited: bool
    position: int | None
    snippet: str

async def check_perplexity(
    query: str, domain: str, api_key: str
) -> VisibilityResult:
    async with httpx.AsyncClient() as client:
        resp = await client.post(
            "https://api.perplexity.ai/chat/completions",
            headers={"Authorization": f"Bearer {api_key}"},
            json={
                "model": "sonar",
                "messages": [{"role": "user", "content": query}],
            },
        )
    data = resp.json()
    citations = data.get("citations", [])
    pos = next((i for i, c in enumerate(citations) if domain in c), None)

    return VisibilityResult(
        platform="perplexity",
        query=query,
        cited=pos is not None,
        position=pos,
        snippet=data["choices"][0]["message"]["content"][:200],
    )

async def check_all_platforms(
    queries: list[str],
    domain: str,
    perplexity_key: str,
) -> list[VisibilityResult]:
    """Проверяет видимость домена на всех AI-платформах."""
    tasks = []
    for q in queries:
        tasks.append(check_perplexity(q, domain, perplexity_key))
        # Добавьте аналогичные функции для других платформ

    return await asyncio.gather(*tasks)

// server/middleware/last-modified.ts
// Nuxt server middleware для отправки заголовка Last-Modified

import { defineEventHandler, setHeader } from 'h3'
import { stat } from 'node:fs/promises'
import { resolve } from 'node:path'

export default defineEventHandler(async (event) => {
  const path = event.path

  // Только для контентных страниц
  if (!path.startsWith('/geo/') && !path.startsWith('/techniques/'))
    return

  const slug = path.replace(/^\//, '').replace(/\/$/, '')
  const filePath = resolve(`content/${slug}.md`)

  try {
    const fileStat = await stat(filePath)
    setHeader(
      event,
      'Last-Modified',
      fileStat.mtime.toUTCString(),
    )
  }
  catch {
    // Файл не найден — пропускаем
  }
})