yt-embeddings-strapi-plugin 0.0.1

package/dist/server/index.mjs

@@ -0,0 +1,2203 @@
+import { OpenAIEmbeddings, ChatOpenAI } from "@langchain/openai";
+import { PGVectorStore } from "@langchain/community/vectorstores/pgvector";
+import { StringOutputParser } from "@langchain/core/output_parsers";
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { RunnableSequence, RunnablePassthrough } from "@langchain/core/runnables";
+import { Pool } from "pg";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import * as crypto from "crypto";
+const EMBEDDING_MODELS = {
+  "text-embedding-3-small": { dimensions: 1536 },
+  "text-embedding-3-large": { dimensions: 3072 },
+  "text-embedding-ada-002": { dimensions: 1536 }
+};
+const config = {
+  default: {
+    openAIApiKey: "",
+    neonConnectionString: "",
+    embeddingModel: "text-embedding-3-small",
+    chunkSize: 4e3,
+    chunkOverlap: 200,
+    autoChunk: false,
+    preprocessContent: true
+  },
+  validator(config2) {
+    if (!config2.openAIApiKey) {
+      console.warn(
+        "yt-embeddings-strapi-plugin: openAIApiKey is not configured. Plugin features will be disabled."
+      );
+    }
+    if (!config2.neonConnectionString) {
+      console.warn(
+        "yt-embeddings-strapi-plugin: neonConnectionString is not configured. Plugin features will be disabled."
+      );
+    }
+    if (config2.embeddingModel && !EMBEDDING_MODELS[config2.embeddingModel]) {
+      console.warn(
+        `yt-embeddings-strapi-plugin: Invalid embeddingModel "${config2.embeddingModel}". Valid options: ${Object.keys(EMBEDDING_MODELS).join(", ")}. Defaulting to "text-embedding-3-small".`
+      );
+    }
+    if (config2.chunkSize && (config2.chunkSize < 100 || config2.chunkSize > 8e3)) {
+      console.warn(
+        `yt-embeddings-strapi-plugin: chunkSize ${config2.chunkSize} is outside recommended range (100-8000). Using default value of 4000.`
+      );
+    }
+  }
+};
+class PluginManager {
+  constructor() {
+    this.embeddings = null;
+    this.chat = null;
+    this.pool = null;
+    this.embeddingModel = "text-embedding-3-small";
+    this.dimensions = 1536;
+    this.vectorStoreConfig = null;
+  }
+  async initializePool(connectionString) {
+    console.log("Initializing Neon DB Pool");
+    if (this.pool) return this.pool;
+    try {
+      const poolConfig = {
+        connectionString,
+        ssl: { rejectUnauthorized: false },
+        max: 10
+      };
+      this.pool = new Pool(poolConfig);
+      const client = await this.pool.connect();
+      await client.query("SELECT 1");
+      client.release();
+      await this.initializeVectorTable();
+      console.log("Neon DB Pool initialized successfully");
+      return this.pool;
+    } catch (error) {
+      console.error(`Failed to initialize Neon DB Pool: ${error}`);
+      throw new Error(`Failed to initialize Neon DB Pool: ${error}`);
+    }
+  }
+  async initializeVectorTable() {
+    if (!this.pool) throw new Error("Pool not initialized");
+    const client = await this.pool.connect();
+    try {
+      await client.query("CREATE EXTENSION IF NOT EXISTS vector");
+      await client.query(`
+        CREATE TABLE IF NOT EXISTS embeddings_documents (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          content TEXT,
+          metadata JSONB,
+          embedding vector(${this.dimensions})
+        )
+      `);
+      await client.query(`
+        DROP INDEX IF EXISTS embeddings_documents_embedding_idx
+      `);
+      await client.query(`
+        CREATE INDEX IF NOT EXISTS embeddings_documents_embedding_hnsw_idx
+        ON embeddings_documents
+        USING hnsw (embedding vector_cosine_ops)
+      `);
+      await client.query(`
+        CREATE INDEX IF NOT EXISTS embeddings_documents_metadata_idx
+        ON embeddings_documents
+        USING gin (metadata)
+      `);
+      console.log(`Vector table initialized (dimensions: ${this.dimensions})`);
+    } catch (error) {
+      console.log("Note: Index creation may require more data");
+    } finally {
+      client.release();
+    }
+  }
+  async initializeEmbeddings(openAIApiKey) {
+    console.log(`Initializing OpenAI Embeddings (model: ${this.embeddingModel})`);
+    if (this.embeddings) return this.embeddings;
+    try {
+      this.embeddings = new OpenAIEmbeddings({
+        openAIApiKey,
+        modelName: this.embeddingModel,
+        dimensions: this.dimensions
+      });
+      return this.embeddings;
+    } catch (error) {
+      console.error(`Failed to initialize Embeddings: ${error}`);
+      throw new Error(`Failed to initialize Embeddings: ${error}`);
+    }
+  }
+  async initializeChat(openAIApiKey) {
+    console.log("Initializing Chat Model");
+    if (this.chat) return this.chat;
+    try {
+      this.chat = new ChatOpenAI({
+        modelName: "gpt-4o-mini",
+        temperature: 0.7,
+        openAIApiKey
+      });
+      return this.chat;
+    } catch (error) {
+      console.error(`Failed to initialize Chat: ${error}`);
+      throw new Error(`Failed to initialize Chat: ${error}`);
+    }
+  }
+  async initialize(config2) {
+    const model = config2.embeddingModel || "text-embedding-3-small";
+    if (EMBEDDING_MODELS[model]) {
+      this.embeddingModel = model;
+      this.dimensions = EMBEDDING_MODELS[model].dimensions;
+    } else {
+      console.warn(`Invalid embedding model "${model}", using default`);
+      this.embeddingModel = "text-embedding-3-small";
+      this.dimensions = EMBEDDING_MODELS["text-embedding-3-small"].dimensions;
+    }
+    console.log(`Using embedding model: ${this.embeddingModel} (${this.dimensions} dimensions)`);
+    await this.initializePool(config2.neonConnectionString);
+    await this.initializeEmbeddings(config2.openAIApiKey);
+    await this.initializeChat(config2.openAIApiKey);
+    if (this.pool) {
+      this.vectorStoreConfig = {
+        pool: this.pool,
+        tableName: "embeddings_documents",
+        columns: {
+          idColumnName: "id",
+          vectorColumnName: "embedding",
+          contentColumnName: "content",
+          metadataColumnName: "metadata"
+        },
+        distanceStrategy: "cosine"
+      };
+    }
+    console.log("Plugin Manager Initialization Complete");
+  }
+  async createEmbedding(docData) {
+    if (!this.embeddings || !this.vectorStoreConfig || !this.pool) {
+      throw new Error("Plugin manager not initialized");
+    }
+    const maxRetries = 3;
+    const retryDelay = 2e3;
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        const embeddingVector = await this.embeddings.embedQuery(docData.content);
+        const metadata = {
+          id: docData.id,
+          title: docData.title,
+          collectionType: docData.collectionType || "standalone",
+          fieldName: docData.fieldName || "content"
+        };
+        const vectorString = `[${embeddingVector.join(",")}]`;
+        const result = await this.pool.query(
+          `INSERT INTO embeddings_documents (content, metadata, embedding)
+           VALUES ($1, $2::jsonb, $3::vector)
+           RETURNING id`,
+          [docData.content, JSON.stringify(metadata), vectorString]
+        );
+        return {
+          embeddingId: result.rows[0]?.id || "",
+          embedding: embeddingVector
+        };
+      } catch (error) {
+        const isRateLimit = error.message?.includes("429") || error.message?.includes("rate");
+        const isLastAttempt = attempt === maxRetries;
+        if (isRateLimit && !isLastAttempt) {
+          console.log(`[createEmbedding] Rate limited, waiting ${retryDelay}ms before retry ${attempt + 1}/${maxRetries}...`);
+          await new Promise((resolve) => setTimeout(resolve, retryDelay * attempt));
+          continue;
+        }
+        console.error(`[createEmbedding] Failed (attempt ${attempt}/${maxRetries}):`, error.message || error);
+        if (isLastAttempt) {
+          throw new Error(`Failed to create embedding after ${maxRetries} attempts: ${error.message || error}`);
+        }
+      }
+    }
+    throw new Error("Failed to create embedding: unexpected error");
+  }
+  async deleteEmbedding(strapiId) {
+    if (!this.pool) {
+      throw new Error("Plugin manager not initialized");
+    }
+    try {
+      await this.pool.query(
+        `DELETE FROM embeddings_documents WHERE metadata->>'id' = $1`,
+        [strapiId]
+      );
+    } catch (error) {
+      console.error(`Failed to delete embedding: ${error}`);
+      throw new Error(`Failed to delete embedding: ${error}`);
+    }
+  }
+  async queryEmbedding(query) {
+    if (!this.embeddings || !this.chat || !this.vectorStoreConfig) {
+      throw new Error("Plugin manager not initialized");
+    }
+    try {
+      const vectorStore = await PGVectorStore.initialize(
+        this.embeddings,
+        this.vectorStoreConfig
+      );
+      const resultsWithScores = await vectorStore.similaritySearchWithScore(query, 6);
+      console.log(`[queryEmbedding] Query: "${query}"`);
+      console.log(`[queryEmbedding] Found ${resultsWithScores.length} results:`);
+      resultsWithScores.forEach(([doc, score], i) => {
+        console.log(`  ${i + 1}. Score: ${score.toFixed(4)}, Title: ${doc.metadata?.title || "N/A"}`);
+      });
+      const SIMILARITY_THRESHOLD = 1;
+      const relevantResults = resultsWithScores.filter(([_, score]) => score < SIMILARITY_THRESHOLD);
+      console.log(`[queryEmbedding] ${relevantResults.length} results passed threshold (< ${SIMILARITY_THRESHOLD})`);
+      const topResults = relevantResults.slice(0, 3);
+      const sourceDocuments = topResults.map(([doc]) => doc);
+      const bestMatchForDisplay = topResults.length > 0 ? [topResults[0][0]] : [];
+      const formatDocs = (docs) => {
+        return docs.map((doc) => {
+          const title = doc.metadata?.title ? `Title: ${doc.metadata.title}
+` : "";
+          return `${title}${doc.pageContent}`;
+        }).join("\n\n");
+      };
+      const ragPrompt = ChatPromptTemplate.fromMessages([
+        [
+          "system",
+          `You are a helpful assistant that answers questions based on the provided context.
+If you cannot find the answer in the context, say so. Be concise and accurate.
+
+Context:
+{context}`
+        ],
+        ["human", "{question}"]
+      ]);
+      const ragChain = RunnableSequence.from([
+        {
+          context: async () => formatDocs(sourceDocuments),
+          question: new RunnablePassthrough()
+        },
+        ragPrompt,
+        this.chat,
+        new StringOutputParser()
+      ]);
+      const text = await ragChain.invoke(query);
+      return {
+        text,
+        sourceDocuments: bestMatchForDisplay
+        // Only return best match to display
+      };
+    } catch (error) {
+      console.error(`Failed to query embeddings: ${error}`);
+      throw new Error(`Failed to query embeddings: ${error}`);
+    }
+  }
+  async similaritySearch(query, k = 4) {
+    if (!this.embeddings || !this.vectorStoreConfig) {
+      throw new Error("Plugin manager not initialized");
+    }
+    try {
+      const vectorStore = await PGVectorStore.initialize(
+        this.embeddings,
+        this.vectorStoreConfig
+      );
+      return await vectorStore.similaritySearch(query, k);
+    } catch (error) {
+      console.error(`Failed to perform similarity search: ${error}`);
+      throw new Error(`Failed to perform similarity search: ${error}`);
+    }
+  }
+  isInitialized() {
+    return !!(this.embeddings && this.chat && this.pool);
+  }
+  /**
+   * Get all embeddings from Neon DB
+   * Returns the metadata (including Strapi documentId) for each embedding
+   */
+  async getAllNeonEmbeddings() {
+    if (!this.pool) {
+      throw new Error("Plugin manager not initialized");
+    }
+    try {
+      const result = await this.pool.query(`
+        SELECT
+          id,
+          content,
+          metadata->>'id' as strapi_id,
+          metadata->>'title' as title,
+          metadata->>'collectionType' as collection_type,
+          metadata->>'fieldName' as field_name
+        FROM embeddings_documents
+        ORDER BY id
+      `);
+      return result.rows.map((row) => ({
+        id: row.id,
+        strapiId: row.strapi_id,
+        title: row.title || "",
+        content: row.content || "",
+        collectionType: row.collection_type || "standalone",
+        fieldName: row.field_name || "content"
+      }));
+    } catch (error) {
+      console.error(`Failed to get Neon embeddings: ${error}`);
+      throw new Error(`Failed to get Neon embeddings: ${error}`);
+    }
+  }
+  /**
+   * Delete an embedding from Neon by its Neon UUID (not Strapi ID)
+   */
+  async deleteNeonEmbeddingById(neonId) {
+    if (!this.pool) {
+      throw new Error("Plugin manager not initialized");
+    }
+    try {
+      await this.pool.query(
+        `DELETE FROM embeddings_documents WHERE id = $1`,
+        [neonId]
+      );
+    } catch (error) {
+      console.error(`Failed to delete Neon embedding: ${error}`);
+      throw new Error(`Failed to delete Neon embedding: ${error}`);
+    }
+  }
+  getPool() {
+    return this.pool;
+  }
+  getEmbeddings() {
+    return this.embeddings;
+  }
+  getEmbeddingModel() {
+    return this.embeddingModel;
+  }
+  getChat() {
+    return this.chat;
+  }
+  async destroy() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+    this.embeddings = null;
+    this.chat = null;
+    this.vectorStoreConfig = null;
+  }
+  /**
+   * Clear all embeddings from Neon DB
+   * Returns the number of deleted rows
+   */
+  async clearAllNeonEmbeddings() {
+    if (!this.pool) {
+      throw new Error("Plugin manager not initialized");
+    }
+    try {
+      const result = await this.pool.query(`
+        DELETE FROM embeddings_documents
+        RETURNING id
+      `);
+      console.log(`[clearAllNeonEmbeddings] Deleted ${result.rowCount} embeddings from Neon`);
+      return result.rowCount || 0;
+    } catch (error) {
+      console.error(`Failed to clear Neon embeddings: ${error}`);
+      throw new Error(`Failed to clear Neon embeddings: ${error}`);
+    }
+  }
+  /**
+   * Debug method to inspect raw data in Neon DB
+   */
+  async debugNeonEmbeddings() {
+    if (!this.pool) {
+      throw new Error("Plugin manager not initialized");
+    }
+    try {
+      const result = await this.pool.query(`
+        SELECT
+          id,
+          content,
+          metadata,
+          pg_typeof(metadata) as metadata_type,
+          embedding IS NOT NULL as has_embedding,
+          CASE WHEN embedding IS NOT NULL THEN array_length(embedding::float[], 1) ELSE 0 END as embedding_length
+        FROM embeddings_documents
+        ORDER BY id
+        LIMIT 20
+      `);
+      return result.rows.map((row) => ({
+        id: row.id,
+        content: row.content?.substring(0, 200) + (row.content?.length > 200 ? "..." : ""),
+        metadata: row.metadata,
+        metadataType: row.metadata_type,
+        hasEmbedding: row.has_embedding,
+        embeddingLength: row.embedding_length || 0
+      }));
+    } catch (error) {
+      console.error(`Failed to debug Neon embeddings: ${error}`);
+      throw new Error(`Failed to debug Neon embeddings: ${error}`);
+    }
+  }
+}
+const pluginManager = new PluginManager();
+const SearchYtKnowledgeSchema = z.object({
+  query: z.string().min(1, "Query is required"),
+  limit: z.number().min(1).max(20).optional().default(5),
+  videoId: z.string().optional(),
+  topics: z.array(z.string()).optional(),
+  contextWindowSeconds: z.number().min(0).optional().default(30),
+  minSimilarity: z.number().min(0).max(1).optional().default(0.65)
+});
+const GetVideoTranscriptRangeSchema = z.object({
+  videoId: z.string().min(1, "Video ID is required"),
+  startSeconds: z.number().min(0, "Start seconds must be >= 0"),
+  endSeconds: z.number().min(0, "End seconds must be >= 0")
+});
+const ListYtVideosSchema = z.object({
+  page: z.number().min(1).optional().default(1),
+  pageSize: z.number().min(1).max(50).optional().default(25)
+});
+const GetYtVideoSummarySchema = z.object({
+  videoId: z.string().min(1, "Video ID is required")
+});
+const ToolSchemas = {
+  search_yt_knowledge: SearchYtKnowledgeSchema,
+  get_video_transcript_range: GetVideoTranscriptRangeSchema,
+  list_yt_videos: ListYtVideosSchema,
+  get_yt_video_summary: GetYtVideoSummarySchema
+};
+function validateToolInput(toolName, input) {
+  const schema = ToolSchemas[toolName];
+  if (!schema) {
+    throw new Error(`No schema defined for tool: ${toolName}`);
+  }
+  const result = schema.safeParse(input);
+  if (!result.success) {
+    const errors = result.error.errors.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ");
+    throw new Error(`Validation failed for ${toolName}: ${errors}`);
+  }
+  return result.data;
+}
+function formatTime$5(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+const searchYtKnowledgeMcpTool = {
+  name: "search_yt_knowledge",
+  description: "Semantically search YouTube video transcripts. Returns relevant passages with timestamps, deep links, video topics, and summary.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        description: "What to search for"
+      },
+      limit: {
+        type: "number",
+        description: "Number of results (default: 5)"
+      },
+      videoId: {
+        type: "string",
+        description: "Optional: limit search to one video"
+      },
+      topics: {
+        type: "array",
+        items: { type: "string" },
+        description: 'Optional: filter to videos covering these topics (e.g. ["RAG", "MCP"])'
+      },
+      contextWindowSeconds: {
+        type: "number",
+        description: "Seconds of context around match (default: 30)"
+      },
+      minSimilarity: {
+        type: "number",
+        description: "Minimum similarity 0-1 (default: 0.65)"
+      }
+    },
+    required: ["query"]
+  }
+};
+async function handleSearchYtKnowledge(strapi, args) {
+  const results = await strapi.plugin("yt-embeddings-strapi-plugin").service("ytEmbeddings").search(args.query, {
+    limit: args.limit ?? 5,
+    minSimilarity: args.minSimilarity ?? 0.65,
+    videoId: args.videoId,
+    topics: args.topics,
+    contextWindowSeconds: args.contextWindowSeconds ?? 30
+  });
+  if (!results.length) {
+    return {
+      content: [{ type: "text", text: "No relevant content found." }]
+    };
+  }
+  const formatted = results.map((r, i) => {
+    const topicLine = r.topics?.length ? `Topics: ${r.topics.join(", ")}
+` : "";
+    const summaryLine = r.videoSummary ? `Summary: ${r.videoSummary}
+` : "";
+    return `
+--- Result ${i + 1} (similarity: ${r.similarity}) ---
+Video: "${r.title}"
+${topicLine}${summaryLine}Timestamp: ${formatTime$5(r.startSeconds)} – ${formatTime$5(r.endSeconds)}
+Watch: ${r.deepLink}
+
+${r.contextText}
+    `.trim();
+  }).join("\n\n");
+  return {
+    content: [{ type: "text", text: formatted }]
+  };
+}
+function formatTime$4(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+const getVideoTranscriptRangeMcpTool = {
+  name: "get_video_transcript_range",
+  description: 'Get the raw transcript text for a specific time range in a YouTube video. Useful for "what was said around 5:30" type queries.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      videoId: {
+        type: "string",
+        description: "YouTube video ID"
+      },
+      startSeconds: {
+        type: "number",
+        description: "Start of range in seconds"
+      },
+      endSeconds: {
+        type: "number",
+        description: "End of range in seconds"
+      }
+    },
+    required: ["videoId", "startSeconds", "endSeconds"]
+  }
+};
+async function handleGetVideoTranscriptRange(strapi, args) {
+  const rows = await strapi.plugin("yt-embeddings-strapi-plugin").service("ytEmbeddings").getTranscriptRange(args.videoId, args.startSeconds, args.endSeconds);
+  if (!rows.length) {
+    return {
+      content: [{
+        type: "text",
+        text: `No transcript found for video ${args.videoId} in that time range.`
+      }]
+    };
+  }
+  const text = rows.flatMap((r) => r.segments).filter((s) => s.end / 1e3 > args.startSeconds && s.start / 1e3 < args.endSeconds).map((s) => s.text).join(" ").replace(/\s+/g, " ").trim();
+  const deepLink = `https://www.youtube.com/watch?v=${args.videoId}&t=${Math.floor(args.startSeconds)}`;
+  return {
+    content: [{
+      type: "text",
+      text: `Transcript ${formatTime$4(args.startSeconds)}–${formatTime$4(args.endSeconds)}:
+
+${text}
+
+Watch: ${deepLink}`
+    }]
+  };
+}
+function formatDuration$1(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = Math.floor(seconds % 60);
+  return h > 0 ? `${h}:${m.toString().padStart(2, "0")}:${s.toString().padStart(2, "0")}` : `${m}:${s.toString().padStart(2, "0")}`;
+}
+const listYtVideosMcpTool = {
+  name: "list_yt_videos",
+  description: "List all ingested YouTube videos with their topics, chunk count, and duration. Useful for discovering available content before searching.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      page: {
+        type: "number",
+        description: "Page number (default: 1)"
+      },
+      pageSize: {
+        type: "number",
+        description: "Results per page (default: 25)"
+      }
+    },
+    required: []
+  }
+};
+async function handleListYtVideos(strapi, args) {
+  const result = await strapi.plugin("yt-embeddings-strapi-plugin").service("ytEmbeddings").listVideos({
+    page: args.page ?? 1,
+    pageSize: args.pageSize ?? 25
+  });
+  if (!result.data.length) {
+    return {
+      content: [{ type: "text", text: "No videos have been ingested yet." }]
+    };
+  }
+  const formatted = result.data.map((v, i) => {
+    const topics = v.topics?.length ? `Topics: ${v.topics.join(", ")}` : "";
+    const duration = v.duration_seconds ? `Duration: ${formatDuration$1(v.duration_seconds)}` : "";
+    return `${i + 1}. "${v.title}"
+   Video ID: ${v.video_id}
+   ${[topics, duration, `Chunks: ${v.chunk_count}`, `Status: ${v.embedding_status}`].filter(Boolean).join(" | ")}`;
+  }).join("\n\n");
+  return {
+    content: [{
+      type: "text",
+      text: `${result.total} videos (page ${result.page}/${Math.ceil(result.total / result.pageSize)}):
+
+${formatted}`
+    }]
+  };
+}
+function formatTime$3(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+const getYtVideoSummaryMcpTool = {
+  name: "get_yt_video_summary",
+  description: "Get a YouTube video's summary, topics, and key moments by video ID. Useful for understanding what a video covers without searching.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      videoId: {
+        type: "string",
+        description: "YouTube video ID"
+      }
+    },
+    required: ["videoId"]
+  }
+};
+async function handleGetYtVideoSummary(strapi, args) {
+  const video = await strapi.plugin("yt-embeddings-strapi-plugin").service("ytEmbeddings").getVideo(args.videoId);
+  if (!video) {
+    return {
+      content: [{ type: "text", text: `Video ${args.videoId} not found.` }]
+    };
+  }
+  const topics = video.topics?.length ? `Topics: ${video.topics.join(", ")}` : "";
+  const summary = video.summary || "No summary available.";
+  let keyMoments = "";
+  if (video.key_moments?.length) {
+    keyMoments = "\n\nKey Moments:\n" + video.key_moments.map((km) => `  ${formatTime$3(km.timestampSeconds)} — ${km.label}`).join("\n");
+  }
+  const watchLink = `https://www.youtube.com/watch?v=${video.video_id}`;
+  return {
+    content: [{
+      type: "text",
+      text: `"${video.title}"
+${topics}
+Chunks: ${video.chunk_count} | Status: ${video.embedding_status}
+Watch: ${watchLink}
+
+Summary:
+${summary}${keyMoments}`
+    }]
+  };
+}
+const tools$1 = [
+  searchYtKnowledgeMcpTool,
+  getVideoTranscriptRangeMcpTool,
+  listYtVideosMcpTool,
+  getYtVideoSummaryMcpTool
+];
+const toolHandlers = {
+  search_yt_knowledge: handleSearchYtKnowledge,
+  get_video_transcript_range: handleGetVideoTranscriptRange,
+  list_yt_videos: handleListYtVideos,
+  get_yt_video_summary: handleGetYtVideoSummary
+};
+async function handleToolCall(strapi, request) {
+  const { name, arguments: args } = request.params;
+  const handler = toolHandlers[name];
+  if (!handler) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: true,
+            message: `Unknown tool: ${name}`,
+            availableTools: Object.keys(toolHandlers)
+          })
+        }
+      ]
+    };
+  }
+  try {
+    const validatedArgs = validateToolInput(name, args || {});
+    const result = await handler(strapi, validatedArgs);
+    return result;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    strapi.log.error(`[yt-embeddings-strapi-plugin] Tool ${name} error:`, { error: errorMessage });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: true,
+            tool: name,
+            message: errorMessage
+          }, null, 2)
+        }
+      ]
+    };
+  }
+}
+function createMcpServer(strapi) {
+  const server = new Server(
+    {
+      name: "yt-embeddings-strapi-plugin-mcp",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: tools$1 };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    return handleToolCall(strapi, request);
+  });
+  return server;
+}
+const YT_TABLES_SQL = `
+-- ─── Videos table (one row per YouTube video) ────────────────────────────────
+CREATE TABLE IF NOT EXISTS yt_videos (
+  id                  UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  strapi_document_id  TEXT NOT NULL UNIQUE,
+  video_id            TEXT NOT NULL UNIQUE,
+  url                 TEXT NOT NULL,
+  title               TEXT NOT NULL,
+  channel_name        TEXT,
+  channel_id          TEXT,
+  duration_seconds    INTEGER,
+  published_at        TIMESTAMPTZ,
+  thumbnail_url       TEXT,
+  description         TEXT,
+  language            TEXT NOT NULL DEFAULT 'en',
+
+  -- Processing state
+  content_hash        TEXT NOT NULL,
+  embedding_status    TEXT NOT NULL DEFAULT 'pending'
+                        CHECK (embedding_status IN ('pending', 'processing', 'complete', 'failed')),
+  chunk_count         INTEGER NOT NULL DEFAULT 0,
+  error_message       TEXT,
+  embedding_model     TEXT NOT NULL DEFAULT 'text-embedding-3-small',
+  embedded_at         TIMESTAMPTZ,
+
+  -- LLM-extracted metadata
+  topics              TEXT[] NOT NULL DEFAULT '{}',
+  summary             TEXT NOT NULL DEFAULT '',
+  key_moments         JSONB NOT NULL DEFAULT '[]',
+
+  created_at          TIMESTAMPTZ DEFAULT NOW(),
+  updated_at          TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- ─── Video chunks table (one row per embeddable unit) ────────────────────────
+CREATE TABLE IF NOT EXISTS yt_video_chunks (
+  id                  UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  video_id            TEXT NOT NULL REFERENCES yt_videos(video_id) ON DELETE CASCADE,
+  strapi_document_id  TEXT NOT NULL,
+
+  text                TEXT NOT NULL,
+  embedding           vector(1536),
+
+  start_seconds       REAL NOT NULL,
+  end_seconds         REAL NOT NULL,
+  chunk_index         INTEGER NOT NULL,
+
+  segments            JSONB NOT NULL,
+
+  prev_chunk_id       UUID,
+  next_chunk_id       UUID,
+
+  tokens              INTEGER,
+
+  created_at          TIMESTAMPTZ DEFAULT NOW()
+);
+
+-- ─── Indexes ─────────────────────────────────────────────────────────────────
+
+-- Video lookups
+CREATE INDEX IF NOT EXISTS idx_yt_videos_video_id
+  ON yt_videos (video_id);
+
+CREATE INDEX IF NOT EXISTS idx_yt_videos_strapi_doc
+  ON yt_videos (strapi_document_id);
+
+CREATE INDEX IF NOT EXISTS idx_yt_videos_content_hash
+  ON yt_videos (content_hash);
+
+CREATE INDEX IF NOT EXISTS idx_yt_videos_status
+  ON yt_videos (embedding_status);
+
+-- Topic filtering
+CREATE INDEX IF NOT EXISTS idx_yt_videos_topics
+  ON yt_videos USING gin (topics);
+
+-- Chunk lookups
+CREATE INDEX IF NOT EXISTS idx_yt_video_chunks_video_time
+  ON yt_video_chunks (video_id, start_seconds, end_seconds);
+
+CREATE INDEX IF NOT EXISTS idx_yt_video_chunks_video_index
+  ON yt_video_chunks (video_id, chunk_index);
+`;
+const YT_HNSW_INDEX_SQL = `
+CREATE INDEX IF NOT EXISTS idx_yt_video_chunks_embedding
+  ON yt_video_chunks USING hnsw (embedding vector_cosine_ops);
+`;
+const DROP_OLD_TABLES_SQL = `
+DROP TABLE IF EXISTS yt_chunks CASCADE;
+DROP TABLE IF EXISTS yt_embedding_jobs CASCADE;
+`;
+async function runYtMigration(pool) {
+  const client = await pool.connect();
+  try {
+    await client.query(DROP_OLD_TABLES_SQL);
+    await client.query(YT_TABLES_SQL);
+    console.log("[yt-migration] yt_videos and yt_video_chunks tables ready");
+    try {
+      await client.query(YT_HNSW_INDEX_SQL);
+      console.log("[yt-migration] HNSW vector index ready");
+    } catch {
+      console.log("[yt-migration] HNSW index creation deferred (may need data first)");
+    }
+  } finally {
+    client.release();
+  }
+}
+const PLUGIN_ID$3 = "yt-embeddings-strapi-plugin";
+const OAUTH_PLUGIN_ID = "strapi-oauth-mcp-manager";
+function createFallbackAuthMiddleware(strapi) {
+  const mcpPath = `/api/${PLUGIN_ID$3}/mcp`;
+  return async (ctx, next) => {
+    if (!ctx.path.startsWith(mcpPath)) {
+      return next();
+    }
+    const authHeader = ctx.request.headers.authorization;
+    if (!authHeader?.startsWith("Bearer ")) {
+      ctx.status = 401;
+      ctx.body = {
+        error: "Unauthorized",
+        message: "Bearer token required. Provide a Strapi API token."
+      };
+      return;
+    }
+    const token = authHeader.slice(7);
+    ctx.state.strapiToken = token;
+    ctx.state.authMethod = "api-token";
+    return next();
+  };
+}
+const bootstrap = async ({ strapi }) => {
+  const actions = [
+    {
+      section: "plugins",
+      displayName: "Read",
+      uid: "read",
+      pluginName: PLUGIN_ID$3
+    },
+    {
+      section: "plugins",
+      displayName: "Update",
+      uid: "update",
+      pluginName: PLUGIN_ID$3
+    },
+    {
+      section: "plugins",
+      displayName: "Create",
+      uid: "create",
+      pluginName: PLUGIN_ID$3
+    },
+    {
+      section: "plugins",
+      displayName: "Delete",
+      uid: "delete",
+      pluginName: PLUGIN_ID$3
+    },
+    {
+      section: "plugins",
+      displayName: "Chat",
+      uid: "chat",
+      pluginName: PLUGIN_ID$3
+    }
+  ];
+  await strapi.admin.services.permission.actionProvider.registerMany(actions);
+  const pluginConfig = strapi.config.get(`plugin::${PLUGIN_ID$3}`);
+  if (pluginConfig?.openAIApiKey && pluginConfig?.neonConnectionString) {
+    try {
+      await pluginManager.initialize({
+        openAIApiKey: pluginConfig.openAIApiKey,
+        neonConnectionString: pluginConfig.neonConnectionString,
+        embeddingModel: pluginConfig.embeddingModel
+      });
+      strapi.contentEmbeddingsManager = pluginManager;
+      const pool = pluginManager.getPool();
+      if (pool) {
+        try {
+          await runYtMigration(pool);
+          strapi.log.info(`[${PLUGIN_ID$3}] YouTube vector tables ready`);
+        } catch (migrationErr) {
+          strapi.log.error(`[${PLUGIN_ID$3}] YT migration failed:`, migrationErr);
+        }
+      }
+      strapi.log.info(`[${PLUGIN_ID$3}] Plugin initialized successfully`);
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID$3}] Failed to initialize:`, error);
+    }
+  } else {
+    strapi.log.warn(
+      `[${PLUGIN_ID$3}] Missing configuration. Set openAIApiKey and neonConnectionString in plugin config.`
+    );
+  }
+  const plugin = strapi.plugin(PLUGIN_ID$3);
+  plugin.createMcpServer = () => createMcpServer(strapi);
+  plugin.sessions = /* @__PURE__ */ new Map();
+  const oauthPlugin = strapi.plugin(OAUTH_PLUGIN_ID);
+  if (oauthPlugin) {
+    strapi.log.info(`[${PLUGIN_ID$3}] OAuth manager detected - OAuth + API token auth enabled`);
+  } else {
+    const fallbackMiddleware = createFallbackAuthMiddleware();
+    strapi.server.use(fallbackMiddleware);
+    strapi.log.info(`[${PLUGIN_ID$3}] Using API token authentication (OAuth manager not installed)`);
+  }
+  strapi.log.info(`[${PLUGIN_ID$3}] MCP endpoint available at: /api/${PLUGIN_ID$3}/mcp`);
+  try {
+    strapi.db.lifecycles.subscribe({
+      models: ["plugin::yt-transcript-strapi-plugin.transcript"],
+      async afterCreate({ result }) {
+        strapi.plugin(PLUGIN_ID$3).service("ytEmbeddings").embedTranscript({
+          documentId: result.documentId,
+          id: result.id,
+          videoId: result.videoId,
+          title: result.title,
+          fullTranscript: result.fullTranscript,
+          transcriptWithTimeCodes: result.transcriptWithTimeCodes
+        }).catch((err) => strapi.log.error("[yt-embed] Pipeline failed:", err));
+      }
+    });
+    strapi.log.info(`[${PLUGIN_ID$3}] YouTube transcript lifecycle hook registered`);
+  } catch (err) {
+    strapi.log.warn(`[${PLUGIN_ID$3}] yt-transcript plugin not found, skipping YT lifecycle hook`);
+  }
+};
+const destroy = async ({ strapi }) => {
+  await pluginManager.destroy();
+  console.log("Content Embeddings plugin destroyed");
+};
+const register = (_args) => {
+};
+const contentTypes = {};
+const PLUGIN_ID$2 = "yt-embeddings-strapi-plugin";
+const YT_TRANSCRIPT_UID = "plugin::yt-transcript-strapi-plugin.transcript";
+const controller = ({ strapi }) => ({
+  async ytEmbed(ctx) {
+    try {
+      const { documentId } = ctx.request.body;
+      if (!documentId) {
+        ctx.throw(400, "documentId is required");
+        return;
+      }
+      const transcript = await strapi.documents(YT_TRANSCRIPT_UID).findOne({ documentId, fields: ["documentId", "videoId", "title", "fullTranscript", "transcriptWithTimeCodes"] });
+      if (!transcript) {
+        ctx.throw(404, `Transcript ${documentId} not found`);
+        return;
+      }
+      const t = transcript;
+      const result = await strapi.plugin(PLUGIN_ID$2).service("ytEmbeddings").embedTranscript({
+        documentId: t.documentId,
+        id: t.id,
+        videoId: t.videoId,
+        title: t.title,
+        fullTranscript: t.fullTranscript,
+        transcriptWithTimeCodes: t.transcriptWithTimeCodes
+      });
+      ctx.body = result;
+    } catch (error) {
+      if (error.status) throw error;
+      console.error("[ytEmbed] Error:", error.message);
+      ctx.throw(500, error.message || "Failed to embed transcript");
+    }
+  },
+  async ytListVideos(ctx) {
+    try {
+      const { page, pageSize, status } = ctx.query;
+      const result = await strapi.plugin(PLUGIN_ID$2).service("ytEmbeddings").listVideos({
+        page: page ? parseInt(page, 10) : 1,
+        pageSize: pageSize ? parseInt(pageSize, 10) : 100,
+        status
+      });
+      ctx.body = result;
+    } catch (error) {
+      console.error("[ytListVideos] Error:", error.message);
+      ctx.throw(500, error.message || "Failed to list videos");
+    }
+  },
+  async ytGetVideo(ctx) {
+    try {
+      const { videoId } = ctx.params;
+      const result = await strapi.plugin(PLUGIN_ID$2).service("ytEmbeddings").getVideo(videoId);
+      if (!result) {
+        ctx.throw(404, "Video not found");
+        return;
+      }
+      ctx.body = { data: result };
+    } catch (error) {
+      if (error.status) throw error;
+      ctx.throw(500, error.message || "Failed to get video");
+    }
+  },
+  async ytGetVideoChunks(ctx) {
+    try {
+      const { videoId } = ctx.params;
+      const { start, end } = ctx.query;
+      const result = await strapi.plugin(PLUGIN_ID$2).service("ytEmbeddings").getVideoChunks(videoId, {
+        start: start ? parseFloat(start) : void 0,
+        end: end ? parseFloat(end) : void 0
+      });
+      ctx.body = { data: result };
+    } catch (error) {
+      ctx.throw(500, error.message || "Failed to get video chunks");
+    }
+  },
+  async ytRecompute(ctx) {
+    try {
+      const result = await strapi.plugin(PLUGIN_ID$2).service("ytEmbeddings").recomputeAll();
+      ctx.body = result;
+    } catch (error) {
+      console.error("[ytRecompute] Error:", error.message);
+      ctx.throw(500, error.message || "Failed to recompute embeddings");
+    }
+  },
+  async ytStatus(ctx) {
+    try {
+      const { documentId } = ctx.params;
+      if (!documentId) {
+        ctx.throw(400, "documentId is required");
+        return;
+      }
+      const result = await strapi.plugin(PLUGIN_ID$2).service("ytEmbeddings").getStatusByDocumentId(documentId);
+      ctx.body = result;
+    } catch (error) {
+      if (error.status) throw error;
+      console.error("[ytStatus] Error:", error.message);
+      ctx.throw(500, error.message || "Failed to get status");
+    }
+  },
+  async queryEmbeddings(ctx) {
+    try {
+      const { query } = ctx.query;
+      if (!query?.trim()) {
+        ctx.body = { error: "Please provide a query" };
+        return;
+      }
+      const ytResults = await strapi.plugin(PLUGIN_ID$2).service("ytEmbeddings").search(query, { limit: 3, minSimilarity: 0.2, contextWindowSeconds: 30 });
+      if (!ytResults.length) {
+        ctx.body = { text: "No relevant transcript content found for your question.", sourceDocuments: [] };
+        return;
+      }
+      const context = ytResults.map(
+        (r) => `Video: "${r.title}" (${r.deepLink})
+Topics: ${(r.topics || []).join(", ")}
+
+${r.contextText || r.chunkText}`
+      ).join("\n\n---\n\n");
+      const chat = pluginManager.getChat();
+      if (!chat) {
+        ctx.body = {
+          text: ytResults.map((r) => `**${r.title}** (${r.deepLink})
+${r.chunkText}`).join("\n\n"),
+          sourceDocuments: ytResults.map((r) => ({
+            pageContent: r.chunkText,
+            metadata: { id: r.videoId, title: r.title, deepLink: r.deepLink }
+          }))
+        };
+        return;
+      }
+      const prompt = ChatPromptTemplate.fromMessages([
+        ["system", `You are a helpful assistant that answers questions based on YouTube transcript content.
+Include timestamps and video links when relevant. Be concise and accurate.
+If you cannot find the answer in the context, say so.
+
+Context:
+{context}`],
+        ["human", "{question}"]
+      ]);
+      const chain = prompt.pipe(chat);
+      const response = await chain.invoke({ context, question: query });
+      ctx.body = {
+        text: response.content,
+        sourceDocuments: ytResults.map((r) => ({
+          pageContent: r.chunkText,
+          metadata: { id: r.videoId, title: r.title, deepLink: r.deepLink }
+        }))
+      };
+    } catch (error) {
+      console.error("[queryEmbeddings] Error:", error.message);
+      ctx.throw(500, error.message || "Failed to query embeddings");
+    }
+  }
+});
+const PLUGIN_ID$1 = "yt-embeddings-strapi-plugin";
+const SESSION_TIMEOUT_MS = 4 * 60 * 60 * 1e3;
+function isSessionExpired(session) {
+  return Date.now() - session.createdAt > SESSION_TIMEOUT_MS;
+}
+function cleanupExpiredSessions(plugin, strapi) {
+  let cleaned = 0;
+  for (const [sessionId, session] of plugin.sessions.entries()) {
+    if (isSessionExpired(session)) {
+      try {
+        session.server.close();
+      } catch {
+      }
+      plugin.sessions.delete(sessionId);
+      cleaned++;
+    }
+  }
+  if (cleaned > 0) {
+    strapi.log.debug(`[${PLUGIN_ID$1}] Cleaned up ${cleaned} expired MCP sessions`);
+  }
+}
+const mcpController = ({ strapi }) => ({
+  /**
+   * Handle MCP requests (POST, GET, DELETE)
+   */
+  async handle(ctx) {
+    const plugin = strapi.plugin(PLUGIN_ID$1);
+    if (!plugin.createMcpServer) {
+      ctx.status = 503;
+      ctx.body = {
+        error: "MCP not initialized",
+        message: "The MCP server is not available. Check plugin configuration."
+      };
+      return;
+    }
+    if (Math.random() < 0.01) {
+      cleanupExpiredSessions(plugin, strapi);
+    }
+    try {
+      const requestedSessionId = ctx.request.headers["mcp-session-id"];
+      let session = requestedSessionId ? plugin.sessions.get(requestedSessionId) : null;
+      if (session && isSessionExpired(session)) {
+        strapi.log.debug(`[${PLUGIN_ID$1}] Session expired, removing: ${requestedSessionId}`);
+        try {
+          session.server.close();
+        } catch {
+        }
+        plugin.sessions.delete(requestedSessionId);
+        session = null;
+      }
+      if (requestedSessionId && !session) {
+        ctx.status = 400;
+        ctx.body = {
+          jsonrpc: "2.0",
+          error: {
+            code: -32e3,
+            message: "Session expired or invalid. Please reinitialize the connection."
+          },
+          id: null
+        };
+        return;
+      }
+      if (!session) {
+        const sessionId = randomUUID();
+        const server = plugin.createMcpServer();
+        const transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => sessionId
+        });
+        await server.connect(transport);
+        session = {
+          server,
+          transport,
+          createdAt: Date.now(),
+          strapiToken: ctx.state.strapiToken
+        };
+        plugin.sessions.set(sessionId, session);
+        strapi.log.debug(
+          `[${PLUGIN_ID$1}] New MCP session created: ${sessionId} (auth: ${ctx.state.authMethod || "unknown"})`
+        );
+      }
+      try {
+        await session.transport.handleRequest(ctx.req, ctx.res, ctx.request.body);
+      } catch (transportError) {
+        strapi.log.warn(`[${PLUGIN_ID$1}] Transport error, cleaning up session: ${requestedSessionId}`, {
+          error: transportError instanceof Error ? transportError.message : String(transportError)
+        });
+        try {
+          session.server.close();
+        } catch {
+        }
+        plugin.sessions.delete(requestedSessionId);
+        if (!ctx.res.headersSent) {
+          ctx.status = 400;
+          ctx.body = {
+            jsonrpc: "2.0",
+            error: {
+              code: -32e3,
+              message: "Session transport error. Please reinitialize the connection."
+            },
+            id: null
+          };
+        }
+        return;
+      }
+      ctx.respond = false;
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID$1}] Error handling MCP request`, {
+        error: error instanceof Error ? error.message : String(error),
+        method: ctx.method,
+        path: ctx.path
+      });
+      if (!ctx.res.headersSent) {
+        ctx.status = 500;
+        ctx.body = {
+          error: "MCP request failed",
+          message: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  }
+});
+const PLUGIN_ID = "yt-embeddings-strapi-plugin";
+const ytController = ({ strapi }) => ({
+  // POST /api/yt-embeddings-strapi-plugin/yt/ingest
+  async ingest(ctx) {
+    try {
+      const { documentId } = ctx.request.body;
+      if (!documentId) {
+        ctx.throw(400, "documentId is required");
+      }
+      const transcript = await strapi.documents("plugin::yt-transcript-strapi-plugin.transcript").findOne({ documentId, fields: ["documentId", "videoId", "title", "fullTranscript", "transcriptWithTimeCodes"] });
+      if (!transcript) {
+        ctx.throw(404, `Transcript ${documentId} not found`);
+      }
+      const t = transcript;
+      const result = await strapi.plugin(PLUGIN_ID).service("ytEmbeddings").embedTranscript({
+        documentId: t.documentId,
+        id: t.id,
+        videoId: t.videoId,
+        title: t.title,
+        fullTranscript: t.fullTranscript,
+        transcriptWithTimeCodes: t.transcriptWithTimeCodes
+      });
+      ctx.body = result;
+    } catch (error) {
+      if (error.status) throw error;
+      ctx.throw(500, error.message || "Failed to ingest transcript");
+    }
+  },
+  // GET /api/yt-embeddings-strapi-plugin/yt/videos
+  async listVideos(ctx) {
+    try {
+      const { page, pageSize, status } = ctx.query;
+      const result = await strapi.plugin(PLUGIN_ID).service("ytEmbeddings").listVideos({
+        page: page ? parseInt(page, 10) : 1,
+        pageSize: pageSize ? parseInt(pageSize, 10) : 25,
+        status
+      });
+      ctx.body = result;
+    } catch (error) {
+      ctx.throw(500, error.message || "Failed to list videos");
+    }
+  },
+  // GET /api/yt-embeddings-strapi-plugin/yt/videos/:videoId
+  async getVideo(ctx) {
+    try {
+      const { videoId } = ctx.params;
+      const result = await strapi.plugin(PLUGIN_ID).service("ytEmbeddings").getVideo(videoId);
+      if (!result) {
+        ctx.throw(404, `Video ${videoId} not found`);
+      }
+      ctx.body = result;
+    } catch (error) {
+      if (error.status) throw error;
+      ctx.throw(500, error.message || "Failed to get video");
+    }
+  },
+  // DELETE /api/yt-embeddings-strapi-plugin/yt/videos/:videoId
+  async deleteVideo(ctx) {
+    try {
+      const { videoId } = ctx.params;
+      const result = await strapi.plugin(PLUGIN_ID).service("ytEmbeddings").deleteVideo(videoId);
+      if (!result) {
+        ctx.throw(404, `Video ${videoId} not found`);
+      }
+      ctx.body = result;
+    } catch (error) {
+      if (error.status) throw error;
+      ctx.throw(500, error.message || "Failed to delete video");
+    }
+  },
+  // GET /api/yt-embeddings-strapi-plugin/yt/search?q=...&limit=5&videoId=...&topics=RAG,MCP
+  async search(ctx) {
+    try {
+      const { q, limit, videoId, topics, minSimilarity, contextWindowSeconds } = ctx.query;
+      if (!q) {
+        ctx.throw(400, 'Query parameter "q" is required');
+      }
+      const result = await strapi.plugin(PLUGIN_ID).service("ytEmbeddings").search(q, {
+        limit: limit ? parseInt(limit, 10) : 5,
+        minSimilarity: minSimilarity ? parseFloat(minSimilarity) : 0.65,
+        videoId,
+        topics: topics ? topics.split(",") : void 0,
+        contextWindowSeconds: contextWindowSeconds ? parseInt(contextWindowSeconds, 10) : 30
+      });
+      ctx.body = result;
+    } catch (error) {
+      if (error.status) throw error;
+      ctx.throw(500, error.message || "Failed to search");
+    }
+  },
+  // GET /api/yt-embeddings-strapi-plugin/yt/videos/:videoId/chunks?start=60&end=120
+  async getVideoChunks(ctx) {
+    try {
+      const { videoId } = ctx.params;
+      const { start, end } = ctx.query;
+      const result = await strapi.plugin(PLUGIN_ID).service("ytEmbeddings").getVideoChunks(videoId, {
+        start: start !== void 0 ? parseFloat(start) : void 0,
+        end: end !== void 0 ? parseFloat(end) : void 0
+      });
+      ctx.body = result;
+    } catch (error) {
+      ctx.throw(500, error.message || "Failed to get video chunks");
+    }
+  },
+  // POST /api/yt-embeddings-strapi-plugin/yt/recompute
+  async recompute(ctx) {
+    try {
+      const result = await strapi.plugin(PLUGIN_ID).service("ytEmbeddings").recomputeAll();
+      ctx.body = result;
+    } catch (error) {
+      ctx.throw(500, error.message || "Failed to recompute");
+    }
+  }
+});
+const controllers = {
+  controller,
+  mcp: mcpController,
+  ytController
+};
+const middlewares = {};
+const policies = {};
+const contentApi = [
+  // MCP routes - auth handled by middleware
+  {
+    method: "POST",
+    path: "/mcp",
+    handler: "mcp.handle",
+    config: {
+      auth: false,
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/mcp",
+    handler: "mcp.handle",
+    config: {
+      auth: false,
+      policies: []
+    }
+  },
+  {
+    method: "DELETE",
+    path: "/mcp",
+    handler: "mcp.handle",
+    config: {
+      auth: false,
+      policies: []
+    }
+  },
+  // YouTube Knowledge Base API routes
+  {
+    method: "POST",
+    path: "/yt/ingest",
+    handler: "ytController.ingest",
+    config: {
+      description: "Ingest a transcript by documentId"
+    }
+  },
+  {
+    method: "GET",
+    path: "/yt/videos",
+    handler: "ytController.listVideos",
+    config: {
+      description: "List all ingested videos with metadata"
+    }
+  },
+  {
+    method: "GET",
+    path: "/yt/videos/:videoId",
+    handler: "ytController.getVideo",
+    config: {
+      description: "Get a single video with metadata"
+    }
+  },
+  {
+    method: "DELETE",
+    path: "/yt/videos/:videoId",
+    handler: "ytController.deleteVideo",
+    config: {
+      description: "Delete a video and all its chunks"
+    }
+  },
+  {
+    method: "GET",
+    path: "/yt/search",
+    handler: "ytController.search",
+    config: {
+      description: "Semantic search across transcripts"
+    }
+  },
+  {
+    method: "GET",
+    path: "/yt/videos/:videoId/chunks",
+    handler: "ytController.getVideoChunks",
+    config: {
+      description: "Get chunks for a video by time range"
+    }
+  },
+  {
+    method: "POST",
+    path: "/yt/recompute",
+    handler: "ytController.recompute",
+    config: {
+      description: "Re-embed all transcripts"
+    }
+  }
+];
+const admin = [
+  {
+    method: "GET",
+    path: "/yt/videos",
+    handler: "controller.ytListVideos",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::yt-embeddings-strapi-plugin.read"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "GET",
+    path: "/yt/videos/:videoId",
+    handler: "controller.ytGetVideo",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::yt-embeddings-strapi-plugin.read"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "GET",
+    path: "/yt/videos/:videoId/chunks",
+    handler: "controller.ytGetVideoChunks",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::yt-embeddings-strapi-plugin.read"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "GET",
+    path: "/yt/status/:documentId",
+    handler: "controller.ytStatus",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::yt-embeddings-strapi-plugin.read"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "POST",
+    path: "/yt/embed",
+    handler: "controller.ytEmbed",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::yt-embeddings-strapi-plugin.create"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "POST",
+    path: "/yt/recompute",
+    handler: "controller.ytRecompute",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::yt-embeddings-strapi-plugin.update"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "GET",
+    path: "/embeddings/embeddings-query",
+    handler: "controller.queryEmbeddings",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::yt-embeddings-strapi-plugin.chat"] }
+        }
+      ]
+    }
+  }
+];
+const routes = {
+  "content-api": {
+    type: "content-api",
+    routes: [...contentApi]
+  },
+  admin: {
+    type: "admin",
+    routes: [...admin]
+  }
+};
+function formatTime$2(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+const searchYtKnowledgeTool = {
+  name: "searchYtKnowledge",
+  description: "Semantically search YouTube video transcripts. Returns relevant passages with timestamps, deep links, video topics, and summary.",
+  schema: SearchYtKnowledgeSchema,
+  execute: async (args, strapi) => {
+    const validated = SearchYtKnowledgeSchema.parse(args);
+    const results = await strapi.plugin("yt-embeddings-strapi-plugin").service("ytEmbeddings").search(validated.query, {
+      limit: validated.limit,
+      minSimilarity: validated.minSimilarity,
+      videoId: validated.videoId,
+      topics: validated.topics,
+      contextWindowSeconds: validated.contextWindowSeconds
+    });
+    if (!results.length) {
+      return { results: [], message: "No relevant content found." };
+    }
+    return {
+      results: results.map((r, i) => ({
+        rank: i + 1,
+        similarity: r.similarity,
+        title: r.title,
+        topics: r.topics,
+        videoSummary: r.videoSummary,
+        timestamp: `${formatTime$2(r.startSeconds)} – ${formatTime$2(r.endSeconds)}`,
+        deepLink: r.deepLink,
+        contextText: r.contextText
+      }))
+    };
+  },
+  publicSafe: true
+};
+function formatTime$1(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+const getVideoTranscriptRangeTool = {
+  name: "getVideoTranscriptRange",
+  description: 'Get the raw transcript text for a specific time range in a YouTube video. Useful for "what was said around 5:30" type queries.',
+  schema: GetVideoTranscriptRangeSchema,
+  execute: async (args, strapi) => {
+    const validated = GetVideoTranscriptRangeSchema.parse(args);
+    const rows = await strapi.plugin("yt-embeddings-strapi-plugin").service("ytEmbeddings").getTranscriptRange(validated.videoId, validated.startSeconds, validated.endSeconds);
+    if (!rows.length) {
+      return {
+        transcript: null,
+        message: `No transcript found for video ${validated.videoId} in that time range.`
+      };
+    }
+    const text = rows.flatMap((r) => r.segments).filter((s) => s.end / 1e3 > validated.startSeconds && s.start / 1e3 < validated.endSeconds).map((s) => s.text).join(" ").replace(/\s+/g, " ").trim();
+    return {
+      videoId: validated.videoId,
+      range: `${formatTime$1(validated.startSeconds)}–${formatTime$1(validated.endSeconds)}`,
+      transcript: text,
+      deepLink: `https://www.youtube.com/watch?v=${validated.videoId}&t=${Math.floor(validated.startSeconds)}`
+    };
+  },
+  publicSafe: true
+};
+function formatDuration(seconds) {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  const s = Math.floor(seconds % 60);
+  return h > 0 ? `${h}:${m.toString().padStart(2, "0")}:${s.toString().padStart(2, "0")}` : `${m}:${s.toString().padStart(2, "0")}`;
+}
+const listYtVideosTool = {
+  name: "listYtVideos",
+  description: "List all ingested YouTube videos with their topics, chunk count, and duration. Useful for discovering available content before searching.",
+  schema: ListYtVideosSchema,
+  execute: async (args, strapi) => {
+    const validated = ListYtVideosSchema.parse(args);
+    const result = await strapi.plugin("yt-embeddings-strapi-plugin").service("ytEmbeddings").listVideos({
+      page: validated.page,
+      pageSize: validated.pageSize
+    });
+    return {
+      videos: result.data.map((v) => ({
+        videoId: v.video_id,
+        title: v.title,
+        topics: v.topics,
+        duration: v.duration_seconds ? formatDuration(v.duration_seconds) : null,
+        chunkCount: v.chunk_count,
+        embeddingStatus: v.embedding_status
+      })),
+      pagination: {
+        page: result.page,
+        pageSize: result.pageSize,
+        total: result.total,
+        pageCount: Math.ceil(result.total / result.pageSize)
+      }
+    };
+  },
+  publicSafe: true
+};
+function formatTime(seconds) {
+  const m = Math.floor(seconds / 60);
+  const s = Math.floor(seconds % 60);
+  return `${m}:${s.toString().padStart(2, "0")}`;
+}
+const getYtVideoSummaryTool = {
+  name: "getYtVideoSummary",
+  description: "Get a YouTube video's summary, topics, and key moments by video ID. Useful for understanding what a video covers without searching.",
+  schema: GetYtVideoSummarySchema,
+  execute: async (args, strapi) => {
+    const validated = GetYtVideoSummarySchema.parse(args);
+    const video = await strapi.plugin("yt-embeddings-strapi-plugin").service("ytEmbeddings").getVideo(validated.videoId);
+    if (!video) {
+      return { error: true, message: `Video ${validated.videoId} not found.` };
+    }
+    return {
+      videoId: video.video_id,
+      title: video.title,
+      topics: video.topics,
+      summary: video.summary || null,
+      chunkCount: video.chunk_count,
+      embeddingStatus: video.embedding_status,
+      watchLink: `https://www.youtube.com/watch?v=${video.video_id}`,
+      keyMoments: video.key_moments?.map((km) => ({
+        timestamp: formatTime(km.timestampSeconds),
+        label: km.label
+      })) || []
+    };
+  },
+  publicSafe: true
+};
+const tools = [
+  searchYtKnowledgeTool,
+  getVideoTranscriptRangeTool,
+  listYtVideosTool,
+  getYtVideoSummaryTool
+];
+const aiTools = ({ strapi }) => ({
+  getTools() {
+    return tools;
+  }
+});
+const TARGET_MS = 6e4;
+const MAX_MS = 9e4;
+const MIN_MS = 15e3;
+function chunkTranscript(segments) {
+  if (!segments.length) return [];
+  validateSegments(segments);
+  const chunks = [];
+  let buffer = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const next = segments[i + 1];
+    buffer.push(seg);
+    const bufferDurationMs = buffer[buffer.length - 1].end - buffer[0].start;
+    const isLast = !next;
+    const atHardCap = bufferDurationMs >= MAX_MS;
+    const atTarget = bufferDurationMs >= TARGET_MS;
+    const pauseAfterMs = next ? next.start - seg.end : Infinity;
+    const isNaturalPause = pauseAfterMs > 1e3;
+    const endsSentence = /[.!?]\s*$/.test(seg.text.trim());
+    const shouldFlush = isLast || atHardCap || atTarget && (isNaturalPause || endsSentence);
+    if (shouldFlush && (bufferDurationMs >= MIN_MS || isLast)) {
+      const text = buffer.map((s) => s.text).join(" ").replace(/\s+/g, " ").trim();
+      chunks.push({
+        text,
+        startSeconds: buffer[0].start / 1e3,
+        endSeconds: buffer[buffer.length - 1].end / 1e3,
+        durationSeconds: bufferDurationMs / 1e3,
+        chunkIndex: chunks.length,
+        segments: buffer.map((s) => ({ ...s })),
+        tokens: Math.ceil(text.split(/\s+/).length / 0.75)
+      });
+      buffer = [];
+    }
+  }
+  if (buffer.length > 0) {
+    const text = buffer.map((s) => s.text).join(" ").replace(/\s+/g, " ").trim();
+    if (text.length > 20) {
+      chunks.push({
+        text,
+        startSeconds: buffer[0].start / 1e3,
+        endSeconds: buffer[buffer.length - 1].end / 1e3,
+        durationSeconds: (buffer[buffer.length - 1].end - buffer[0].start) / 1e3,
+        chunkIndex: chunks.length,
+        segments: buffer.map((s) => ({ ...s })),
+        tokens: Math.ceil(text.split(/\s+/).length / 0.75)
+      });
+    }
+  }
+  validateChunkBoundaries(chunks);
+  return chunks;
+}
+function validateSegments(segments) {
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (seg.end <= seg.start) {
+      throw new Error(`[yt-chunker] Segment ${i}: end(${seg.end}) <= start(${seg.start})`);
+    }
+    if (i > 0 && seg.start < segments[i - 1].end) {
+      seg.start = segments[i - 1].end;
+      seg.duration = seg.end - seg.start;
+    }
+  }
+}
+function validateChunkBoundaries(chunks) {
+  for (let i = 1; i < chunks.length; i++) {
+    const prev = chunks[i - 1];
+    const curr = chunks[i];
+    if (curr.startSeconds < prev.endSeconds - 0.1) {
+      throw new Error(
+        `[yt-chunker] Chunk ${i} overlaps chunk ${i - 1}: prev ends ${prev.endSeconds}s, curr starts ${curr.startSeconds}s`
+      );
+    }
+  }
+}
+const metadataSchema = z.object({
+  topics: z.array(z.string()).max(8),
+  summary: z.string().max(400),
+  keyMoments: z.array(z.object({
+    label: z.string(),
+    startSeconds: z.number(),
+    summary: z.string().max(150)
+  })).max(10),
+  language: z.string().default("en")
+});
+async function extractVideoMetadata(title, fullTranscript, durationSeconds, openAIApiKey) {
+  const llm = new ChatOpenAI({
+    modelName: "gpt-4o-mini",
+    temperature: 0,
+    openAIApiKey
+  });
+  const structured = llm.withStructuredOutput(metadataSchema);
+  const words = fullTranscript.split(/\s+/);
+  const sample = words.length > 4e3 ? [...words.slice(0, 2e3), "...", ...words.slice(-2e3)].join(" ") : fullTranscript;
+  const result = await structured.invoke(`
+Video title: "${title}"
+Duration: ${Math.floor(durationSeconds / 60)} minutes
+
+Transcript (may be truncated for long videos):
+"""
+${sample}
+"""
+
+Extract:
+- topics: key subjects covered (use specific terms, not generic like "technology")
+- summary: 2-3 sentences describing what the video teaches or argues
+- keyMoments: the 5-8 most important moments, with approximate start time in seconds
+- language: ISO 639-1 language code of the transcript
+  `.trim());
+  return {
+    topics: result.topics ?? [],
+    summary: result.summary ?? "",
+    keyMoments: result.keyMoments ?? [],
+    language: result.language ?? "en"
+  };
+}
+function computeContentHash(content) {
+  return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+const ytEmbeddings = ({ strapi }) => ({
+  // ── Ingest a single transcript ──────────────────────────────────────────────
+  async embedTranscript(transcript) {
+    const pool = pluginManager.getPool();
+    const embeddings = pluginManager.getEmbeddings();
+    const embeddingModel = pluginManager.getEmbeddingModel();
+    if (!pool || !embeddings) {
+      throw new Error("[yt-embed] Plugin manager not initialized");
+    }
+    const contentHash = computeContentHash(transcript.fullTranscript);
+    const existing = await pool.query(
+      "SELECT id, embedding_status, content_hash FROM yt_videos WHERE video_id = $1",
+      [transcript.videoId]
+    );
+    if (existing.rows.length > 0) {
+      const row = existing.rows[0];
+      if (row.embedding_status === "complete" && row.content_hash === contentHash) {
+        strapi.log.info(`[yt-embed] ${transcript.videoId} already ingested, skipping`);
+        return { videoId: transcript.videoId, chunkCount: 0, skipped: true };
+      }
+      strapi.log.info(`[yt-embed] Re-ingesting ${transcript.videoId} (status: ${row.embedding_status}, hash changed: ${row.content_hash !== contentHash})`);
+      await pool.query("DELETE FROM yt_videos WHERE video_id = $1", [transcript.videoId]);
+    }
+    const segs = transcript.transcriptWithTimeCodes;
+    const durationSeconds = segs.length > 0 ? Math.floor(segs[segs.length - 1].end / 1e3) : 0;
+    await pool.query(
+      `INSERT INTO yt_videos
+        (strapi_document_id, video_id, url, title, duration_seconds,
+         content_hash, embedding_status, embedding_model)
+       VALUES ($1, $2, $3, $4, $5, $6, 'processing', $7)`,
+      [
+        transcript.documentId,
+        transcript.videoId,
+        `https://www.youtube.com/watch?v=${transcript.videoId}`,
+        transcript.title,
+        durationSeconds,
+        contentHash,
+        embeddingModel
+      ]
+    );
+    try {
+      const config2 = strapi.config.get("plugin::yt-embeddings-strapi-plugin");
+      let topics = [];
+      let summary = "";
+      let keyMoments = [];
+      let language = "en";
+      try {
+        const meta = await extractVideoMetadata(
+          transcript.title,
+          transcript.fullTranscript,
+          durationSeconds,
+          config2.openAIApiKey
+        );
+        topics = meta.topics;
+        summary = meta.summary;
+        keyMoments = meta.keyMoments;
+        language = meta.language;
+        strapi.log.info(`[yt-embed] Metadata extracted: ${topics.length} topics, ${keyMoments.length} key moments`);
+      } catch (err) {
+        strapi.log.warn(`[yt-embed] Metadata extraction failed, continuing without it:`, err);
+      }
+      const chunks = chunkTranscript(transcript.transcriptWithTimeCodes);
+      if (chunks.length === 0) {
+        await pool.query(
+          `UPDATE yt_videos
+           SET embedding_status = 'complete', chunk_count = 0, embedded_at = NOW(),
+               topics = $1, summary = $2, key_moments = $3, language = $4, updated_at = NOW()
+           WHERE video_id = $5`,
+          [topics, summary, JSON.stringify(keyMoments), language, transcript.videoId]
+        );
+        strapi.log.info(`[yt-embed] ${transcript.title} — no chunks (empty transcript)`);
+        return { videoId: transcript.videoId, chunkCount: 0, skipped: false };
+      }
+      const embeddingVectors = await embeddings.embedDocuments(chunks.map((c) => c.text));
+      const insertedIds = [];
+      for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        const vectorStr = `[${embeddingVectors[i].join(",")}]`;
+        const result = await pool.query(
+          `INSERT INTO yt_video_chunks
+            (video_id, strapi_document_id, text, embedding,
+             start_seconds, end_seconds, chunk_index, segments, tokens)
+           VALUES ($1, $2, $3, $4::vector, $5, $6, $7, $8, $9)
+           RETURNING id`,
+          [
+            transcript.videoId,
+            transcript.documentId,
+            chunk.text,
+            vectorStr,
+            chunk.startSeconds,
+            chunk.endSeconds,
+            i,
+            JSON.stringify(chunk.segments),
+            chunk.tokens
+          ]
+        );
+        insertedIds.push(result.rows[0].id);
+      }
+      for (let i = 0; i < insertedIds.length; i++) {
+        await pool.query(
+          "UPDATE yt_video_chunks SET prev_chunk_id = $1, next_chunk_id = $2 WHERE id = $3",
+          [insertedIds[i - 1] ?? null, insertedIds[i + 1] ?? null, insertedIds[i]]
+        );
+      }
+      await pool.query(
+        `UPDATE yt_videos
+         SET embedding_status = 'complete', chunk_count = $1, embedded_at = NOW(),
+             topics = $2, summary = $3, key_moments = $4, language = $5, updated_at = NOW()
+         WHERE video_id = $6`,
+        [chunks.length, topics, summary, JSON.stringify(keyMoments), language, transcript.videoId]
+      );
+      strapi.log.info(`[yt-embed] ${transcript.title} — ${chunks.length} chunks embedded`);
+      return { videoId: transcript.videoId, chunkCount: chunks.length, skipped: false };
+    } catch (err) {
+      await pool.query(
+        `UPDATE yt_videos SET embedding_status = 'failed', error_message = $1, updated_at = NOW() WHERE video_id = $2`,
+        [String(err), transcript.videoId]
+      );
+      throw err;
+    }
+  },
+  // ── Semantic search with context expansion ──────────────────────────────────
+  async search(query, options = {}) {
+    const pool = pluginManager.getPool();
+    const embeddingsClient = pluginManager.getEmbeddings();
+    if (!pool || !embeddingsClient) {
+      throw new Error("[yt-embed] Plugin manager not initialized");
+    }
+    const { limit = 5, minSimilarity = 0.2, contextWindowSeconds = 30 } = options;
+    const queryVector = await embeddingsClient.embedQuery(query);
+    const vectorStr = `[${queryVector.join(",")}]`;
+    const params = [vectorStr, minSimilarity, limit * 2];
+    const filters = [];
+    if (options.videoId) {
+      params.push(options.videoId);
+      filters.push(`vc.video_id = $${params.length}`);
+    }
+    if (options.topics?.length) {
+      params.push(options.topics);
+      filters.push(`v.topics && $${params.length}::text[]`);
+    }
+    const whereExtra = filters.length > 0 ? "AND " + filters.join(" AND ") : "";
+    const rows = await pool.query(`
+      SELECT
+        vc.id, vc.video_id, vc.text, vc.start_seconds, vc.end_seconds,
+        vc.chunk_index, vc.segments, vc.strapi_document_id,
+        vc.prev_chunk_id, vc.next_chunk_id,
+        v.title, v.channel_name, v.summary AS video_summary,
+        v.topics, v.duration_seconds,
+        1 - (vc.embedding <=> $1::vector) AS similarity
+      FROM yt_video_chunks vc
+      JOIN yt_videos v ON v.video_id = vc.video_id
+      WHERE 1 - (vc.embedding <=> $1::vector) >= $2
+        AND v.embedding_status = 'complete'
+        ${whereExtra}
+      ORDER BY vc.embedding <=> $1::vector
+      LIMIT $3
+    `, params);
+    if (!rows.rows.length) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = rows.rows.filter((row) => {
+      if (seen.has(row.prev_chunk_id) || seen.has(row.next_chunk_id)) return false;
+      seen.add(row.id);
+      return true;
+    }).slice(0, limit);
+    return Promise.all(deduped.map(async (row) => {
+      const half = contextWindowSeconds / 2;
+      const ctxStart = Math.max(0, row.start_seconds - half);
+      const ctxEnd = Math.min(
+        row.duration_seconds ?? row.end_seconds + half,
+        row.end_seconds + half
+      );
+      const ctxRows = await pool.query(`
+        SELECT segments, start_seconds, end_seconds
+        FROM yt_video_chunks
+        WHERE video_id = $1
+          AND start_seconds < $2
+          AND end_seconds   > $3
+        ORDER BY start_seconds
+      `, [row.video_id, ctxEnd, ctxStart]);
+      const contextText = buildContextText(
+        ctxRows.rows,
+        ctxStart,
+        ctxEnd,
+        row.start_seconds,
+        row.end_seconds
+      );
+      return {
+        chunkText: row.text,
+        startSeconds: row.start_seconds,
+        endSeconds: row.end_seconds,
+        similarity: Math.round(row.similarity * 1e3) / 1e3,
+        contextText,
+        videoId: row.video_id,
+        title: row.title,
+        channelName: row.channel_name,
+        videoSummary: row.video_summary,
+        topics: row.topics,
+        strapiDocumentId: row.strapi_document_id,
+        deepLink: `https://www.youtube.com/watch?v=${row.video_id}&t=${Math.floor(row.start_seconds)}`,
+        contextLink: `https://www.youtube.com/watch?v=${row.video_id}&t=${Math.floor(ctxStart)}`
+      };
+    }));
+  },
+  // ── Get transcript range for a specific video ──────────────────────────────
+  async getTranscriptRange(videoId, startSeconds, endSeconds) {
+    const pool = pluginManager.getPool();
+    if (!pool) throw new Error("[yt-embed] Plugin manager not initialized");
+    const rows = await pool.query(`
+      SELECT text, start_seconds, end_seconds, segments
+      FROM yt_video_chunks
+      WHERE video_id = $1
+        AND start_seconds < $3
+        AND end_seconds   > $2
+      ORDER BY start_seconds
+    `, [videoId, startSeconds, endSeconds]);
+    return rows.rows;
+  },
+  // ── List all ingested videos ────────────────────────────────────────────────
+  async listVideos(options = {}) {
+    const pool = pluginManager.getPool();
+    if (!pool) throw new Error("[yt-embed] Plugin manager not initialized");
+    const { page = 1, pageSize = 25, status } = options;
+    const offset = (page - 1) * pageSize;
+    const params = [pageSize, offset];
+    let statusFilter = "";
+    if (status) {
+      params.push(status);
+      statusFilter = `WHERE embedding_status = $${params.length}`;
+    }
+    const [dataResult, countResult] = await Promise.all([
+      pool.query(`
+        SELECT id, strapi_document_id, video_id, url, title, channel_name,
+               duration_seconds, language, topics, summary, key_moments,
+               embedding_status, chunk_count, embedded_at, created_at
+        FROM yt_videos
+        ${statusFilter}
+        ORDER BY created_at DESC
+        LIMIT $1 OFFSET $2
+      `, params),
+      pool.query(
+        `SELECT count(*)::int FROM yt_videos ${statusFilter}`,
+        status ? [status] : []
+      )
+    ]);
+    return {
+      data: dataResult.rows,
+      total: countResult.rows[0].count,
+      page,
+      pageSize
+    };
+  },
+  // ── Get single video with key moments ──────────────────────────────────────
+  async getVideo(videoId) {
+    const pool = pluginManager.getPool();
+    if (!pool) throw new Error("[yt-embed] Plugin manager not initialized");
+    const result = await pool.query(
+      "SELECT * FROM yt_videos WHERE video_id = $1",
+      [videoId]
+    );
+    return result.rows[0] ?? null;
+  },
+  // ── Delete a video and all its chunks ──────────────────────────────────────
+  async deleteVideo(videoId) {
+    const pool = pluginManager.getPool();
+    if (!pool) throw new Error("[yt-embed] Plugin manager not initialized");
+    const result = await pool.query(
+      "DELETE FROM yt_videos WHERE video_id = $1 RETURNING id, title, chunk_count",
+      [videoId]
+    );
+    return result.rows[0] ?? null;
+  },
+  // ── Get chunks for a video by time range ───────────────────────────────────
+  async getVideoChunks(videoId, options = {}) {
+    const pool = pluginManager.getPool();
+    if (!pool) throw new Error("[yt-embed] Plugin manager not initialized");
+    const params = [videoId];
+    let timeFilter = "";
+    if (options.start !== void 0 && options.end !== void 0) {
+      params.push(options.end, options.start);
+      timeFilter = `AND start_seconds < $${params.length - 1} AND end_seconds > $${params.length}`;
+    }
+    const result = await pool.query(`
+      SELECT id, text, start_seconds, end_seconds, chunk_index, segments, tokens
+      FROM yt_video_chunks
+      WHERE video_id = $1 ${timeFilter}
+      ORDER BY chunk_index
+    `, params);
+    return result.rows;
+  },
+  // ── Check embedding status by Strapi document ID ─────────────────────────
+  async getStatusByDocumentId(documentId) {
+    const pool = pluginManager.getPool();
+    if (!pool) throw new Error("[yt-embed] Plugin manager not initialized");
+    const result = await pool.query(
+      "SELECT video_id, chunk_count, embedded_at, embedding_status FROM yt_videos WHERE strapi_document_id = $1",
+      [documentId]
+    );
+    if (!result.rows.length) return { embedded: false };
+    const row = result.rows[0];
+    return {
+      embedded: row.embedding_status === "complete",
+      videoId: row.video_id,
+      chunkCount: row.chunk_count,
+      embeddedAt: row.embedded_at
+    };
+  },
+  // ── Re-embed all transcripts ───────────────────────────────────────────────
+  async recomputeAll() {
+    const pool = pluginManager.getPool();
+    if (!pool) throw new Error("[yt-embed] Plugin manager not initialized");
+    strapi.log.info("[yt-embed] Recompute: dropping all yt data...");
+    await pool.query("DELETE FROM yt_video_chunks");
+    await pool.query("DELETE FROM yt_videos");
+    const transcripts = await strapi.documents("plugin::yt-transcript-strapi-plugin.transcript").findMany({ fields: ["documentId", "videoId", "title", "fullTranscript", "transcriptWithTimeCodes"] });
+    let processed = 0;
+    for (const t of transcripts) {
+      try {
+        await this.embedTranscript({
+          documentId: t.documentId,
+          id: t.id,
+          videoId: t.videoId,
+          title: t.title,
+          fullTranscript: t.fullTranscript,
+          transcriptWithTimeCodes: t.transcriptWithTimeCodes
+        });
+        processed++;
+      } catch (err) {
+        strapi.log.error(`[yt-embed] Failed to embed ${t.videoId}:`, err);
+      }
+    }
+    strapi.log.info(`[yt-embed] Recompute complete. ${processed}/${transcripts.length} videos embedded.`);
+    return { total: transcripts.length, processed };
+  }
+});
+function buildContextText(rows, ctxStart, ctxEnd, matchStart, matchEnd) {
+  const parts = [];
+  let inMatch = false;
+  for (const row of rows) {
+    const segs = row.segments;
+    for (const seg of segs) {
+      const s = seg.start / 1e3;
+      const e = seg.end / 1e3;
+      if (e <= ctxStart || s >= ctxEnd) continue;
+      if (!inMatch && s >= matchStart) {
+        parts.push("[RELEVANT]");
+        inMatch = true;
+      }
+      if (inMatch && s >= matchEnd) {
+        parts.push("[/RELEVANT]");
+        inMatch = false;
+      }
+      parts.push(seg.text);
+    }
+  }
+  if (inMatch) parts.push("[/RELEVANT]");
+  return parts.join(" ").replace(/\s+/g, " ").trim();
+}
+const services = {
+  "ai-tools": aiTools,
+  ytEmbeddings
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};