Generative AI — A Complete, Friendly Guide for Everyone

npm install openai

# .env.local
OPENAI_API_KEY=your_api_key_here

import OpenAI from "openai";

// Set OPENAI_API_KEY in your environment (e.g., .env.local)
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function main() {
  const completion = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      { role: "system", content: "You are a helpful writing assistant." },
      { role: "user", content: "Write a 120-word intro about Generative AI." }
    ],
  });

  console.log(completion.choices[0].message.content);
}

main().catch(console.error);

// app/api/generate/route.ts (Next.js 13+ App Router)
import { NextResponse } from "next/server";
import OpenAI from "openai";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

export async function POST(req: Request) {
  try {
    const { prompt } = await req.json();
    const completion = await openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [{ role: "user", content: prompt }],
      temperature: 0.7,
    });
    const text = completion.choices[0].message.content;
    return NextResponse.json({ ok: true, text });
  } catch (err: any) {
    return NextResponse.json({ ok: false, error: err?.message ?? "Unknown error" }, { status: 500 });
  }
}

// Example client call from a React component
async function generate(topic: string) {
  const res = await fetch("/api/generate", {
    method: "POST",
    body: JSON.stringify({ prompt: `Write a 150-word blog section about "${topic}"` }),
    headers: { "Content-Type": "application/json" },
  });
  const data = await res.json();
  return data.text as string;
}

# Prompt Patterns (copy → adapt → iterate)

/*
1) Role + Task + Constraints
*/
"You are a senior technical writer. Write a concise, non-repetitive 200-word
summary of Generative AI for beginners. Use short paragraphs and avoid jargon."

/*
2) Few-shot (give examples)
*/
"Rewrite the paragraph in a friendly tone. Example:
Input: 'Generative AI is complex.'
Output: 'Generative AI helps computers create new things.'

Now rewrite:
<your text here>"

/*
3) Chain-of-Thought Hints (no private reasoning leakage in production)
*/
"List the key points you will cover (bullets), then write a 2-paragraph explanation."

/*
4) Output Formatting
*/
"Return JSON with keys: title (string), bullets (string[]), summary (string, ~120 words)."

// RAG (Retrieval-Augmented Generation) sketch (Node/TypeScript)
// 1) Embed documents → store vectors
// 2) On user query → embed query → similarity search → provide top-k snippets to the model

import OpenAI from "openai";
// For demo purposes, let's simulate an in-memory vector store
// In production, use Pinecone, Weaviate, pgvector, or Supabase Vector.

type Doc = { id: string; text: string; embedding: number[] };
const docs: Doc[] = [];

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function embedText(text: string): Promise<number[]> {
  const res = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: text,
  });
  return res.data[0].embedding;
}

function cosineSim(a: number[], b: number[]) {
  let dot = 0, na = 0, nb = 0;
  for (let i = 0; i < a.length; i++) {
    dot += a[i] * b[i];
    na += a[i] * a[i];
    nb += b[i] * b[i];
  }
  return dot / (Math.sqrt(na) * Math.sqrt(nb));
}

async function addDocument(id: string, text: string) {
  const embedding = await embedText(text);
  docs.push({ id, text, embedding });
}

async function ragAnswer(question: string) {
  const qEmbed = await embedText(question);
  const ranked = docs
    .map(d => ({ d, score: cosineSim(qEmbed, d.embedding) }))
    .sort((a, b) => b.score - a.score)
    .slice(0, 3); // top-k

  const context = ranked.map(r => `[Doc ${r.d.id}] ${r.d.text}`).join("\n\n");

  const prompt = `Use ONLY the following context to answer. If unsure, say "I don't know".\n\nContext:\n${context}\n\nQuestion: ${question}`;

  const completion = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: prompt }],
    temperature: 0.2,
  });

  return completion.choices[0].message.content;
}

// Usage (one-time indexing then query):
// await addDocument("policy-001", "New employees receive 12 days of vacation.");
// console.log(await ragAnswer("How many vacation days do new employees get?"));

// Generation controls (OpenAI Chat Completions)
const result = await openai.chat.completions.create({
  model: "gpt-4o-mini",
  messages: [{ role: "user", content: "Write 3 alternative taglines for a GenAI blog." }],
  temperature: 0.9,      // higher = more diverse/creative
  top_p: 1,               // nucleus sampling (keep top cumulative probability)
  frequency_penalty: 0.2, // discourage repeating words
  presence_penalty: 0.3,  // encourage introducing new topics
});

# Safety & Quality Checklist (copy this into your README)
- [ ] Add system prompts that set tone, audience, and boundaries.
- [ ] Validate model outputs (length, format, JSON schemas).
- [ ] Add "use only provided context" instruction for RAG answers.
- [ ] Log prompts + responses (with redaction) for QA.
- [ ] Add rate limits and request timeouts.
- [ ] Handle null/empty responses and upstream errors.
- [ ] Provide a feedback button for users to flag issues.
- [ ] Disclose AI usage and obtain consent where required.