> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mem0.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Elasticsearch

> Use Elasticsearch as a vector database in Mem0 for distributed vector search using dense vectors and k-NN queries.

[Elasticsearch](https://www.elastic.co/) is a distributed, RESTful search and analytics engine that can efficiently store and search vector data using dense vectors and k-NN search.

### Installation

Elasticsearch support requires the Elasticsearch client as an extra dependency.

<CodeGroup>
  ```bash Python theme={null}
  pip install elasticsearch>=8.0.0
  ```

  ```bash TypeScript theme={null}
  npm install mem0ai @elastic/elasticsearch
  ```
</CodeGroup>

### Usage

<CodeGroup>
  ```python Python theme={null}
  import os
  from mem0 import Memory

  os.environ["OPENAI_API_KEY"] = "sk-xx"

  config = {
      "vector_store": {
          "provider": "elasticsearch",
          "config": {
              "collection_name": "mem0",
              "host": "localhost",
              "port": 9200,
              "embedding_model_dims": 1536
          }
      }
  }

  m = Memory.from_config(config)
  messages = [
      {"role": "user", "content": "I'm planning to watch a movie tonight. Any recommendations?"},
      {"role": "assistant", "content": "How about thriller movies? They can be quite engaging."},
      {"role": "user", "content": "I'm not a big fan of thriller movies but I love sci-fi movies."},
      {"role": "assistant", "content": "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future."}
  ]
  m.add(messages, user_id="alice", metadata={"category": "movies"})
  ```

  ```typescript TypeScript theme={null}
  import { Memory } from "mem0ai/oss";

  // Set OPENAI_API_KEY in your environment.
  const config = {
    embedder: {
      provider: "openai",
      config: {
        apiKey: process.env.OPENAI_API_KEY,
        model: "text-embedding-3-small",
      },
    },
    vectorStore: {
      provider: "elasticsearch",
      config: {
        collectionName: "mem0",
        embeddingModelDims: 1536,
        host: "localhost",
        port: 9200,
        // For Elastic Cloud, pass cloudId and apiKey instead of host/port.
        // For basic auth, pass username and password.
      },
    },
  };

  const memory = new Memory(config);
  const messages = [
    { role: "user", content: "I'm planning to watch a movie tonight. Any recommendations?" },
    { role: "assistant", content: "How about thriller movies? They can be quite engaging." },
    { role: "user", content: "I'm not a big fan of thriller movies but I love sci-fi movies." },
    { role: "assistant", content: "Got it! I'll avoid thriller recommendations and suggest sci-fi movies in the future." },
  ];
  await memory.add(messages, { userId: "alice", metadata: { category: "movies" } });
  ```
</CodeGroup>

<Note>
  The TypeScript SDK uses camelCase config keys: `collectionName`, `embeddingModelDims`, `cloudId`, `apiKey`, `useSsl`, `verifyCerts`, `caCerts`, `autoCreateIndex`, and `username` (in place of the Python `user`). `collectionName` and `embeddingModelDims` are required. Because the vector store embeds text with your configured embedder before writing, set an `embedder` in the config as shown above.
</Note>

### Config

Here are the parameters available for configuring Elasticsearch:

| Parameter              | Description                                        | Default Value |
| ---------------------- | -------------------------------------------------- | ------------- |
| `collection_name`      | The name of the index to store the vectors         | `mem0`        |
| `embedding_model_dims` | Dimensions of the embedding model                  | `1536`        |
| `host`                 | The host where the Elasticsearch server is running | `localhost`   |
| `port`                 | The port where the Elasticsearch server is running | `9200`        |
| `cloud_id`             | Cloud ID for Elastic Cloud deployment              | `None`        |
| `api_key`              | API key for authentication                         | `None`        |
| `user`                 | Username for basic authentication                  | `None`        |
| `password`             | Password for basic authentication                  | `None`        |
| `use_ssl`              | Whether to use SSL for the connection              | `True`        |
| `ca_certs`             | Path to CA bundle for SSL certificate verification | `None`        |
| `verify_certs`         | Whether to verify SSL certificates                 | `True`        |
| `auto_create_index`    | Whether to automatically create the index          | `True`        |
| `custom_search_query`  | Function returning a custom search query           | `None`        |
| `headers`              | Custom headers to include in requests              | `None`        |

### Features

* Efficient vector search using Elasticsearch's native k-NN search
* Support for both local and cloud deployments (Elastic Cloud)
* Multiple authentication methods (Basic Auth, API Key)
* Automatic index creation with optimized mappings for vector search
* Memory isolation through payload filtering
* Custom search query function to customize the search query

### Custom Search Query

<Note>
  `custom_search_query` is available in the Python SDK only. The TypeScript SDK runs a fixed k-NN query with optional metadata filters.
</Note>

The `custom_search_query` parameter allows you to customize the search query when `Memory.search` is called.

**Example**

```python theme={null}
import os
from typing import List, Optional, Dict
from mem0 import Memory

def custom_search_query(query: List[float], limit: int, filters: Optional[Dict]) -> Dict:
    return {
        "knn": {
            "field": "vector", 
            "query_vector": query, 
            "k": limit, 
            "num_candidates": limit * 2
        }
    }

os.environ["OPENAI_API_KEY"] = "sk-xx"

config = {
    "vector_store": {
        "provider": "elasticsearch",
        "config": {
            "collection_name": "mem0",
            "host": "localhost",
            "port": 9200,
            "embedding_model_dims": 1536,
            "custom_search_query": custom_search_query
        }
    }
}
```

It should be a function that takes the following parameters:

* `query`: a query vector used in `Memory.search`
* `limit`: a number of results used in `Memory.search`
* `filters`: a dictionary of key-value pairs used in `Memory.search`. You can add custom pairs for the custom search query.

The function should return a query body for the Elasticsearch search API.