strapi-content-embeddings 0.1.0

package/dist/server/index.mjs

@@ -0,0 +1,1360 @@
+import { OpenAIEmbeddings, ChatOpenAI } from "@langchain/openai";
+import { PGVectorStore } from "@langchain/community/vectorstores/pgvector";
+import { Document } from "@langchain/core/documents";
+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";
+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"
+  },
+  validator(config2) {
+    if (!config2.openAIApiKey) {
+      console.warn(
+        "strapi-content-embeddings: openAIApiKey is not configured. Plugin features will be disabled."
+      );
+    }
+    if (!config2.neonConnectionString) {
+      console.warn(
+        "strapi-content-embeddings: neonConnectionString is not configured. Plugin features will be disabled."
+      );
+    }
+    if (config2.embeddingModel && !EMBEDDING_MODELS[config2.embeddingModel]) {
+      console.warn(
+        `strapi-content-embeddings: Invalid embeddingModel "${config2.embeddingModel}". Valid options: ${Object.keys(EMBEDDING_MODELS).join(", ")}. Defaulting to "text-embedding-3-small".`
+      );
+    }
+  }
+};
+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) {
+      throw new Error("Plugin manager not initialized");
+    }
+    try {
+      const embeddingVector = await this.embeddings.embedQuery(docData.content);
+      const doc = new Document({
+        pageContent: docData.content,
+        metadata: {
+          id: docData.id,
+          title: docData.title,
+          collectionType: docData.collectionType || "standalone",
+          fieldName: docData.fieldName || "content"
+        }
+      });
+      await PGVectorStore.fromDocuments(
+        [doc],
+        this.embeddings,
+        this.vectorStoreConfig
+      );
+      const result = await this.pool.query(
+        `SELECT id FROM embeddings_documents
+         WHERE metadata->>'id' = $1
+         ORDER BY id DESC LIMIT 1`,
+        [docData.id]
+      );
+      return {
+        embeddingId: result.rows[0]?.id || "",
+        embedding: embeddingVector
+      };
+    } catch (error) {
+      console.error(`Failed to create embedding: ${error}`);
+      throw new Error(`Failed to create embedding: ${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 retriever = vectorStore.asRetriever({ k: 4 });
+      const sourceDocuments = await retriever.invoke(query);
+      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
+      };
+    } 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);
+  }
+  async destroy() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+    this.embeddings = null;
+    this.chat = null;
+    this.vectorStoreConfig = null;
+  }
+}
+const pluginManager = new PluginManager();
+const SemanticSearchSchema = z.object({
+  query: z.string().min(1, "Query is required"),
+  limit: z.number().min(1).max(20).optional().default(5)
+});
+const RagQuerySchema = z.object({
+  query: z.string().min(1, "Query is required"),
+  includeSourceDocuments: z.boolean().optional().default(true)
+});
+const ListEmbeddingsSchema = z.object({
+  page: z.number().min(1).optional().default(1),
+  pageSize: z.number().min(1).max(50).optional().default(25),
+  search: z.string().optional()
+});
+const GetEmbeddingSchema = z.object({
+  documentId: z.string().min(1, "Document ID is required"),
+  includeContent: z.boolean().optional().default(true)
+});
+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()
+});
+const ToolSchemas = {
+  semantic_search: SemanticSearchSchema,
+  rag_query: RagQuerySchema,
+  list_embeddings: ListEmbeddingsSchema,
+  get_embedding: GetEmbeddingSchema,
+  create_embedding: CreateEmbeddingSchema
+};
+function validateToolInput(toolName, input) {
+  const schema2 = ToolSchemas[toolName];
+  if (!schema2) {
+    throw new Error(`No schema defined for tool: ${toolName}`);
+  }
+  const result = schema2.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;
+}
+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 {
+    const pluginManager2 = strapi.contentEmbeddingsManager;
+    if (!pluginManager2) {
+      throw new Error("Content embeddings plugin not initialized");
+    }
+    const results = await pluginManager2.similaritySearch(query, maxLimit);
+    const formattedResults = results.map((doc, index2) => ({
+      rank: index2 + 1,
+      content: doc.pageContent,
+      metadata: doc.metadata,
+      score: doc.score || null
+    }));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              query,
+              resultCount: formattedResults.length,
+              results: formattedResults
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  } 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.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      query: {
+        type: "string",
+        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: ["query"]
+  }
+};
+async function handleRagQuery(strapi, args) {
+  const { query, includeSourceDocuments = true } = args;
+  try {
+    const embeddingsService = strapi.plugin("strapi-content-embeddings").service("embeddings");
+    const result = await embeddingsService.queryEmbeddings(query);
+    const response = {
+      query,
+      answer: result.text
+    };
+    if (includeSourceDocuments && result.sourceDocuments) {
+      response.sourceDocuments = result.sourceDocuments.map((doc, index2) => ({
+        rank: index2 + 1,
+        content: doc.pageContent?.substring(0, 500) + (doc.pageContent?.length > 500 ? "..." : ""),
+        metadata: doc.metadata
+      }));
+      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.",
+  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: {
+        type: "string",
+        description: "Search filter for title"
+      }
+    },
+    required: []
+  }
+};
+async function handleListEmbeddings(strapi, args) {
+  const { page = 1, pageSize = 25, search } = args;
+  const limit = Math.min(pageSize, 50);
+  try {
+    const embeddingsService = strapi.plugin("strapi-content-embeddings").service("embeddings");
+    const filters = {};
+    if (search) {
+      filters.title = { $containsi: search };
+    }
+    const result = await embeddingsService.getEmbeddings({
+      page,
+      pageSize: limit,
+      filters
+    });
+    const embeddings2 = (result.results || []).map((emb) => ({
+      id: emb.id,
+      documentId: emb.documentId,
+      title: emb.title,
+      collectionType: emb.collectionType,
+      fieldName: emb.fieldName,
+      metadata: emb.metadata,
+      contentPreview: emb.content?.substring(0, 200) + (emb.content?.length > 200 ? "..." : ""),
+      createdAt: emb.createdAt,
+      updatedAt: emb.updatedAt
+    }));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              embeddings: embeddings2,
+              pagination: result.pagination || {
+                page,
+                pageSize: limit,
+                total: embeddings2.length
+              }
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  } 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.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      documentId: {
+        type: "string",
+        description: "The document ID of the embedding to retrieve"
+      },
+      includeContent: {
+        type: "boolean",
+        description: "Include the full content text (default: true)",
+        default: true
+      }
+    },
+    required: ["documentId"]
+  }
+};
+async function handleGetEmbedding(strapi, args) {
+  const { documentId, includeContent = true } = args;
+  try {
+    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}`
+            })
+          }
+        ]
+      };
+    }
+    const result = {
+      id: embedding2.id,
+      documentId: embedding2.documentId,
+      title: embedding2.title,
+      collectionType: embedding2.collectionType,
+      fieldName: embedding2.fieldName,
+      metadata: embedding2.metadata,
+      embeddingId: embedding2.embeddingId,
+      createdAt: embedding2.createdAt,
+      updatedAt: embedding2.updatedAt
+    };
+    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.",
+  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.)"
+      }
+    },
+    required: ["title", "content"]
+  }
+};
+async function handleCreateEmbedding(strapi, args) {
+  const { title, content, metadata } = args;
+  try {
+    const embeddingsService = strapi.plugin("strapi-content-embeddings").service("embeddings");
+    const embedding2 = await embeddingsService.createEmbedding({
+      title,
+      content,
+      metadata: metadata || {},
+      collectionType: "standalone",
+      fieldName: "content"
+    });
+    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
+              }
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to create embedding: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+const tools = [
+  semanticSearchTool,
+  ragQueryTool,
+  listEmbeddingsTool,
+  getEmbeddingTool,
+  createEmbeddingTool
+];
+const toolHandlers = {
+  semantic_search: handleSemanticSearch,
+  rag_query: handleRagQuery,
+  list_embeddings: handleListEmbeddings,
+  get_embedding: handleGetEmbedding,
+  create_embedding: handleCreateEmbedding
+};
+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(`[strapi-content-embeddings] 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: "strapi-content-embeddings-mcp",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    return handleToolCall(strapi, request);
+  });
+  return server;
+}
+const PLUGIN_ID$4 = "strapi-content-embeddings";
+const OAUTH_PLUGIN_ID = "strapi-oauth-mcp-manager";
+function createFallbackAuthMiddleware(strapi) {
+  const mcpPath = `/api/${PLUGIN_ID$4}/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$4
+    },
+    {
+      section: "plugins",
+      displayName: "Update",
+      uid: "update",
+      pluginName: PLUGIN_ID$4
+    },
+    {
+      section: "plugins",
+      displayName: "Create",
+      uid: "create",
+      pluginName: PLUGIN_ID$4
+    },
+    {
+      section: "plugins",
+      displayName: "Delete",
+      uid: "delete",
+      pluginName: PLUGIN_ID$4
+    },
+    {
+      section: "plugins",
+      displayName: "Chat",
+      uid: "chat",
+      pluginName: PLUGIN_ID$4
+    }
+  ];
+  await strapi.admin.services.permission.actionProvider.registerMany(actions);
+  const pluginConfig = strapi.config.get(`plugin::${PLUGIN_ID$4}`);
+  if (pluginConfig?.openAIApiKey && pluginConfig?.neonConnectionString) {
+    try {
+      await pluginManager.initialize({
+        openAIApiKey: pluginConfig.openAIApiKey,
+        neonConnectionString: pluginConfig.neonConnectionString,
+        embeddingModel: pluginConfig.embeddingModel
+      });
+      strapi.contentEmbeddingsManager = pluginManager;
+      strapi.log.info(`[${PLUGIN_ID$4}] Plugin initialized successfully`);
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID$4}] Failed to initialize:`, error);
+    }
+  } else {
+    strapi.log.warn(
+      `[${PLUGIN_ID$4}] Missing configuration. Set openAIApiKey and neonConnectionString in plugin config.`
+    );
+  }
+  const plugin = strapi.plugin(PLUGIN_ID$4);
+  plugin.createMcpServer = () => createMcpServer(strapi);
+  plugin.sessions = /* @__PURE__ */ new Map();
+  const oauthPlugin = strapi.plugin(OAUTH_PLUGIN_ID);
+  if (oauthPlugin) {
+    strapi.log.info(`[${PLUGIN_ID$4}] OAuth manager detected - OAuth + API token auth enabled`);
+  } else {
+    const fallbackMiddleware = createFallbackAuthMiddleware();
+    strapi.server.use(fallbackMiddleware);
+    strapi.log.info(`[${PLUGIN_ID$4}] Using API token authentication (OAuth manager not installed)`);
+  }
+  strapi.log.info(`[${PLUGIN_ID$4}] MCP endpoint available at: /api/${PLUGIN_ID$4}/mcp`);
+};
+const destroy = async ({ strapi }) => {
+  await pluginManager.destroy();
+  console.log("Content Embeddings plugin destroyed");
+};
+const PLUGIN_ID$3 = "strapi-content-embeddings";
+const register = ({ strapi }) => {
+  Object.values(strapi.contentTypes).forEach((contentType) => {
+    if (contentType.uid.startsWith("admin::") || contentType.uid.startsWith("strapi::") || contentType.uid === `plugin::${PLUGIN_ID$3}.embedding`) {
+      return;
+    }
+    contentType.attributes.embedding = {
+      type: "relation",
+      relation: "morphOne",
+      target: `plugin::${PLUGIN_ID$3}.embedding`,
+      morphBy: "related",
+      private: false,
+      configurable: false
+    };
+  });
+};
+const kind = "collectionType";
+const collectionName = "strapi_content_embeddings";
+const info = {
+  singularName: "embedding",
+  pluralName: "embeddings",
+  displayName: "Embedding"
+};
+const options = {
+  draftAndPublish: false
+};
+const pluginOptions = {
+  "content-manager": {
+    visible: true
+  },
+  "content-type-builder": {
+    visible: false
+  }
+};
+const attributes = {
+  title: {
+    type: "string",
+    required: true
+  },
+  content: {
+    type: "text"
+  },
+  embedding: {
+    type: "json"
+  },
+  embeddingId: {
+    type: "string"
+  },
+  collectionType: {
+    type: "string",
+    "default": "standalone"
+  },
+  fieldName: {
+    type: "string",
+    "default": "content"
+  },
+  metadata: {
+    type: "json"
+  },
+  related: {
+    type: "relation",
+    relation: "morphToOne",
+    configurable: false
+  }
+};
+const schema = {
+  kind,
+  collectionName,
+  info,
+  options,
+  pluginOptions,
+  attributes
+};
+const embedding = {
+  schema
+};
+const contentTypes = {
+  embedding
+};
+const PLUGIN_ID$2 = "strapi-content-embeddings";
+const controller = ({ strapi }) => ({
+  async createEmbedding(ctx) {
+    try {
+      const result = await strapi.plugin(PLUGIN_ID$2).service("embeddings").createEmbedding(ctx.request.body);
+      ctx.body = result;
+    } catch (error) {
+      ctx.throw(500, error.message || "Failed to create embedding");
+    }
+  },
+  async deleteEmbedding(ctx) {
+    try {
+      const { id } = ctx.params;
+      const result = await strapi.plugin(PLUGIN_ID$2).service("embeddings").deleteEmbedding(id);
+      ctx.body = result;
+    } catch (error) {
+      ctx.throw(500, error.message || "Failed to delete embedding");
+    }
+  },
+  async updateEmbedding(ctx) {
+    try {
+      const { id } = ctx.params;
+      const result = await strapi.plugin(PLUGIN_ID$2).service("embeddings").updateEmbedding(id, ctx.request.body);
+      ctx.body = result;
+    } catch (error) {
+      ctx.throw(500, error.message || "Failed to update embedding");
+    }
+  },
+  async getEmbeddings(ctx) {
+    try {
+      const { page, pageSize, filters } = ctx.query;
+      const result = await strapi.plugin(PLUGIN_ID$2).service("embeddings").getEmbeddings({
+        page: page ? parseInt(page, 10) : 1,
+        pageSize: pageSize ? parseInt(pageSize, 10) : 10,
+        filters
+      });
+      ctx.body = result;
+    } catch (error) {
+      ctx.throw(500, error.message || "Failed to get embeddings");
+    }
+  },
+  async getEmbedding(ctx) {
+    try {
+      const { id } = ctx.params;
+      const result = await strapi.plugin(PLUGIN_ID$2).service("embeddings").getEmbedding(id);
+      if (!result) {
+        ctx.throw(404, "Embedding not found");
+      }
+      ctx.body = result;
+    } catch (error) {
+      if (error.status === 404) {
+        ctx.throw(404, error.message);
+      }
+      ctx.throw(500, error.message || "Failed to get embedding");
+    }
+  },
+  async queryEmbeddings(ctx) {
+    try {
+      const { query } = ctx.query;
+      const result = await strapi.plugin(PLUGIN_ID$2).service("embeddings").queryEmbeddings(query);
+      ctx.body = result;
+    } catch (error) {
+      ctx.throw(500, error.message || "Failed to query embeddings");
+    }
+  }
+});
+const PLUGIN_ID$1 = "strapi-content-embeddings";
+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 controllers = {
+  controller,
+  mcp: mcpController
+};
+const middlewares = {};
+const policies = {};
+const contentApi = [
+  {
+    method: "GET",
+    path: "/embeddings-query",
+    handler: "controller.queryEmbeddings"
+  },
+  // 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: []
+    }
+  }
+];
+const admin = [
+  {
+    method: "POST",
+    path: "/embeddings/create-embedding",
+    handler: "controller.createEmbedding",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::strapi-content-embeddings.create"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "DELETE",
+    path: "/embeddings/delete-embedding/:id",
+    handler: "controller.deleteEmbedding",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::strapi-content-embeddings.delete"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "PUT",
+    path: "/embeddings/update-embedding/:id",
+    handler: "controller.updateEmbedding",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::strapi-content-embeddings.update"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "GET",
+    path: "/embeddings/embeddings-query",
+    handler: "controller.queryEmbeddings",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::strapi-content-embeddings.chat"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "GET",
+    path: "/embeddings/find/:id",
+    handler: "controller.getEmbedding",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::strapi-content-embeddings.read"] }
+        }
+      ]
+    }
+  },
+  {
+    method: "GET",
+    path: "/embeddings/find",
+    handler: "controller.getEmbeddings",
+    config: {
+      policies: [
+        {
+          name: "admin::hasPermissions",
+          config: { actions: ["plugin::strapi-content-embeddings.read"] }
+        }
+      ]
+    }
+  }
+];
+const routes = {
+  "content-api": {
+    type: "content-api",
+    routes: [...contentApi]
+  },
+  admin: {
+    type: "admin",
+    routes: [...admin]
+  }
+};
+const PLUGIN_ID = "strapi-content-embeddings";
+const CONTENT_TYPE_UID = `plugin::${PLUGIN_ID}.embedding`;
+const embeddings = ({ strapi }) => ({
+  async createEmbedding(data) {
+    const { title, content, collectionType, fieldName, metadata, related } = data.data;
+    const entityData = {
+      title,
+      content,
+      collectionType: collectionType || "standalone",
+      fieldName: fieldName || "content",
+      metadata: metadata || null
+    };
+    if (related && related.__type && related.id) {
+      entityData.related = related;
+    }
+    const entity = await strapi.documents(CONTENT_TYPE_UID).create({
+      data: entityData
+    });
+    if (!pluginManager.isInitialized()) {
+      console.warn("Plugin manager not initialized, skipping vector embedding");
+      return entity;
+    }
+    try {
+      const result = await pluginManager.createEmbedding({
+        id: entity.documentId,
+        title,
+        content,
+        collectionType: collectionType || "standalone",
+        fieldName: fieldName || "content"
+      });
+      const updatedEntity = await strapi.documents(CONTENT_TYPE_UID).update({
+        documentId: entity.documentId,
+        data: {
+          embeddingId: result.embeddingId,
+          embedding: result.embedding
+        }
+      });
+      return updatedEntity;
+    } catch (error) {
+      console.error("Failed to create embedding in vector store:", error);
+      return entity;
+    }
+  },
+  async deleteEmbedding(id) {
+    const currentEntry = await strapi.documents(CONTENT_TYPE_UID).findOne({
+      documentId: String(id)
+    });
+    if (!currentEntry) {
+      throw new Error(`Embedding with id ${id} not found`);
+    }
+    if (pluginManager.isInitialized()) {
+      try {
+        await pluginManager.deleteEmbedding(String(id));
+      } catch (error) {
+        console.error("Failed to delete from vector store:", error);
+      }
+    }
+    const deletedEntry = await strapi.documents(CONTENT_TYPE_UID).delete({
+      documentId: String(id)
+    });
+    return deletedEntry;
+  },
+  async updateEmbedding(id, data) {
+    const { title, content, metadata } = data.data;
+    const currentEntry = await strapi.documents(CONTENT_TYPE_UID).findOne({
+      documentId: id
+    });
+    if (!currentEntry) {
+      throw new Error(`Embedding with id ${id} not found`);
+    }
+    const updateData = {};
+    if (title !== void 0) updateData.title = title;
+    if (content !== void 0) updateData.content = content;
+    if (metadata !== void 0) updateData.metadata = metadata;
+    const contentChanged = content !== void 0 && content !== currentEntry.content;
+    let updatedEntity = await strapi.documents(CONTENT_TYPE_UID).update({
+      documentId: id,
+      data: updateData
+    });
+    if (contentChanged && pluginManager.isInitialized()) {
+      try {
+        await pluginManager.deleteEmbedding(id);
+        const result = await pluginManager.createEmbedding({
+          id,
+          title: title || currentEntry.title,
+          content,
+          collectionType: currentEntry.collectionType || "standalone",
+          fieldName: currentEntry.fieldName || "content"
+        });
+        updatedEntity = await strapi.documents(CONTENT_TYPE_UID).update({
+          documentId: id,
+          data: {
+            embeddingId: result.embeddingId,
+            embedding: result.embedding
+          }
+        });
+      } catch (error) {
+        console.error("Failed to update embedding in vector store:", error);
+      }
+    }
+    return updatedEntity;
+  },
+  async queryEmbeddings(query) {
+    if (!query || query.trim() === "") {
+      return { error: "Please provide a query" };
+    }
+    if (!pluginManager.isInitialized()) {
+      return { error: "Plugin not initialized. Check your configuration." };
+    }
+    try {
+      const response = await pluginManager.queryEmbedding(query);
+      return response;
+    } catch (error) {
+      console.error("Query failed:", error);
+      return { error: "Failed to query embeddings" };
+    }
+  },
+  async getEmbedding(id) {
+    return await strapi.documents(CONTENT_TYPE_UID).findOne({
+      documentId: String(id)
+    });
+  },
+  async getEmbeddings(params) {
+    const page = params?.page || 1;
+    const pageSize = params?.pageSize || 10;
+    const start = (page - 1) * pageSize;
+    const [data, totalCount] = await Promise.all([
+      strapi.documents(CONTENT_TYPE_UID).findMany({
+        limit: pageSize,
+        start,
+        filters: params?.filters
+      }),
+      strapi.documents(CONTENT_TYPE_UID).count({
+        filters: params?.filters
+      })
+    ]);
+    return {
+      data,
+      count: data.length,
+      totalCount
+    };
+  }
+});
+const services = {
+  embeddings
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};