@vector_store
@staticmethod
def my_vector_store() -> ResourceDescriptor:
    return ResourceDescriptor(
        clazz=ResourceName.VectorStore.CHROMA_VECTOR_STORE,
        embedding_model="embedding_model",
        collection="my_chroma_store"
    )

@VectorStore
public static ResourceDescriptor vectorStore() {
    return ResourceDescriptor.Builder.newBuilder(ResourceName.VectorStore.ELASTICSEARCH_VECTOR_STORE)
            .addInitialArgument("embedding_model", "embeddingModel")
            .addInitialArgument("host", "http://localhost:9200")
            .addInitialArgument("index", "my_documents")
            .addInitialArgument("vector_field", "content_vector")
            .addInitialArgument("dims", 1536)
            .build();
}

# Create a semantic search query
query = VectorStoreQuery(
    query_text="What is Apache Flink Agents?",
    limit=3,
    collection_name="my_collection",        # optional: defaults to the store's collection
    filters={"category": "docs"},           # optional: unified equality filter
    extra_args={"where_document": {...}},   # optional: backend-specific parameters
)

// Simple semantic-search query (defaults to default collection, no filter)
VectorStoreQuery query = new VectorStoreQuery(
        "What is Apache Flink Agents?", // query text
        3                                // limit
);

// Query with filters and explicit collection
VectorStoreQuery filteredQuery = new VectorStoreQuery(
        VectorStoreQueryMode.SEMANTIC,
        "What is Apache Flink Agents?",
        3,
        "my_collection",
        Map.of("category", "docs"),      // unified equality filter
        Map.of()                          // extraArgs (backend-specific)
);

# Execute the query
result = vector_store.query(query)

// Execute the query
VectorStoreQueryResult result = vectorStore.query(query);

# get the vector store from runner context
vector_store: CollectionManageableVectorStore = ctx.get_resource("vector_store", ResourceType.VECTOR_STORE)

# create a collection (no-op if it already exists)
vector_store.create_collection_if_not_exists(
    "my_collection",
    metadata={"key1": "value1", "key2": "value2"},  # backend-specific, ignored if unsupported
)

# delete the collection
vector_store.delete_collection("my_collection")

// get the vector store from runner context
CollectionManageableVectorStore vectorStore =
        (CollectionManageableVectorStore)
                ctx.getResource("vector_store", ResourceType.VECTOR_STORE);

// create a collection (no-op if it already exists)
vectorStore.createCollectionIfNotExists(
        "my_collection",
        Map.of("key1", "value1", "key2", "value2")); // backend-specific, ignored if unsupported

// delete the collection
vectorStore.deleteCollection("my_collection");

# get the vector store from runner context
vector_store: CollectionManageableVectorStore = ctx.get_resource("vector_store", ResourceType.VECTOR_STORE)

# ensure the collection exists (no-op if it already does)
vector_store.create_collection_if_not_exists("my_collection")

# add documents to the collection (embeddings are auto-computed from `content`)
documents = [Document(id="doc1", content="the first doc", metadata={"key": "value1"}),
             Document(id="doc2", content="the second doc", metadata={"key": "value2"})]
vector_store.add(documents=documents, collection_name="my_collection")

# update documents in place — every document must already have its `id` set
vector_store.update(
    documents=[Document(id="doc1", content="rewritten first doc", metadata={"key": "value1"})],
    collection_name="my_collection",
)

# get documents by IDs
docs: List[Document] = vector_store.get(ids="doc2", collection_name="my_collection")
# get documents matching a metadata filter (limit defaults to 100; pass None for unbounded)
docs = vector_store.get(filters={"key": "value1"}, collection_name="my_collection")
# get all documents (bounded by `limit`, defaults to 100)
docs = vector_store.get(collection_name="my_collection")

# delete documents by IDs
vector_store.delete(ids=["doc1", "doc2"], collection_name="my_collection")
# delete documents matching a metadata filter
vector_store.delete(filters={"key": "value1"}, collection_name="my_collection")
# delete all documents
vector_store.delete(collection_name="my_collection")

// get the vector store from runner context
BaseVectorStore vectorStore =
        (BaseVectorStore) ctx.getResource("vectorStore", ResourceType.VECTOR_STORE);

// ensure the collection exists (no-op if it already does)
((CollectionManageableVectorStore) vectorStore)
        .createCollectionIfNotExists("my_collection", Map.of());

// add documents to the collection (embeddings are auto-computed from `content`)
List<Document> documents = List.of(
        new Document("the first doc.",  Map.of("key", "value1"), "doc1"),
        new Document("the second doc", Map.of("key", "value2"), "doc2"));
vectorStore.add(documents, "my_collection", Map.of());

// update documents in place — every document must already have its `id` set
vectorStore.update(
        List.of(new Document("rewritten first doc", Map.of("key", "value1"), "doc1")),
        "my_collection",
        Map.of());

// get documents by IDs (convenience overloads avoid passing nulls)
List<Document> docs = vectorStore.getByIds(List.of("doc1"), "my_collection");
// get documents matching a metadata filter
docs = vectorStore.getByFilters(Map.of("key", "value1"));
// full signature — pass `limit=null` for unbounded
docs = vectorStore.get(null, "my_collection", Map.of("key", "value1"), 100, Map.of());

// delete documents by IDs
vectorStore.deleteByIds(List.of("doc1", "doc2"), "my_collection");
// delete documents matching a metadata filter
vectorStore.deleteByFilters(Map.of("key", "value1"));
// delete all documents in a collection
vectorStore.delete(null, "my_collection", null, Map.of());

# Equality — "field equals value":
{"field": value}

# Multiple top-level keys are implicitly AND-ed:
{"user_id": "u1", "run_id": "r1"}

class MyAgent(Agent):

    # Embedding model setup (required for vector store)
    @embedding_model_connection
    @staticmethod
    def openai_connection() -> ResourceDescriptor:
        return ResourceDescriptor(
            clazz=ResourceName.EmbeddingModel.OPENAI_CONNECTION,
            api_key="your-api-key-here"
        )

    @embedding_model_setup
    @staticmethod
    def openai_embedding() -> ResourceDescriptor:
        return ResourceDescriptor(
            clazz=ResourceName.EmbeddingModel.OPENAI_SETUP,
            connection="openai_connection",
            model="your-embedding-model-here"
        )

    # In-memory Chroma setup
    @vector_store
    @staticmethod
    def chroma_store() -> ResourceDescriptor:
        return ResourceDescriptor(
            clazz=ResourceName.VectorStore.CHROMA_VECTOR_STORE,
            embedding_model="openai_embedding",
            collection="my_chroma_store"
        )

    @action(InputEvent.EVENT_TYPE)
    @staticmethod
    def search_documents(event: Event, ctx: RunnerContext) -> None:
        # Get the vector store from the runtime context
        vector_store = ctx.get_resource("chroma_store", ResourceType.VECTOR_STORE)

        # Create a semantic search query
        input_event = InputEvent.from_event(event)
        user_query = str(input_event.input)
        query = VectorStoreQuery(
            query_text=user_query,
            limit=3
        )

        # Perform the search
        result = vector_store.query(query)

        # Handle the VectorStoreQueryResult
        # Process the retrieved context as needed for your use case

public class MyAgent extends Agent {

    @EmbeddingModelConnection
    public static ResourceDescriptor embeddingConnection() {
        return ResourceDescriptor.Builder.newBuilder(ResourceName.EmbeddingModel.OLLAMA_CONNECTION)
                .addInitialArgument("host", "http://localhost:11434")
                .build();
    }

    @EmbeddingModelSetup
    public static ResourceDescriptor embeddingModel() {
        return ResourceDescriptor.Builder.newBuilder(ResourceName.EmbeddingModel.OLLAMA_SETUP)
                .addInitialArgument("connection", "embeddingConnection")
                .addInitialArgument("model", "nomic-embed-text")
                .build();
    }

    @VectorStore
    public static ResourceDescriptor vectorStore() {
        return ResourceDescriptor.Builder.newBuilder(ResourceName.VectorStore.ELASTICSEARCH_VECTOR_STORE)
                .addInitialArgument("embedding_model", "embeddingModel")
                .addInitialArgument("host", "http://localhost:9200")
                .addInitialArgument("index", "my_documents")
                .addInitialArgument("vector_field", "content_vector")
                .addInitialArgument("dims", 1536)
                .build();
    }

    @Action(listenEventTypes = {InputEvent.EVENT_TYPE})
    public static void searchDocuments(Event event, RunnerContext ctx) {
        InputEvent inputEvent = InputEvent.fromEvent(event);
        // Option 1: Manual search via the vector store
        VectorStore vectorStore = (VectorStore) ctx.getResource("vectorStore", ResourceType.VECTOR_STORE);
        String queryText = (String) inputEvent.getInput();
        VectorStoreQuery query = new VectorStoreQuery(queryText, 3);
        VectorStoreQueryResult result = vectorStore.query(query);

        // Option 2: Request context retrieval via built-in events
        ctx.sendEvent(new ContextRetrievalRequestEvent(queryText, "vectorStore"));
    }

    @Action(listenEventTypes = {ContextRetrievalResponseEvent.EVENT_TYPE})
    public static void onSearchResponse(Event event, RunnerContext ctx) {
        ContextRetrievalResponseEvent response = ContextRetrievalResponseEvent.fromEvent(event);
        List<Document> documents = response.getDocuments();
        // Process the retrieved documents...
    }
}

public class MyAgent extends Agent {

    @EmbeddingModelConnection
    public static ResourceDescriptor bedrockEmbeddingConnection() {
        return ResourceDescriptor.Builder.newBuilder(ResourceName.EmbeddingModel.BEDROCK_CONNECTION)
                .addInitialArgument("region", "us-east-1")
                .build();
    }

    @EmbeddingModelSetup
    public static ResourceDescriptor bedrockEmbedding() {
        return ResourceDescriptor.Builder.newBuilder(ResourceName.EmbeddingModel.BEDROCK_SETUP)
                .addInitialArgument("connection", "bedrockEmbeddingConnection")
                .addInitialArgument("dimensions", 1024)
                .build();
    }

    @VectorStore
    public static ResourceDescriptor opensearchStore() {
        return ResourceDescriptor.Builder.newBuilder(ResourceName.VectorStore.OPENSEARCH_VECTOR_STORE)
                .addInitialArgument("embedding_model", "bedrockEmbedding")
                .addInitialArgument("endpoint", "https://abc123.us-east-1.aoss.amazonaws.com")
                .addInitialArgument("index", "my-vectors")
                // service_type defaults to "serverless"; auth defaults to "iam"
                .addInitialArgument("dims", 1024)
                .build();
    }

    ...
}

@VectorStore
public static ResourceDescriptor opensearchDomainStore() {
    return ResourceDescriptor.Builder.newBuilder(ResourceName.VectorStore.OPENSEARCH_VECTOR_STORE)
            .addInitialArgument("embedding_model", "bedrockEmbedding")
            .addInitialArgument("endpoint", "https://my-domain.us-east-1.es.amazonaws.com")
            .addInitialArgument("index", "my-vectors")
            .addInitialArgument("service_type", "domain")
            .addInitialArgument("auth", "iam")
            .addInitialArgument("dims", 1024)
            .build();
}

@VectorStore
public static ResourceDescriptor opensearchDomainBasicAuth() {
    return ResourceDescriptor.Builder.newBuilder(ResourceName.VectorStore.OPENSEARCH_VECTOR_STORE)
            .addInitialArgument("embedding_model", "bedrockEmbedding")
            .addInitialArgument("endpoint", "https://my-domain.us-east-1.es.amazonaws.com")
            .addInitialArgument("index", "my-vectors")
            .addInitialArgument("service_type", "domain")
            .addInitialArgument("auth", "basic")
            .addInitialArgument("username", "admin")
            .addInitialArgument("password", "your-password")
            .addInitialArgument("dims", 1024)
            .build();
}

public class MyAgent extends Agent {

    @EmbeddingModelConnection
    public static ResourceDescriptor bedrockEmbeddingConnection() {
        return ResourceDescriptor.Builder.newBuilder(ResourceName.EmbeddingModel.BEDROCK_CONNECTION)
                .addInitialArgument("region", "us-east-1")
                .build();
    }

    @EmbeddingModelSetup
    public static ResourceDescriptor bedrockEmbedding() {
        return ResourceDescriptor.Builder.newBuilder(ResourceName.EmbeddingModel.BEDROCK_SETUP)
                .addInitialArgument("connection", "bedrockEmbeddingConnection")
                .addInitialArgument("dimensions", 1024)
                .build();
    }

    @VectorStore
    public static ResourceDescriptor s3VectorsStore() {
        return ResourceDescriptor.Builder.newBuilder(ResourceName.VectorStore.S3_VECTORS_VECTOR_STORE)
                .addInitialArgument("embedding_model", "bedrockEmbedding")
                .addInitialArgument("vector_bucket", "my-vector-bucket")
                .addInitialArgument("vector_index", "my-index")
                .addInitialArgument("region", "us-east-1")
                .build();
    }

    ...
}

class MyAgent(Agent):

    # Embedding model setup (required for vector store)
    @embedding_model_connection
    @staticmethod
    def openai_connection() -> ResourceDescriptor:
        return ResourceDescriptor(
            clazz=ResourceName.EmbeddingModel.OPENAI_CONNECTION,
            api_key="your-api-key-here"
        )

    @embedding_model_setup
    @staticmethod
    def openai_embedding() -> ResourceDescriptor:
        return ResourceDescriptor(
            clazz=ResourceName.EmbeddingModel.OPENAI_SETUP,
            connection="openai_connection",
          model="your-embedding-model-here"
        )

    # Vector store setup
    @vector_store
    @staticmethod
    def chroma_store() -> ResourceDescriptor:
        return ResourceDescriptor(
            clazz=ResourceName.VectorStore.CHROMA_VECTOR_STORE,
            embedding_model="openai_embedding",
            persist_directory="/path/to/chroma/data",  # For persistent storage
            collection="my_documents",
            auto_create_collection=True
            # Or use other modes:
            # "host": "localhost", "port": 8000  # For server mode
            # "api_key": "your-chroma-cloud-key"  # For cloud mode
        )

    ...

@vector_store
@staticmethod
def chroma_store() -> ResourceDescriptor:
    return ResourceDescriptor(
        clazz=ResourceName.VectorStore.CHROMA_VECTOR_STORE,
        embedding_model="your_embedding_model",
        collection="my_documents"
        # No connection configuration needed for in-memory mode
    )

@vector_store
@staticmethod
def chroma_store() -> ResourceDescriptor:
    return ResourceDescriptor(
        clazz=ResourceName.VectorStore.CHROMA_VECTOR_STORE,
        embedding_model="your_embedding_model",
        persist_directory="/path/to/chroma/data",
        collection="my_documents"
    )

@vector_store
@staticmethod
def chroma_store() -> ResourceDescriptor:
    return ResourceDescriptor(
        clazz=ResourceName.VectorStore.CHROMA_VECTOR_STORE,
        embedding_model="your_embedding_model",
        host="your-chroma-server.com",
        port=8000,
        collection="my_documents"
    )

@vector_store
@staticmethod
def chroma_store() -> ResourceDescriptor:
    return ResourceDescriptor(
        clazz=ResourceName.VectorStore.CHROMA_VECTOR_STORE,
        embedding_model="your_embedding_model",
        api_key="your-chroma-cloud-api-key",
        collection="my_documents"
    )

@VectorStore
public static ResourceDescriptor vectorStore() {
    return ResourceDescriptor.Builder.newBuilder(ResourceName.VectorStore.ELASTICSEARCH_VECTOR_STORE)
            .addInitialArgument("embedding_model", "embeddingModel")
            .addInitialArgument("host", "http://localhost:9200")
            .addInitialArgument("index", "my_documents")
            .addInitialArgument("vector_field", "content_vector")
            .addInitialArgument("dims", 1536)
            // Optional authentication
            // .addInitialArgument("username", "elastic")
            // .addInitialArgument("password", "secret")
            .build();
}

class MyAgent(Agent):

    # Embedding model setup (required for vector store)
    @embedding_model_connection
    @staticmethod
    def openai_connection() -> ResourceDescriptor:
        return ResourceDescriptor(
            clazz=ResourceName.EmbeddingModel.OPENAI_CONNECTION,
            api_key="your-api-key-here"
        )

    @embedding_model_setup
    @staticmethod
    def openai_embedding() -> ResourceDescriptor:
        return ResourceDescriptor(
            clazz=ResourceName.EmbeddingModel.OPENAI_SETUP,
            connection="openai_connection",
            model="your-embedding-model-here"
        )

    # Mem0 vector store backed by Qdrant
    @vector_store
    @staticmethod
    def mem0_store() -> ResourceDescriptor:
        return ResourceDescriptor(
            clazz=ResourceName.VectorStore.MEM0_VECTOR_STORE,
            embedding_model="openai_embedding",
            provider="qdrant",
            provider_config={"host": "localhost", "port": 6333, "embedding_model_dims": 1536},
            collection="my_documents"
        )

    ...

@VectorStore
public static ResourceDescriptor vectorStore() {
    return ResourceDescriptor.Builder.newBuilder(ResourceName.VectorStore.MILVUS_VECTOR_STORE)
            .addInitialArgument("embedding_model", "embeddingModel")
            .addInitialArgument("uri", "http://localhost:19530")
            .addInitialArgument("collection", "my_documents")
            .addInitialArgument("dims", 1536)
            .addInitialArgument("metric_type", "COSINE")
            .addInitialArgument("index_type", "AUTOINDEX")
            // Optional metadata JSON path indexes
            // .addInitialArgument("metadata_index_keys", List.of("user_id", "agent_id", "run_id"))
            .build();
}

class MyAgent(Agent):

    # Define embedding model (can be Java or Python implementation)
    @embedding_model_connection
    @staticmethod
    def my_embedding_connection() -> ResourceDescriptor:
        # Configure embedding model connection as needed
        pass

    @embedding_model_setup
    @staticmethod
    def my_embedding_model() -> ResourceDescriptor:
        # Configure embedding model setup as needed
        pass

    # Use Java vector store with embedding model
    @vector_store
    @staticmethod
    def java_vector_store() -> ResourceDescriptor:
        # In pure Java, the equivalent ResourceDescriptor would be:
        # ResourceDescriptor.Builder
        #     .newBuilder(ResourceName.VectorStore.ELASTICSEARCH_VECTOR_STORE)
        #     .addInitialArgument("embedding_model", "my_embedding_model")
        #     .addInitialArgument("host", "http://localhost:9200")
        #     .addInitialArgument("index", "my_documents")
        #     .addInitialArgument("dims", 768)
        #     .build();
        return ResourceDescriptor(
            clazz=ResourceName.VectorStore.JAVA_WRAPPER_COLLECTION_MANAGEABLE_VECTOR_STORE,
            java_clazz=ResourceName.VectorStore.Java.ELASTICSEARCH_VECTOR_STORE,
            embedding_model="my_embedding_model",
            host="http://localhost:9200",
            index="my_documents",
            dims=768
        )

    @action(InputEvent.EVENT_TYPE)
    @staticmethod
    def process_input(event: Event, ctx: RunnerContext) -> None:
        # Use Java vector store from Python
        input_event = InputEvent.from_event(event)
        vector_store = ctx.get_resource("java_vector_store", ResourceType.VECTOR_STORE)

        # Perform semantic search
        query = VectorStoreQuery(query_text=str(input_event.input), limit=3)
        result = vector_store.query(query)

        # Process the retrieved documents

public class MyAgent extends Agent {

    // Define embedding model (can be Java or Python implementation)
    @EmbeddingModelConnection
    public static ResourceDescriptor myEmbeddingConnection() {
        // Configure embedding model connection as needed
        return null;
    }

    @EmbeddingModelSetup
    public static ResourceDescriptor myEmbeddingModel() {
        // Configure embedding model setup as needed
        return null;
    }

    @VectorStore
    public static ResourceDescriptor pythonVectorStore() {
        // In pure Python, the equivalent ResourceDescriptor would be:
        // ResourceDescriptor(
        //     clazz=ResourceName.VectorStore.CHROMA_VECTOR_STORE,
        //     embedding_model="my_embedding_model",
        // )
        return ResourceDescriptor.Builder.newBuilder(ResourceName.VectorStore.PYTHON_WRAPPER_COLLECTION_MANAGEABLE_VECTOR_STORE)
                .addInitialArgument("pythonClazz", ResourceName.VectorStore.Python.CHROMA_VECTOR_STORE)
                .addInitialArgument("embedding_model", "myEmbeddingModel")
                .build();
    }

    @Action(listenEventTypes = {InputEvent.EVENT_TYPE})
    public static void processInput(Event event, RunnerContext ctx) throws Exception {
        InputEvent inputEvent = InputEvent.fromEvent(event);
        // Use Python vector store from Java
        VectorStore vectorStore =
            (VectorStore) ctx.getResource("pythonVectorStore", ResourceType.VECTOR_STORE);

        // Perform semantic search
        VectorStoreQuery query = new VectorStoreQuery((String) inputEvent.getInput(), 3);
        VectorStoreQueryResult result = vectorStore.query(query);

        // Process the retrieved documents
    }
}

class MyVectorStore(BaseVectorStore):
    # Add your custom configuration fields here

    @property
    def store_kwargs(self) -> Dict[str, Any]:
        # Return vector store-specific configuration
        # These parameters are merged with query-specific parameters
        return {"index": "my_index", ...}

    @override
    def get(
        self,
        ids: str | List[str] | None = None,
        collection_name: str | None = None,
        filters: Dict[str, Any] | None = None,
        limit: int | None = 100,
        **kwargs: Any,
    ) -> List[Document]:
        """Retrieve documents from the vector store.

        When ``ids`` is provided, the ``ids`` list itself bounds the result size
        and ``limit`` is effectively ignored. Without ``ids``, up to ``limit``
        documents matching ``filters`` (or all, when no filter is set) are
        returned. ``limit=None`` means unbounded.

        Args:
            ids: Unique identifier(s) of the documents to retrieve.
            collection_name: Target collection. If not provided, use the default collection.
            filters: Metadata filter in the unified DSL (equality only); ``None`` = no filter.
            limit: Maximum number of documents to return. Defaults to 100; pass ``None`` for unbounded.
            **kwargs: Vector store-specific parameters (offset, etc.).
        """
        documents: List[Document] = ...
        return documents

    @override
    def delete(
        self,
        ids: str | List[str] | None = None,
        collection_name: str | None = None,
        filters: Dict[str, Any] | None = None,
        **kwargs: Any,
    ) -> None:
        """Delete documents in the vector store.

        Args:
            ids: Unique identifier(s) of the documents to delete. If neither ``ids``
                 nor ``filters`` is provided, all documents in the collection are deleted.
            collection_name: Target collection. If not provided, use the default collection.
            filters: Metadata filter in the unified DSL (equality only); ``None`` = no filter.
            **kwargs: Vector store-specific parameters.
        """
        # delete the documents
        pass

    @override
    def _query_embedding(
        self,
        embedding: List[float],
        limit: int = 10,
        collection_name: str | None = None,
        filters: Dict[str, Any] | None = None,
        **kwargs: Any,
    ) -> List[Document]:
        """Perform vector search using a pre-computed embedding.

        Args:
            embedding: Pre-computed embedding vector for semantic search.
            limit: Maximum number of results to return (default: 10).
            collection_name: Target collection. If not provided, use the default collection.
            filters: Metadata filter in the unified DSL (equality only); ``None`` = no filter.
            **kwargs: Vector store-specific parameters (distance metrics, etc.).
        """
        documents: List[Document] = ...
        return documents

    @override
    def _add_embedding(
        self,
        *,
        documents: List[Document],
        collection_name: str | None = None,
        **kwargs: Any,
    ) -> List[str]:
        """Add documents with pre-computed embeddings to the vector store.

        Args:
            documents: Documents (with ``embedding`` populated) to add.
            collection_name: Target collection. If not provided, use the default collection.
            **kwargs: Vector store-specific parameters.

        Returns:
            List of document IDs that were added.
        """
        # add the documents
        ids: List[str] = ...
        return ids

    @override
    def _update_embedding(
        self,
        *,
        documents: List[Document],
        collection_name: str | None = None,
        **kwargs: Any,
    ) -> None:
        """Update documents with pre-computed embeddings. Identity is read from ``Document.id``.

        Args:
            documents: Documents carrying ``id`` plus the new content / metadata / embedding.
            collection_name: Target collection. If not provided, use the default collection.
            **kwargs: Vector store-specific parameters.
        """
        # update the documents
        pass

public class MyVectorStore extends BaseVectorStore {

    public MyVectorStore(
            ResourceDescriptor descriptor,
            ResourceContext resourceContext) {
        super(descriptor, resourceContext);
    }

    @Override
    public Map<String, Object> getStoreKwargs() {
        // Return vector store-specific configuration
        // These parameters are merged with query-specific parameters
        Map<String, Object> kwargs = new HashMap<>();
        kwargs.put("index", "my_index");
        return kwargs;
    }

    /**
     * Retrieve documents from the vector store.
     *
     * <p>When {@code ids} is provided, the {@code ids} list itself bounds the result size
     * and {@code limit} is effectively ignored. Without {@code ids}, up to {@code limit}
     * documents matching {@code filters} (or all, when no filter is set) are returned.
     *
     * @param ids        The ids of the documents. If null, retrieve documents matching {@code filters}.
     * @param collection Target collection. If null, retrieve from the default collection.
     * @param filters    Metadata filter in the unified DSL (equality only); {@code null} = no filter.
     * @param limit      Maximum number of documents to return. Defaults to 100; pass {@code null} for unbounded.
     * @param extraArgs  Additional arguments.
     */
    @Override
    public List<Document> get(
            @Nullable List<String> ids,
            @Nullable String collection,
            @Nullable Map<String, Object> filters,
            @Nullable Integer limit,
            Map<String, Object> extraArgs)
            throws IOException {
        List<Document> documents = ...;
        return documents;
    }

    /**
     * Delete documents in the vector store.
     *
     * @param ids        The ids of the documents. If null, delete documents matching {@code filters}.
     * @param collection Target collection. If null, use the default collection.
     * @param filters    Metadata filter in the unified DSL (equality only); {@code null} = no filter.
     * @param extraArgs  Additional arguments.
     */
    @Override
    public void delete(
            @Nullable List<String> ids,
            @Nullable String collection,
            @Nullable Map<String, Object> filters,
            Map<String, Object> extraArgs)
            throws IOException {
        // delete the documents
    }

    /**
     * Performs vector search using a pre-computed embedding.
     *
     * @param embedding  The embedding vector to search with.
     * @param limit      Maximum number of results to return.
     * @param collection Target collection. If null, query the default collection.
     * @param filters    Metadata filter in the unified DSL (equality only); {@code null} = no filter.
     * @param args       Additional arguments for the vector search.
     */
    @Override
    public List<Document> queryEmbedding(
            float[] embedding,
            int limit,
            @Nullable String collection,
            @Nullable Map<String, Object> filters,
            Map<String, Object> args) {
        List<Document> documents = ...;
        return documents;
    }

    /**
     * Add documents with pre-computed embeddings to the vector store.
     *
     * @param documents  Documents (with embeddings populated) to add.
     * @param collection Target collection. If null, add to the default collection.
     * @param extraArgs  Additional arguments.
     * @return IDs of the added documents.
     */
    @Override
    public List<String> addEmbedding(
            List<Document> documents, @Nullable String collection, Map<String, Object> extraArgs)
            throws IOException {
        // add the documents
        List<String> ids = ...;
        return ids;
    }

    /**
     * Update documents with pre-computed embeddings. Identity is read from {@link Document#getId()}.
     *
     * @param documents  Documents carrying id plus the new content / metadata / embedding.
     * @param collection Target collection. If null, use the default collection.
     * @param extraArgs  Additional arguments.
     */
    @Override
    public void updateEmbedding(
            List<Document> documents, @Nullable String collection, Map<String, Object> extraArgs)
            throws IOException {
        // update the documents
    }
}

class MyVectorStore(CollectionManageableVectorStore):
    # Add your custom configuration fields here

    # implementation for `BaseVectorStore` methods (see above).

    @override
    def create_collection_if_not_exists(self, name: str, **kwargs: Any) -> None:
        """Create the collection if it doesn't already exist; no-op otherwise.

        Args:
            name: Name of the collection.
            **kwargs: Backend-specific options applied only when the collection
                is created (e.g. Chroma's ``metadata`` dict, Pinecone's
                ``dimension`` / ``metric``). Document which keys are recognized;
                unknown keys should be ignored.
        """
        # create the collection if missing
        pass

    @override
    def delete_collection(self, name: str) -> None:
        """Delete a collection.

        Args:
            name: Name of the collection.
        """
        # delete the collection
        pass

public class MyVectorStore extends BaseVectorStore
        implements CollectionManageableVectorStore {
    // Add your custom configuration fields here

    // implementation for `BaseVectorStore` methods (see above).

    /**
     * Create the collection if it doesn't already exist; no-op otherwise.
     *
     * @param name   The name of the collection.
     * @param kwargs Backend-specific options applied only when the collection is created.
     *               Document which keys are recognized; unknown keys should be ignored.
     */
    @Override
    public void createCollectionIfNotExists(String name, Map<String, Object> kwargs) throws Exception {
        // create the collection if missing
    }

    /**
     * Delete a collection by name.
     *
     * @param name The name of the collection to delete.
     */
    @Override
    public void deleteCollection(String name) throws Exception {
        // delete the collection
    }
}