MockTextEmbedder

A Text Embedder that returns deterministic embeddings without calling any API, for tests and quick prototypes.

Most common position in a pipeline	In place of a real Text Embedder, in tests and prototypes
Mandatory init variables	None
Mandatory run variables	text: A string
Output variables	embedding: A list of float numbers meta: A dictionary of metadata
API reference	Embedders
GitHub link	https://github.com/deepset-ai/haystack/blob/main/haystack/components/embedders/mock_text_embedder.py
Package name	haystack-ai

Overview

MockTextEmbedder is a deterministic, zero-cost drop-in replacement for real Text Embedders such as OpenAITextEmbedder. It implements run, run_async, and serialization like any other embedder but never contacts an external service, which makes it ideal for unit tests, smoke tests, and quick prototypes.

The embedding is selected based on how the component is configured:

• Deterministic (default): With no configuration, the embedding is derived from a stable hash of the input text. The same text always yields the same unit-length embedding, and different texts yield different embeddings, so the mock works in retrieval pipelines and is reproducible across runs and processes.
• Fixed embedding: Pass an embedding vector. The same vector is returned for every input.
• Dynamic embedding: Pass an embedding_fn callable that receives the prepared text (after prefix/suffix are applied) and returns the embedding. To support serialization, pass a named function.

embedding and embedding_fn are mutually exclusive.

Further optional parameters:

• dimension: The number of dimensions of the deterministic embedding. Defaults to 768. Ignored when embedding or embedding_fn is provided, since their length is determined by the value or callable.
• model: The model name reported in the metadata. Defaults to "mock-model".
• meta: Additional metadata merged into the output meta.
• prefix / suffix: Strings added to the beginning and end of the text before embedding, mirroring real embedders.

info

The deterministic embeddings are derived from a hash: identical texts get identical vectors and the similarity between different texts is stable but arbitrary. For exact-match retrieval in tests this is exactly what you want. Do not expect semantically similar texts to end up close together.

Use MockTextEmbedder for queries and its counterpart MockDocumentEmbedder for documents. With the default deterministic mode, a query whose text matches a document's content produces the same vector, so the document is retrieved as the top hit.

Usage

On its own

python

from haystack.components.embedders import MockTextEmbedder

embedder = MockTextEmbedder(dimension=8)
result = embedder.run("I love pizza!")
print(result["embedding"])  # a deterministic list of 8 floats

In a pipeline

A retrieval pipeline built with mock embedders runs without any API key and always returns the same result for the same input:

python

from haystack import Document, Pipeline
from haystack.components.embedders import MockDocumentEmbedder, MockTextEmbedder
from haystack.components.retrievers.in_memory import InMemoryEmbeddingRetriever
from haystack.document_stores.in_memory import InMemoryDocumentStore

document_store = InMemoryDocumentStore()
documents = [
    Document(content="My name is Wolfgang and I live in Berlin"),
    Document(content="I saw a black horse running"),
]

indexed = MockDocumentEmbedder(dimension=8).run(documents=documents)
document_store.write_documents(indexed["documents"])

query_pipeline = Pipeline()
query_pipeline.add_component("text_embedder", MockTextEmbedder(dimension=8))
query_pipeline.add_component(
    "retriever",
    InMemoryEmbeddingRetriever(document_store=document_store),
)
query_pipeline.connect("text_embedder.embedding", "retriever.query_embedding")

result = query_pipeline.run(
    {"text_embedder": {"text": "I saw a black horse running"}},
)
print(result["retriever"]["documents"][0].content)  # "I saw a black horse running"