# Vector Stores

> **Version:** langchain-mariadb v0.0.21

## DistanceStrategy

Distance strategies for vector similarity.

### Attributes

* **EUCLIDEAN**:
* **COSINE**:

***

## TableConfig

Configuration for database table names.

### Constructor

```python
__init__(embedding_table: Optional[str] = None, collection_table: Optional[str] = None) -> None
```

Initialize TableConfig with custom or default table names.

**Parameters:**

* **embedding\_table** (`Optional[str]`): Name for embedding table (default: langchain\_embedding)
* **collection\_table** (`Optional[str]`): Name for collection table (default: langchain\_collection)

### Methods

#### `default`

```python
default() -> 'TableConfig'
```

Create TableConfig with default values.

### Attributes

* **embedding\_table** (`str`):
* **collection\_table** (`str`):

***

## ColumnConfig

Configuration for database column names.

### Constructor

```python
__init__(
    embedding_id: Optional[str] = None,
    embedding: Optional[str] = None,
    content: Optional[str] = None,
    metadata: Optional[str] = None,
    collection_id: Optional[str] = None,
    collection_label: Optional[str] = None,
    collection_metadata: Optional[str] = None
) -> None
```

Initialize ColumnConfig with custom or default column names.

**Parameters:**

* **embedding\_id** (`Optional[str]`): Name for embedding ID column (default: id)
* **embedding** (`Optional[str]`): Name for embedding vector column (default: embedding)
* **content** (`Optional[str]`): Name for content column (default: content)
* **metadata** (`Optional[str]`): Name for metadata column (default: metadata)
* **collection\_id** (`Optional[str]`): Name for collection ID column (default: id)
* **collection\_label** (`Optional[str]`): Name for collection label column (default: label)
* **collection\_metadata** (`Optional[str]`): Name for collection metadata column (default: metadata)

### Methods

#### `default`

```python
default() -> 'ColumnConfig'
```

Create ColumnConfig with default values.

### Attributes

* **embedding\_id** (`str`):
* **embedding** (`str`):
* **content** (`str`):
* **metadata** (`str`):
* **collection\_id** (`str`):
* **collection\_label** (`str`):
* **collection\_metadata** (`str`):

***

## MariaDBStoreSettings

Configuration for MariaDBStore.

### Constructor

```python
__init__(
    tables: Optional[TableConfig] = None,
    columns: Optional[ColumnConfig] = None,
    pre_delete_collection: bool = False,
    lazy_init: bool = False
) -> None
```

Initialize MariaDBStoreSettings with custom or default configurations.

**Parameters:**

* **tables** (`Optional[TableConfig]`): Table configuration
* **columns** (`Optional[ColumnConfig]`): Column configuration
* **pre\_delete\_collection** (`bool`): delete existing collection (default: False)

### Methods

#### `default`

```python
default() -> 'MariaDBStoreSettings'
```

Create MariaDBStoreSettings with default values.

### Attributes

* **tables** (`TableConfig`):
* **columns** (`ColumnConfig`):
* **pre\_delete\_collection** (`bool`):
* **lazy\_init** (`bool`):

***

## MariaDBStore

MariaDB vector store integration for LangChain.

**Examples:**

```python
Basic usage::

    from langchain_mariadb import MariaDBStore
    from langchain_openai import OpenAIEmbeddings

    # Create connection
    url = "mariadb+mariadbconnector://user:pass@localhost/db"
    embeddings = OpenAIEmbeddings()

    # Create vector store
    store = MariaDBStore.from_texts(
        texts=["Hello, world!", "Another text"],
        embedding=embeddings,
        datasource=url,
        collection_name="my_collection"
    )

    # Search similar texts
    results = store.similarity_search("Hello", k=2)

Search with metadata filter::

    results = store.similarity_search(
        "Hello",
        filter={"category": "greeting"}
    )

Complex filter with operators::

    results = store.similarity_search(
        "Hello",
        filter={
            "$and": [
                {"category": "greeting"},
                {"language": {"$in": ["en", "es"]}}
            ]
        }
    )

Asynchronous usage::

    import asyncio

    async def search_docs():
        results = await store.amax_marginal_relevance_search(
            "Hello", k=2, fetch_k=10, lambda_mult=0.5
        )
        return results

    results = asyncio.run(search_docs())

Custom configuration::

    from langchain_mariadb import (
        MariaDBStore, MariaDBStoreSettings,
        TableConfig, ColumnConfig
    )

    config = MariaDBStoreSettings(
        tables=TableConfig(
            embedding_table="custom_embeddings",
            collection_table="custom_collections"
        ),
        columns=ColumnConfig(
            embedding_id="doc_id",
            content="text_content",
            metadata="doc_metadata"
        )
    )

    store = MariaDBStore.from_texts(
        texts=["Hello"],
        embedding=embeddings,
        datasource=url,
        config=config
    )

Working with documents::

    from langchain_core.documents import Document

    documents = [
        Document(
            page_content="Hello",
            metadata={"source": "greeting.txt"}
        ),
        Document(
            page_content="World",
            metadata={"source": "greeting.txt"}
        )
    ]

    store = MariaDBStore.from_documents(
        documents=documents,
        embedding=embeddings,
        datasource=url
    )

    # Add more documents
    store.add_documents(documents)
```

### Constructor

```python
__init__(
    embeddings: Embeddings,
    embedding_length: Optional[int] = None,
    datasource: Union[Engine | str],
    collection_name: str = _LANGCHAIN_DEFAULT_COLLECTION_NAME,
    collection_metadata: Optional[dict] = None,
    distance_strategy: DistanceStrategy = DistanceStrategy.COSINE,
    config: MariaDBStoreSettings = MariaDBStoreSettings(),
    logger: Optional[logging.Logger] = None,
    engine_args: Optional[dict[str, Any]] = None,
    relevance_score_fn: Optional[Callable[[float], float]] = None
) -> None
```

Initialize the MariaDB vector store.

**Parameters:**

* **embeddings** (`Embeddings`): Embeddings object for creating embeddings
* **embedding\_length** (`Optional[int]`): Length of embedding vectors (default: 1536)
* **datasource** (`Union[Engine | str]`): datasource (connection string, sqlalchemy engine or MariaDB connection pool)
* **collection\_name** (`str`): Name of the collection to store vectors
* **collection\_metadata** (`Optional[dict]`): Optional metadata for the collection
* **distance\_strategy** (`DistanceStrategy`): Strategy for distances (COSINE or EUCLIDEAN)
* **config** (`MariaDBStoreSettings`): Store configuration for tables and columns
* **logger** (`Optional[logging.Logger]`): Optional logger instance for debugging
* **relevance\_score\_fn** (`Optional[Callable[[float], float]]`): function to override relevance score calculation

### Methods

#### `create_tables_if_not_exists`

```python
create_tables_if_not_exists() -> None
```

Create the necessary database tables if they don't exist.

#### `drop_tables`

```python
drop_tables() -> None
```

Drop all tables used by the vector store.

#### `create_collection`

```python
create_collection() -> None
```

Create a new collection or retrieve existing one.

#### `delete_collection`

```python
delete_collection() -> None
```

Delete the current collection and its associated data.

#### `delete`

```python
delete(ids: Optional[List[str]] = None, kwargs: Any = {}) -> None
```

Delete vectors by their IDs.

**Parameters:**

* **ids** (`Optional[List[str]]`): List of IDs to delete
* \*\***kwargs** (`Any`): Additional arguments (not used)

#### `get_by_ids`

```python
get_by_ids(ids: Sequence[str]) -> List[Document]
```

Get documents by their IDs.

#### `add_embeddings`

```python
add_embeddings(
    texts: Sequence[str],
    embeddings: List[List[float]],
    metadatas: Optional[List[dict]] = None,
    ids: Optional[List[str]] = None,
    kwargs: Any = {}
) -> List[str]
```

Add embeddings to the vectorstore.

**Parameters:**

* **texts** (`Sequence[str]`): Sequence of strings to add
* **embeddings** (`List[List[float]]`): List of embedding vectors
* **metadatas** (`Optional[List[dict]]`): Optional list of metadata dicts for each text
* **ids** (`Optional[List[str]]`): Optional list of IDs for the documents
* \*\***kwargs** (`Any`): Additional arguments (not used)

**Returns:**

`List[str]` - List of IDs for the added documents

**Raises:**

* **ValueError**: If any provided ID contains invalid characters

#### `add_texts`

```python
add_texts(
    texts: Iterable[str],
    metadatas: Optional[List[dict]] = None,
    ids: Optional[List[str]] = None,
    kwargs: Any = {}
) -> List[str]
```

Run more texts through the embeddings and add to the vectorstore.

**Parameters:**

* **texts** (`Iterable[str]`): Iterable of strings to add to the vectorstore.
* **metadatas** (`Optional[List[dict]]`): Optional list of metadatas associated with the texts.
* **ids** (`Optional[List[str]]`): Optional list of ids for the texts. If not provided, will generate a new id for each text.
* **kwargs** (`Any`): vectorstore specific parameters

**Returns:**

`List[str]` - List of ids from adding the texts into the vectorstore.

#### `similarity_search`

```python
similarity_search(
    query: str,
    k: int = 4,
    filter: Union[None, dict] = None,
    kwargs: Any = {}
) -> List[Document]
```

Run similarity search with MariaDB.

**Parameters:**

* **query** (`str`): Query text to search for
* **k** (`int`): Number of results to return (default: 4)
* **filter** (`Union[None, dict]`): Optional filter by metadata
* \*\***kwargs** (`Any`): Additional arguments passed to similarity\_search\_by\_vector

**Returns:**

`List[Document]` - List of Documents most similar to the query

#### `similarity_search_with_score`

```python
similarity_search_with_score(query: str, k: int = 4, filter: Union[None, dict] = None) -> List[Tuple[Document, float]]
```

Return docs most similar to query along with scores.

**Parameters:**

* **query** (`str`): Text to look up documents similar to
* **k** (`int`): Number of Documents to return (default: 4)
* **filter** (`Union[None, dict]`): Optional filter by metadata

**Returns:**

`List[Tuple[Document, float]]` - List of tuples of (Document, similarity\_score)

#### `similarity_search_with_score_by_vector`

```python
similarity_search_with_score_by_vector(embedding: List[float], k: int = 4, filter: Union[None, dict] = None) -> List[Tuple[Document, float]]
```

Return docs most similar to embedding vector along with scores.

**Parameters:**

* **embedding** (`List[float]`): Embedding vector to look up documents similar to
* **k** (`int`): Number of Documents to return (default: 4)
* **filter** (`Union[None, dict]`): Optional filter by metadata

**Returns:**

`List[Tuple[Document, float]]` - List of tuples of (Document, similarity\_score)

#### `similarity_search_by_vector`

```python
similarity_search_by_vector(
    embedding: List[float],
    k: int = 4,
    filter: Union[None, dict] = None,
    kwargs: Any = {}
) -> List[Document]
```

Return docs most similar to embedding vector.

**Parameters:**

* **embedding** (`List[float]`): Embedding vector to look up documents similar to
* **k** (`int`): Number of Documents to return (default: 4)
* **filter** (`Union[None, dict]`): Optional metadata filter
* \*\***kwargs** (`Any`): Additional arguments (not used)

**Returns:**

`List[Document]` - List of Documents most similar to the query vector

#### `max_marginal_relevance_search`

```python
max_marginal_relevance_search(
    query: str,
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    filter: Union[None, dict] = None,
    kwargs: Any = {}
) -> List[Document]
```

Return docs selected using maximal marginal relevance.

**Parameters:**

* **query** (`str`): Text to look up documents similar to
* **k** (`int`): Number of documents to return (default: 4)
* **fetch\_k** (`int`): Number of documents to fetch before selecting top-k (default: 20)
* **lambda\_mult** (`float`): Balance between relevance and diversity, 0-1 (default: 0.5) 0 = maximize diversity, 1 = maximize relevance
* **filter** (`Union[None, dict]`): Optional metadata filter
* \*\***kwargs** (`Any`): Additional arguments passed to search\_by\_vector

**Returns:**

`List[Document]` - List of Documents selected by maximal marginal relevance

#### `amax_marginal_relevance_search`

```python
amax_marginal_relevance_search(
    query: str,
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    filter: Union[None, dict] = None,
    kwargs: Any = {}
) -> List[Document]
```

Return docs selected using maximal marginal relevance asynchronously.

**Parameters:**

* **query** (`str`): Text to look up documents similar to
* **k** (`int`): Number of documents to return (default: 4)
* **fetch\_k** (`int`): Number of documents to fetch before selecting top-k (default: 20)
* **lambda\_mult** (`float`): Balance between relevance and diversity, 0-1 (default: 0.5) 0 = maximize diversity, 1 = maximize relevance
* **filter** (`Union[None, dict]`): Optional metadata filter
* \*\***kwargs** (`Any`): Additional arguments passed to search\_by\_vector

**Returns:**

`List[Document]` - List of Documents selected by maximal marginal relevance

#### `max_marginal_relevance_search_with_score`

```python
max_marginal_relevance_search_with_score(
    query: str,
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    filter: Union[None, dict] = None,
    kwargs: Any = {}
) -> List[Tuple[Document, float]]
```

Return docs selected using maximal marginal relevance with scores.

**Parameters:**

* **query** (`str`): Text to look up documents similar to
* **k** (`int`): Number of documents to return (default: 4)
* **fetch\_k** (`int`): Number of documents to fetch before selecting top-k (default: 20)
* **lambda\_mult** (`float`): Balance between relevance and diversity, 0-1 (default: 0.5) 0 = maximize diversity, 1 = maximize relevance
* **filter** (`Union[None, dict]`): Optional metadata filter
* \*\***kwargs** (`Any`): Additional arguments passed to search\_by\_vector

**Returns:**

`List[Tuple[Document, float]]` - List of tuples of (Document, score) selected by maximal marginal relevance

#### `amax_marginal_relevance_search_with_score`

```python
amax_marginal_relevance_search_with_score(
    query: str,
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    filter: Union[None, dict] = None,
    kwargs: Any = {}
) -> List[Tuple[Document, float]]
```

Return docs selected using maximal marginal relevance with scores asynchronously.

**Parameters:**

* **query** (`str`): Text to look up documents similar to
* **k** (`int`): Number of documents to return (default: 4)
* **fetch\_k** (`int`): Number of documents to fetch before selecting top-k (default: 20)
* **lambda\_mult** (`float`): Balance between relevance and diversity, 0-1 (default: 0.5) 0 = maximize diversity, 1 = maximize relevance
* **filter** (`Union[None, dict]`): Optional metadata filter
* \*\***kwargs** (`Any`): Additional arguments passed to search\_by\_vector

**Returns:**

`List[Tuple[Document, float]]` - List of tuples of (Document, score) selected by maximal marginal relevance

#### `max_marginal_relevance_search_by_vector`

```python
max_marginal_relevance_search_by_vector(
    embedding: List[float],
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    filter: Union[None, dict] = None,
    kwargs: Any = {}
) -> List[Document]
```

Return docs selected using maximal marginal relevance.

**Parameters:**

* **embedding** (`List[float]`): Query embedding vector
* **k** (`int`): Number of documents to return (default: 4)
* **fetch\_k** (`int`): Number of documents to fetch before selecting top-k (default: 20)
* **lambda\_mult** (`float`): Balance between relevance and diversity, 0-1 (default: 0.5) 0 = maximize diversity, 1 = maximize relevance
* **filter** (`Union[None, dict]`): Optional metadata filter
* \*\***kwargs** (`Any`): Additional arguments (not used)

**Returns:**

`List[Document]` - List of Documents selected by maximal marginal relevance

#### `amax_marginal_relevance_search_by_vector`

```python
amax_marginal_relevance_search_by_vector(
    embedding: List[float],
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    filter: Union[None, dict] = None,
    kwargs: Any = {}
) -> List[Document]
```

Return docs selected using maximal marginal relevance asynchronously.

**Parameters:**

* **embedding** (`List[float]`): Query embedding vector
* **k** (`int`): Number of documents to return (default: 4)
* **fetch\_k** (`int`): Number of documents to fetch before selecting top-k (default: 20)
* **lambda\_mult** (`float`): Balance between relevance and diversity, 0-1 (default: 0.5) 0 = maximize diversity, 1 = maximize relevance
* **filter** (`Union[None, dict]`): Optional metadata filter
* \*\***kwargs** (`Any`): Additional arguments (not used)

**Returns:**

`List[Document]` - List of Documents selected by maximal marginal relevance

#### `max_marginal_relevance_search_with_score_by_vector`

```python
max_marginal_relevance_search_with_score_by_vector(
    embedding: List[float],
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    filter: Union[None, dict] = None,
    kwargs: Any = {}
) -> List[Tuple[Document, float]]
```

Return docs selected using maximal marginal relevance with scores.

**Parameters:**

* **embedding** (`List[float]`): Query embedding vector
* **k** (`int`): Number of documents to return (default: 4)
* **fetch\_k** (`int`): Number of documents to fetch before selecting top-k (default: 20)
* **lambda\_mult** (`float`): Balance between relevance and diversity, 0-1 (default: 0.5) 0 = maximize diversity, 1 = maximize relevance
* **filter** (`Union[None, dict]`): Optional metadata filter
* \*\***kwargs** (`Any`): Additional arguments (not used)

**Returns:**

`List[Tuple[Document, float]]` - List of tuples of (Document, score) selected by maximal marginal relevance

#### `amax_marginal_relevance_search_with_score_by_vector`

```python
amax_marginal_relevance_search_with_score_by_vector(
    embedding: List[float],
    k: int = 4,
    fetch_k: int = 20,
    lambda_mult: float = 0.5,
    filter: Union[None, dict] = None,
    kwargs: Any = {}
) -> List[Tuple[Document, float]]
```

Return docs selected using maximal marginal relevance with scores asynchronously.

**Parameters:**

* **embedding** (`List[float]`): Query embedding vector
* **k** (`int`): Number of documents to return (default: 4)
* **fetch\_k** (`int`): Number of documents to fetch before selecting top-k (default: 20)
* **lambda\_mult** (`float`): Balance between relevance and diversity, 0-1 (default: 0.5) 0 = maximize diversity, 1 = maximize relevance
* **filter** (`Union[None, dict]`): Optional metadata filter
* \*\***kwargs** (`Any`): Additional arguments (not used)

**Returns:**

`List[Tuple[Document, float]]` - List of tuples of (Document, score) selected by maximal marginal relevance

#### `from_texts`

```python
from_texts(
    texts: List[str],
    embedding: Embeddings,
    metadatas: Optional[List[dict]] = None,
    ids: Optional[List[str]] = None,
    datasource: Optional[Union[Engine, str]] = None,
    collection_name: str = _LANGCHAIN_DEFAULT_COLLECTION_NAME,
    distance_strategy: DistanceStrategy = DistanceStrategy.COSINE,
    embedding_length: Optional[int] = None,
    config: MariaDBStoreSettings = MariaDBStoreSettings(),
    logger: Optional[logging.Logger] = None,
    relevance_score_fn: Optional[Callable[[float], float]] = None,
    kwargs: Any = {}
) -> MariaDBStore
```

Create a MariaDBStore instance from texts.

**Parameters:**

* **texts** (`List[str]`): List of text strings to store
* **embedding** (`Embeddings`): Embeddings object for creating embeddings
* **metadatas** (`Optional[List[dict]]`): Optional list of metadata dicts for each text
* **ids** (`Optional[List[str]]`): Optional list of unique IDs for each text
* **datasource** (`Optional[Union[Engine, str]]`): Database connection (connection string or sqlalchemy engine)
* **collection\_name** (`str`): Name of the collection to store vectors
* **distance\_strategy** (`DistanceStrategy`): Strategy for distances (COSINE or EUCLIDEAN)
* **embedding\_length** (`Optional[int]`): Length of embedding vectors (default: 1536)
* **config** (`MariaDBStoreSettings`): Store configuration for tables and columns
* **logger** (`Optional[logging.Logger]`): Optional logger instance for debugging
* **relevance\_score\_fn** (`Optional[Callable[[float], float]]`): Optional function to override relevance score calculation
* \*\***kwargs** (`Any`): Additional arguments passed to add\_embeddings

**Returns:**

`MariaDBStore` - MariaDBStore instance initialized with the provided texts

**Raises:**

* **ValueError**: If `datasource` is not provided.

#### `from_embeddings`

```python
from_embeddings(
    text_embeddings: List[Tuple[str, List[float]]],
    ids: Optional[List[str]] = None,
    metadatas: Optional[List[dict]] = None,
    embedding: Embeddings,
    distance_strategy: DistanceStrategy = DistanceStrategy.COSINE,
    relevance_score_fn: Optional[Callable[[float], float]] = None,
    config: MariaDBStoreSettings = MariaDBStoreSettings(),
    kwargs: Any = {}
) -> MariaDBStore
```

Create a MariaDBStore instance from text-embedding pairs.

**Parameters:**

* **text\_embeddings** (`List[Tuple[str, List[float]]]`): List of (text, embedding) tuples
* **ids** (`Optional[List[str]]`): Optional list of IDs for the documents
* **metadatas** (`Optional[List[dict]]`): Optional list of metadata dicts
* **embedding** (`Embeddings`): Embeddings object for creating embeddings
* **distance\_strategy** (`DistanceStrategy`): Strategy for computing distances
* **relevance\_score\_fn** (`Optional[Callable[[float], float]]`): Optional function to compute relevance scores
* **config** (`MariaDBStoreSettings`): Store configuration for tables and columns
* \*\***kwargs** (`Any`): Additional arguments including datasource, collection\_name

**Returns:**

`MariaDBStore` - MariaDBStore instance

#### `from_existing_index`

```python
from_existing_index(
    embedding: Embeddings,
    collection_name: str = _LANGCHAIN_DEFAULT_COLLECTION_NAME,
    distance_strategy: DistanceStrategy = DistanceStrategy.COSINE,
    datasource: Union[Engine | str],
    config: MariaDBStoreSettings = MariaDBStoreSettings(),
    kwargs: Any = {}
) -> MariaDBStore
```

Create a MariaDBStore instance from an existing index.

**Parameters:**

* **embedding** (`Embeddings`): Embeddings object for creating embeddings
* **collection\_name** (`str`): Name of collection (default: langchain)
* **distance\_strategy** (`DistanceStrategy`): Strategy for computing distances
* **datasource** (`Union[Engine | str]`): datasource (connection string, sqlalchemy engine or MariaDB connection pool)
* \*\***kwargs** (`Any`): Additional arguments passed to constructor

**Returns:**

`MariaDBStore` - MariaDBStore instance connected to existing index

#### `from_documents`

```python
from_documents(
    documents: List[Document],
    embedding: Embeddings,
    ids: Optional[List[str]] = None,
    datasource: Optional[Union[Engine, str]] = None,
    collection_name: str = _LANGCHAIN_DEFAULT_COLLECTION_NAME,
    distance_strategy: DistanceStrategy = DistanceStrategy.COSINE,
    embedding_length: Optional[int] = None,
    config: MariaDBStoreSettings = MariaDBStoreSettings(),
    logger: Optional[logging.Logger] = None,
    relevance_score_fn: Optional[Callable[[float], float]] = None,
    kwargs: Any = {}
) -> MariaDBStore
```

Create a MariaDBStore instance from documents.

**Parameters:**

* **documents** (`List[Document]`): List of Document objects to store
* **embedding** (`Embeddings`): Embeddings object for creating embeddings
* **ids** (`Optional[List[str]]`): Optional list of IDs for the documents
* **datasource** (`Optional[Union[Engine, str]]`): Database connection (connection string or sqlalchemy engine)
* **collection\_name** (`str`): Name of the collection to store vectors
* **distance\_strategy** (`DistanceStrategy`): Strategy for distances (COSINE or EUCLIDEAN)
* **embedding\_length** (`Optional[int]`): Length of embedding vectors (default: 1536)
* **config** (`MariaDBStoreSettings`): Store configuration for tables and columns
* **logger** (`Optional[logging.Logger]`): Optional logger instance for debugging
* **relevance\_score\_fn** (`Optional[Callable[[float], float]]`): Optional function to override relevance score calculation
* \*\***kwargs** (`Any`): Additional arguments passed to from\_texts

**Returns:**

`MariaDBStore` - MariaDBStore instance

#### `as_retriever`

```python
as_retriever(kwargs: Any = {}) -> VectorStoreRetriever
```

Return VectorStoreRetriever initialized from this VectorStore.

**Parameters:**

* \*\***kwargs** (`Any`): Keyword arguments to pass to the search function. Can include:
  * search\_type: Defines the type of search that the Retriever should perform. Can be 'similarity' (default), 'mmr', or 'similarity\_score\_threshold'.
  * search\_kwargs: Keyword arguments to pass to the search function. Can include:
  * k: Amount of documents to return (Default: 4)
  * score\_threshold: Minimum relevance threshold for similarity\_score\_threshold
  * fetch\_k: Amount of documents to pass to MMR algorithm (Default: 20)
  * lambda\_mult: Diversity of results returned by MMR; 1 for minimum diversity and 0 for maximum. (Default: 0.5)
  * filter: Filter by document metadata

**Returns:**

`VectorStoreRetriever` - VectorStoreRetriever instance configured for this vector store.

**Examples:**

```python
Retrieve more documents with higher diversity::

    docsearch.as_retriever(
        search_type="mmr",
        search_kwargs={"k": 6, "lambda_mult": 0.25}
    )

Fetch more documents for the MMR algorithm to consider::

    docsearch.as_retriever(
        search_type="mmr",
        search_kwargs={"k": 5, "fetch_k": 50}
    )

Only retrieve documents above a relevance threshold::

    docsearch.as_retriever(
        search_type="similarity_score_threshold",
        search_kwargs={"score_threshold": 0.8}
    )

Get only the single most similar document::

    docsearch.as_retriever(search_kwargs={"k": 1})
```

### Attributes

* **embedding\_function**:
* **collection\_name**:
* **collection\_metadata**:
* **pre\_delete\_collection**:
* **lazy\_init**:
* **logger**:
* **override\_relevance\_score\_fn**:
* **embeddings** (`Embeddings`):

***


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://mariadb.com/docs/connectors/other/langchain-mariadb/api-reference/vectorstores.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.