strapi-content-embeddings 0.2.0 → 0.2.2

package/dist/server/index.mjs

@@ -438,7 +438,8 @@ const GetEmbeddingSchema = z.object({
 const CreateEmbeddingSchema = z.object({
   title: z.string().min(1, "Title is required"),
   content: z.string().min(1, "Content is required"),
-  metadata: z.record(z.any()).optional()
+  metadata: z.record(z.any()).optional(),
+  autoChunk: z.boolean().optional().describe("Automatically split large content into chunks")
 });
 const ToolSchemas = {
   semantic_search: SemanticSearchSchema,
@@ -460,28 +461,12 @@ function validateToolInput(toolName, input) {
   return result.data;
 }
 const semanticSearchTool = {
-  name: "semantic_search",
-  description: 'TRIGGER: Use when user types "/rag" or asks to search embeddings/content. Search for semantically similar content using vector embeddings. Returns the most relevant documents matching your query based on meaning, not just keywords.',
-  inputSchema: {
-    type: "object",
-    properties: {
-      query: {
-        type: "string",
-        description: "The search query text to find similar content"
-      },
-      limit: {
-        type: "number",
-        description: "Maximum number of results to return (default: 5, max: 20)",
-        default: 5
-      }
-    },
-    required: ["query"]
-  }
-};
-async function handleSemanticSearch(strapi, args) {
-  const { query, limit = 5 } = args;
-  const maxLimit = Math.min(limit, 20);
-  try {
+  name: "semanticSearch",
+  description: "Search for semantically similar content using vector embeddings. Finds relevant documents by meaning, not just keywords.",
+  schema: SemanticSearchSchema,
+  execute: async (args, strapi) => {
+    const { query, limit = 5 } = args;
+    const maxLimit = Math.min(limit, 20);
     const pluginManager2 = strapi.contentEmbeddingsManager;
     if (!pluginManager2) {
       throw new Error("Content embeddings plugin not initialized");
@@ -494,49 +479,49 @@ async function handleSemanticSearch(strapi, args) {
       score: doc.score || null
     }));
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            {
-              query,
-              resultCount: formattedResults.length,
-              results: formattedResults
-            },
-            null,
-            2
-          )
-        }
-      ]
+      query,
+      resultCount: formattedResults.length,
+      results: formattedResults
     };
-  } catch (error) {
-    throw new Error(
-      `Semantic search failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-const ragQueryTool = {
-  name: "rag_query",
-  description: 'TRIGGER: Use when user types "/rag" followed by a question. Ask a question and get an AI-generated answer based on your embedded content. Uses RAG (Retrieval-Augmented Generation) to find relevant documents and generate a contextual response. This is the PRIMARY tool for /rag queries.',
+  },
+  publicSafe: true
+};
+const semanticSearchMcpTool = {
+  name: "semantic_search",
+  description: semanticSearchTool.description,
   inputSchema: {
     type: "object",
     properties: {
       query: {
         type: "string",
-        description: "The question or query to answer using embedded content"
+        description: "The search query text to find similar content"
       },
-      includeSourceDocuments: {
-        type: "boolean",
-        description: "Include the source documents used to generate the answer (default: true)",
-        default: true
+      limit: {
+        type: "number",
+        description: "Maximum number of results to return (default: 5, max: 20)",
+        default: 5
       }
     },
     required: ["query"]
   }
 };
-async function handleRagQuery(strapi, args) {
-  const { query, includeSourceDocuments = true } = args;
-  try {
+async function handleSemanticSearch(strapi, args) {
+  const result = await semanticSearchTool.execute(args, strapi);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+const ragQueryTool = {
+  name: "ragQuery",
+  description: "Ask a question and get an AI-generated answer grounded in embedded content. Uses retrieval-augmented generation (RAG) with vector search.",
+  schema: RagQuerySchema,
+  execute: async (args, strapi) => {
+    const { query, includeSourceDocuments = true } = args;
     const embeddingsService = strapi.plugin("strapi-content-embeddings").service("embeddings");
     const result = await embeddingsService.queryEmbeddings(query);
     const response = {
@@ -551,48 +536,47 @@ async function handleRagQuery(strapi, args) {
       }));
       response.sourceCount = result.sourceDocuments.length;
     }
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(response, null, 2)
-        }
-      ]
-    };
-  } catch (error) {
-    throw new Error(
-      `RAG query failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-const listEmbeddingsTool = {
-  name: "list_embeddings",
-  description: "List all embeddings stored in the database. Returns metadata without the full content to avoid context overflow.",
+    return response;
+  },
+  publicSafe: true
+};
+const ragQueryMcpTool = {
+  name: "rag_query",
+  description: ragQueryTool.description,
   inputSchema: {
     type: "object",
     properties: {
-      page: {
-        type: "number",
-        description: "Page number (starts at 1)",
-        default: 1
-      },
-      pageSize: {
-        type: "number",
-        description: "Number of items per page (max: 50)",
-        default: 25
-      },
-      search: {
+      query: {
         type: "string",
-        description: "Search filter for title"
+        description: "The question or query to answer using embedded content"
+      },
+      includeSourceDocuments: {
+        type: "boolean",
+        description: "Include the source documents used to generate the answer (default: true)",
+        default: true
       }
     },
-    required: []
+    required: ["query"]
   }
 };
-async function handleListEmbeddings(strapi, args) {
-  const { page = 1, pageSize = 25, search } = args;
-  const limit = Math.min(pageSize, 50);
-  try {
+async function handleRagQuery(strapi, args) {
+  const result = await ragQueryTool.execute(args, strapi);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+const listEmbeddingsTool = {
+  name: "listEmbeddings",
+  description: "List all embedded documents with pagination. Returns metadata and content preview without full text.",
+  schema: ListEmbeddingsSchema,
+  execute: async (args, strapi) => {
+    const { page = 1, pageSize = 25, search } = args;
+    const limit = Math.min(pageSize, 50);
     const embeddingsService = strapi.plugin("strapi-content-embeddings").service("embeddings");
     const filters = {};
     if (search) {
@@ -615,65 +599,63 @@ async function handleListEmbeddings(strapi, args) {
       updatedAt: emb.updatedAt
     }));
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            {
-              embeddings: embeddings2,
-              pagination: result.pagination || {
-                page,
-                pageSize: limit,
-                total: embeddings2.length
-              }
-            },
-            null,
-            2
-          )
-        }
-      ]
+      embeddings: embeddings2,
+      pagination: result.pagination || {
+        page,
+        pageSize: limit,
+        total: embeddings2.length
+      }
     };
-  } catch (error) {
-    throw new Error(
-      `Failed to list embeddings: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-const getEmbeddingTool = {
-  name: "get_embedding",
-  description: "Get a specific embedding by its document ID. Returns the full content and metadata.",
+  },
+  publicSafe: true
+};
+const listEmbeddingsMcpTool = {
+  name: "list_embeddings",
+  description: listEmbeddingsTool.description,
   inputSchema: {
     type: "object",
     properties: {
-      documentId: {
-        type: "string",
-        description: "The document ID of the embedding to retrieve"
+      page: {
+        type: "number",
+        description: "Page number (starts at 1)",
+        default: 1
       },
-      includeContent: {
-        type: "boolean",
-        description: "Include the full content text (default: true)",
-        default: true
+      pageSize: {
+        type: "number",
+        description: "Number of items per page (max: 50)",
+        default: 25
+      },
+      search: {
+        type: "string",
+        description: "Search filter for title"
       }
     },
-    required: ["documentId"]
+    required: []
   }
 };
-async function handleGetEmbedding(strapi, args) {
-  const { documentId, includeContent = true } = args;
-  try {
+async function handleListEmbeddings(strapi, args) {
+  const result = await listEmbeddingsTool.execute(args, strapi);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+const getEmbeddingTool = {
+  name: "getEmbedding",
+  description: "Get a specific embedded document by its document ID. Returns full content and metadata.",
+  schema: GetEmbeddingSchema,
+  execute: async (args, strapi) => {
+    const { documentId, includeContent = true } = args;
     const embeddingsService = strapi.plugin("strapi-content-embeddings").service("embeddings");
     const embedding2 = await embeddingsService.getEmbedding(documentId);
     if (!embedding2) {
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({
-              error: true,
-              message: `Embedding not found with documentId: ${documentId}`
-            })
-          }
-        ]
+        error: true,
+        message: `Embedding not found with documentId: ${documentId}`
       };
     }
     const result = {
@@ -690,49 +672,46 @@ async function handleGetEmbedding(strapi, args) {
     if (includeContent) {
       result.content = embedding2.content;
     }
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(result, null, 2)
-        }
-      ]
-    };
-  } catch (error) {
-    throw new Error(
-      `Failed to get embedding: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-const createEmbeddingTool = {
-  name: "create_embedding",
-  description: "Create a new embedding from text content. The content will be vectorized and stored for semantic search. For large content (over 4000 characters), enable autoChunk to automatically split into multiple embeddings.",
+    return result;
+  },
+  publicSafe: true
+};
+const getEmbeddingMcpTool = {
+  name: "get_embedding",
+  description: getEmbeddingTool.description,
   inputSchema: {
     type: "object",
     properties: {
-      title: {
-        type: "string",
-        description: "A descriptive title for the embedding"
-      },
-      content: {
+      documentId: {
         type: "string",
-        description: "The text content to embed (will be vectorized)"
-      },
-      metadata: {
-        type: "object",
-        description: "Optional metadata to associate with the embedding (tags, source, etc.)"
+        description: "The document ID of the embedding to retrieve"
       },
-      autoChunk: {
+      includeContent: {
         type: "boolean",
-        description: "Automatically split large content into chunks (default: false). When enabled, content over 4000 characters will be split into multiple embeddings with overlap for context preservation."
+        description: "Include the full content text (default: true)",
+        default: true
       }
     },
-    required: ["title", "content"]
+    required: ["documentId"]
   }
 };
-async function handleCreateEmbedding(strapi, args) {
-  const { title, content, metadata, autoChunk } = args;
-  try {
+async function handleGetEmbedding(strapi, args) {
+  const result = await getEmbeddingTool.execute(args, strapi);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
+}
+const createEmbeddingTool = {
+  name: "createEmbedding",
+  description: "Create a new embedding from text content for future semantic search. Large content can be auto-chunked into multiple embeddings.",
+  schema: CreateEmbeddingSchema,
+  execute: async (args, strapi) => {
+    const { title, content, metadata, autoChunk } = args;
     const embeddingsService = strapi.plugin("strapi-content-embeddings").service("embeddings");
     if (autoChunk) {
       const result = await embeddingsService.createChunkedEmbedding({
@@ -745,34 +724,23 @@ async function handleCreateEmbedding(strapi, args) {
         }
       });
       return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                success: true,
-                message: result.wasChunked ? `Content chunked into ${result.totalChunks} embeddings` : "Embedding created successfully (no chunking needed)",
-                wasChunked: result.wasChunked,
-                totalChunks: result.totalChunks,
-                primaryEmbedding: {
-                  id: result.entity.id,
-                  documentId: result.entity.documentId,
-                  title: result.entity.title,
-                  embeddingId: result.entity.embeddingId
-                },
-                chunks: result.chunks.map((chunk) => ({
-                  documentId: chunk.documentId,
-                  title: chunk.title,
-                  contentLength: chunk.content?.length || 0
-                })),
-                contentLength: content.length,
-                estimatedTokens: Math.ceil(content.length / 4)
-              },
-              null,
-              2
-            )
-          }
-        ]
+        success: true,
+        message: result.wasChunked ? `Content chunked into ${result.totalChunks} embeddings` : "Embedding created successfully (no chunking needed)",
+        wasChunked: result.wasChunked,
+        totalChunks: result.totalChunks,
+        primaryEmbedding: {
+          id: result.entity.id,
+          documentId: result.entity.documentId,
+          title: result.entity.title,
+          embeddingId: result.entity.embeddingId
+        },
+        chunks: result.chunks.map((chunk) => ({
+          documentId: chunk.documentId,
+          title: chunk.title,
+          contentLength: chunk.content?.length || 0
+        })),
+        contentLength: content.length,
+        estimatedTokens: Math.ceil(content.length / 4)
       };
     }
     const embedding2 = await embeddingsService.createEmbedding({
@@ -785,42 +753,65 @@ async function handleCreateEmbedding(strapi, args) {
       }
     });
     return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(
-            {
-              success: true,
-              message: "Embedding created successfully",
-              embedding: {
-                id: embedding2.id,
-                documentId: embedding2.documentId,
-                title: embedding2.title,
-                embeddingId: embedding2.embeddingId,
-                contentLength: content.length,
-                metadata: embedding2.metadata,
-                createdAt: embedding2.createdAt
-              },
-              hint: content.length > 4e3 ? "Content is large. Consider using autoChunk: true for better search results." : void 0
-            },
-            null,
-            2
-          )
-        }
-      ]
+      success: true,
+      message: "Embedding created successfully",
+      embedding: {
+        id: embedding2.id,
+        documentId: embedding2.documentId,
+        title: embedding2.title,
+        embeddingId: embedding2.embeddingId,
+        contentLength: content.length,
+        metadata: embedding2.metadata,
+        createdAt: embedding2.createdAt
+      },
+      hint: content.length > 4e3 ? "Content is large. Consider using autoChunk: true for better search results." : void 0
     };
-  } catch (error) {
-    throw new Error(
-      `Failed to create embedding: ${error instanceof Error ? error.message : String(error)}`
-    );
+  },
+  publicSafe: false
+};
+const createEmbeddingMcpTool = {
+  name: "create_embedding",
+  description: createEmbeddingTool.description,
+  inputSchema: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "A descriptive title for the embedding"
+      },
+      content: {
+        type: "string",
+        description: "The text content to embed (will be vectorized)"
+      },
+      metadata: {
+        type: "object",
+        description: "Optional metadata to associate with the embedding (tags, source, etc.)"
+      },
+      autoChunk: {
+        type: "boolean",
+        description: "Automatically split large content into chunks (default: false). When enabled, content over 4000 characters will be split into multiple embeddings with overlap for context preservation."
+      }
+    },
+    required: ["title", "content"]
   }
+};
+async function handleCreateEmbedding(strapi, args) {
+  const result = await createEmbeddingTool.execute(args, strapi);
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(result, null, 2)
+      }
+    ]
+  };
 }
-const tools = [
-  semanticSearchTool,
-  ragQueryTool,
-  listEmbeddingsTool,
-  getEmbeddingTool,
-  createEmbeddingTool
+const tools$1 = [
+  semanticSearchMcpTool,
+  ragQueryMcpTool,
+  listEmbeddingsMcpTool,
+  getEmbeddingMcpTool,
+  createEmbeddingMcpTool
 ];
 const toolHandlers = {
   semantic_search: handleSemanticSearch,
@@ -880,7 +871,7 @@ function createMcpServer(strapi) {
     }
   );
   server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return { tools };
+    return { tools: tools$1 };
   });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
     return handleToolCall(strapi, request);
@@ -2528,9 +2519,22 @@ const sync = ({ strapi }) => ({
     }
   }
 });
+const tools = [
+  semanticSearchTool,
+  ragQueryTool,
+  listEmbeddingsTool,
+  getEmbeddingTool,
+  createEmbeddingTool
+];
+const aiTools = ({ strapi }) => ({
+  getTools() {
+    return tools;
+  }
+});
 const services = {
   embeddings,
-  sync
+  sync,
+  "ai-tools": aiTools
 };
 const index = {
   register,
@@ -2547,4 +2551,3 @@ const index = {
 export {
   index as default
 };
-//# sourceMappingURL=index.mjs.map

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

@@ -133,6 +133,11 @@ declare const _default: {
             }>;
             recreateAllEmbeddings(): Promise<import("./services/sync").RecreateResult>;
         };
+        'ai-tools': ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => {
+            getTools(): import("./tools").ToolDefinition[];
+        };
     };
     contentTypes: {
         embedding: {

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

@@ -49,14 +49,17 @@ export declare const CreateEmbeddingSchema: z.ZodObject<{
     title: z.ZodString;
     content: z.ZodString;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    autoChunk: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     metadata?: Record<string, any>;
     content?: string;
     title?: string;
+    autoChunk?: boolean;
 }, {
     metadata?: Record<string, any>;
     content?: string;
     title?: string;
+    autoChunk?: boolean;
 }>;
 export declare const ToolSchemas: Record<string, z.ZodSchema>;
 /**

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

@@ -1,11 +1,10 @@
 /**
- * Create Embedding Tool
+ * Create Embedding Tool — MCP Wrapper
  *
- * Creates a new embedding from text content.
- * Supports automatic chunking for large content.
+ * Thin MCP adapter that delegates to the canonical tool implementation.
  */
 import type { Core } from '@strapi/strapi';
-export declare const createEmbeddingTool: {
+export declare const createEmbeddingMcpTool: {
     name: string;
     description: string;
     inputSchema: {

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

@@ -1,10 +1,10 @@
 /**
- * Get Embedding Tool
+ * Get Embedding Tool — MCP Wrapper
  *
- * Retrieves a single embedding by ID.
+ * Thin MCP adapter that delegates to the canonical tool implementation.
  */
 import type { Core } from '@strapi/strapi';
-export declare const getEmbeddingTool: {
+export declare const getEmbeddingMcpTool: {
     name: string;
     description: string;
     inputSchema: {

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

@@ -2,6 +2,7 @@
  * MCP Tools for Content Embeddings
  *
  * Exposes vector search, RAG queries, and embedding management tools.
+ * Each handler is a thin wrapper around canonical tool definitions in ../../tools.
  */
 import type { Core } from '@strapi/strapi';
 export declare const tools: ({

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

@@ -1,10 +1,10 @@
 /**
- * List Embeddings Tool
+ * List Embeddings Tool — MCP Wrapper
  *
- * Lists all embeddings stored in the database.
+ * Thin MCP adapter that delegates to the canonical tool implementation.
  */
 import type { Core } from '@strapi/strapi';
-export declare const listEmbeddingsTool: {
+export declare const listEmbeddingsMcpTool: {
     name: string;
     description: string;
     inputSchema: {