+-------------------------------------------------------------------------------+
|                       INGESTION PIPELINE (Индексация)                         |
|   PDF / Markdown -> Semantic Chunker -> text-embedding-3-small (1536 dim)     |
|   -> PostgreSQL (pgvector + HNSW Index + Full-Text Search tsvector)          |
+-------------------------------------------------------------------------------+
                                        |
+---------------------------------------v---------------------------------------+
|                    RETRIEVAL & GENERATION PIPELINE                            |
|                                                                               |
|   Пользовательский запрос: "Каковы условия SLA по инцидентам категории P1?" |
|                                                                               |
|       +------------------------------------+-----------------------------+    |
|       |                                    |                             |    |
|       v                                    v                             |    |
|   1. Dense Vector Search (pgvector)    2. Sparse Text Search (tsvector)  |    |
|   Топ-25 векторных совпадений          Топ-25 точных ключевых слов       |    |
|       |                                    |                             |    |
|       +----------------->  [RRF FUSION] <--+                             |    |
|                               |                                               |
|                               v                                               |
|                    Топ-20 объединенных чанков                                |
|                               |                                               |
|                               v                                               |
|               3. Cohere Rerank 3.5 (Cross-Encoder)                            |
|               Глубокий анализ соответствия запрос <-> документ                |
|                               |                                               |
|                               v                                               |
|                    Топ-4 эталонных чанка высокой точности                     |
|                               |                                               |
|                               v                                               |
|         4. LLM Generation (Gemini 2.5 / Claude 3.5 Sonnet)                   |
|         Фактологически точный ответ с прямыми цитатами и источниками          |
+-------------------------------------------------------------------------------+

-- Включаем расширение pgvector
CREATE EXTENSION IF NOT EXISTS vector;

-- Создаем таблицу чанков корпоративной базы знаний
CREATE TABLE knowledge_chunks (
  id BIGSERIAL PRIMARY KEY,
  document_id TEXT NOT NULL,
  title TEXT NOT NULL,
  content TEXT NOT NULL,
  embedding vector(1536), -- Размерность text-embedding-3-small
  fts tsvector GENERATED ALWAYS AS (to_tsvector('russian', content)) STORED,
  metadata JSONB DEFAULT '{}'::jsonb,
  created_at TIMESTAMPTZ DEFAULT NOW()
);

-- Создаем HNSW индекс для косинусного сходства векторов
CREATE INDEX knowledge_chunks_hnsw_idx 
ON knowledge_chunks 
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);

-- Создаем GIN индекс для полнотекстового поиска
CREATE INDEX knowledge_chunks_fts_idx 
ON knowledge_chunks 
USING gin (fts);

-- Хранимая функция гибридного поиска на базе Reciprocal Rank Fusion (RRF)
CREATE OR REPLACE FUNCTION match_knowledge_hybrid (
  query_text TEXT,
  query_embedding vector(1536),
  match_count INT DEFAULT 20,
  rrf_k INT DEFAULT 60
)
RETURNS TABLE (
  id BIGINT,
  document_id TEXT,
  title TEXT,
  content TEXT,
  metadata JSONB,
  combined_score FLOAT
)
LANGUAGE sql
AS $$
WITH vector_search AS (
  SELECT id, ROW_NUMBER() OVER (ORDER BY embedding <=> query_embedding) AS rank
  FROM knowledge_chunks
  ORDER BY embedding <=> query_embedding
  LIMIT 50
),
text_search AS (
  SELECT id, ROW_NUMBER() OVER (ORDER BY ts_rank_cd(fts, plainto_tsquery('russian', query_text)) DESC) AS rank
  FROM knowledge_chunks
  WHERE fts @@ plainto_tsquery('russian', query_text)
  LIMIT 50
)
SELECT 
  k.id,
  k.document_id,
  k.title,
  k.content,
  k.metadata,
  COALESCE(1.0 / (rrf_k + v.rank), 0.0) + COALESCE(1.0 / (rrf_k + t.rank), 0.0) AS combined_score
FROM knowledge_chunks k
LEFT JOIN vector_search v ON k.id = v.id
LEFT JOIN text_search t ON k.id = t.id
WHERE v.id IS NOT NULL OR t.id IS NOT NULL
ORDER BY combined_score DESC
LIMIT match_count;
$$;

import { createClient } from '@supabase/supabase-js';
import { CohereClient } from 'cohere-ai';

interface RetrievedChunk {
  id: number;
  document_id: string;
  title: string;
  content: string;
  metadata: Record<string, unknown>;
  combined_score: number;
}

export interface FinalRAGResult {
  content: string;
  documentId: string;
  relevanceScore: number;
}

const supabase = createClient(
  process.env.NEXT_PUBLIC_SUPABASE_URL!,
  process.env.SUPABASE_SERVICE_ROLE_KEY!
);

const cohere = new CohereClient({
  token: process.env.COHERE_API_KEY!
});

/**
 * Генерация эмбеддинга запроса (OpenAI text-embedding-3-small)
 */
async function generateQueryEmbedding(query: string): Promise<number[]> {
  const response = await fetch('https://api.openai.com/v1/embeddings', {
    method: 'POST',
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      input: query,
      model: 'text-embedding-3-small'
    })
  });

  const json = await response.json();
  return json.data[0].embedding;
}

/**
 * Выполнение Enterprise Hybrid RAG с Re-ranking
 */
export async function executeEnterpriseRAG(
  userQuery: string,
  topK: number = 4
): Promise<FinalRAGResult[]> {
  // 1. Параллельно вычисляем эмбеддинг для пользовательского запроса
  const embedding = await generateQueryEmbedding(userQuery);

  // 2. Вызываем хранимую процедуру гибридного поиска (BM25 + pgvector)
  const { data: rawChunks, error } = await supabase.rpc('match_knowledge_hybrid', {
    query_text: userQuery,
    query_embedding: embedding,
    match_count: 20, // Предварительная широкая выборка
    rrf_k: 60
  });

  if (error || !rawChunks || rawChunks.length === 0) {
    console.error('Ошибка гибридного поиска Supabase:', error);
    return [];
  }

  const chunks = rawChunks as RetrievedChunk[];

  // 3. Финальный кросс-энкодер Re-ranking через Cohere
  const rerankResponse = await cohere.rerank({
    model: 'rerank-v3.5',
    query: userQuery,
    documents: chunks.map(c => ({ text: `${c.title}\n\n${c.content}` })),
    topN: topK
  });

  // 4. Формирование отфильтрованного эталонного контекста
  const results: FinalRAGResult[] = rerankResponse.results.map(r => {
    const originalChunk = chunks[r.index];
    return {
      content: originalChunk.content,
      documentId: originalChunk.document_id,
      relevanceScore: r.relevanceScore
    };
  });

  return results;
}