OpenAI API w praktyce: function calling, embeddings i RAG

import OpenAI from "openai";
import { z } from "zod";

const client = new OpenAI();

// Definiuj schemat tego co model ma zwrócić
const TaskSchema = z.object({
  action: z.enum(["send_email", "create_task", "search_docs", "none"]),
  args: z.record(z.string(), z.any()),
  reasoning: z.string().max(500),
});

type Task = z.infer<typeof TaskSchema>;

async function classifyIntent(userMessage: string): Promise<Task> {
  const completion = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      {
        role: "system",
        content: `Jesteś asystentem. Klasyfikuj intencję użytkownika
        w jedną z 4 akcji. Bądź zwięzły.`,
      },
      { role: "user", content: userMessage },
    ],
    tools: [
      {
        type: "function",
        function: {
          name: "execute_action",
          description: "Wykonaj akcję na podstawie intencji użytkownika",
          parameters: {
            type: "object",
            properties: {
              action: {
                type: "string",
                enum: ["send_email", "create_task", "search_docs", "none"],
              },
              args: { type: "object", additionalProperties: true },
              reasoning: { type: "string" },
            },
            required: ["action", "args", "reasoning"],
          },
        },
      },
    ],
    tool_choice: { type: "function", function: { name: "execute_action" } },
  });

  const toolCall = completion.choices[0].message.tool_calls?.[0];
  if (!toolCall) throw new Error("No tool call returned");

  // WAŻNE: waliduj output modelu zanim go użyjesz
  const parsed = TaskSchema.parse(JSON.parse(toolCall.function.arguments));
  return parsed;
}

import { createHash } from "crypto";
import { Redis } from "@upstash/redis";

const redis = Redis.fromEnv();

async function getEmbedding(text: string): Promise<number[]> {
  // Cache hit: 0ms, $0
  const cached = await redis.get<number[]>(`emb:${hashText(text)}`);
  if (cached) return cached;

  // Cache miss: 200ms, $0.00000002
  const response = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: text,
  });

  const vector = response.data[0].embedding;
  await redis.set(`emb:${hashText(text)}`, vector, { ex: 60 * 60 * 24 * 30 });
  return vector;
}

function hashText(text: string): string {
  return createHash("sha256").update(text).digest("hex").slice(0, 16);
}

-- Migration: enable pgvector
CREATE EXTENSION IF NOT EXISTS vector;

-- Table with embeddings
CREATE TABLE documents (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  content TEXT NOT NULL,
  metadata JSONB DEFAULT '{}',
  embedding vector(1536),
  created_at TIMESTAMPTZ DEFAULT now()
);

-- Index for fast similarity search
CREATE INDEX documents_embedding_idx
ON documents
USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100);

import { createClient } from "@supabase/supabase-js";

const supabase = createClient(
  process.env.SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_KEY!
);

async function findSimilarDocuments(
  queryEmbedding: number[],
  matchThreshold = 0.7,
  matchCount = 5
) {
  const { data, error } = await supabase.rpc("match_documents", {
    query_embedding: queryEmbedding,
    match_threshold: matchThreshold,
    match_count: matchCount,
  });

  if (error) throw error;
  return data;
}

// SQL function
// CREATE FUNCTION match_documents(
//   query_embedding vector(1536),
//   match_threshold float,
//   match_count int
// ) RETURNS SETOF documents AS $$
//   SELECT * FROM documents
//   WHERE 1 - (documents.embedding <=> query_embedding) > match_threshold
//   ORDER BY documents.embedding <=> query_embedding
//   LIMIT match_count;
// $$ LANGUAGE sql;

async function ragQuery(userQuestion: string): Promise<string> {
  // 1. Embedding pytania (cache'owany)
  const questionEmbedding = await getEmbedding(userQuestion);

  // 2. Retrieval: top-5 najbardziej podobnych fragmentów
  const relevantDocs = await findSimilarDocuments(questionEmbedding, 0.7, 5);

  if (relevantDocs.length === 0) {
    return "Nie znam odpowiedzi na to pytanie. Mogę pomóc w inny sposób?";
  }

  // 3. Konstrukcja kontekstu z cytatami
  const context = relevantDocs
    .map((doc, i) => `[${i + 1}] ${doc.content}`)
    .join("\n\n");

  // 4. Prompt z kontekstem i instrukcją cytowania
  const completion = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [
      {
        role: "system",
        content: `Jesteś asystentem. Odpowiadaj TYLKO na podstawie
        dostarczonego kontekstu. Jeśli kontekst nie zawiera odpowiedzi,
        powiedz to wprost. ZAWSZE cytuj źródło używając numeru [N] przy
        każdym fakcie.`,
      },
      {
        role: "user",
        content: `Kontekst:\n${context}\n\nPytanie: ${userQuestion}`,
      },
    ],
    temperature: 0.2, // niska = bardziej deterministyczny
  });

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