strapi-content-embeddings 0.1.0

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,26 @@
+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;
+}
+declare const _default: {
+    default: {
+        openAIApiKey: string;
+        neonConnectionString: string;
+        embeddingModel: "text-embedding-3-small" | "text-embedding-3-large" | "text-embedding-ada-002";
+    };
+    validator(config: PluginConfigSchema): void;
+};
+export default _default;

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

@@ -0,0 +1,54 @@
+declare const _default: {
+    schema: {
+        kind: string;
+        collectionName: string;
+        info: {
+            singularName: string;
+            pluralName: string;
+            displayName: string;
+        };
+        options: {
+            draftAndPublish: boolean;
+        };
+        pluginOptions: {
+            "content-manager": {
+                visible: boolean;
+            };
+            "content-type-builder": {
+                visible: boolean;
+            };
+        };
+        attributes: {
+            title: {
+                type: string;
+                required: boolean;
+            };
+            content: {
+                type: string;
+            };
+            embedding: {
+                type: string;
+            };
+            embeddingId: {
+                type: string;
+            };
+            collectionType: {
+                type: string;
+                default: string;
+            };
+            fieldName: {
+                type: string;
+                default: string;
+            };
+            metadata: {
+                type: string;
+            };
+            related: {
+                type: string;
+                relation: string;
+                configurable: boolean;
+            };
+        };
+    };
+};
+export default _default;

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

@@ -0,0 +1,56 @@
+declare const _default: {
+    embedding: {
+        schema: {
+            kind: string;
+            collectionName: string;
+            info: {
+                singularName: string;
+                pluralName: string;
+                displayName: string;
+            };
+            options: {
+                draftAndPublish: boolean;
+            };
+            pluginOptions: {
+                "content-manager": {
+                    visible: boolean;
+                };
+                "content-type-builder": {
+                    visible: boolean;
+                };
+            };
+            attributes: {
+                title: {
+                    type: string;
+                    required: boolean;
+                };
+                content: {
+                    type: string;
+                };
+                embedding: {
+                    type: string;
+                };
+                embeddingId: {
+                    type: string;
+                };
+                collectionType: {
+                    type: string;
+                    default: string;
+                };
+                fieldName: {
+                    type: string;
+                    default: string;
+                };
+                metadata: {
+                    type: string;
+                };
+                related: {
+                    type: string;
+                    relation: string;
+                    configurable: boolean;
+                };
+            };
+        };
+    };
+};
+export default _default;

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

@@ -0,0 +1,12 @@
+import type { Core } from "@strapi/strapi";
+declare const controller: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    createEmbedding(ctx: any): Promise<void>;
+    deleteEmbedding(ctx: any): Promise<void>;
+    updateEmbedding(ctx: any): Promise<void>;
+    getEmbeddings(ctx: any): Promise<void>;
+    getEmbedding(ctx: any): Promise<void>;
+    queryEmbeddings(ctx: any): Promise<void>;
+};
+export default controller;

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

@@ -0,0 +1,18 @@
+declare const _default: {
+    controller: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        createEmbedding(ctx: any): Promise<void>;
+        deleteEmbedding(ctx: any): Promise<void>;
+        updateEmbedding(ctx: any): Promise<void>;
+        getEmbeddings(ctx: any): Promise<void>;
+        getEmbedding(ctx: any): Promise<void>;
+        queryEmbeddings(ctx: any): Promise<void>;
+    };
+    mcp: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => {
+        handle(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/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,154 @@
+declare const _default: {
+    register: ({ strapi }: {
+        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";
+        };
+        validator(config: import("./config").PluginConfigSchema): void;
+    };
+    controllers: {
+        controller: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            createEmbedding(ctx: any): Promise<void>;
+            deleteEmbedding(ctx: any): Promise<void>;
+            updateEmbedding(ctx: any): Promise<void>;
+            getEmbeddings(ctx: any): Promise<void>;
+            getEmbedding(ctx: any): Promise<void>;
+            queryEmbeddings(ctx: any): Promise<void>;
+        };
+        mcp: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            handle(ctx: any): Promise<void>;
+        };
+    };
+    routes: {
+        "content-api": {
+            type: string;
+            routes: ({
+                method: string;
+                path: string;
+                handler: string;
+                config?: undefined;
+            } | {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    auth: boolean;
+                    policies: any[];
+                };
+            })[];
+        };
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    }[];
+                };
+            }[];
+        };
+    };
+    services: {
+        embeddings: ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            createEmbedding(data: import("./services/embeddings").CreateEmbeddingData): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+            deleteEmbedding(id: string | number): Promise<{
+                documentId: string;
+                entries: import("@strapi/types/dist/modules/documents").AnyDocument[];
+            }>;
+            updateEmbedding(id: string, data: import("./services/embeddings").UpdateEmbeddingData): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+            queryEmbeddings(query: string): Promise<import("./plugin-manager").QueryResponse | {
+                error: string;
+            }>;
+            getEmbedding(id: string | number): Promise<import("@strapi/types/dist/modules/documents").AnyDocument>;
+            getEmbeddings(params?: {
+                page?: number;
+                pageSize?: number;
+                filters?: any;
+            }): Promise<{
+                data: import("@strapi/types/dist/modules/documents").AnyDocument[];
+                count: number;
+                totalCount: number;
+            }>;
+        };
+    };
+    contentTypes: {
+        embedding: {
+            schema: {
+                kind: string;
+                collectionName: string;
+                info: {
+                    singularName: string;
+                    pluralName: string;
+                    displayName: string;
+                };
+                options: {
+                    draftAndPublish: boolean;
+                };
+                pluginOptions: {
+                    "content-manager": {
+                        visible: boolean;
+                    };
+                    "content-type-builder": {
+                        visible: boolean;
+                    };
+                };
+                attributes: {
+                    title: {
+                        type: string;
+                        required: boolean;
+                    };
+                    content: {
+                        type: string;
+                    };
+                    embedding: {
+                        type: string;
+                    };
+                    embeddingId: {
+                        type: string;
+                    };
+                    collectionType: {
+                        type: string;
+                        default: string;
+                    };
+                    fieldName: {
+                        type: string;
+                        default: string;
+                    };
+                    metadata: {
+                        type: string;
+                    };
+                    related: {
+                        type: string;
+                        relation: string;
+                        configurable: boolean;
+                    };
+                };
+            };
+        };
+    };
+    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,65 @@
+/**
+ * Zod Schemas for MCP Tool Input Validation
+ */
+import { z } from 'zod';
+export declare const SemanticSearchSchema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    query?: string;
+    limit?: number;
+}, {
+    query?: string;
+    limit?: number;
+}>;
+export declare const RagQuerySchema: z.ZodObject<{
+    query: z.ZodString;
+    includeSourceDocuments: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    query?: string;
+    includeSourceDocuments?: boolean;
+}, {
+    query?: string;
+    includeSourceDocuments?: boolean;
+}>;
+export declare const ListEmbeddingsSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    search: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}, {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}>;
+export declare const GetEmbeddingSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    includeContent: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    documentId?: string;
+    includeContent?: boolean;
+}, {
+    documentId?: string;
+    includeContent?: boolean;
+}>;
+export declare const CreateEmbeddingSchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    metadata?: Record<string, any>;
+    content?: string;
+    title?: string;
+}, {
+    metadata?: Record<string, any>;
+    content?: string;
+    title?: string;
+}>;
+export declare const ToolSchemas: Record<string, z.ZodSchema>;
+/**
+ * Validate tool input against its schema
+ */
+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/create-embedding.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Create Embedding Tool
+ *
+ * Creates a new embedding from text content.
+ */
+import type { Core } from '@strapi/strapi';
+export declare const createEmbeddingTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            title: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            metadata: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleCreateEmbedding(strapi: Core.Strapi, args: {
+    title: string;
+    content: string;
+    metadata?: Record<string, any>;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

package/dist/server/src/mcp/tools/get-embedding.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Get Embedding Tool
+ *
+ * Retrieves a single embedding by ID.
+ */
+import type { Core } from '@strapi/strapi';
+export declare const getEmbeddingTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            documentId: {
+                type: string;
+                description: string;
+            };
+            includeContent: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleGetEmbedding(strapi: Core.Strapi, args: {
+    documentId: string;
+    includeContent?: boolean;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;

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

@@ -0,0 +1,114 @@
+/**
+ * MCP Tools for Content Embeddings
+ *
+ * Exposes vector search, RAG queries, and embedding management tools.
+ */
+import type { Core } from '@strapi/strapi';
+export declare const tools: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+                default: number;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            includeSourceDocuments: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            page: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            pageSize: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            search: {
+                type: string;
+                description: string;
+            };
+        };
+        required: any[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            documentId: {
+                type: string;
+                description: string;
+            };
+            includeContent: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            title: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+            };
+            metadata: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+})[];
+/**
+ * Handle MCP tool calls
+ */
+export declare function handleToolCall(strapi: Core.Strapi, request: {
+    params: {
+        name: string;
+        arguments?: unknown;
+    };
+}): Promise<any>;

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

@@ -0,0 +1,40 @@
+/**
+ * List Embeddings Tool
+ *
+ * Lists all embeddings stored in the database.
+ */
+import type { Core } from '@strapi/strapi';
+export declare const listEmbeddingsTool: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            page: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            pageSize: {
+                type: string;
+                description: string;
+                default: number;
+            };
+            search: {
+                type: string;
+                description: string;
+            };
+        };
+        required: any[];
+    };
+};
+export declare function handleListEmbeddings(strapi: Core.Strapi, args: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+}): Promise<{
+    content: {
+        type: string;
+        text: string;
+    }[];
+}>;