Generowanie treści z AI w CMS — automatyczne opisy produktów i meta tagi

// actions/ai-content.ts
'use server'
 
import { openai } from '@ai-sdk/openai'
import { generateObject, generateText } from 'ai'
import { z } from 'zod'
 
const metaSchema = z.object({
  metaTitle: z.string().max(60).describe('SEO title, max 60 znaków'),
  metaDescription: z
    .string()
    .max(160)
    .describe('Meta description, max 160 znaków, z call-to-action'),
  ogTitle: z.string().max(70).describe('Open Graph title'),
})
 
export async function generateMetaTags(content: string, pageType: string) {
  const { object } = await generateObject({
    model: openai('gpt-4o-mini'),
    schema: metaSchema,
    prompt: `Na podstawie poniższej treści wygeneruj meta tagi SEO po polsku.
Typ strony: ${pageType}
 
Treść:
${content.slice(0, 1500)}
 
Zasady:
- metaTitle: zawierać główne słowo kluczowe, max 60 znaków
- metaDescription: zachęcający, z call-to-action, max 160 znaków
- ogTitle: lekko inny niż metaTitle, bardziej angażujący, ale nadal zgodny z treścią`,
  })
 
  return object
}

const productDescriptionSchema = z.object({
  shortDescription: z
    .string()
    .max(200)
    .describe('Krótki opis na karcie produktu'),
  fullDescription: z.string().max(1000).describe('Pełny opis z korzyściami'),
  bulletPoints: z
    .array(z.string())
    .max(5)
    .describe('Kluczowe cechy jako bullet points'),
  seoKeywords: z.array(z.string()).max(10).describe('Słowa kluczowe SEO'),
})
 
export async function generateProductDescription(product: {
  name: string
  category: string
  specs: string
  targetAudience?: string
}) {
  const { object } = await generateObject({
    model: openai('gpt-4o-mini'),
    schema: productDescriptionSchema,
    prompt: `Wygeneruj opis produktu po polsku:
Nazwa: ${product.name}
Kategoria: ${product.category}
Specyfikacja: ${product.specs}
${product.targetAudience ? `Grupa docelowa: ${product.targetAudience}` : ''}
 
Zasady:
- Używaj języka korzyści
- Używaj języka, którym mówi klient
- shortDescription: jedno zdanie, które ma zachęcić klienta
- fullDescription: 2-3 akapity, SEO-friendly
- bulletPoints: max 5, tylko konkretne korzyści`,
  })
 
  return object
}

export async function generateAltTexts(
  images: { url: string; context: string }[],
) {
  const results = []
 
  for (const image of images) {
    const { text } = await generateText({
      model: openai('gpt-4o-mini'),
      prompt: `Wygeneruj alt text po polsku dla zdjęcia produktu.
Kontekst: ${image.context}
 
Zasady:
- Max 125 znaków
- Opisowy, nie "zdjęcie..."
- Zawierać słowo kluczowe produktu
- Naturalny język`,
    })
 
    results.push({ url: image.url, alt: text.trim() })
  }
 
  return results
}

// app/admin/products/[id]/ai-panel.tsx
'use client'
 
import { useState } from 'react'
import {
  generateProductDescription,
  generateMetaTags,
} from '@/actions/ai-content'
 
export function AIContentPanel({ product }: { product: Product }) {
  const [generated, setGenerated] = useState<any>(null)
  const [isGenerating, setIsGenerating] = useState(false)
 
  async function handleGenerate() {
    setIsGenerating(true)
    const [description, meta] = await Promise.all([
      generateProductDescription({
        name: product.name,
        category: product.category,
        specs: product.specifications,
      }),
      generateMetaTags(product.name + ' ' + product.specifications, 'product'),
    ])
 
    setGenerated({ ...description, ...meta })
    setIsGenerating(false)
  }
 
  async function handleApply() {
    // Zapisz wygenerowane treści do CMS/bazy
    await updateProduct(product.id, generated)
  }
 
  return (
    <div className="space-y-4 rounded-xl border p-6">
      <div className="flex items-center justify-between">
        <h3 className="font-semibold">Asystent AI</h3>
        <button
          onClick={handleGenerate}
          disabled={isGenerating}
          className="rounded-lg bg-purple-600 px-4 py-2 text-sm text-white disabled:opacity-50"
        >
          {isGenerating ? 'Generuję...' : 'Wygeneruj treści'}
        </button>
      </div>
 
      {generated && (
        <div className="space-y-4">
          <div>
            <label className="text-sm font-medium text-gray-500">
              Krótki opis
            </label>
            <textarea
              defaultValue={generated.shortDescription}
              className="mt-1 w-full rounded-lg border p-3"
              rows={2}
            />
          </div>
 
          <div>
            <label className="text-sm font-medium text-gray-500">
              Pełny opis
            </label>
            <textarea
              defaultValue={generated.fullDescription}
              className="mt-1 w-full rounded-lg border p-3"
              rows={6}
            />
          </div>
 
          <div>
            <label className="text-sm font-medium text-gray-500">
              Meta title ({generated.metaTitle?.length}/60)
            </label>
            <input
              defaultValue={generated.metaTitle}
              className="mt-1 w-full rounded-lg border p-3"
            />
          </div>
 
          <div>
            <label className="text-sm font-medium text-gray-500">
              Meta description ({generated.metaDescription?.length}/160)
            </label>
            <textarea
              defaultValue={generated.metaDescription}
              className="mt-1 w-full rounded-lg border p-3"
              rows={2}
            />
          </div>
 
          <button
            onClick={handleApply}
            className="w-full rounded-lg bg-green-600 py-3 text-white"
          >
            Zatwierdź i zapisz
          </button>
        </div>
      )}
    </div>
  )
}

// lib/cms.ts
import { createClient } from '@sanity/client'
 
const client = createClient({
  projectId: process.env.SANITY_PROJECT_ID!,
  dataset: process.env.SANITY_DATASET!,
  token: process.env.SANITY_WRITE_TOKEN!, // token z uprawnieniem do zapisu
  apiVersion: '2024-01-01',
  useCdn: false, // przy zapisie i świeżym odczycie wyłącz CDN
})
 
export async function saveGeneratedContent(
  productId: string,
  content: {
    shortDescription: string
    fullDescription: string
    metaTitle: string
    metaDescription: string
    seoKeywords: string[]
  },
) {
  return client
    .patch(productId)
    .set({
      ...content,
      aiGenerated: true, // ta sama para flag co w batchu
      needsReview: true,
    })
    .commit()
}

// Łatwa podmiana dostawcy — ten sam generateObject, inny model
import { anthropic } from '@ai-sdk/anthropic'
import { openai } from '@ai-sdk/openai'
 
const draftModel = openai('gpt-4o-mini') // szybki, tani draft
const polishModel = anthropic('claude-opus-4-8') // mocniejszy szlif

// scripts/generate-descriptions.ts
import { generateProductDescription } from '@/lib/ai-content'
import { db } from '@/lib/db'
 
async function withRetry<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn()
    } catch (error) {
      if (attempt === maxRetries) throw error
      // Wykładniczy backoff: 1s, 2s, 4s — daje API czas na ochłonięcie
      const delay = 1000 * 2 ** attempt
      console.warn(`Próba ${attempt + 1} nieudana, ponawiam za ${delay}ms`)
      await new Promise((r) => setTimeout(r, delay))
    }
  }
  throw new Error('unreachable')
}
 
async function batchGenerate() {
  const products = await db.product.findMany({
    where: { description: null }, // Produkty bez opisu
  })
 
  console.log(`${products.length} produktów do wygenerowania`)
  const failed: string[] = []
 
  for (const product of products) {
    try {
      const description = await withRetry(() =>
        generateProductDescription({
          name: product.name,
          category: product.category,
          specs: product.specs || '',
        }),
      )
 
      await db.product.update({
        where: { id: product.id },
        data: {
          shortDescription: description.shortDescription,
          fullDescription: description.fullDescription,
          seoKeywords: description.seoKeywords,
          aiGenerated: true, // Oznacz jako wygenerowane przez AI
          needsReview: true, // Wymaga przeglądu człowieka
        },
      })
 
      console.log(`✓ ${product.name}`)
 
      // Rate limit — nie przekraczaj limitów API
      await new Promise((r) => setTimeout(r, 1000))
    } catch (error) {
      console.error(`✗ ${product.name}:`, error)
      failed.push(product.id) // do ponownego przejścia w kolejnym uruchomieniu
    }
  }
 
  if (failed.length > 0) {
    console.log(`Nie udało się: ${failed.length}. IDs: ${failed.join(', ')}`)
  }
}
 
batchGenerate()