fix(community): Add INSERT support to PrismaVectorStore for ParentDocumentRetriever compatibility (#8833)

Previously, PrismaVectorStore only used UPDATE statements when adding vectors, which caused
silent failures when used with ParentDocumentRetriever. The retriever creates new child
documents that don't exist in the database, so UPDATE statements would succeed but not
create any records.

Changes:
- Add new `addDocumentsWithVectors` method that uses INSERT statements to create records
- Modify `addDocuments` to use `addDocumentsWithVectors` instead of `addVectors`
- Maintain backward compatibility by keeping the original `addVectors` method unchanged
- Add tests to verify the new behavior and ensure no regression

This fix ensures PrismaVectorStore works correctly with ParentDocumentRetriever while
maintaining compatibility with existing code.

Fixes #8833

Author: christian-bromann

libs/langchain-community/src/vectorstores/prisma.ts

@@ -303,7 +303,7 @@ export class PrismaVectorStore<
    */
   async addDocuments(documents: Document<TModel>[]) {
     const texts = documents.map(({ pageContent }) => pageContent);
-    return this.addVectors(
+    return this.addDocumentsWithVectors(
       await this.embeddings.embedDocuments(texts),
       documents
     );
@@ -350,6 +350,58 @@ export class PrismaVectorStore<
     );
   }
 
+  /**
+   * Adds documents with their corresponding vectors to the store using INSERT statements.
+   * This method ensures documents are created if they don't exist, making it compatible
+   * with ParentDocumentRetriever which creates new child documents.
+   * @param vectors The vectors to add.
+   * @param documents The documents associated with the vectors.
+   * @returns A promise that resolves when the documents have been added.
+   */
+  async addDocumentsWithVectors(
+    vectors: number[][],
+    documents: Document<TModel>[]
+  ) {
+    // table name, column name cannot be parametrised
+    // these fields are thus not escaped by Prisma and can be dangerous if user input is used
+    const tableNameRaw = this.Prisma.raw(`"${this.tableName}"`);
+    const vectorColumnRaw = this.Prisma.raw(`"${this.vectorColumnName}"`);
+
+    // Build column names for INSERT statement
+    const columnNames = this.selectColumns.map((col) =>
+      this.Prisma.raw(`"${col}"`)
+    );
+    const allColumns = [...columnNames, vectorColumnRaw];
+
+    await this.db.$transaction(
+      vectors.map((vector, idx) => {
+        const document = documents[idx];
+        const vectorString = `[${vector.join(",")}]`;
+
+        // Build values for each column
+        const columnValues = this.selectColumns.map((col) => {
+          if (col === this.contentColumn) {
+            return document.pageContent;
+          }
+          return document.metadata[col];
+        });
+
+        // Add vector as the last value
+        const allValues = [
+          ...columnValues,
+          this.Prisma.sql`${vectorString}::vector`,
+        ];
+
+        return this.db.$executeRaw(
+          this.Prisma.sql`
+            INSERT INTO ${tableNameRaw} (${this.Prisma.join(allColumns, ", ")})
+            VALUES (${this.Prisma.join(allValues, ", ")})
+          `
+        );
+      })
+    );
+  }
+
   /**
    * Performs a similarity search with the specified query.
    * @param query The query to use for the similarity search.

libs/langchain-community/src/vectorstores/tests/prisma.test.ts

@@ -1,6 +1,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { FakeEmbeddings } from "@langchain/core/utils/testing";
 import { jest, test, expect } from "@jest/globals";
+import { Document } from "@langchain/core/documents";
 import { PrismaVectorStore } from "../prisma.js";
 
 class Sql {
@@ -39,6 +40,7 @@ describe("Prisma", () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
+
   test("passes provided filters with simiaritySearch", async () => {
     const embeddings = new FakeEmbeddings();
     const store = new PrismaVectorStore(new FakeEmbeddings(), {
@@ -270,4 +272,111 @@ describe("Prisma", () => {
       expect(sqlCall).toBeDefined();
     });
   });
+
+  test("addDocumentsWithVectors creates new documents with INSERT", async () => {
+    const embeddings = new FakeEmbeddings();
+    const store = new PrismaVectorStore(embeddings, {
+      db: mockPrismaClient,
+      prisma: mockPrismaNamespace,
+      tableName: "test",
+      vectorColumnName: "vector",
+      columns: mockColumns,
+    });
+
+    const documents = [
+      new Document({
+        pageContent: "test content 1",
+        metadata: { id: "doc1", custom: "value1" },
+      }),
+      new Document({
+        pageContent: "test content 2",
+        metadata: { id: "doc2", custom: "value2" },
+      }),
+    ];
+
+    const vectors = [
+      [1, 2, 3],
+      [4, 5, 6],
+    ];
+
+    // Mock the transaction to capture the SQL statements
+    $transaction.mockImplementation((queries) => {
+      // Verify that INSERT statements are being used
+      expect(queries).toHaveLength(2);
+      return Promise.resolve();
+    });
+
+    await store.addDocumentsWithVectors(vectors, documents);
+
+    expect($transaction).toHaveBeenCalledTimes(1);
+    expect($executeRaw).toHaveBeenCalledTimes(2);
+  });
+
+  test("addDocuments uses addDocumentsWithVectors instead of addVectors", async () => {
+    const embeddings = new FakeEmbeddings();
+    const store = new PrismaVectorStore(embeddings, {
+      db: mockPrismaClient,
+      prisma: mockPrismaNamespace,
+      tableName: "test",
+      vectorColumnName: "vector",
+      columns: mockColumns,
+    });
+
+    const documents = [
+      new Document({
+        pageContent: "test content",
+        metadata: { id: "doc1" },
+      }),
+    ];
+
+    // Spy on both methods
+    const addDocumentsWithVectorsSpy = jest
+      .spyOn(store, "addDocumentsWithVectors")
+      .mockResolvedValue();
+    const addVectorsSpy = jest.spyOn(store, "addVectors").mockResolvedValue();
+
+    await store.addDocuments(documents);
+
+    // Verify addDocumentsWithVectors was called
+    expect(addDocumentsWithVectorsSpy).toHaveBeenCalledTimes(1);
+    // Verify addVectors was NOT called
+    expect(addVectorsSpy).not.toHaveBeenCalled();
+  });
+
+  test("addVectors still uses UPDATE statements for backward compatibility", async () => {
+    const embeddings = new FakeEmbeddings();
+    const store = new PrismaVectorStore(embeddings, {
+      db: mockPrismaClient,
+      prisma: mockPrismaNamespace,
+      tableName: "test",
+      vectorColumnName: "vector",
+      columns: mockColumns,
+    });
+
+    const documents = [
+      new Document({
+        pageContent: "test content",
+        metadata: { id: "doc1" },
+      }),
+    ];
+
+    const vectors = [[1, 2, 3]];
+
+    // Mock sql function to capture the SQL template
+    let capturedSql = "";
+    // @ts-expect-error - we are mocking the sql function
+    sql.mockImplementation((strings: string[], ...values) => {
+      capturedSql = strings.join("");
+      return { strings, values };
+    });
+
+    $transaction.mockResolvedValue([]);
+
+    await store.addVectors(vectors, documents);
+
+    expect($transaction).toHaveBeenCalledTimes(1);
+    // Verify UPDATE statement is used
+    expect(capturedSql).toContain("UPDATE");
+    expect(capturedSql).not.toContain("INSERT");
+  });
 });