Building an AI-Powered Content Site with Gemini API and Astro

// src/pages/api/summarize.ts
import type { APIRoute } from 'astro';
import { GoogleGenAI } from '@google/genai';
 
const ai = new GoogleGenAI({ apiKey: import.meta.env.GEMINI_API_KEY });
 
export const prerender = false; // Enable SSR for this endpoint
 
export const POST: APIRoute = async ({ request }) => {
  try {
    const { content } = await request.json();
    if (!content || typeof content !== 'string') {
      return new Response(JSON.stringify({ error: 'content is required' }), { status: 400 });
    }
 
    const result = await ai.models.generateContent({
      model: 'gemini-2.5-flash',
      contents: [
        {
          role: 'user',
          parts: [{
            text: `Summarize the following article in 140 characters or less. No decorative preface — just the key points.\n\n${content}`,
          }],
        },
      ],
      config: { temperature: 0.3, maxOutputTokens: 256 },
    });
 
    const summary = result.text?.trim() ?? '';
    return new Response(JSON.stringify({ summary }), {
      status: 200,
      headers: { 'Content-Type': 'application/json' },
    });
  } catch (err) {
    console.error('[summarize] error:', err);
    return new Response(JSON.stringify({ error: 'Generation failed' }), { status: 500 });
  }
};

curl -X POST http://localhost:4321/api/summarize \
  -H "Content-Type: application/json" \
  -d '{"content": "Astro is a static site generator that..."}'
# → {"summary": "Astro is a static site generator..."}

// src/content/config.ts
import { defineCollection, z } from 'astro:content';
 
const blog = defineCollection({
  type: 'content',
  schema: z.object({
    title: z.string(),
    pubDate: z.coerce.date(),
    description: z.string().optional(),
    tags: z.array(z.string()).default([]),
    aiSummary: z.string().optional(), // Generated by Gemini
    aiTags: z.array(z.string()).default([]),
  }),
});
 
export const collections = { blog };

// scripts/generate-summaries.ts
import { readdir, readFile, writeFile } from 'node:fs/promises';
import { join } from 'node:path';
import matter from 'gray-matter';
import { GoogleGenAI } from '@google/genai';
 
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY! });
const BLOG_DIR = join(process.cwd(), 'src/content/blog');
 
async function summarize(text: string): Promise<string> {
  const result = await ai.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: [{ role: 'user', parts: [{ text: `Summarize in 140 chars: ${text}` }] }],
    config: { temperature: 0.3, maxOutputTokens: 200 },
  });
  return result.text?.trim() ?? '';
}
 
const files = await readdir(BLOG_DIR);
for (const file of files.filter(f => f.endsWith('.md'))) {
  const path = join(BLOG_DIR, file);
  const raw = await readFile(path, 'utf-8');
  const { data, content } = matter(raw);
 
  if (data.aiSummary) {
    console.log(`SKIP: ${file} (aiSummary exists)`);
    continue;
  }
 
  const summary = await summarize(content.slice(0, 4000));
  data.aiSummary = summary;
 
  await writeFile(path, matter.stringify(content, data), 'utf-8');
  console.log(`OK: ${file} → ${summary.slice(0, 40)}...`);
}

{
  "scripts": {
    "prebuild": "tsx scripts/generate-summaries.ts",
    "build": "astro build"
  }
}

// scripts/build-embeddings.ts
import { readdir, readFile, writeFile } from 'node:fs/promises';
import { join } from 'node:path';
import matter from 'gray-matter';
import { GoogleGenAI } from '@google/genai';
 
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY! });
 
async function embed(text: string): Promise<number[]> {
  const result = await ai.models.embedContent({
    model: 'gemini-embedding-001',
    contents: [{ parts: [{ text: text.slice(0, 8000) }] }],
    config: { taskType: 'SEMANTIC_SIMILARITY' },
  });
  return result.embeddings?.[0]?.values ?? [];
}
 
const BLOG_DIR = join(process.cwd(), 'src/content/blog');
const embeddings: Record<string, number[]> = {};
 
for (const file of (await readdir(BLOG_DIR)).filter(f => f.endsWith('.md'))) {
  const raw = await readFile(join(BLOG_DIR, file), 'utf-8');
  const { content } = matter(raw);
  embeddings[file.replace('.md', '')] = await embed(content);
  console.log(`embed: ${file}`);
}
 
await writeFile(
  join(process.cwd(), 'src/data/embeddings.json'),
  JSON.stringify(embeddings, null, 2),
  'utf-8',
);

---
// src/components/RelatedArticles.astro
import { getCollection } from 'astro:content';
import embeddings from '../data/embeddings.json';
 
interface Props { currentSlug: string }
const { currentSlug } = Astro.props;
 
function cosine(a: number[], b: number[]): number {
  let dot = 0, na = 0, nb = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i];
    na += a[i] ** 2;
    nb += b[i] ** 2;
  }
  return dot / (Math.sqrt(na) * Math.sqrt(nb));
}
 
const current = embeddings[currentSlug] as number[] | undefined;
const allBlog = await getCollection('blog');
 
const related = current
  ? Object.entries(embeddings)
      .filter(([slug]) => slug !== currentSlug)
      .map(([slug, vec]) => ({
        slug,
        score: cosine(current, vec as number[]),
        entry: allBlog.find(e => e.slug === slug),
      }))
      .sort((a, b) => b.score - a.score)
      .slice(0, 3)
  : [];
---
 
<aside class="related">
  <h2>Related</h2>
  <ul>
    {related.map(r => r.entry && (
      <li><a href={`/blog/${r.entry.slug}`}>{r.entry.data.title}</a></li>
    ))}
  </ul>
</aside>

// scripts/auto-tag.ts
import { GoogleGenAI, Type } from '@google/genai';
 
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY! });
 
// The canonical tag vocabulary — the core that pins each tag to one spelling
const TAG_VOCABULARY = [
  'gemini-api', 'astro', 'rag', 'embedding',
  'structured-output', 'ssr', 'performance', 'cost-optimization',
];
 
export async function suggestTags(title: string, body: string): Promise<string[]> {
  const result = await ai.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: [{
      role: 'user',
      parts: [{
        text:
          `Pick up to 4 tags for the article below. ` +
          `Choose only from this vocabulary and never invent new terms. ` +
          `Vocabulary: ${TAG_VOCABULARY.join(', ')} / Title: ${title} / Body: ${body.slice(0, 4000)}`,
      }],
    }],
    config: {
      temperature: 0,                       // tagging should be deterministic
      responseMimeType: 'application/json',
      responseSchema: {
        type: Type.OBJECT,
        properties: {
          tags: {
            type: Type.ARRAY,
            items: { type: Type.STRING, enum: TAG_VOCABULARY },
            maxItems: 4,
          },
        },
        required: ['tags'],
      },
    },
  });
 
  const parsed = JSON.parse(result.text ?? '{"tags":[]}') as { tags: string[] };
  // Final filter in case anything outside the enum slips through (belt and suspenders)
  return parsed.tags.filter(t => TAG_VOCABULARY.includes(t));
}

// scripts/embeddings-incremental.ts (a diff-aware version of build-embeddings.ts)
import { createHash } from 'node:crypto';
import { readFile, writeFile } from 'node:fs/promises';
 
type Cache = Record<string, { hash: string; vec: number[] }>;
 
function hash(text: string): string {
  return createHash('sha256').update(text).digest('hex');
}
 
// Load the existing cache; articles whose body hash matches are not recomputed
async function loadCache(path: string): Promise<Cache> {
  try { return JSON.parse(await readFile(path, 'utf-8')) as Cache; }
  catch { return {}; }
}
 
export async function buildIncremental(
  articles: { slug: string; body: string }[],
  embed: (t: string) => Promise<number[]>,
  cachePath = 'src/data/embeddings.json',
) {
  const cache = await loadCache(cachePath);
  let recomputed = 0;
 
  for (const { slug, body } of articles) {
    const h = hash(body);
    if (cache[slug]?.hash === h) continue;   // unchanged -> skip
    cache[slug] = { hash: h, vec: await embed(body) };
    recomputed++;
  }
 
  await writeFile(cachePath, JSON.stringify(cache), 'utf-8');
  console.log(`recomputed ${recomputed}/${articles.length} embeddings`);
}