"ValueError: Vectorstore has not implemented the delete method" occurs when using the asyncio version of index

[oubeichen]

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 asyncio

from langchain.indexes import SQLRecordManager, aindex
from langchain_chroma import Chroma
from langchain_core.documents import Document
from langchain_core.embeddings import FakeEmbeddings


async def main():

    collection_name = "test_index"

    embedding = FakeEmbeddings(size=100)

    vectorstore = Chroma(collection_name, embedding_function=embedding)

    namespace = f"chroma/{collection_name}"
    record_manager = SQLRecordManager(
        namespace,
        db_url="sqlite+aiosqlite:///record_manager_cache.sqlite3",
        async_mode=True,
    )

    await record_manager.acreate_schema()

    doc = Document(page_content="kitty", metadata={"source": "kitty.txt"})

    await aindex(
        [doc],
        record_manager,
        vectorstore,
        cleanup=None,
        source_id_key="source",
    )

asyncio.run(main())

Description

I'm using LangChain's built-in aindex to create document indexes. However, most VectorStore implementations in LangChain (such as Chroma) do not override the adelete method, instead relying on the default method from the parent class, which is actually functional. But at this line:

langchain/libs/core/langchain_core/indexing/api.py

Line 523 in f679ed7

if type(destination).adelete == VectorStore.adelete:

There's a strict requirement that the method needs to be overridden. Could you explain why this is necessary?

Currently, my workaround is to create a new class that inherits from Chroma and implements the adelete method:

class AsyncChroma(Chroma):
    """Async Chroma."""

    async def adelete(self, *args: Any, **kwargs: Any) -> bool | None:
        """Async delete by vector ID or other criteria."""
        return await super().adelete(*args, **kwargs)

System Info

System Information

OS: Darwin
OS Version: Darwin Kernel Version 21.6.0: Mon Jun 24 00:56:10 PDT 2024; root:xnu-8020.240.18.709.2~1/RELEASE_X86_64
Python Version: 3.11.9 (main, Jul 3 2024, 14:33:17) [Clang 14.0.0 (clang-1400.0.29.202)]

Package Information

langchain_core: 0.2.29
langchain: 0.2.12
langchain_community: 0.2.11
langsmith: 0.1.98
langchain_chroma: 0.1.2
langchain_openai: 0.1.20
langchain_text_splitters: 0.2.2
langchain_unstructured: 0.1.1

Optional packages not installed

langgraph
langserve

Other Dependencies

aiohttp: 3.10.2
async-timeout: Installed. No version info available.
chromadb: 0.5.5
dataclasses-json: 0.6.7
fastapi: 0.112.0
jsonpatch: 1.33
numpy: 1.26.4
openai: 1.40.2
orjson: 3.10.7
packaging: 24.1
pydantic: 2.8.2
PyYAML: 6.0.2
requests: 2.32.3
SQLAlchemy: 2.0.32
tenacity: 8.5.0
tiktoken: 0.7.0
typing-extensions: 4.12.2
unstructured-client: 0.24.1

[dosubot[bot]]

Hey there, @oubeichen! I'm here to help you with any bugs, questions, or if you'd like to become a contributor. Let's tackle this issue together!

The adelete method needs to be overridden in VectorStore implementations like Chroma to provide asynchronous deletion functionality. This is necessary to handle asynchronous operations efficiently, especially when dealing with databases or external APIs that support asynchronous calls. By overriding adelete, the implementation can ensure that deletions are performed without blocking the main execution thread, which is crucial for maintaining performance and responsiveness in applications that require concurrent operations.

For example, in the Cassandra implementation, the adelete method is defined as follows:

async def adelete(
    self, ids: Optional[List[str]] = None, **kwargs: Any
) -> Optional[bool]:
    """Delete by vector IDs.

    Args:
        ids: List of ids to delete.

    Returns:
        Optional[bool]: True if deletion is successful,
        False otherwise, None if not implemented.
    """

    if ids is None:
        raise ValueError("No ids provided to delete.")

    for document_id in ids:
        await self.adelete_by_document_id(document_id)
    return True

This method allows for asynchronous deletion of documents by their IDs, leveraging concurrency to handle multiple delete requests efficiently. The use of asynchronous operations ensures that the deletion process does not block the main execution thread, thus maintaining the application's performance and responsiveness ^[1].

Your workaround of creating a subclass (AsyncChroma) that implements the adelete method is a valid approach to meet this requirement.

To continue talking to Dosu, mention @dosu.