RAG: полный обзор

// Разрезать документ на куски до ~800 символов по границам абзацев.
// Каждый кусок помнит источник и заголовок — ответ будет на них ссылаться.
export type Chunk = { source: string; heading: string; text: string };

export function chunk(source: string, markdown: string, maxChars = 800): Chunk[] {
  const chunks: Chunk[] = [];
  let heading = '';
  let buffer: string[] = [];

  const flush = () => {
    const text = buffer.join('\n\n').trim();
    if (text) chunks.push({ source, heading, text });
    buffer = [];
  };

  for (const block of markdown.split(/\n{2,}/)) {
    if (block.startsWith('#')) {
      flush(); // новый заголовок всегда начинает новый кусок
      heading = block.replace(/^#+\s*/, '');
      continue;
    }
    if (buffer.join('\n\n').length + block.length > maxChars) flush();
    buffer.push(block);
  }
  flush();
  return chunks;
}

// Индексация: каждый кусок получает вектор и ложится в PostgreSQL с pgvector.
// CREATE TABLE chunks (id bigserial PRIMARY KEY, source text, heading text,
//                      text text, embedding vector(384));
import pg from 'pg';
import { chunk } from './chunk.ts';

const db = new pg.Pool({ connectionString: process.env.DATABASE_URL });

// Любой OpenAI-совместимый API эмбеддингов — облачный провайдер или локальная модель
export async function embed(texts: string[]): Promise<number[][]> {
  const res = await fetch(`${process.env.EMBEDDINGS_URL}/v1/embeddings`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${process.env.EMBEDDINGS_KEY}`,
    },
    body: JSON.stringify({ model: process.env.EMBEDDINGS_MODEL, input: texts }),
  });
  if (!res.ok) throw new Error(`embeddings: HTTP ${res.status}`);
  const { data } = (await res.json()) as { data: { embedding: number[] }[] };
  return data.map((d) => d.embedding);
}

export async function indexDocument(source: string, markdown: string): Promise<number> {
  const pieces = chunk(source, markdown);
  const vectors = await embed(pieces.map((p) => `${p.heading}\n${p.text}`));
  // Один запрос: старые куски документа заменяются атомарно
  await db.query(
    `WITH old AS (DELETE FROM chunks WHERE source = $1)
     INSERT INTO chunks (source, heading, text, embedding)
     SELECT $1, h, t, e::vector FROM unnest($2::text[], $3::text[], $4::text[]) AS u(h, t, e)`,
    [source, pieces.map((p) => p.heading), pieces.map((p) => p.text), vectors.map((v) => JSON.stringify(v))],
  );
  return pieces.length;
}

// Ответ: найти ближайшие куски, отдать их модели с номерами, потребовать ссылки —
// и вовсе не вызывать модель, если ничего не нашлось
import pg from 'pg';
import { embed } from './index.ts';

const db = new pg.Pool({ connectionString: process.env.DATABASE_URL });
const API = process.env.ANTHROPIC_BASE_URL ?? 'https://api.anthropic.com';

export async function ask(question: string) {
  const [q] = await embed([question]);
  const { rows } = await db.query(
    `SELECT source, heading, text, 1 - (embedding <=> $1) AS score
       FROM chunks ORDER BY embedding <=> $1 LIMIT 4`,
    [JSON.stringify(q)],
  );
  // Порог подбирается на ваших вопросах; ниже него — не ответ
  const found = rows.filter((r) => r.score > 0.5);
  if (found.length === 0) return { answer: null, sources: [] }; // передать человеку

  const context = found.map((r, i) => `[${i + 1}] ${r.heading}\n${r.text}`).join('\n\n');
  const res = await fetch(`${API}/v1/messages`, {
    method: 'POST',
    headers: {
      'content-type': 'application/json',
      'x-api-key': process.env.ANTHROPIC_API_KEY ?? '',
      'anthropic-version': '2023-06-01',
    },
    body: JSON.stringify({
      model: 'claude-sonnet-5',
      max_tokens: 600,
      system:
        'Отвечай только по источникам ниже и ссылайся на них как [1], [2]. ' +
        'Если в источниках нет ответа, так и скажи.\n\n' + context,
      messages: [{ role: 'user', content: question }],
    }),
  });
  if (!res.ok) throw new Error(`model: HTTP ${res.status}`);
  const data = (await res.json()) as { content: { type: string; text: string }[] };
  return { answer: data.content[0].text, sources: found.map((r) => r.source) };
}