diff --git a/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/__init__.py b/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/__init__.py
index eb75ffa6c..56dc30db4 100644
--- a/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/__init__.py
+++ b/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/__init__.py
@@ -1,3 +1,5 @@
+from .bm25_retriever import AzureAISearchBM25Retriever
 from .embedding_retriever import AzureAISearchEmbeddingRetriever
+from .hybrid_retriever import AzureAISearchHybridRetriever
 
-__all__ = ["AzureAISearchEmbeddingRetriever"]
+__all__ = ["AzureAISearchBM25Retriever", "AzureAISearchEmbeddingRetriever", "AzureAISearchHybridRetriever"]
diff --git a/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/bm25_retriever.py b/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/bm25_retriever.py
new file mode 100644
index 000000000..4a1c7f98c
--- /dev/null
+++ b/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/bm25_retriever.py
@@ -0,0 +1,135 @@
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+from haystack import Document, component, default_from_dict, default_to_dict
+from haystack.document_stores.types import FilterPolicy
+from haystack.document_stores.types.filter_policy import apply_filter_policy
+
+from haystack_integrations.document_stores.azure_ai_search import AzureAISearchDocumentStore, _normalize_filters
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class AzureAISearchBM25Retriever:
+    """
+    Retrieves documents from the AzureAISearchDocumentStore using BM25 retrieval.
+    Must be connected to the AzureAISearchDocumentStore to run.
+
+    """
+
+    def __init__(
+        self,
+        *,
+        document_store: AzureAISearchDocumentStore,
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: int = 10,
+        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
+        **kwargs,
+    ):
+        """
+        Create the AzureAISearchBM25Retriever component.
+
+        :param document_store: An instance of AzureAISearchDocumentStore to use with the Retriever.
+        :param filters: Filters applied when fetching documents from the Document Store.
+            Filters are applied during the BM25 search to ensure the Retriever returns
+              `top_k` matching documents.
+        :param top_k: Maximum number of documents to return.
+        :param filter_policy: Policy to determine how filters are applied.
+        :param kwargs: Additional keyword arguments to pass to the Azure AI's search endpoint.
+            Some of the supported parameters:
+                - `query_type`: A string indicating the type of query to perform. Possible values are
+                'simple','full' and 'semantic'.
+                - `semantic_configuration_name`: The name of semantic configuration to be used when
+                processing semantic queries.
+            For more information on parameters, see the
+            [official Azure AI Search documentation](https://learn.microsoft.com/en-us/azure/search/).
+        :raises TypeError: If the document store is not an instance of AzureAISearchDocumentStore.
+        :raises RuntimeError: If the query is not valid, or if the document store is not correctly configured.
+
+        """
+        self._filters = filters or {}
+        self._top_k = top_k
+        self._document_store = document_store
+        self._filter_policy = (
+            filter_policy if isinstance(filter_policy, FilterPolicy) else FilterPolicy.from_str(filter_policy)
+        )
+        self._kwargs = kwargs
+        if not isinstance(document_store, AzureAISearchDocumentStore):
+            message = "document_store must be an instance of AzureAISearchDocumentStore"
+            raise TypeError(message)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            filters=self._filters,
+            top_k=self._top_k,
+            document_store=self._document_store.to_dict(),
+            filter_policy=self._filter_policy.value,
+            **self._kwargs,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AzureAISearchBM25Retriever":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+
+        :returns:
+            Deserialized component.
+        """
+        data["init_parameters"]["document_store"] = AzureAISearchDocumentStore.from_dict(
+            data["init_parameters"]["document_store"]
+        )
+
+        # Pipelines serialized with old versions of the component might not
+        # have the filter_policy field.
+        if "filter_policy" in data["init_parameters"]:
+            data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(data["init_parameters"]["filter_policy"])
+        return default_from_dict(cls, data)
+
+    @component.output_types(documents=List[Document])
+    def run(self, query: str, filters: Optional[Dict[str, Any]] = None, top_k: Optional[int] = None):
+        """Retrieve documents from the AzureAISearchDocumentStore.
+
+        :param query: Text of the query.
+        :param filters: Filters applied to the retrieved Documents. The way runtime filters are applied depends on
+                        the `filter_policy` chosen at retriever initialization. See init method docstring for more
+                        details.
+        :param top_k: the maximum number of documents to retrieve.
+        :raises RuntimeError: If an error occurs during the BM25 retrieval process.
+        :returns: a dictionary with the following keys:
+            - `documents`: A list of documents retrieved from the AzureAISearchDocumentStore.
+        """
+
+        top_k = top_k or self._top_k
+        filters = filters or self._filters
+        if filters:
+            applied_filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+            normalized_filters = _normalize_filters(applied_filters)
+        else:
+            normalized_filters = ""
+
+        try:
+            docs = self._document_store._bm25_retrieval(
+                query=query,
+                filters=normalized_filters,
+                top_k=top_k,
+                **self._kwargs,
+            )
+        except Exception as e:
+            msg = (
+                "An error occurred during the bm25 retrieval process from the AzureAISearchDocumentStore. "
+                "Ensure that the query is valid and the document store is correctly configured."
+            )
+            raise RuntimeError(msg) from e
+
+        return {"documents": docs}
diff --git a/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/embedding_retriever.py b/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/embedding_retriever.py
index af48b74fb..69fad7208 100644
--- a/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/embedding_retriever.py
+++ b/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/embedding_retriever.py
@@ -107,7 +107,8 @@ def run(self, query_embedding: List[float], filters: Optional[Dict[str, Any]] =
         """
 
         top_k = top_k or self._top_k
-        if filters is not None:
+        filters = filters or self._filters
+        if filters:
             applied_filters = apply_filter_policy(self._filter_policy, self._filters, filters)
             normalized_filters = _normalize_filters(applied_filters)
         else:
diff --git a/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/hybrid_retriever.py b/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/hybrid_retriever.py
new file mode 100644
index 000000000..79282933f
--- /dev/null
+++ b/integrations/azure_ai_search/src/haystack_integrations/components/retrievers/azure_ai_search/hybrid_retriever.py
@@ -0,0 +1,139 @@
+import logging
+from typing import Any, Dict, List, Optional, Union
+
+from haystack import Document, component, default_from_dict, default_to_dict
+from haystack.document_stores.types import FilterPolicy
+from haystack.document_stores.types.filter_policy import apply_filter_policy
+
+from haystack_integrations.document_stores.azure_ai_search import AzureAISearchDocumentStore, _normalize_filters
+
+logger = logging.getLogger(__name__)
+
+
+@component
+class AzureAISearchHybridRetriever:
+    """
+    Retrieves documents from the AzureAISearchDocumentStore using a hybrid (vector + BM25) retrieval.
+    Must be connected to the AzureAISearchDocumentStore to run.
+
+    """
+
+    def __init__(
+        self,
+        *,
+        document_store: AzureAISearchDocumentStore,
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: int = 10,
+        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
+        **kwargs,
+    ):
+        """
+        Create the AzureAISearchHybridRetriever component.
+
+        :param document_store: An instance of AzureAISearchDocumentStore to use with the Retriever.
+        :param filters: Filters applied when fetching documents from the Document Store.
+            Filters are applied during the hybrid search to ensure the Retriever returns
+              `top_k` matching documents.
+        :param top_k: Maximum number of documents to return.
+        :param filter_policy: Policy to determine how filters are applied.
+        :param kwargs: Additional keyword arguments to pass to the Azure AI's search endpoint.
+            Some of the supported parameters:
+                - `query_type`: A string indicating the type of query to perform. Possible values are
+                'simple','full' and 'semantic'.
+                - `semantic_configuration_name`: The name of semantic configuration to be used when
+                processing semantic queries.
+            For more information on parameters, see the
+            [official Azure AI Search documentation](https://learn.microsoft.com/en-us/azure/search/).
+        :raises TypeError: If the document store is not an instance of AzureAISearchDocumentStore.
+        :raises RuntimeError: If query or query_embedding are invalid, or if document store is not correctly configured.
+        """
+        self._filters = filters or {}
+        self._top_k = top_k
+        self._document_store = document_store
+        self._filter_policy = (
+            filter_policy if isinstance(filter_policy, FilterPolicy) else FilterPolicy.from_str(filter_policy)
+        )
+        self._kwargs = kwargs
+
+        if not isinstance(document_store, AzureAISearchDocumentStore):
+            message = "document_store must be an instance of AzureAISearchDocumentStore"
+            raise TypeError(message)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
+        return default_to_dict(
+            self,
+            filters=self._filters,
+            top_k=self._top_k,
+            document_store=self._document_store.to_dict(),
+            filter_policy=self._filter_policy.value,
+            **self._kwargs,
+        )
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "AzureAISearchHybridRetriever":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            Dictionary to deserialize from.
+
+        :returns:
+            Deserialized component.
+        """
+        data["init_parameters"]["document_store"] = AzureAISearchDocumentStore.from_dict(
+            data["init_parameters"]["document_store"]
+        )
+
+        # Pipelines serialized with old versions of the component might not
+        # have the filter_policy field.
+        if "filter_policy" in data["init_parameters"]:
+            data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(data["init_parameters"]["filter_policy"])
+        return default_from_dict(cls, data)
+
+    @component.output_types(documents=List[Document])
+    def run(
+        self,
+        query: str,
+        query_embedding: List[float],
+        filters: Optional[Dict[str, Any]] = None,
+        top_k: Optional[int] = None,
+    ):
+        """Retrieve documents from the AzureAISearchDocumentStore.
+
+        :param query: Text of the query.
+        :param query_embedding: A list of floats representing the query embedding
+        :param filters: Filters applied to the retrieved Documents. The way runtime filters are applied depends on
+                        the `filter_policy` chosen at retriever initialization. See `__init__` method docstring for more
+                        details.
+        :param top_k: The maximum number of documents to retrieve.
+        :raises RuntimeError: If an error occurs during the hybrid retrieval process.
+        :returns: A dictionary with the following keys:
+            - `documents`: A list of documents retrieved from the AzureAISearchDocumentStore.
+        """
+
+        top_k = top_k or self._top_k
+        filters = filters or self._filters
+        if filters:
+            applied_filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+            normalized_filters = _normalize_filters(applied_filters)
+        else:
+            normalized_filters = ""
+
+        try:
+            docs = self._document_store._hybrid_retrieval(
+                query=query, query_embedding=query_embedding, filters=normalized_filters, top_k=top_k, **self._kwargs
+            )
+        except Exception as e:
+            msg = (
+                "An error occurred during the hybrid retrieval process from the AzureAISearchDocumentStore. "
+                "Ensure that the query and query_embedding are valid and the document store is correctly configured."
+            )
+            raise RuntimeError(msg) from e
+
+        return {"documents": docs}
diff --git a/integrations/azure_ai_search/src/haystack_integrations/document_stores/azure_ai_search/document_store.py b/integrations/azure_ai_search/src/haystack_integrations/document_stores/azure_ai_search/document_store.py
index 74260b4fa..137ff621c 100644
--- a/integrations/azure_ai_search/src/haystack_integrations/document_stores/azure_ai_search/document_store.py
+++ b/integrations/azure_ai_search/src/haystack_integrations/document_stores/azure_ai_search/document_store.py
@@ -240,6 +240,9 @@ def write_documents(self, documents: List[Document], policy: DuplicatePolicy = D
         Writes the provided documents to search index.
 
         :param documents: documents to write to the index.
+        :param policy: Policy to determine how duplicates are handled.
+        :raises ValueError: If the documents are not of type Document.
+        :raises TypeError: If the document ids are not strings.
         :return: the number of documents added to index.
         """
 
@@ -247,7 +250,7 @@ def _convert_input_document(documents: Document):
             document_dict = asdict(documents)
             if not isinstance(document_dict["id"], str):
                 msg = f"Document id {document_dict['id']} is not a string, "
-                raise Exception(msg)
+                raise TypeError(msg)
             index_document = self._convert_haystack_documents_to_azure(document_dict)
 
             return index_document
@@ -421,7 +424,7 @@ def _embedding_retrieval(
     ) -> List[Document]:
         """
         Retrieves documents that are most similar to the query embedding using a vector similarity metric.
-        It uses the vector configuration of the document store. By default it uses the HNSW algorithm
+        It uses the vector configuration specified in the document store. By default, it uses the HNSW algorithm
         with cosine similarity.
 
         This method is not meant to be part of the public interface of
@@ -429,13 +432,12 @@ def _embedding_retrieval(
         `AzureAISearchEmbeddingRetriever` uses this method directly and is the public interface for it.
 
         :param query_embedding: Embedding of the query.
-        :param top_k: Maximum number of Documents to return, defaults to 10.
-        :param filters: Filters applied to the retrieved Documents. Defaults to None.
-            Filters are applied during the approximate kNN search to ensure that top_k matching documents are returned.
+        :param top_k: Maximum number of Documents to return.
+        :param filters: Filters applied to the retrieved Documents.
         :param kwargs: Optional keyword arguments to pass to the Azure AI's search endpoint.
 
-        :raises ValueError: If `query_embedding` is an empty list
-        :returns: List of Document that are most similar to `query_embedding`
+        :raises ValueError: If `query_embedding` is an empty list.
+        :returns: List of Document that are most similar to `query_embedding`.
         """
 
         if not query_embedding:
@@ -446,3 +448,80 @@ def _embedding_retrieval(
         result = self.client.search(vector_queries=[vector_query], filter=filters, **kwargs)
         azure_docs = list(result)
         return self._convert_search_result_to_documents(azure_docs)
+
+    def _bm25_retrieval(
+        self,
+        query: str,
+        top_k: int = 10,
+        filters: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> List[Document]:
+        """
+        Retrieves documents that are most similar to `query`, using the BM25 algorithm.
+
+        This method is not meant to be part of the public interface of
+        `AzureAISearchDocumentStore` nor called directly.
+        `AzureAISearchBM25Retriever` uses this method directly and is the public interface for it.
+
+        :param query: Text of the query.
+        :param filters: Filters applied to the retrieved Documents.
+        :param top_k: Maximum number of Documents to return.
+        :param kwargs: Optional keyword arguments to pass to the Azure AI's search endpoint.
+
+
+        :raises ValueError: If `query` is an empty string.
+        :returns: List of Document that are most similar to `query`.
+        """
+
+        if query is None:
+            msg = "query must not be None"
+            raise ValueError(msg)
+
+        result = self.client.search(search_text=query, filter=filters, top=top_k, query_type="simple", **kwargs)
+        azure_docs = list(result)
+        return self._convert_search_result_to_documents(azure_docs)
+
+    def _hybrid_retrieval(
+        self,
+        query: str,
+        query_embedding: List[float],
+        top_k: int = 10,
+        filters: Optional[Dict[str, Any]] = None,
+        **kwargs,
+    ) -> List[Document]:
+        """
+        Retrieves documents similar to query using the vector configuration in the document store and
+        the BM25 algorithm. This method combines vector similarity and BM25 for improved retrieval.
+
+        This method is not meant to be part of the public interface of
+        `AzureAISearchDocumentStore` nor called directly.
+        `AzureAISearchHybridRetriever` uses this method directly and is the public interface for it.
+
+        :param query: Text of the query.
+        :param query_embedding: Embedding of the query.
+        :param filters: Filters applied to the retrieved Documents.
+        :param top_k: Maximum number of Documents to return.
+        :param kwargs: Optional keyword arguments to pass to the Azure AI's search endpoint.
+
+        :raises ValueError: If `query` or `query_embedding` is empty.
+        :returns: List of Document that are most similar to `query`.
+        """
+
+        if query is None:
+            msg = "query must not be None"
+            raise ValueError(msg)
+        if not query_embedding:
+            msg = "query_embedding must be a non-empty list of floats"
+            raise ValueError(msg)
+
+        vector_query = VectorizedQuery(vector=query_embedding, k_nearest_neighbors=top_k, fields="embedding")
+        result = self.client.search(
+            search_text=query,
+            vector_queries=[vector_query],
+            filter=filters,
+            top=top_k,
+            query_type="simple",
+            **kwargs,
+        )
+        azure_docs = list(result)
+        return self._convert_search_result_to_documents(azure_docs)
diff --git a/integrations/azure_ai_search/tests/test_bm25_retriever.py b/integrations/azure_ai_search/tests/test_bm25_retriever.py
new file mode 100644
index 000000000..6ebb20949
--- /dev/null
+++ b/integrations/azure_ai_search/tests/test_bm25_retriever.py
@@ -0,0 +1,175 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+import os
+from unittest.mock import Mock
+
+import pytest
+from haystack.dataclasses import Document
+from haystack.document_stores.types import FilterPolicy
+
+from haystack_integrations.components.retrievers.azure_ai_search import AzureAISearchBM25Retriever
+from haystack_integrations.document_stores.azure_ai_search import AzureAISearchDocumentStore
+
+
+def test_init_default():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    retriever = AzureAISearchBM25Retriever(document_store=mock_store)
+    assert retriever._document_store == mock_store
+    assert retriever._filters == {}
+    assert retriever._top_k == 10
+    assert retriever._filter_policy == FilterPolicy.REPLACE
+
+    retriever = AzureAISearchBM25Retriever(document_store=mock_store, filter_policy="replace")
+    assert retriever._filter_policy == FilterPolicy.REPLACE
+
+    with pytest.raises(ValueError):
+        AzureAISearchBM25Retriever(document_store=mock_store, filter_policy="unknown")
+
+
+def test_to_dict():
+    document_store = AzureAISearchDocumentStore(hosts="some fake host")
+    retriever = AzureAISearchBM25Retriever(document_store=document_store)
+    res = retriever.to_dict()
+    assert res == {
+        "type": "haystack_integrations.components.retrievers.azure_ai_search.bm25_retriever.AzureAISearchBM25Retriever",
+        "init_parameters": {
+            "filters": {},
+            "top_k": 10,
+            "document_store": {
+                "type": "haystack_integrations.document_stores.azure_ai_search.document_store.AzureAISearchDocumentStore",  # noqa: E501
+                "init_parameters": {
+                    "azure_endpoint": {
+                        "type": "env_var",
+                        "env_vars": ["AZURE_SEARCH_SERVICE_ENDPOINT"],
+                        "strict": True,
+                    },
+                    "api_key": {"type": "env_var", "env_vars": ["AZURE_SEARCH_API_KEY"], "strict": False},
+                    "index_name": "default",
+                    "embedding_dimension": 768,
+                    "metadata_fields": None,
+                    "vector_search_configuration": {
+                        "profiles": [
+                            {"name": "default-vector-config", "algorithm_configuration_name": "cosine-algorithm-config"}
+                        ],
+                        "algorithms": [
+                            {
+                                "name": "cosine-algorithm-config",
+                                "kind": "hnsw",
+                                "parameters": {"m": 4, "ef_construction": 400, "ef_search": 500, "metric": "cosine"},
+                            }
+                        ],
+                    },
+                    "hosts": "some fake host",
+                },
+            },
+            "filter_policy": "replace",
+        },
+    }
+
+
+def test_from_dict():
+    data = {
+        "type": "haystack_integrations.components.retrievers.azure_ai_search.bm25_retriever.AzureAISearchBM25Retriever",
+        "init_parameters": {
+            "filters": {},
+            "top_k": 10,
+            "document_store": {
+                "type": "haystack_integrations.document_stores.azure_ai_search.document_store.AzureAISearchDocumentStore",  # noqa: E501
+                "init_parameters": {
+                    "azure_endpoint": {
+                        "type": "env_var",
+                        "env_vars": ["AZURE_SEARCH_SERVICE_ENDPOINT"],
+                        "strict": True,
+                    },
+                    "api_key": {"type": "env_var", "env_vars": ["AZURE_SEARCH_API_KEY"], "strict": False},
+                    "index_name": "default",
+                    "metadata_fields": None,
+                    "hosts": "some fake host",
+                },
+            },
+            "filter_policy": "replace",
+        },
+    }
+    retriever = AzureAISearchBM25Retriever.from_dict(data)
+    assert isinstance(retriever._document_store, AzureAISearchDocumentStore)
+    assert retriever._filters == {}
+    assert retriever._top_k == 10
+    assert retriever._filter_policy == FilterPolicy.REPLACE
+
+
+def test_run():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    mock_store._bm25_retrieval.return_value = [Document(content="Test doc")]
+    retriever = AzureAISearchBM25Retriever(document_store=mock_store)
+    res = retriever.run(query="Test query")
+    mock_store._bm25_retrieval.assert_called_once_with(
+        query="Test query",
+        filters="",
+        top_k=10,
+    )
+    assert len(res) == 1
+    assert len(res["documents"]) == 1
+    assert res["documents"][0].content == "Test doc"
+
+
+def test_run_init_params():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    mock_store._bm25_retrieval.return_value = [Document(content="Test doc")]
+    retriever = AzureAISearchBM25Retriever(
+        document_store=mock_store, filters={"field": "type", "operator": "==", "value": "article"}, top_k=11
+    )
+    res = retriever.run(query="Test query")
+    mock_store._bm25_retrieval.assert_called_once_with(
+        query="Test query",
+        filters="type eq 'article'",
+        top_k=11,
+    )
+    assert len(res) == 1
+    assert len(res["documents"]) == 1
+    assert res["documents"][0].content == "Test doc"
+
+
+def test_run_time_params():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    mock_store._bm25_retrieval.return_value = [Document(content="Test doc")]
+    retriever = AzureAISearchBM25Retriever(
+        document_store=mock_store,
+        filters={"field": "type", "operator": "==", "value": "article"},
+        top_k=11,
+        select="name",
+    )
+    res = retriever.run(query="Test query", filters={"field": "type", "operator": "==", "value": "book"}, top_k=5)
+    mock_store._bm25_retrieval.assert_called_once_with(
+        query="Test query", filters="type eq 'book'", top_k=5, select="name"
+    )
+    assert len(res) == 1
+    assert len(res["documents"]) == 1
+    assert res["documents"][0].content == "Test doc"
+
+
+@pytest.mark.skipif(
+    not os.environ.get("AZURE_SEARCH_SERVICE_ENDPOINT", None) and not os.environ.get("AZURE_SEARCH_API_KEY", None),
+    reason="Missing AZURE_SEARCH_SERVICE_ENDPOINT or AZURE_SEARCH_API_KEY.",
+)
+@pytest.mark.integration
+class TestRetriever:
+
+    def test_run(self, document_store: AzureAISearchDocumentStore):
+        docs = [Document(id="1", content="Test document")]
+        document_store.write_documents(docs)
+        retriever = AzureAISearchBM25Retriever(document_store=document_store)
+        res = retriever.run(query="Test document")
+        assert res["documents"] == docs
+
+    def test_document_retrieval(self, document_store: AzureAISearchDocumentStore):
+        docs = [
+            Document(content="This is first document"),
+            Document(content="This is second document"),
+            Document(content="This is third document"),
+        ]
+
+        document_store.write_documents(docs)
+        retriever = AzureAISearchBM25Retriever(document_store=document_store)
+        results = retriever.run(query="This is first document")
+        assert results["documents"][0].content == "This is first document"
diff --git a/integrations/azure_ai_search/tests/test_embedding_retriever.py b/integrations/azure_ai_search/tests/test_embedding_retriever.py
index d4615ec44..576ecda08 100644
--- a/integrations/azure_ai_search/tests/test_embedding_retriever.py
+++ b/integrations/azure_ai_search/tests/test_embedding_retriever.py
@@ -103,6 +103,66 @@ def test_from_dict():
     assert retriever._filter_policy == FilterPolicy.REPLACE
 
 
+def test_run():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    mock_store._embedding_retrieval.return_value = [Document(content="Test doc", embedding=[0.1, 0.2])]
+    retriever = AzureAISearchEmbeddingRetriever(document_store=mock_store)
+    res = retriever.run(query_embedding=[0.5, 0.7])
+    mock_store._embedding_retrieval.assert_called_once_with(
+        query_embedding=[0.5, 0.7],
+        filters="",
+        top_k=10,
+    )
+    assert len(res) == 1
+    assert len(res["documents"]) == 1
+    assert res["documents"][0].content == "Test doc"
+    assert res["documents"][0].embedding == [0.1, 0.2]
+
+
+def test_run_init_params():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    mock_store._embedding_retrieval.return_value = [Document(content="Test doc", embedding=[0.1, 0.2])]
+    retriever = AzureAISearchEmbeddingRetriever(
+        document_store=mock_store,
+        filters={"field": "type", "operator": "==", "value": "article"},
+        top_k=11,
+    )
+    res = retriever.run(query_embedding=[0.5, 0.7])
+    mock_store._embedding_retrieval.assert_called_once_with(
+        query_embedding=[0.5, 0.7],
+        filters="type eq 'article'",
+        top_k=11,
+    )
+    assert len(res) == 1
+    assert len(res["documents"]) == 1
+    assert res["documents"][0].content == "Test doc"
+    assert res["documents"][0].embedding == [0.1, 0.2]
+
+
+def test_run_time_params():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    mock_store._embedding_retrieval.return_value = [Document(content="Test doc", embedding=[0.1, 0.2])]
+    retriever = AzureAISearchEmbeddingRetriever(
+        document_store=mock_store,
+        filters={"field": "type", "operator": "==", "value": "article"},
+        top_k=11,
+        select="name",
+    )
+    res = retriever.run(
+        query_embedding=[0.5, 0.7], filters={"field": "type", "operator": "==", "value": "book"}, top_k=9
+    )
+    mock_store._embedding_retrieval.assert_called_once_with(
+        query_embedding=[0.5, 0.7],
+        filters="type eq 'book'",
+        top_k=9,
+        select="name",
+    )
+    assert len(res) == 1
+    assert len(res["documents"]) == 1
+    assert res["documents"][0].content == "Test doc"
+    assert res["documents"][0].embedding == [0.1, 0.2]
+
+
 @pytest.mark.skipif(
     not os.environ.get("AZURE_SEARCH_SERVICE_ENDPOINT", None) and not os.environ.get("AZURE_SEARCH_API_KEY", None),
     reason="Missing AZURE_SEARCH_SERVICE_ENDPOINT or AZURE_SEARCH_API_KEY.",
diff --git a/integrations/azure_ai_search/tests/test_hybrid_retriever.py b/integrations/azure_ai_search/tests/test_hybrid_retriever.py
new file mode 100644
index 000000000..bf305c4fe
--- /dev/null
+++ b/integrations/azure_ai_search/tests/test_hybrid_retriever.py
@@ -0,0 +1,211 @@
+# SPDX-FileCopyrightText: 2023-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+import os
+from typing import List
+from unittest.mock import Mock
+
+import pytest
+from azure.core.exceptions import HttpResponseError
+from haystack.dataclasses import Document
+from haystack.document_stores.types import FilterPolicy
+from numpy.random import rand  # type: ignore
+
+from haystack_integrations.components.retrievers.azure_ai_search import AzureAISearchHybridRetriever
+from haystack_integrations.document_stores.azure_ai_search import DEFAULT_VECTOR_SEARCH, AzureAISearchDocumentStore
+
+
+def test_init_default():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    retriever = AzureAISearchHybridRetriever(document_store=mock_store)
+    assert retriever._document_store == mock_store
+    assert retriever._filters == {}
+    assert retriever._top_k == 10
+    assert retriever._filter_policy == FilterPolicy.REPLACE
+
+    retriever = AzureAISearchHybridRetriever(document_store=mock_store, filter_policy="replace")
+    assert retriever._filter_policy == FilterPolicy.REPLACE
+
+    with pytest.raises(ValueError):
+        AzureAISearchHybridRetriever(document_store=mock_store, filter_policy="unknown")
+
+
+def test_to_dict():
+    document_store = AzureAISearchDocumentStore(hosts="some fake host")
+    retriever = AzureAISearchHybridRetriever(document_store=document_store)
+    res = retriever.to_dict()
+    assert res == {
+        "type": "haystack_integrations.components.retrievers.azure_ai_search.hybrid_retriever.AzureAISearchHybridRetriever",  # noqa: E501
+        "init_parameters": {
+            "filters": {},
+            "top_k": 10,
+            "document_store": {
+                "type": "haystack_integrations.document_stores.azure_ai_search.document_store.AzureAISearchDocumentStore",  # noqa: E501
+                "init_parameters": {
+                    "azure_endpoint": {
+                        "type": "env_var",
+                        "env_vars": ["AZURE_SEARCH_SERVICE_ENDPOINT"],
+                        "strict": True,
+                    },
+                    "api_key": {"type": "env_var", "env_vars": ["AZURE_SEARCH_API_KEY"], "strict": False},
+                    "index_name": "default",
+                    "embedding_dimension": 768,
+                    "metadata_fields": None,
+                    "vector_search_configuration": {
+                        "profiles": [
+                            {"name": "default-vector-config", "algorithm_configuration_name": "cosine-algorithm-config"}
+                        ],
+                        "algorithms": [
+                            {
+                                "name": "cosine-algorithm-config",
+                                "kind": "hnsw",
+                                "parameters": {"m": 4, "ef_construction": 400, "ef_search": 500, "metric": "cosine"},
+                            }
+                        ],
+                    },
+                    "hosts": "some fake host",
+                },
+            },
+            "filter_policy": "replace",
+        },
+    }
+
+
+def test_from_dict():
+    data = {
+        "type": "haystack_integrations.components.retrievers.azure_ai_search.hybrid_retriever.AzureAISearchHybridRetriever",  # noqa: E501
+        "init_parameters": {
+            "filters": {},
+            "top_k": 10,
+            "document_store": {
+                "type": "haystack_integrations.document_stores.azure_ai_search.document_store.AzureAISearchDocumentStore",  # noqa: E501
+                "init_parameters": {
+                    "azure_endpoint": {
+                        "type": "env_var",
+                        "env_vars": ["AZURE_SEARCH_SERVICE_ENDPOINT"],
+                        "strict": True,
+                    },
+                    "api_key": {"type": "env_var", "env_vars": ["AZURE_SEARCH_API_KEY"], "strict": False},
+                    "index_name": "default",
+                    "embedding_dimension": 768,
+                    "metadata_fields": None,
+                    "vector_search_configuration": DEFAULT_VECTOR_SEARCH,
+                    "hosts": "some fake host",
+                },
+            },
+            "filter_policy": "replace",
+        },
+    }
+    retriever = AzureAISearchHybridRetriever.from_dict(data)
+    assert isinstance(retriever._document_store, AzureAISearchDocumentStore)
+    assert retriever._filters == {}
+    assert retriever._top_k == 10
+    assert retriever._filter_policy == FilterPolicy.REPLACE
+
+
+def test_run():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    mock_store._hybrid_retrieval.return_value = [Document(content="Test doc", embedding=[0.1, 0.2])]
+    retriever = AzureAISearchHybridRetriever(document_store=mock_store)
+    res = retriever.run(query_embedding=[0.5, 0.7], query="Test query")
+    mock_store._hybrid_retrieval.assert_called_once_with(
+        query="Test query",
+        query_embedding=[0.5, 0.7],
+        filters="",
+        top_k=10,
+    )
+    assert len(res) == 1
+    assert len(res["documents"]) == 1
+    assert res["documents"][0].content == "Test doc"
+    assert res["documents"][0].embedding == [0.1, 0.2]
+
+
+def test_run_init_params():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    mock_store._hybrid_retrieval.return_value = [Document(content="Test doc", embedding=[0.1, 0.2])]
+    retriever = AzureAISearchHybridRetriever(
+        document_store=mock_store,
+        filters={"field": "type", "operator": "==", "value": "article"},
+        top_k=11,
+    )
+    res = retriever.run(query_embedding=[0.5, 0.7], query="Test query")
+    mock_store._hybrid_retrieval.assert_called_once_with(
+        query="Test query",
+        query_embedding=[0.5, 0.7],
+        filters="type eq 'article'",
+        top_k=11,
+    )
+    assert len(res) == 1
+    assert len(res["documents"]) == 1
+    assert res["documents"][0].content == "Test doc"
+    assert res["documents"][0].embedding == [0.1, 0.2]
+
+
+def test_run_time_params():
+    mock_store = Mock(spec=AzureAISearchDocumentStore)
+    mock_store._hybrid_retrieval.return_value = [Document(content="Test doc", embedding=[0.1, 0.2])]
+    retriever = AzureAISearchHybridRetriever(
+        document_store=mock_store,
+        filters={"field": "type", "operator": "==", "value": "article"},
+        top_k=11,
+        select="name",
+    )
+    res = retriever.run(
+        query_embedding=[0.5, 0.7],
+        query="Test query",
+        filters={"field": "type", "operator": "==", "value": "book"},
+        top_k=9,
+    )
+    mock_store._hybrid_retrieval.assert_called_once_with(
+        query="Test query",
+        query_embedding=[0.5, 0.7],
+        filters="type eq 'book'",
+        top_k=9,
+        select="name",
+    )
+    assert len(res) == 1
+    assert len(res["documents"]) == 1
+    assert res["documents"][0].content == "Test doc"
+    assert res["documents"][0].embedding == [0.1, 0.2]
+
+
+@pytest.mark.skipif(
+    not os.environ.get("AZURE_SEARCH_SERVICE_ENDPOINT", None) and not os.environ.get("AZURE_SEARCH_API_KEY", None),
+    reason="Missing AZURE_SEARCH_SERVICE_ENDPOINT or AZURE_SEARCH_API_KEY.",
+)
+@pytest.mark.integration
+class TestRetriever:
+
+    def test_run(self, document_store: AzureAISearchDocumentStore):
+        docs = [Document(id="1")]
+        document_store.write_documents(docs)
+        retriever = AzureAISearchHybridRetriever(document_store=document_store)
+        res = retriever.run(query="Test document", query_embedding=[0.1] * 768)
+        assert res["documents"] == docs
+
+    def test_hybrid_retrieval(self, document_store: AzureAISearchDocumentStore):
+        query_embedding = [0.1] * 768
+        most_similar_embedding = [0.8] * 768
+        second_best_embedding = [0.8] * 200 + [0.1] * 300 + [0.2] * 268
+        another_embedding = rand(768).tolist()
+
+        docs = [
+            Document(content="This is first document", embedding=most_similar_embedding),
+            Document(content="This is second document", embedding=second_best_embedding),
+            Document(content="This is third document", embedding=another_embedding),
+        ]
+
+        document_store.write_documents(docs)
+        retriever = AzureAISearchHybridRetriever(document_store=document_store)
+        results = retriever.run(query="This is first document", query_embedding=query_embedding)
+        assert results["documents"][0].content == "This is first document"
+
+    def test_empty_query_embedding(self, document_store: AzureAISearchDocumentStore):
+        query_embedding: List[float] = []
+        with pytest.raises(ValueError):
+            document_store._hybrid_retrieval(query="", query_embedding=query_embedding)
+
+    def test_query_embedding_wrong_dimension(self, document_store: AzureAISearchDocumentStore):
+        query_embedding = [0.1] * 4
+        with pytest.raises(HttpResponseError):
+            document_store._hybrid_retrieval(query="", query_embedding=query_embedding)