Incremental index issue with ElasticVectorSearch

[telekosmos]

Checked other resources

• I added a very descriptive title to this question.
• I searched the LangChain documentation with the integrated search.
• I used the GitHub search to find a similar question and didn't find it.

Commit to Help

• I commit to help with one of those options 👆

Example Code

import { PostgresRecordManager } from '@langchain/community/indexes/postgres';
import { index } from 'langchain/indexes';
import { ElasticVectorSearch, ElasticClientArgs } from '@langchain/community/vectorstores/elasticsearch';
import { Client } from '@elastic/elasticsearch';
import { PoolConfig } from 'pg';
import { OpenAIEmbeddings } from '@langchain/openai';

const client = new Client({
  node: 'http://localhost:9200',
});
const clientArgs: ElasticClientArgs = {
  client,
  indexName: 'myindex',
};

const embeddings = new OpenAIEmbeddings({
  azureOpenAIApiKey: _azureOpenAIApiKey,
  azureOpenAIApiVersion: _azureOpenAIApiVersion,
  azureOpenAIApiInstanceName:  _azureOpenAIApiInstanceName,
  azureOpenAIApiDeploymentName: _azureOpenAIApiEmbeddingsDeploymentName,
});
const vectorStore = new ElasticVectorSearch(embeddings, clientArgs);

// Create a new record manager
const recordManagerConfig = {
  postgresConnectionOptions: {
    type: 'postgres',
    host: '127.0.0.1,
    port: 5432,
    user: 'theUser',
    password: 'daPassword',
    database: 'postgres',
  } as PoolConfig,
  tableName: 'upsertion_records',
};
const recordManager = new PostgresRecordManager('test_namespace', recordManagerConfig);

(async () => {
  await recordManager.createSchema();

  const doc1 = {
    pageContent: 'kitty',
    metadata: { source: 'kitty.txt' },
  };

  const doc2 = {
    pageContent: 'doggy',
    metadata: { source: 'doggy.txt' },
  };

  // prepare: clear
  await index({
    docsSource: [],
    recordManager,
    vectorStore,
    options: {
      cleanup: 'full',
      sourceIdKey: 'source',
    },
  });
 
  // will crash
  await index({
    docsSource: [doc1, doc2],
    recordManager,
    vectorStore,
    options: {
      cleanup: 'incremental',
      sourceIdKey: 'source',
    },
  });
})();

Description

Hi there
Using the javascript API, trying to follow this article I've observed the index(args: IndexArgs) function crashes when there is no documents to delete in the vector store if cleanup mode is incremental. Sample code is as posted above.

The code above will crash as is with an error similar to:

service-ai/node_modules/@elastic/transport/lib/Transport.js:492
                    throw new errors_1.ResponseError(result, errorOptions);
                          ^

ResponseError: parse_exception
	Root causes:
		parse_exception: request body is required
    at SniffingTransport.request (/service-ai/node_modules/@elastic/transport/lib/Transport.js:492:27)
    at process.processTicksAndRejections (node:internal/process/task_queues:95:5)
    at async Client.BulkApi [as bulk] (/service-ai/node_modules/@elastic/elasticsearch/lib/api/api/bulk.js:51:12)
    at async ElasticVectorSearch.delete (/service-ai/node_modules/@langchain/community/dist/vectorstores/elasticsearch.cjs:180:9)
    at async index (/service-ai/node_modules/langchain/dist/indexes/indexing.cjs:238:13)
    at async /service-ai/dist/lab.js:44:5 {

I wonder if this is a bug or the intended behaviour and the vector store has to be initialized some way. I've read this indexing workflow won't work properly if the store is pre-populated, but nothing about a crash in some circumstances.

Appreciate any help

System Info

macOS 14.3

$ npm ls langchain                                              
[email protected] /Users/telekosmos/Projects/gs/ob-service-ai
└── [email protected]

node -v
v20.11.0

Elastic

{
  "name": "9a40982229a8",
  "cluster_name": "docker-cluster",
  "cluster_uuid": "RWxNqn9-TCapAUqlu6fspR",
  "version": {
    "number": "8.11.0",
    "build_flavor": "default",
    "build_type": "docker",
    "build_hash": "d9ec3fa628c7b0ba3d25692e277ba26814820bb0",
    "build_date": "2023-11-04T10:04:57.184859352Z",
    "build_snapshot": false,
    "lucene_version": "9.8.0",
    "minimum_wire_compatibility_version": "7.17.0",
    "minimum_index_compatibility_version": "7.0.0"
  },
  "tagline": "You Know, for Search"
}

[dosubot[bot]]

Based on the error message you provided, it seems like the issue is related to the ElasticSearch bulk delete operation. The error parse_exception: request body is required indicates that the bulk delete operation is expecting a request body but it's not receiving one. This could happen if there are no documents to delete, which aligns with your description of the issue.

The index(args: IndexArgs) function in the LangChain JavaScript API is designed to handle the indexing process by managing document records, updating the vector store with new or updated documents, and optionally cleaning up documents that are no longer relevant. When there are no documents to delete in the vector store and the cleanup mode is set to incremental, the expected behavior of the function is not explicitly described in the provided context. However, based on the general behavior observed in the tests for the full cleanup mode when no new documents are added, it can be inferred that if the incremental cleanup mode behaves similarly in terms of handling no changes to the document set, the expected result would likely be:

{
    "num_added": 0,
    "num_deleted": 0,
    "num_skipped": 0,
    "num_updated": 0,
}

This inference is based on the consistent pattern across tests where no modifications to the document set result in all counts (num_added, num_deleted, num_skipped, num_updated) being zero. However, without explicit context or code handling the incremental cleanup mode specifically in this scenario, this is an educated guess rather than a confirmed behavior.

I found a similar solved discussion index function crashes with ElasticVectorSearch in incremental mode which was last updated on March 20, 2024. However, it's marked as no longer valid, so it might not be directly applicable to your case.

You mentioned that you're using LangChain version 0.1.12. I wasn't able to find specific changes made to the index(args: IndexArgs) function from version 0.1.12 to 0.1.13 within the repository. It's possible that the issue you're experiencing has been addressed in a newer version. If possible, I would recommend updating to the latest version (v0.1.13) and see if the issue persists.

If the issue still persists after updating, it would be helpful to have more information about your setup. Specifically, how you're initializing the vector store and the exact parameters you're passing to the index function. This could help in identifying if there's a specific condition or setup that's causing the issue.

Sources

• index function crashes with ElasticVectorSearch in incremental mode
• libs/langchain/tests/unit_tests/indexes/test_indexing.py
• libs/langchain/langchain/indexes/_api.py

About Dosu

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[telekosmos]

@dosu-bot the code snippet provided gives you the whole scenario to be run. you can add this code

const indexName = 'myindex';
  const exists = await client.indices.exists({ index: indexName });
  if (!exists) {
    console.warn(`index ${indexName} does not exist. creating...`);
    await client.indices.create({ index: indexName });
  }

just at the beginning of the async function in the case the index is not created in Elastic.

On the other hand, if you check the code of the index function at https://github.com/langchain-ai/langchainjs/blob/c9d445b3cf29c3253699fa4a375db9c560b4c2d3/langchain/src/indexes/indexing.ts, especifically at here deletions for increamental cleanup are got, but at here for full cleanup the same deletions are got but then at line 366 there is a guard on deletions having 0 length (preventing of calling vectorStore.delete with no elems).

I think that guard makes the difference between crashing with incremental and passing with full cleanup, but I need confirmation and recommendation about if a patch is needed either at that file or at the ElasticVectorSearch implementation.

[dosubot[bot]]

Based on the information you've provided and the context from the LangChain repository, it seems like the parse_exception: request body is required error you're encountering is likely a bug. This error is typically thrown by Elasticsearch when it expects a request body for an operation, but none is provided. In your case, this is happening when there are no documents to delete in the vector store and the cleanup mode is set to incremental.

The index function in the LangChain JavaScript API handles the incremental cleanup mode by not performing any deletion operations when there are no documents to delete. However, it appears that this logic might not be correctly implemented, causing the function to attempt a bulk delete operation with an empty request body, hence the error.

The index function should ideally check if there are any documents to delete before attempting the deletion operation. This can be done by checking if the list of documents (or document IDs) to be deleted is empty and skipping the deletion operation if it is. This logic seems to be present for the full cleanup mode, but not for the incremental mode, which might be causing the issue you're facing.

To fix this issue, you could patch the index function to include a check for an empty list of documents to delete before attempting the deletion operation, similar to the check that's already in place for the full cleanup mode. This should prevent the function from attempting a bulk delete operation with an empty request body and thus avoid the parse_exception: request body is required error.

Here's a potential patch for the index function:

// ... existing code ...

// prepare: clear
await index({
  docsSource: [],
  recordManager,
  vectorStore,
  options: {
    cleanup: 'full',
    sourceIdKey: 'source',
  },
});

// will crash
await index({
  docsSource: [doc1, doc2],
  recordManager,
  vectorStore,
  options: {
    cleanup: 'incremental',
    sourceIdKey: 'source',
  },
});

// ... existing code ...

// Patched index function
async function index(args: IndexArgs) {
  // ... existing code ...

  if (args.options.cleanup === 'incremental') {
    const docsToDelete = /* logic to determine documents to delete */;
    if (docsToDelete.length > 0) {
      // Only attempt deletion if there are documents to delete
      // ... existing deletion logic ...
    }
  }

  // ... existing code ...
}

Please note that this is a simplified example and the actual patch might need to be more complex, depending on the exact implementation of the index function and the structure of the IndexArgs type.

I hope this helps! If you have any further questions or need more clarification, feel free to ask.

Sources

• index function crashes with ElasticVectorSearch in incremental mode
• libs/community/langchain_community/vectorstores/elastic_vector_search.py
• libs/langchain/langchain/indexes/_api.py

About Dosu

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.

[dosubot[bot]]

Hey @telekosmos, great to see you back with another insightful question! Hope you're doing well.

Thank you for providing such a detailed issue report. Based on the code and error message you've provided, it seems like the index function is indeed crashing when there are no documents to delete in the vector store and the cleanup mode is set to 'incremental'. This is happening because the delete method in the ElasticVectorSearch class is trying to perform a bulk delete operation without checking if the ids array is empty.

In the index function, when the cleanup mode is set to 'incremental', it tries to delete documents from the vector store and the record manager based on the uidsToDelete array. If there are no documents to delete (i.e., the uidsToDelete array is empty), then no deletion operation is performed, and thus numDeleted remains 0. However, the delete method in the ElasticVectorSearch class does not handle the case where the ids array is empty, and this is causing the crash.

This behavior is not explicitly defined as a bug or intended in the LangChain JS framework. However, it would be more logical and efficient for the framework to handle such scenarios by checking if the ids array is empty before attempting to perform a deletion operation. This would prevent unnecessary operations and potential errors.

I would recommend opening an issue in the LangChain JS repository to bring this to the attention of the maintainers. They might consider adding a check for an empty ids array in the delete method of the ElasticVectorSearch class to handle this scenario.

In the meantime, as a workaround, you could add a check in your code before calling the index function to ensure that there are documents to delete in the vector store. Here's an example:

// Get the list of documents to delete
const docsToDelete = await recordManager.listKeys({
  before: indexStartDt,
  groupIds: sourceIds,
});

// Only call the index function if there are documents to delete
if (docsToDelete.length > 0) {
  await index({
    docsSource: [doc1, doc2],
    recordManager,
    vectorStore,
    options: {
      cleanup: 'incremental',
      sourceIdKey: 'source',
    },
  });
}

I hope this helps! If you have any other questions or need further clarification, please let me know.

Sources

• libs/langchain-community/src/vectorstores/couchbase.ts
• langchain/src/indexes/indexing.ts
• libs/langchain-community/src/vectorstores/elasticsearch.ts

About Dosu

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.