Multimodal embedder

.code-samples.meilisearch.yaml

@@ -11,6 +11,8 @@ create_an_index_1: |-
   client.create_index('movies', {'primaryKey': 'id'})
 update_an_index_1: |-
   client.index('movies').update(primary_key='id')
+compact_index_1: |-
+    client.index('movies').compact()
 delete_an_index_1: |-
   client.delete_index('movies')
   // OR

meilisearch/client.py

@@ -984,6 +984,34 @@ def update_chat_workspace_settings(
 
         return self.http.patch(f"chats/{workspace_uid}/settings", body=settings)
 
+    def get_experimental_features(self) -> dict:
+        """
+        Retrieve the current settings for all experimental features.
+
+        Returns:
+            dict: A mapping of feature names to their enabled/disabled state.
+
+        Example:
+            >>> client.get_experimental_features()
+        """
+        return self.http.get(self.config.paths.experimental_features)
+
+    def update_experimental_features(self, features: dict) -> dict:
+        """
+        Update one or more experimental features.
+
+        Args:
+            features (dict): A dictionary mapping feature names to booleans.
+                             For example, {"multimodal": True} to enable multimodal.
+
+        Returns:
+            dict: The updated experimental features settings.
+
+        Example:
+            >>> client.update_experimental_features({"multimodal": True})
+        """
+        return self.http.patch(self.config.paths.experimental_features, body=features)
+
     @staticmethod
     def _base64url_encode(data: bytes) -> str:
         return base64.urlsafe_b64encode(data).decode("utf-8").replace("=", "")

meilisearch/config.py

@@ -47,6 +47,7 @@ class Paths:
         localized_attributes = "localized-attributes"
         edit = "edit"
         network = "network"
+        experimental_features = "experimental-features"
 
     def __init__(
         self,

meilisearch/index.py

@@ -2333,3 +2333,17 @@ def _build_url(
         if primary_key is None and csv_delimiter is None:
             return f"{self.config.paths.index}/{self.uid}/{self.config.paths.document}"
         return f"{self.config.paths.index}/{self.uid}/{self.config.paths.document}?{parse.urlencode(parameters)}"
+
+    def compact(self) -> TaskInfo:
+        """
+        Trigger the compaction of the index.
+        This is an asynchronous operation in Meilisearch.
+
+        Returns
+        -------
+        task_info: TaskInfo
+            Contains information to track the progress of the compaction task.
+        """
+        path = f"{self.config.paths.index}/{self.uid}/compact"
+        task = self.http.post(path)
+        return TaskInfo(**task)

meilisearch/models/embedders.py

@@ -167,6 +167,12 @@ class RestEmbedder(CamelBase):
         Template defining the data Meilisearch sends to the embedder
     document_template_max_bytes: Optional[int]
         Maximum allowed size of rendered document template (defaults to 400)
+    indexing_fragments: Optional[Dict[str, Dict[str, str]]]
+        Defines how to fragment documents for indexing (multi-modal search)
+        Example: {"text": {"value": "{{doc.title}} - {{doc.overview}}"}}
+    search_fragments: Optional[Dict[str, Dict[str, str]]]
+        Defines how to fragment search queries (multi-modal search)
+        Example: {"text": {"value": "{{fragment}}"}}
     request: Dict[str, Any]
         A JSON value representing the request Meilisearch makes to the remote embedder
     response: Dict[str, Any]
@@ -185,6 +191,8 @@ class RestEmbedder(CamelBase):
     dimensions: Optional[int] = None
     document_template: Optional[str] = None
     document_template_max_bytes: Optional[int] = None
+    indexing_fragments: Optional[Dict[str, Dict[str, str]]] = None
+    search_fragments: Optional[Dict[str, Dict[str, str]]] = None
     request: Dict[str, Any]
     response: Dict[str, Any]
     headers: Optional[Dict[str, str]] = None

meilisearch/version.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-__version__ = "0.37.1"
+__version__ = "0.38.0"
 
 
 def qualified_version() -> str:

tests/client/test_client_experimental_features.py

@@ -0,0 +1,40 @@
+"""Tests for client experimental features methods."""
+
+def test_get_experimental_features(client):
+    """Test getting experimental features returns a dict including 'multimodal'."""
+    response = client.get_experimental_features()
+
+    assert isinstance(response, dict)
+    assert len(response) > 0
+    assert "multimodal" in response
+    assert isinstance(response["multimodal"], bool)
+
+
+def test_update_experimental_features(client):
+    """Test updating experimental features and verify changes persist."""
+    initial = client.get_experimental_features()
+    initial_multimodal = initial.get("multimodal", False)
+
+    # Toggle multimodal
+    new_value = not initial_multimodal
+    response = client.update_experimental_features({"multimodal": new_value})
+
+    assert isinstance(response, dict)
+    assert response.get("multimodal") == new_value
+    assert client.get_experimental_features().get("multimodal") == new_value
+
+    # Reset to original value
+    client.update_experimental_features({"multimodal": initial_multimodal})
+
+
+def test_multimodal_idempotency_generic(client):
+    """Test that updating multimodal via generic method is idempotent."""
+    # Enable twice
+    client.update_experimental_features({"multimodal": True})
+    response = client.update_experimental_features({"multimodal": True})
+    assert response.get("multimodal") is True
+
+    # Disable twice
+    client.update_experimental_features({"multimodal": False})
+    response = client.update_experimental_features({"multimodal": False})
+    assert response.get("multimodal") is False

tests/conftest.py

@@ -152,6 +152,79 @@ def index_maker(index_uid=common.INDEX_UID, documents=small_movies):
     return index_maker
 
 
+@fixture(scope="function")
+def mock_embedder_server():
+    """Fixture that starts a mock HTTP server to act as an embedder.
+
+    This server responds to embedding requests with fake vectors,
+    allowing us to test search_with_media without a real AI service.
+    """
+    from http.server import HTTPServer, BaseHTTPRequestHandler
+    import threading
+    import json
+
+    class MockEmbedderHandler(BaseHTTPRequestHandler):
+        def do_POST(self):
+            # Return a fake embedding vector
+            response = {"data": [{"embedding": [0.1] * 512}]}
+            self.send_response(200)
+            self.send_header('Content-Type', 'application/json')
+            self.end_headers()
+            self.wfile.write(json.dumps(response).encode())
+
+        def log_message(self, format, *args):
+            # Suppress logging
+            pass
+
+    # Start server in background thread
+    server = HTTPServer(('localhost', 8080), MockEmbedderHandler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+
+    yield server
+
+    # Cleanup
+    server.shutdown()
+
+
+@fixture(scope="function")
+def index_with_rest_embedder(empty_index, small_movies, mock_embedder_server, experimental_features):
+    """Fixture for index with REST embedder configured for media search testing.
+
+    Uses a mock HTTP server to act as the embedder, allowing real
+    search_with_media() testing without external AI services.
+    """
+    def index_maker(index_uid=common.INDEX_UID, documents=small_movies):
+        experimental_features({"multimodal": True})
+        index = empty_index(index_uid)
+        # Configure REST embedder pointing to mock server
+        settings_update_task = index.update_embedders(
+            {
+                "default": {
+                    "source": "rest",
+                    "url": "http://localhost:8080/embed",
+                    "apiKey": "test-key",
+                    "dimensions": 512,
+                    "indexingFragments": {
+                        "text": {"value": "{{doc.title}}"}
+                    },
+                    "searchFragments": {
+                        "text": {"value": "{{fragment}}"}
+                    },
+                    "request": {"input": ["{{fragment}}"], "model": "test-model"},
+                    "response": {"data": [{"embedding": "{{embedding}}"}]},
+                }
+            }
+        )
+        index.wait_for_task(settings_update_task.task_uid)
+        # Add documents - embedder will be called via mock server
+        document_addition_task = index.add_documents(documents)
+        index.wait_for_task(document_addition_task.task_uid)
+        return index
+
+    return index_maker
+
+
 @fixture(scope="function")
 def index_with_documents_and_facets(empty_index, small_movies):
     def index_maker(index_uid=common.INDEX_UID, documents=small_movies):
@@ -308,3 +381,42 @@ def enable_network_options():
         json={"network": False},
         timeout=10,
     )
+
+
+@fixture
+def experimental_features():
+    """
+    Fixture to temporarily set experimental features for a test.
+
+    Usage:
+        def test_example(experimental_features):
+            experimental_features({"multimodal": True, "new_ui": True})
+    """
+    def _set_features(features: dict):
+        # Enable features
+        requests.patch(
+            f"{common.BASE_URL}/experimental-features",
+            headers={"Authorization": f"Bearer {common.MASTER_KEY}"},
+            json=features,
+            timeout=10,
+        )
+        # Return features so we can reset later
+        return features
+
+    yield _set_features
+
+    # Reset features after the test
+    def _reset(features: dict):
+        # Create a reset payload inside the function
+        reset_payload = {key: False for key in features.keys()}
+        requests.patch(
+            f"{common.BASE_URL}/experimental-features",
+            headers={"Authorization": f"Bearer {common.MASTER_KEY}"},
+            json=reset_payload,
+            timeout=10,
+        )
+
+@fixture
+def multimodal_enabled(experimental_features):
+    """Convenience fixture: enables multimodal experimental feature."""
+    experimental_features({"multimodal": True})

tests/index/test_index.py

@@ -219,3 +219,18 @@ def test_delete_index(client):
     client.wait_for_task(deleted.task_uid)
     with pytest.raises(MeilisearchApiError):
         client.get_index(uid=common.INDEX_UID)
+
+
+@pytest.mark.usefixtures("indexes_sample")
+def test_index_compact(client):
+    """Tests the compaction of an index."""
+    index = client.index(common.INDEX_UID)
+    # Get stats before compaction
+    stats_before = index.get_stats()
+
+    task_info = index.compact()
+    client.wait_for_task(task_info.task_uid)
+    stats_after = index.get_stats()
+
+    assert stats_before.number_of_documents == stats_after.number_of_documents
+    assert stats_after.is_indexing is False