strapi-content-embeddings 0.1.9 → 0.2.1

package/dist/server/index.js

@@ -441,7 +441,8 @@ const GetEmbeddingSchema = zod.z.object({
 const CreateEmbeddingSchema = zod.z.object({
   title: zod.z.string().min(1, "Title is required"),
   content: zod.z.string().min(1, "Content is required"),
-  metadata: zod.z.record(zod.z.any()).optional()
+  metadata: zod.z.record(zod.z.any()).optional(),
+  autoChunk: zod.z.boolean().optional().describe("Automatically split large content into chunks")
 });
 const ToolSchemas = {
   semantic_search: SemanticSearchSchema,
@@ -463,28 +464,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");
@@ -497,49 +482,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 = {
@@ -554,48 +539,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) {
@@ -618,65 +602,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 = {
@@ -693,49 +675,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({
@@ -748,34 +727,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({
@@ -788,42 +756,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,
@@ -883,7 +874,7 @@ function createMcpServer(strapi) {
     }
   );
   server.setRequestHandler(types_js.ListToolsRequestSchema, async () => {
-    return { tools };
+    return { tools: tools$1 };
   });
   server.setRequestHandler(types_js.CallToolRequestSchema, async (request) => {
     return handleToolCall(strapi, request);
@@ -2070,12 +2061,12 @@ const embeddings = ({ strapi }) => ({
     return chunks.length;
   },
   /**
-   * Update a single chunk's content and embedding
-   * Updates only the specified chunk without affecting other chunks in the group
+   * Update embeddings with automatic chunking support
+   * Handles re-chunking when content changes and exceeds chunk size
    */
   async updateChunkedEmbedding(id, data) {
-    const { title, content, metadata } = data.data;
-    this.getConfig();
+    const { title, content, metadata, autoChunk } = data.data;
+    const config2 = this.getConfig();
     const currentEntry = await strapi.documents(CONTENT_TYPE_UID$1).findOne({
       documentId: id
     });
@@ -2083,61 +2074,64 @@ const embeddings = ({ strapi }) => ({
       throw new Error(`Embedding with id ${id} not found`);
     }
     const currentMetadata = currentEntry.metadata;
-    const contentChanged = content !== void 0 && content !== currentEntry.content;
-    console.log(`[updateChunkedEmbedding] Updating single chunk ${id}, contentChanged: ${contentChanged}`);
-    const updateData = {};
-    if (title !== void 0) {
-      const currentTitle = currentEntry.title || "";
-      const partMatch = currentTitle.match(/\s*\[Part \d+\/\d+\]$/);
-      updateData.title = partMatch ? `${title}${partMatch[0]}` : title;
-    }
-    if (content !== void 0) {
-      updateData.content = content;
-    }
-    if (metadata !== void 0) {
-      updateData.metadata = {
-        ...currentMetadata,
-        ...metadata
-      };
-      if (contentChanged) {
-        updateData.metadata.estimatedTokens = estimateTokens(updateData.content || currentEntry.content);
-      }
-    }
-    const updatedEntity = await strapi.documents(CONTENT_TYPE_UID$1).update({
-      documentId: id,
-      data: updateData
-    });
-    if (pluginManager.isInitialized() && (contentChanged || title !== void 0)) {
-      try {
-        console.log(`[updateChunkedEmbedding] Updating embedding in Neon for chunk ${id}`);
-        await pluginManager.deleteEmbedding(id);
-        const newContent = updateData.content || currentEntry.content;
-        const result = await pluginManager.createEmbedding({
-          id,
-          title: updatedEntity.title || currentEntry.title,
+    const parentDocumentId = currentMetadata?.parentDocumentId || id;
+    const newContent = content ?? currentEntry.content;
+    const newTitle = title ?? currentMetadata?.originalTitle ?? currentEntry.title;
+    const shouldChunk = autoChunk ?? config2.autoChunk;
+    const chunkSize = config2.chunkSize || 4e3;
+    const contentNeedsChunking = shouldChunk && needsChunking(newContent, chunkSize);
+    const existingChunks = await this.findRelatedChunks(id);
+    let originalRelated;
+    const firstChunk = existingChunks.find(
+      (c) => c.metadata?.chunkIndex === 0 || c.documentId === parentDocumentId
+    );
+    if (firstChunk?.related) {
+      originalRelated = firstChunk.related;
+    }
+    const deletedCount = await this.deleteRelatedChunks(id);
+    console.log(`Deleted ${deletedCount} existing chunk(s) for update`);
+    const preservedMetadata = { ...metadata };
+    delete preservedMetadata?.isChunk;
+    delete preservedMetadata?.chunkIndex;
+    delete preservedMetadata?.totalChunks;
+    delete preservedMetadata?.startOffset;
+    delete preservedMetadata?.endOffset;
+    delete preservedMetadata?.originalTitle;
+    delete preservedMetadata?.parentDocumentId;
+    delete preservedMetadata?.estimatedTokens;
+    if (contentNeedsChunking) {
+      return await this.createChunkedEmbedding({
+        data: {
+          title: newTitle.replace(/\s*\[Part \d+\/\d+\]$/, ""),
+          // Remove old part suffix
           content: newContent,
           collectionType: currentEntry.collectionType || "standalone",
-          fieldName: currentEntry.fieldName || "content"
-        });
-        await strapi.documents(CONTENT_TYPE_UID$1).update({
-          documentId: id,
-          data: {
-            embeddingId: result.embeddingId,
-            embedding: result.embedding
-          }
-        });
-        console.log(`[updateChunkedEmbedding] Successfully updated embedding for chunk ${id}`);
-      } catch (error) {
-        console.error(`Failed to update vector store for ${id}:`, error);
-      }
+          fieldName: currentEntry.fieldName || "content",
+          metadata: preservedMetadata,
+          related: originalRelated,
+          autoChunk: true
+        }
+      });
+    } else {
+      const entity = await this.createEmbedding({
+        data: {
+          title: newTitle.replace(/\s*\[Part \d+\/\d+\]$/, ""),
+          // Remove old part suffix
+          content: newContent,
+          collectionType: currentEntry.collectionType || "standalone",
+          fieldName: currentEntry.fieldName || "content",
+          metadata: preservedMetadata,
+          related: originalRelated,
+          autoChunk: false
+        }
+      });
+      return {
+        entity,
+        chunks: [entity],
+        totalChunks: 1,
+        wasChunked: false
+      };
     }
-    const allChunks = await this.findRelatedChunks(id);
-    return {
-      entity: updatedEntity,
-      chunks: allChunks,
-      totalChunks: allChunks.length,
-      wasChunked: allChunks.length > 1
-    };
   },
   async updateEmbedding(id, data) {
     const { title, content: rawContent, metadata, autoChunk } = data.data;
@@ -2531,9 +2525,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,