Add filters support for AI field (baserow#4166)

Add filters support for AI Field

Author: dimmur-brw

backend/src/baserow/contrib/database/fields/registries.py

@@ -1674,6 +1674,19 @@ def check_can_filter_by(self, field: Field) -> bool:
 
         return len(compatible_vft) > 0
 
+    def get_compatible_filter_field_type(self, field: Field) -> "FieldType":
+        """
+        Returns the canonical field type to use when determining compatibility with
+        view filters. By default this returns self, but field types that should be
+        treated as another field type for filtering can override this and return that
+        other field type instance.
+
+        :param field: The concrete field instance being checked.
+        :return: The FieldType that should be used for filter compatibility.
+        """
+
+        return self
+
     def check_can_order_by(self, field: Field, sort_type: str) -> bool:
         """
         Override this method if this field type can sometimes be ordered or sometimes

backend/src/baserow/contrib/database/views/registries.py

@@ -921,10 +921,11 @@ def get_filter(self, field_name, value):
 
     compatible_field_types: List[Union[str, Callable[["Field"], bool]]] = []
     """
-    Defines which field types are compatible with the filter. Only the supported ones
-    can be used in combination with the field. The values in this list can either be
-    the literal field_type.type string, or a callable which takes the field being
-    checked and returns True if compatible or False if not.
+    Defines which field types are compatible with the filter. The values in this list
+    can either be the literal `FieldType.type` string, or a callable taking the
+    concrete field and returning True/False. When checking compatibility the
+    `FieldType.get_compatible_filter_field_type(field)` indirection is applied first,
+    allowing field types to alias themselves to another type for filtering purposes.
     """
 
     def default_filter_on_exception(self):
@@ -1000,9 +1001,9 @@ def field_is_compatible(self, field: "Field") -> bool:
         Given a particular instance of a field returns a list of Type[FieldType] which
         are compatible with this particular field type.
 
-        Works by checking the field_type against this view filters list of compatible
-        field types or compatibility checking functions defined in
-        self.allowed_field_types.
+        Works by checking the field's canonical filter type (as returned by
+        `FieldType.get_compatible_filter_field_type(field)`) against this filter's
+        `compatible_field_types`.
 
         :param field: The field to check.
         :return: True if the field is compatible, False otherwise.
@@ -1011,9 +1012,12 @@ def field_is_compatible(self, field: "Field") -> bool:
         from baserow.contrib.database.fields.registries import field_type_registry
 
         field_type = field_type_registry.get_by_model(field.specific_class)
+        # Allow field types to map themselves to another field type for filter
+        # compatibility checks.
+        compatible_field_type = field_type.get_compatible_filter_field_type(field)
 
         return any(
-            callable(t) and t(field) or t == field_type.type
+            (callable(t) and t(field)) or t == compatible_field_type.type
             for t in self.compatible_field_types
         )
 

backend/src/baserow/contrib/database/views/view_filters.py

@@ -1104,7 +1104,8 @@ def get_filter(self, field_name, value, model_field, field):
             return Q()
 
         field_type = field_type_registry.get_by_model(field)
-        filter_function = self.filter_functions[field_type.type]
+        effective_field_type = field_type.get_compatible_filter_field_type(field)
+        filter_function = self.filter_functions[effective_field_type.type]
         return filter_function(field_name, value, model_field, field)
 
     def set_import_serialized_value(self, value, id_mapping):
@@ -1160,7 +1161,8 @@ def get_filter(self, field_name, value: str, model_field, field):
             return self.default_filter_on_exception()
 
         field_type = field_type_registry.get_by_model(field)
-        filter_function = self.filter_functions[field_type.type]
+        effective_field_type = field_type.get_compatible_filter_field_type(field)
+        filter_function = self.filter_functions[effective_field_type.type]
         return filter_function(field_name, option_ids, model_field, field)
 
     def set_import_serialized_value(self, value: str | None, id_mapping: dict) -> str:
@@ -1419,7 +1421,8 @@ def get_filter(self, field_name, value: str, model_field, field):
             return self.default_filter_on_exception()
 
         field_type = field_type_registry.get_by_model(field)
-        filter_function = self.filter_functions[field_type.type]
+        effective_field_type = field_type.get_compatible_filter_field_type(field)
+        filter_function = self.filter_functions[effective_field_type.type]
         return filter_function(field_name, option_ids, model_field, field)
 
     def set_import_serialized_value(self, value: str | None, id_mapping: dict) -> str:

backend/tests/baserow/contrib/database/field/test_field_types.py

@@ -304,7 +304,6 @@
         "is_even_and_whole",
     ],
     "password": ["empty", "not_empty"],
-    "ai": [],
 }
 
 
@@ -1216,7 +1215,14 @@ def test_field_type_prepare_db_value_with_invalid_values(data_fixture):
             field_type.prepare_value_for_db(field, test_payload)
 
 
-@pytest.mark.parametrize("field_type", field_type_registry.get_all())
+@pytest.mark.parametrize(
+    "field_type",
+    [
+        ft
+        for ft in field_type_registry.get_all()
+        if ft.type in COMPATIBLE_FIELD_TYPE_VIEW_FILTER_TYPES
+    ],
+)
 @patch("baserow.contrib.database.fields.registries.FieldTypeRegistry.get_by_model")
 def test_field_type_check_can_filter_by(mock_get_by_model, field_type):
     mock_get_by_model.return_value = field_type

backend/tests/baserow/contrib/integrations/local_baserow/test_service_types.py

@@ -1050,7 +1050,7 @@ def reset_metadata(schema, field_name):
             "default": None,
             "searchable": True,
             "sortable": True,
-            "filterable": False,
+            "filterable": True,
             "original_type": "ai",
             "metadata": {},
             "type": "string",
@@ -1060,7 +1060,7 @@ def reset_metadata(schema, field_name):
             "default": None,
             "searchable": True,
             "sortable": True,
-            "filterable": False,
+            "filterable": True,
             "original_type": "ai",
             "metadata": {},
             "properties": {

changelog/entries/unreleased/feature/3801_add_filters_support_for_ai_field.json

@@ -0,0 +1,8 @@
+{
+    "type": "feature",
+    "message": "Add filters support for AI field",
+    "domain": "database",
+    "issue_number": 3801,
+    "bullet_points": [],
+    "created_at": "2025-10-23"
+}

premium/backend/src/baserow_premium/fields/field_types.py

@@ -166,6 +166,18 @@ def contains_query(self, field_name, value, model_field, field):
         baserow_field_type = self.get_baserow_field_type(field)
         return baserow_field_type.contains_query(field_name, value, model_field, field)
 
+    def parse_filter_value(self, field, model_field, value):
+        baserow_field_type = self.get_baserow_field_type(field)
+        return baserow_field_type.parse_filter_value(field, model_field, value)
+
+    def get_compatible_filter_field_type(self, field):
+        """
+        For AI fields, return the underlying core field type used for filtering.
+        """
+
+        ai_field_instance = field.specific if hasattr(field, "specific") else field
+        return self.get_baserow_field_type(ai_field_instance)
+
     def contains_word_query(self, field_name, value, model_field, field):
         baserow_field_type = self.get_baserow_field_type(field)
         return baserow_field_type.contains_word_query(