yt-embeddings-strapi-plugin 0.0.1

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from "@strapi/strapi";
+declare const bootstrap: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default bootstrap;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,38 @@
+export declare const EMBEDDING_MODELS: {
+    readonly "text-embedding-3-small": {
+        readonly dimensions: 1536;
+    };
+    readonly "text-embedding-3-large": {
+        readonly dimensions: 3072;
+    };
+    readonly "text-embedding-ada-002": {
+        readonly dimensions: 1536;
+    };
+};
+export type EmbeddingModelName = keyof typeof EMBEDDING_MODELS;
+export interface PluginConfigSchema {
+    openAIApiKey?: string;
+    neonConnectionString?: string;
+    embeddingModel?: EmbeddingModelName;
+    /** Maximum characters per chunk (default: 4000, roughly ~1000 tokens) */
+    chunkSize?: number;
+    /** Number of characters to overlap between chunks (default: 200) */
+    chunkOverlap?: number;
+    /** Automatically chunk content that exceeds chunkSize (default: false) */
+    autoChunk?: boolean;
+    /** Preprocess content before embedding - strips HTML/Markdown (default: true) */
+    preprocessContent?: boolean;
+}
+declare const _default: {
+    default: {
+        openAIApiKey: string;
+        neonConnectionString: string;
+        embeddingModel: "text-embedding-3-small" | "text-embedding-3-large" | "text-embedding-ada-002";
+        chunkSize: number;
+        chunkOverlap: number;
+        autoChunk: boolean;
+        preprocessContent: boolean;
+    };
+    validator(config: PluginConfigSchema): void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/controllers/controller.d.ts

@@ -0,0 +1,13 @@
+import type { Core } from "@strapi/strapi";
+declare const controller: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    ytEmbed(ctx: any): Promise<void>;
+    ytListVideos(ctx: any): Promise<void>;
+    ytGetVideo(ctx: any): Promise<void>;
+    ytGetVideoChunks(ctx: any): Promise<void>;
+    ytRecompute(ctx: any): Promise<void>;
+    ytStatus(ctx: any): Promise<void>;
+    queryEmbeddings(ctx: any): Promise<void>;
+};
+export default controller;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,30 @@
+declare const _default: {
+    controller: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        ytEmbed(ctx: any): Promise<void>;
+        ytListVideos(ctx: any): Promise<void>;
+        ytGetVideo(ctx: any): Promise<void>;
+        ytGetVideoChunks(ctx: any): Promise<void>;
+        ytRecompute(ctx: any): Promise<void>;
+        ytStatus(ctx: any): Promise<void>;
+        queryEmbeddings(ctx: any): Promise<void>;
+    };
+    mcp: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        handle(ctx: any): Promise<void>;
+    };
+    ytController: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        ingest(ctx: any): Promise<void>;
+        listVideos(ctx: any): Promise<void>;
+        getVideo(ctx: any): Promise<void>;
+        deleteVideo(ctx: any): Promise<void>;
+        search(ctx: any): Promise<void>;
+        getVideoChunks(ctx: any): Promise<void>;
+        recompute(ctx: any): Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/controllers/mcp.d.ts

@@ -0,0 +1,18 @@
+/**
+ * MCP Controller for Content Embeddings
+ *
+ * Handles MCP (Model Context Protocol) requests with session management.
+ */
+import type { Core } from '@strapi/strapi';
+/**
+ * MCP Controller
+ */
+declare const mcpController: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    /**
+     * Handle MCP requests (POST, GET, DELETE)
+     */
+    handle(ctx: any): Promise<void>;
+};
+export default mcpController;

package/dist/server/src/controllers/yt-controller.d.ts

@@ -0,0 +1,13 @@
+import type { Core } from '@strapi/strapi';
+declare const ytController: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    ingest(ctx: any): Promise<void>;
+    listVideos(ctx: any): Promise<void>;
+    getVideo(ctx: any): Promise<void>;
+    deleteVideo(ctx: any): Promise<void>;
+    search(ctx: any): Promise<void>;
+    getVideoChunks(ctx: any): Promise<void>;
+    recompute(ctx: any): Promise<void>;
+};
+export default ytController;

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from "@strapi/strapi";
+declare const destroy: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default destroy;

package/dist/server/src/index.d.ts

@@ -0,0 +1,280 @@
+declare const _default: {
+    register: (_args: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => Promise<void>;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => Promise<void>;
+    config: {
+        default: {
+            openAIApiKey: string;
+            neonConnectionString: string;
+            embeddingModel: "text-embedding-3-small" | "text-embedding-3-large" | "text-embedding-ada-002";
+            chunkSize: number;
+            chunkOverlap: number;
+            autoChunk: boolean;
+            preprocessContent: boolean;
+        };
+        validator(config: import("./config").PluginConfigSchema): void;
+    };
+    controllers: {
+        controller: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            ytEmbed(ctx: any): Promise<void>;
+            ytListVideos(ctx: any): Promise<void>;
+            ytGetVideo(ctx: any): Promise<void>;
+            ytGetVideoChunks(ctx: any): Promise<void>;
+            ytRecompute(ctx: any): Promise<void>;
+            ytStatus(ctx: any): Promise<void>;
+            queryEmbeddings(ctx: any): Promise<void>;
+        };
+        mcp: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            handle(ctx: any): Promise<void>;
+        };
+        ytController: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            ingest(ctx: any): Promise<void>;
+            listVideos(ctx: any): Promise<void>;
+            getVideo(ctx: any): Promise<void>;
+            deleteVideo(ctx: any): Promise<void>;
+            search(ctx: any): Promise<void>;
+            getVideoChunks(ctx: any): Promise<void>;
+            recompute(ctx: any): Promise<void>;
+        };
+    };
+    routes: {
+        "content-api": {
+            type: string;
+            routes: ({
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    auth: boolean;
+                    policies: any[];
+                    description?: undefined;
+                };
+            } | {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    description: string;
+                    auth?: undefined;
+                    policies?: undefined;
+                };
+            })[];
+        };
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    }[];
+                };
+            }[];
+        };
+    };
+    services: {
+        'ai-tools': ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            getTools(): ({
+                name: string;
+                description: string;
+                schema: import("zod").ZodObject<{
+                    query: import("zod").ZodString;
+                    limit: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                    videoId: import("zod").ZodOptional<import("zod").ZodString>;
+                    topics: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                    contextWindowSeconds: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                    minSimilarity: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    query?: string;
+                    limit?: number;
+                    videoId?: string;
+                    topics?: string[];
+                    contextWindowSeconds?: number;
+                    minSimilarity?: number;
+                }, {
+                    query?: string;
+                    limit?: number;
+                    videoId?: string;
+                    topics?: string[];
+                    contextWindowSeconds?: number;
+                    minSimilarity?: number;
+                }>;
+                execute: (args: unknown, strapi: import("@strapi/types/dist/core").Strapi) => Promise<{
+                    results: any[];
+                    message: string;
+                } | {
+                    results: any;
+                    message?: undefined;
+                }>;
+                publicSafe: boolean;
+            } | {
+                name: string;
+                description: string;
+                schema: import("zod").ZodObject<{
+                    videoId: import("zod").ZodString;
+                    startSeconds: import("zod").ZodNumber;
+                    endSeconds: import("zod").ZodNumber;
+                }, "strip", import("zod").ZodTypeAny, {
+                    videoId?: string;
+                    startSeconds?: number;
+                    endSeconds?: number;
+                }, {
+                    videoId?: string;
+                    startSeconds?: number;
+                    endSeconds?: number;
+                }>;
+                execute: (args: unknown, strapi: import("@strapi/types/dist/core").Strapi) => Promise<{
+                    transcript: any;
+                    message: string;
+                    videoId?: undefined;
+                    range?: undefined;
+                    deepLink?: undefined;
+                } | {
+                    videoId: string;
+                    range: string;
+                    transcript: any;
+                    deepLink: string;
+                    message?: undefined;
+                }>;
+                publicSafe: boolean;
+            } | {
+                name: string;
+                description: string;
+                schema: import("zod").ZodObject<{
+                    page: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                    pageSize: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodNumber>>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    page?: number;
+                    pageSize?: number;
+                }, {
+                    page?: number;
+                    pageSize?: number;
+                }>;
+                execute: (args: unknown, strapi: import("@strapi/types/dist/core").Strapi) => Promise<{
+                    videos: any;
+                    pagination: {
+                        page: any;
+                        pageSize: any;
+                        total: any;
+                        pageCount: number;
+                    };
+                }>;
+                publicSafe: boolean;
+            } | {
+                name: string;
+                description: string;
+                schema: import("zod").ZodObject<{
+                    videoId: import("zod").ZodString;
+                }, "strip", import("zod").ZodTypeAny, {
+                    videoId?: string;
+                }, {
+                    videoId?: string;
+                }>;
+                execute: (args: unknown, strapi: import("@strapi/types/dist/core").Strapi) => Promise<{
+                    error: boolean;
+                    message: string;
+                    videoId?: undefined;
+                    title?: undefined;
+                    topics?: undefined;
+                    summary?: undefined;
+                    chunkCount?: undefined;
+                    embeddingStatus?: undefined;
+                    watchLink?: undefined;
+                    keyMoments?: undefined;
+                } | {
+                    videoId: any;
+                    title: any;
+                    topics: any;
+                    summary: any;
+                    chunkCount: any;
+                    embeddingStatus: any;
+                    watchLink: string;
+                    keyMoments: any;
+                    error?: undefined;
+                    message?: undefined;
+                }>;
+                publicSafe: boolean;
+            })[];
+        };
+        ytEmbeddings: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            embedTranscript(transcript: import("./services/yt-embeddings").TranscriptInput): Promise<{
+                videoId: string;
+                chunkCount: number;
+                skipped: boolean;
+            }>;
+            search(query: string, options?: {
+                limit?: number;
+                minSimilarity?: number;
+                videoId?: string;
+                topics?: string[];
+                contextWindowSeconds?: number;
+            }): Promise<{
+                chunkText: any;
+                startSeconds: any;
+                endSeconds: any;
+                similarity: number;
+                contextText: string;
+                videoId: any;
+                title: any;
+                channelName: any;
+                videoSummary: any;
+                topics: any;
+                strapiDocumentId: any;
+                deepLink: string;
+                contextLink: string;
+            }[]>;
+            getTranscriptRange(videoId: string, startSeconds: number, endSeconds: number): Promise<any[]>;
+            listVideos(options?: {
+                page?: number;
+                pageSize?: number;
+                status?: string;
+            }): Promise<{
+                data: any[];
+                total: any;
+                page: number;
+                pageSize: number;
+            }>;
+            getVideo(videoId: string): Promise<any>;
+            deleteVideo(videoId: string): Promise<any>;
+            getVideoChunks(videoId: string, options?: {
+                start?: number;
+                end?: number;
+            }): Promise<any[]>;
+            getStatusByDocumentId(documentId: string): Promise<{
+                embedded: boolean;
+                videoId?: string;
+                chunkCount?: number;
+                embeddedAt?: string;
+            }>;
+            recomputeAll(): Promise<{
+                total: number;
+                processed: number;
+            }>;
+        };
+    };
+    contentTypes: {};
+    policies: {};
+    middlewares: {};
+};
+export default _default;

package/dist/server/src/mcp/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP Module Exports
+ */
+export { createMcpServer } from './server';
+export { tools, handleToolCall } from './tools';
+export { validateToolInput, ToolSchemas } from './schemas';

package/dist/server/src/mcp/schemas/index.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export declare const SearchYtKnowledgeSchema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    videoId: z.ZodOptional<z.ZodString>;
+    topics: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    contextWindowSeconds: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    minSimilarity: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    query?: string;
+    limit?: number;
+    videoId?: string;
+    topics?: string[];
+    contextWindowSeconds?: number;
+    minSimilarity?: number;
+}, {
+    query?: string;
+    limit?: number;
+    videoId?: string;
+    topics?: string[];
+    contextWindowSeconds?: number;
+    minSimilarity?: number;
+}>;
+export declare const GetVideoTranscriptRangeSchema: z.ZodObject<{
+    videoId: z.ZodString;
+    startSeconds: z.ZodNumber;
+    endSeconds: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    videoId?: string;
+    startSeconds?: number;
+    endSeconds?: number;
+}, {
+    videoId?: string;
+    startSeconds?: number;
+    endSeconds?: number;
+}>;
+export declare const ListYtVideosSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    page?: number;
+    pageSize?: number;
+}, {
+    page?: number;
+    pageSize?: number;
+}>;
+export declare const GetYtVideoSummarySchema: z.ZodObject<{
+    videoId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    videoId?: string;
+}, {
+    videoId?: string;
+}>;
+export declare const ToolSchemas: Record<string, z.ZodSchema>;
+export declare function validateToolInput<T = unknown>(toolName: string, input: unknown): T;

package/dist/server/src/mcp/server.d.ts

@@ -0,0 +1,8 @@
+/**
+ * MCP Server Factory for Content Embeddings
+ *
+ * Creates an MCP server that exposes vector search and RAG tools.
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { Core } from '@strapi/strapi';
+export declare function createMcpServer(strapi: Core.Strapi): Server;

package/dist/server/src/mcp/tools/get-video-transcript-range.d.ts

@@ -0,0 +1,33 @@
+import type { Core } from '@strapi/strapi';
+export declare const getVideoTranscriptRangeMcpTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            videoId: {
+                type: string;
+                description: string;
+            };
+            startSeconds: {
+                type: string;
+                description: string;
+            };
+            endSeconds: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleGetVideoTranscriptRange(strapi: Core.Strapi, args: {
+    videoId: string;
+    startSeconds: number;
+    endSeconds: number;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/server/src/mcp/tools/get-yt-video-summary.d.ts

@@ -0,0 +1,23 @@
+import type { Core } from '@strapi/strapi';
+export declare const getYtVideoSummaryMcpTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            videoId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleGetYtVideoSummary(strapi: Core.Strapi, args: {
+    videoId: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/server/src/mcp/tools/index.d.ts

@@ -0,0 +1,38 @@
+import type { Core } from '@strapi/strapi';
+export declare const tools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            page: {
+                type: string;
+                description: string;
+            };
+            pageSize: {
+                type: string;
+                description: string;
+            };
+        };
+        required: any[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            videoId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+})[];
+export declare function handleToolCall(strapi: Core.Strapi, request: {
+    params: {
+        name: string;
+        arguments?: unknown;
+    };
+}): Promise<any>;

package/dist/server/src/mcp/tools/list-yt-videos.d.ts

@@ -0,0 +1,28 @@
+import type { Core } from '@strapi/strapi';
+export declare const listYtVideosMcpTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            page: {
+                type: string;
+                description: string;
+            };
+            pageSize: {
+                type: string;
+                description: string;
+            };
+        };
+        required: any[];
+    };
+};
+export declare function handleListYtVideos(strapi: Core.Strapi, args: {
+    page?: number;
+    pageSize?: number;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/server/src/mcp/tools/search-yt-knowledge.d.ts

@@ -0,0 +1,51 @@
+import type { Core } from '@strapi/strapi';
+export declare const searchYtKnowledgeMcpTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+            videoId: {
+                type: string;
+                description: string;
+            };
+            topics: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            contextWindowSeconds: {
+                type: string;
+                description: string;
+            };
+            minSimilarity: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleSearchYtKnowledge(strapi: Core.Strapi, args: {
+    query: string;
+    limit?: number;
+    videoId?: string;
+    topics?: string[];
+    contextWindowSeconds?: number;
+    minSimilarity?: number;
+}): Promise<{
+    content: {
+        type: string;
+        text: any;
+    }[];
+}>;

package/dist/server/src/middlewares/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/migrations/002-yt-tables.d.ts

@@ -0,0 +1,2 @@
+import type { Pool } from 'pg';
+export declare function runYtMigration(pool: Pool): Promise<void>;