# What Embedding Models Are Available in Mem0 and How to Switch Between Them

> Explore the 12+ embedding models in Mem0, including OpenAI, Hugging Face, and Gemini. Easily switch between providers by configuring EmbedderConfig for your AI projects.

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

---

**Mem0 supports 12+ embedding providers—including OpenAI, Azure OpenAI, Hugging Face, Ollama, Gemini, VertexAI, Together, LMStudio, LangChain, AWS Bedrock, and FastEmbed—which you can switch between by setting the `provider` field in `EmbedderConfig` when initializing the `Memory` class.**

Mem0 (mem0ai/mem0) is a memory layer for LLM applications that abstracts embedding generation through a unified factory pattern. Understanding what embedding models are available in Mem0 and how to configure them is essential for optimizing retrieval performance, managing costs, and ensuring data sovereignty across different deployment environments.

## Available Embedding Providers in Mem0

The `EmbedderFactory` in [`mem0/utils/factory.py`](https://github.com/mem0ai/mem0/blob/main/mem0/utils/factory.py) maintains a `provider_to_class` mapping that registers all supported embedding backends. According to the source code, the following providers are available:

| Provider | Implementation Module | Use Case |
|----------|----------------------|----------|
| **openai** | `mem0.embeddings.openai.OpenAIEmbedding` | OpenAI API (text-embedding-3-small, etc.) |
| **ollama** | `mem0.embeddings.ollama.OllamaEmbedding` | Local Ollama server |
| **huggingface** | `mem0.embeddings.huggingface.HuggingFaceEmbedding` | Hugging Face Inference API or local models |
| **azure_openai** | `mem0.embeddings.azure_openai.AzureOpenAIEmbedding` | Azure OpenAI Service |
| **gemini** | `mem0.embeddings.gemini.GoogleGenAIEmbedding` | Google Gemini API |
| **vertexai** | `mem0.embeddings.vertexai.VertexAIEmbedding` | Google Cloud Vertex AI |
| **together** | `mem0.embeddings.together.TogetherEmbedding` | Together AI API |
| **lmstudio** | `mem0.embeddings.lmstudio.LMStudioEmbedding` | LM Studio local server |
| **langchain** | `mem0.embeddings.langchain.LangchainEmbedding` | Any LangChain-compatible embedder |
| **aws_bedrock** | `mem0.embeddings.aws_bedrock.AWSBedrockEmbedding` | Amazon Bedrock |
| **fastembed** | `mem0.embeddings.fastembed.FastEmbedEmbedding` | FastEmbed (Qdrant) |
| **mock** | `mem0.embeddings.mock.MockEmbeddings` | Fallback for `upstash_vector` store |

The list of allowed provider names is enforced by the embedder configuration model in [`mem0/embeddings/configs.py`](https://github.com/mem0ai/mem0/blob/main/mem0/embeddings/configs.py) (`EmbedderConfig`)—any name outside this whitelist raises a validation error.

## How to Switch Between Embedding Models

Mem0 provides three primary methods for switching embedding providers: via the high-level `Memory` API, direct factory usage, or environment variables.

### Using the High-Level Memory API

The most common approach is configuring the `EmbedderConfig` within `MemoryConfig` when instantiating the `Memory` class:

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

# Choose the provider you want, e.g., "huggingface"

embed_cfg = EmbedderConfig(
    provider="huggingface",
    config={"model": "sentence-transformers/all-MiniLM-L6-v2"}   # provider-specific args

)

mem_cfg = MemoryConfig(embedder=embed_cfg)

memory = Memory(mem_cfg)   # The Memory object now uses the HuggingFace embedder

```

Changing `provider` to `"openai"`, `"azure_openai"`, `"gemini"`, or any other supported key automatically swaps the underlying embedder class instantiated by the factory.

### Using the EmbedderFactory Directly

For custom pipelines that only need the embedder without the full memory stack, call `EmbedderFactory.create` from [`mem0/utils/factory.py`](https://github.com/mem0ai/mem0/blob/main/mem0/utils/factory.py):

```python
from mem0.utils.factory import EmbedderFactory

# OpenAI example

openai_embedder = EmbedderFactory.create(
    provider_name="openai",
    config={"model": "text-embedding-3-large", "embedding_dims": 3072},
    vector_config=None   # not needed for the embedder itself

)

# Ollama example

ollama_embedder = EmbedderFactory.create(
    provider_name="ollama",
    config={"model": "nomic-embed-text"},
    vector_config=None
)

```

The factory loads the appropriate class from the `provider_to_class` mapping and builds a `BaseEmbedderConfig` instance internally before instantiating the concrete embedder.

### Environment-Based Configuration

Many embedder implementations fall back to environment variables when a required key is not supplied in the `config` dict. For instance, `OpenAIEmbedding` reads `OPENAI_API_KEY` and `OPENAI_BASE_URL` automatically. You can keep the same embedder class and switch keys by changing environment variables, but **the provider name itself must be changed in the configuration** to use a different backend (e.g., switching from `"openai"` to `"azure_openai"`).

## Practical Code Examples

### Switching from OpenAI to Azure OpenAI

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

# 1️⃣ OpenAI (default)

mem_openai = Memory(
    MemoryConfig(
        embedder=EmbedderConfig(
            provider="openai",
            config={"model": "text-embedding-3-small"}
        )
    )
)

# 2️⃣ Azure OpenAI

mem_azure = Memory(
    MemoryConfig(
        embedder=EmbedderConfig(
            provider="azure_openai",
            config={
                "model": "text-embedding-3-large",
                "api_key": "AZURE_API_KEY",
                "azure_endpoint": "https://my-azure-openai.cognitiveservices.azure.com/",
                "azure_deployment": "my-deployment"
            }
        )
    )
)

# Both objects expose the same `add`, `search`, … methods; only the embedding provider differs.

```

### Runtime Provider Selection

```python
from mem0.utils.factory import EmbedderFactory

def get_embedder(name: str):
    cfg = {"model": "default-model"}   # provider-specific defaults can be omitted

    return EmbedderFactory.create(name, cfg, vector_config=None)

# Choose at runtime:

embedder = get_embedder("fastembed")   # Fastembed backend

vectors = embedder.embed("Mem0 is a memory-augmented LLM framework")

```

### Listing Available Providers Programmatically

```python
from mem0.utils.factory import EmbedderFactory

available = list(EmbedderFactory.provider_to_class.keys())
print("Supported embedder providers:", available)

# Output: ['openai', 'ollama', 'huggingface', 'azure_openai', 'gemini',

#          'vertexai', 'together', 'lmstudio', 'langchain',

#          'aws_bedrock', 'fastembed']

```

## Key Implementation Files

The embedding system in Mem0 is implemented across several key files:

- **[`mem0/utils/factory.py`](https://github.com/mem0ai/mem0/blob/main/mem0/utils/factory.py)**: Contains the `EmbedderFactory` class and the `provider_to_class` mapping that enumerates all supported embedder backends.
- **[`mem0/embeddings/configs.py`](https://github.com/mem0ai/mem0/blob/main/mem0/embeddings/configs.py)**: Defines the `EmbedderConfig` Pydantic model that validates the `provider` field against the whitelist of allowed names.
- **[`mem0/configs/base.py`](https://github.com/mem0ai/mem0/blob/main/mem0/configs/base.py)**: Houses the top-level `MemoryConfig` that nests the embedder configuration via the `embedder: EmbedderConfig` field.
- **[`mem0/embeddings/openai.py`](https://github.com/mem0ai/mem0/blob/main/mem0/embeddings/openai.py)**, **[`mem0/embeddings/huggingface.py`](https://github.com/mem0ai/mem0/blob/main/mem0/embeddings/huggingface.py)**, etc.: Concrete implementations that interact with each provider's SDK.
- **[`mem0/embeddings/mock.py`](https://github.com/mem0ai/mem0/blob/main/mem0/embeddings/mock.py)**: Fallback mock embedder used internally for the `upstash_vector` store.

These files together define **what** embedding models Mem0 can use and **how** you tell the library which one to employ. By adjusting the `provider` field (and any provider-specific options) in the `EmbedderConfig`, you seamlessly switch between OpenAI, Azure, Hugging Face, Ollama, Gemini, VertexAI, Together, LMStudio, LangChain, AWS Bedrock, FastEmbed, or the internal mock implementation.

## Summary

- Mem0 provides **12+ embedding providers** through a plugin-style factory pattern defined in [`mem0/utils/factory.py`](https://github.com/mem0ai/mem0/blob/main/mem0/utils/factory.py).
- Switch models by setting the `provider` string in `EmbedderConfig` (e.g., `"openai"`, `"huggingface"`, `"azure_openai"`).
- The factory validates provider names against a whitelist in [`mem0/embeddings/configs.py`](https://github.com/mem0ai/mem0/blob/main/mem0/embeddings/configs.py), raising errors for invalid selections.
- Configure provider-specific parameters (model names, API keys, endpoints) via the `config` dict in `EmbedderConfig`.
- Access the underlying factory directly via `EmbedderFactory.create()` for custom pipelines without the full Memory stack.

## Frequently Asked Questions

### What is the default embedding model in Mem0?

If you do not specify an embedder configuration, Mem0 typically defaults to the **OpenAI** provider using the `text-embedding-3-small` model. However, this depends on your environment variables; if `OPENAI_API_KEY` is not set and another provider is configured, the system will use the explicitly defined provider instead.

### Can I use a custom embedding model not listed in the factory?

Yes, via the **langchain** provider. The `LangchainEmbedding` class in [`mem0/embeddings/langchain.py`](https://github.com/mem0ai/mem0/blob/main/mem0/embeddings/langchain.py) wraps any LangChain-compatible embeddings object, allowing you to inject custom models or third-party LangChain integrations that are not natively implemented in Mem0.

### How do I configure API keys for different embedding providers?

Most embedder implementations read API keys from environment variables when not provided in the config dict. For example, `OpenAIEmbedding` automatically reads `OPENAI_API_KEY` and `OPENAI_BASE_URL`. For Azure OpenAI, you can pass `api_key`, `azure_endpoint`, and `azure_deployment` directly in the `config` dict of `EmbedderConfig`, or set the corresponding environment variables.

### Does switching embedding models affect existing stored memories?

**Yes.** Embeddings generated by different models are not compatible because each model produces vectors with different dimensions and semantic mappings. If you switch from OpenAI to Hugging Face (or any other provider), you should treat this as a new memory configuration. Existing memories stored with the previous embedder will not be retrievable via vector similarity search unless you re-embed all data with the new model.