docs: Update filtering requirements for Postgres and SQLite backends …

…in alpha-vector-database.md; enhance error handling in feature_server.py for invalid requests; clarify unsupported parameters in feature_store.py; ensure requested_features is a list in remote.py Signed-off-by: Chaitany patel <patelchaitany93@gmail.com> Signed-off-by: Chaitany Patel <patelchaitany93@gmail.com>
franciscojavierarceo · Jul 22, 2026 · Mar 17, 2026 · Mar 24, 2026 · May 19, 2026 · Jun 23, 2026
commit ec4ccceefce1bc613bd129535735264f2f58abcc
@@ -108,7 +108,7 @@ The endpoint supports OpenAI-style filters for narrowing results beyond vector s
 }
 ```
 
-String equality filters work on all backends. Numeric and boolean filters require `enable_openai_compatible_store: true` in the online store config.
+For Postgres and SQLite backends, all filtering (including string equality) requires `enable_openai_compatible_store: true` in the online store config. After enabling, run `feast apply` to update the database schema.
 
 ### Response format
 

@@ -555,6 +555,14 @@ async def vector_store_search(
             "/v1/vector_stores/{vector_store_id}/search"
         ):
             try:
+                feature_view = await run_in_threadpool(
+                    store.get_feature_view, vector_store_id
+                )
+                assert_permissions(
+                    resource=feature_view,
+                    actions=[AuthzedAction.READ_ONLINE],
+                )
+
                 result = await store.retrieve_online_documents_openai(
                     vector_store_id=vector_store_id,
                     query=request.query,
@@ -582,6 +590,16 @@ async def vector_store_search(
                         }
                     },
                 )
+            except ValueError as e:
+                return JSONResponse(
+                    status_code=422,
+                    content={
+                        "error": {
+                            "message": str(e),
+                            "type": "invalid_request_error",
+                        }
+                    },
+                )
             return JSONResponse(content=result)
 
     @app.post("/push", dependencies=[Depends(inject_user_details)])

@@ -4169,10 +4169,11 @@ async def retrieve_online_documents_openai(
             query: Natural language query string, or list of strings.
             max_num_results: Maximum number of results to return.
             filters: OpenAI-compatible filters applied to the search.
-            ranking_options: OpenAI-compatible ranking options (accepted
-                but not yet applied).
-            rewrite_query: Whether to rewrite the query (accepted but
-                not yet applied).
+            ranking_options: OpenAI-compatible ranking options. Currently
+                unsupported; a ``ValueError`` is raised if
+                ``score_threshold`` or ``ranker`` are provided.
+            rewrite_query: Whether to rewrite the query. Currently
+                unsupported; a ``ValueError`` is raised if set.
             features_to_retrieve: Specific feature names to return.
                 If None, all features from the feature view are used.
 
@@ -4201,12 +4202,29 @@ async def retrieve_online_documents_openai(
                     features_to_retrieve=["name", "description"],
                 )
         """
+        unsupported: List[str] = []
+        if ranking_options:
+            if ranking_options.get("score_threshold") is not None:
+                unsupported.append("ranking_options.score_threshold")
+            if ranking_options.get("ranker") is not None:
+                unsupported.append("ranking_options.ranker")
+        if rewrite_query is not None:
+            unsupported.append("rewrite_query")
+        if unsupported:
+            raise ValueError(
+                f"The following parameters are not yet supported: "
+                f"{', '.join(unsupported)}. Remove them from the request or "
+                f"wait for a future release that implements them."
+            )
+
         feature_view = self.get_feature_view(vector_store_id)
 
         if features_to_retrieve:
             feature_names = features_to_retrieve
         else:
-            feature_names = [f.name for f in feature_view.features]
+            feature_names = [
+                f.name for f in feature_view.features if not f.vector_index
+            ]
 
         features = [f"{feature_view.name}:{name}" for name in feature_names]
         query_text = query if isinstance(query, str) else " ".join(query)

@@ -48,6 +48,7 @@
     from_feast_type,
 )
 from feast.utils import (
+    _distance_to_score,
     _serialize_vector_to_float_list,
     to_naive_utc,
 )
@@ -463,9 +464,13 @@ def online_write_batch(
             single_entity_record.update(values_dict)
             for field in required_fields:
                 if field not in single_entity_record:
-                    single_entity_record[field] = _default_for_milvus_type(
-                        collection_field_types.get(field, DataType.VARCHAR)
-                    )
+                    field_type = collection_field_types.get(field, DataType.VARCHAR)
+                    if field == "_placeholder_vector":
+                        single_entity_record[field] = [float("nan")]
+                    else:
+                        single_entity_record[field] = _default_for_milvus_type(
+                            field_type
+                        )
             # Store only the latest event timestamp per entity
             if (
                 entity_key_str not in unique_entities
@@ -943,9 +948,15 @@ def _combine_exprs(*parts: Optional[str]) -> Optional[str]:
                     else:
                         val.string_val = str(field_value)
                         res[field] = val
-                distance = hit.get("distance", None)
+                raw_distance = hit.get("distance", None)
                 res["distance"] = (
-                    ValueProto(float_val=distance) if distance else ValueProto()
+                    ValueProto(
+                        float_val=_distance_to_score(raw_distance, distance_metric)
+                    )
+                    if raw_distance is not None and embedding is not None
+                    else ValueProto(float_val=raw_distance)
+                    if raw_distance is not None
+                    else ValueProto()
                 )
                 result_list.append((res_ts, entity_key_proto, res if res else None))
         return result_list

@@ -46,7 +46,7 @@
 from feast.protos.feast.types.EntityKey_pb2 import EntityKey as EntityKeyProto
 from feast.protos.feast.types.Value_pb2 import Value as ValueProto
 from feast.repo_config import RepoConfig
-from feast.utils import _build_retrieve_online_document_record
+from feast.utils import _build_retrieve_online_document_record, _distance_to_score
 
 SUPPORTED_DISTANCE_METRICS_DICT = {
     "cosine": "<=>",
@@ -1044,7 +1044,9 @@ def retrieve_online_documents_v2(
                         "vector_distance"
                     ] != float("inf"):
                         dist_val = ValueProto()
-                        dist_val.double_val = entity_data["vector_distance"]
+                        dist_val.double_val = _distance_to_score(
+                            entity_data["vector_distance"], distance_metric
+                        )
                         features["distance"] = dist_val
 
                     if embedding is None or query_string is not None:

@@ -488,6 +488,8 @@ def retrieve_online_documents_v2(
             result_tuples = []
             if requested_features is None:
                 requested_features = []
+            else:
+                requested_features = list(requested_features)
             if "distance" not in requested_features:
                 requested_features.append("distance")
             for row_idx in range(num_results):

@@ -64,6 +64,7 @@
 from feast.types import FEAST_VECTOR_TYPES, PrimitiveFeastType
 from feast.utils import (
     _build_retrieve_online_document_record,
+    _distance_to_score,
     _get_feature_view_vector_field_metadata,
     _serialize_vector_to_float_list,
     to_naive_utc,
@@ -873,7 +874,11 @@ def retrieve_online_documents_v2(
                 entity_dict[entity_key][vector_field] = _serialize_vector_to_float_list(
                     vector_value
                 )
-            entity_dict[entity_key]["distance"] = ValueProto(float_val=distance)
+            entity_dict[entity_key]["distance"] = ValueProto(
+                float_val=_distance_to_score(distance, distance_metric)
+                if embedding is not None
+                else distance
+            )
             entity_dict[entity_key]["event_ts"] = event_ts
             entity_dict[entity_key]["created_ts"] = created_ts
 

@@ -1779,3 +1779,24 @@ def _get_feature_view_vector_field_metadata(
     if not vector_fields:
         return None
     return vector_fields[0]
+
+
+def _distance_to_score(distance: float, metric: Optional[str] = None) -> float:
+    """Convert a raw distance value into a higher-is-better relevance score.
+
+    OpenAI clients treat ``score`` as higher-is-better (used with
+    ``score_threshold``).  Online stores return raw *distance* values where
+    lower is better, so a metric-aware conversion is required.
+
+    * **L2 / euclidean**: ``1 / (1 + distance)`` — maps [0, inf) to (0, 1]
+    * **cosine** (pgvector ``<=>`` returns ``1 - cosine_similarity``):
+      ``1 - distance`` — recovers cosine similarity, clamped >= 0
+    * **inner_product / ip / dot** (pgvector ``<#>`` returns ``-dot(a, b)``):
+      ``-distance`` — recovers the raw inner product
+    """
+    m = (metric or "L2").lower()
+    if m in ("cosine",):
+        return max(0.0, 1.0 - distance)
+    if m in ("inner_product", "ip", "dot"):
+        return -distance
+    return 1.0 / (1.0 + distance)
-Original file line number
+Diff line change
@@ Expand Up @@
     }
     ```
-    String equality filters work on all backends. Numeric and boolean filters require `enable_openai_compatible_store: true` in the online store config.
+    For Postgres and SQLite backends, all filtering (including string equality) requires `enable_openai_compatible_store: true` in the online store config. After enabling, run `feast apply` to update the database schema.
     ### Response format
@@ Expand Down @@