# How to Configure Mem0 to Use a Custom Vector Store (Pinecone or Qdrant)

> Configure Mem0 to use a custom vector store like Pinecone or Qdrant. Set the provider in MemoryConfig and supply the necessary parameters for seamless integration.

- Repository: [Mem0/mem0](https://github.com/mem0ai/mem0)
- Tags: how-to-guide
- Published: 2026-03-07

---

**To configure Mem0 with a custom vector store, set the `provider` field in your `MemoryConfig` to `"pinecone"` or `"qdrant"` and supply the provider-specific configuration parameters; Mem0's `VectorStoreFactory` automatically instantiates the correct backend.**

Mem0 is an open-source memory layer for LLM applications that abstracts vector database interactions through a unified interface. Whether you need the serverless scalability of Pinecone or the on-premise flexibility of Qdrant, configuring a custom vector store requires understanding the factory pattern and Pydantic configuration classes used throughout the codebase.

## Understanding the Vector Store Architecture

Mem0 decouples the memory logic from storage implementation through a factory pattern. This allows you to swap vector databases without changing your application code.

### The VectorStoreFactory Pattern

The `VectorStoreFactory` in [`mem0/utils/factory.py`](https://github.com/mem0ai/mem0/blob/main/mem0/utils/factory.py) maintains a mapping between provider names and concrete implementation classes. When you initialize a `Memory` instance, the factory reads `config.vector_store.provider` and returns the appropriate class:

- `"pinecone"` → `mem0.vector_stores.pinecone.PineconeDB`
- `"qdrant"` → `mem0.vector_stores.qdrant.Qdrant`

The `Memory.__init__` method in [`mem0/memory/main.py`](https://github.com/mem0ai/mem0/blob/main/mem0/memory/main.py) calls `VectorStoreFactory.create` with the processed configuration, ensuring the vector store is ready before any memory operations occur.

### Configuration Validation with Pydantic

Each vector store has a dedicated Pydantic configuration class that validates required fields at instantiation:

- `PineconeConfig` ([`mem0/configs/vector_stores/pinecone.py`](https://github.com/mem0ai/mem0/blob/main/mem0/configs/vector_stores/pinecone.py)) validates `api_key`, `environment`, `serverless_config`, and `collection_name`
- `QdrantConfig` ([`mem0/configs/vector_stores/qdrant.py`](https://github.com/mem0ai/mem0/blob/main/mem0/configs/vector_stores/qdrant.py)) validates connection parameters including `host`, `port`, `path`, or `url`

These validators ensure that missing or incompatible settings raise immediate errors during startup rather than at query time.

## Configuring Pinecone as Your Vector Store

Pinecone provides managed, serverless vector search with metadata filtering. To use it with Mem0, you must configure both the connection parameters and the index settings.

### Required Configuration Parameters

The `PineconeConfig` class requires the following fields:

- `collection_name`: The name of your Pinecone index
- `embedding_model_dims`: Dimensionality of your embeddings (e.g., 1536 for OpenAI)
- `api_key`: Your Pinecone API key (or set `PINECONE_API_KEY` environment variable)
- `environment`: Pinecone environment identifier (e.g., `"us-west1-gcp"`)
- `serverless_config`: Dictionary with `cloud` (e.g., `"aws"`) and `region` (e.g., `"us-east-1"`) for serverless indexes
- `metric`: Distance metric (e.g., `"cosine"`, `"euclidean"`)
- `batch_size`: Number of vectors to upsert in batches (default 100)

### Python Implementation Example

```python
from mem0 import Memory
from mem0.configs.base import MemoryConfig

# Configure Pinecone vector store

pinecone_config = {
    "provider": "pinecone",
    "config": {
        "collection_name": "mem0_conversations",
        "embedding_model_dims": 1536,
        "api_key": "YOUR_PINECONE_API_KEY",
        "environment": "us-west1-gcp",
        "serverless_config": {
            "cloud": "aws",
            "region": "us-east-1"
        },
        "metric": "cosine",
        "batch_size": 200
    }
}

# Initialize Mem0 with Pinecone backend

memory = Memory(MemoryConfig(vector_store=pinecone_config))

# Use Mem0 normally

memory.add(
    messages=[{"role": "user", "content": "I prefer Python for data science"}],
    user_id="user123"
)

```

## Configuring Qdrant as Your Vector Store

Qdrant offers both local storage and distributed deployment options. Mem0 supports Qdrant through the `Qdrant` class in [`mem0/vector_stores/qdrant.py`](https://github.com/mem0ai/mem0/blob/main/mem0/vector_stores/qdrant.py).

### Connection Modes and Settings

The `QdrantConfig` class supports three connection modes:

1. **Host and Port**: Connect to a running Qdrant server
   - `host`: Server hostname (e.g., `"localhost"`)
   - `port`: Server port (e.g., `6333`)
   - `api_key`: Optional authentication key

2. **URL**: Connect via full URL string
   - `url`: Complete connection string (e.g., `"http://localhost:6333"`)

3. **Local Path**: Run Qdrant in embedded mode
   - `path`: Local directory for storage (e.g., `"./qdrant_storage"`)

Common configuration fields include:
- `collection_name`: Name of the Qdrant collection
- `embedding_model_dims`: Vector dimensionality
- `metric`: Distance metric (`"cosine"`, `"euclidean"`, or `"dot"`)
- `on_disk`: Boolean to store vectors on disk rather than memory

### Python Implementation Example

```python
from mem0 import Memory
from mem0.configs.base import MemoryConfig

# Configure Qdrant vector store (local mode)

qdrant_config = {
    "provider": "qdrant",
    "config": {
        "collection_name": "mem0_local",
        "embedding_model_dims": 1536,
        "path": "./qdrant_data",  # Local storage path

        "metric": "cosine",
        "on_disk": False
    }
}

# Or configure for remote Qdrant server

qdrant_server_config = {
    "provider": "qdrant",
    "config": {
        "collection_name": "mem0_production",
        "embedding_model_dims": 1536,
        "host": "qdrant.example.com",
        "port": 6333,
        "api_key": "YOUR_QDRANT_API_KEY",
        "metric": "cosine"
    }
}

# Initialize Mem0

memory = Memory(MemoryConfig(vector_store=qdrant_config))

# Add and search memories

memory.add(
    messages=[{"role": "assistant", "content": "The user enjoys hiking in the Alps"}],
    user_id="alice"
)

results = memory.search(
    query="outdoor activities",
    user_id="alice",
    limit=3
)

```

## Loading Configuration from Files and Environment Variables

Mem0 supports flexible configuration loading beyond Python dictionaries, allowing you to externalize settings for different deployment environments.

### YAML and JSON Configuration Files

You can define your vector store configuration in YAML or JSON files and load them at runtime. The structure mirrors the Python dictionary format exactly.

```yaml

# config.yaml

vector_store:
  provider: pinecone
  config:
    collection_name: mem0_production
    embedding_model_dims: 1536
    api_key: ${PINECONE_API_KEY}  # Environment variable substitution

    environment: us-east-1-aws
    serverless_config:
      cloud: aws
      region: us-east-1
    metric: cosine
    batch_size: 100

```

```python
import yaml
from mem0 import Memory
from mem0.configs.base import MemoryConfig

with open("config.yaml") as f:
    config_dict = yaml.safe_load(f)

memory = Memory(MemoryConfig(**config_dict))

```

### Environment Variable Overrides

Mem0's Pydantic configuration classes automatically read from environment variables using standard naming conventions. This allows sensitive credentials like API keys to stay out of your codebase.

For Pinecone:
- `PINECONE_API_KEY` – Automatically mapped to the `api_key` field
- `PINECONE_ENVIRONMENT` – Maps to `environment`

For Qdrant:
- `QDRANT_API_KEY` – Authentication key for remote servers
- `QDRANT_HOST` – Server hostname

You can also use the `MEM0_` prefix for general Mem0 settings:

```bash
export MEM0_VECTOR_STORE_PROVIDER=qdrant
export MEM0_VECTOR_STORE_COLLECTION_NAME=mem0_env_collection
export MEM0_VECTOR_STORE_EMBEDDING_MODEL_DIMS=1536

```

```python
from mem0 import Memory

# Configuration loaded automatically from environment variables

memory = Memory()

```

## Summary

Configuring Mem0 to use a custom vector store involves understanding the factory-based architecture that decouples memory logic from storage implementation:

- **Use the `provider` field** in `MemoryConfig.vector_store` to select `"pinecone"` or `"qdrant"`
- **Supply provider-specific configurations** through `PineconeConfig` or `QdrantConfig`, which validate required fields like API keys, hosts, and collection names
- **Leverage the VectorStoreFactory** in [`mem0/utils/factory.py`](https://github.com/mem0ai/mem0/blob/main/mem0/utils/factory.py) to automatically instantiate the correct backend class based on your configuration
- **Externalize sensitive credentials** using environment variables that Pydantic config classes automatically detect

The unified interface in [`mem0/memory/main.py`](https://github.com/mem0ai/mem0/blob/main/mem0/memory/main.py) ensures that once configured, all vector stores expose the same `add()`, `search()`, and `get()` methods regardless of the underlying database.

## Frequently Asked Questions

### What vector stores does Mem0 support besides Pinecone and Qdrant?

Mem0 supports multiple vector stores including Chroma, PGVector, Milvus, and Redis, in addition to Pinecone and Qdrant. Each provider follows the same factory pattern in [`mem0/utils/factory.py`](https://github.com/mem0ai/mem0/blob/main/mem0/utils/factory.py), requiring a config class in `mem0/configs/vector_stores/` and an implementation class in `mem0/vector_stores/`. You can check the factory mapping to see the complete list of supported providers.

### How do I switch from one vector store to another without losing data?

Switching vector stores requires migrating your vector data since each store uses different storage formats and indexing structures. Mem0 does not provide automatic migration tools between different vector databases. To switch, you must export your data from the current store (using the store's native export tools), transform the vectors and metadata into the format expected by the new store, and then ingest them into the new collection configured in your `MemoryConfig`.

### Can I use a local vector store for development and a cloud provider for production?

Yes, this is a common pattern supported by Mem0's configuration system. For local development, configure Qdrant with the `path` parameter to use embedded mode (`path: "./qdrant_data"`), or use Chroma with a local directory. For production, switch to Pinecone or a remote Qdrant server by updating the `host`, `port`, and `api_key` fields. Use environment variables to toggle between configurations without code changes, or maintain separate YAML config files for each environment.

### What happens if I omit required configuration fields for Pinecone or Qdrant?

Mem0 uses Pydantic models (`PineconeConfig` and `QdrantConfig`) that validate configuration at instantiation. If you omit required fields like `api_key` for Pinecone or `collection_name` for either provider, Pydantic raises a validation error immediately when creating the `Memory` instance. This prevents runtime failures during vector operations. To avoid these errors, ensure all mandatory fields are provided in your config dictionary, YAML file, or as environment variables that the Pydantic models can automatically detect.