Merge remote-tracking branch 'origin/main' into agent_rewrite

llama_stack/core/library_client.py

@@ -496,12 +496,11 @@ class AsyncLlamaStackAsLibraryClient(AsyncLlamaStackClient):
         return await response.parse()
 
     def _convert_body(self, func: Any, body: dict | None = None, exclude_params: set[str] | None = None) -> dict:
-        if not body:
-            return {}
-
+        body = body or {}
         exclude_params = exclude_params or set()
         sig = inspect.signature(func)
         params_list = [p for p in sig.parameters.values() if p.name != "self"]
+
         # Flatten if there's a single unwrapped body parameter (BaseModel or Annotated[BaseModel, Body(embed=False)])
         if len(params_list) == 1:
             param = params_list[0]
@@ -530,11 +529,12 @@ class AsyncLlamaStackAsLibraryClient(AsyncLlamaStackClient):
                     converted_body[param_name] = value
                 else:
                     converted_body[param_name] = convert_to_pydantic(param.annotation, value)
-            elif unwrapped_body_param and param.name == unwrapped_body_param.name:
-                # This is the unwrapped body param - construct it from remaining body keys
-                base_type = get_args(param.annotation)[0]
-                # Extract only the keys that aren't already used by other params
-                remaining_keys = {k: v for k, v in body.items() if k not in converted_body}
-                converted_body[param.name] = base_type(**remaining_keys)
+
+        # handle unwrapped body parameter after processing all named parameters
+        if unwrapped_body_param:
+            base_type = get_args(unwrapped_body_param.annotation)[0]
+            # extract only keys not already used by other params
+            remaining_keys = {k: v for k, v in body.items() if k not in converted_body}
+            converted_body[unwrapped_body_param.name] = base_type(**remaining_keys)
 
         return converted_body

llama_stack/core/routers/vector_io.py

@@ -120,13 +120,7 @@ class VectorIORouter(VectorIO):
         embedding_dimension = extra.get("embedding_dimension")
         provider_id = extra.get("provider_id")
 
-        logger.debug(f"VectorIORouter.openai_create_vector_store: name={params.name}, provider_id={provider_id}")
-
-        # Require explicit embedding model specification
-        if embedding_model is None:
-            raise ValueError("embedding_model is required in extra_body when creating a vector store")
-
-        if embedding_dimension is None:
+        if embedding_model is not None and embedding_dimension is None:
             embedding_dimension = await self._get_embedding_model_dimension(embedding_model)
 
         # Auto-select provider if not specified
@@ -158,8 +152,10 @@ class VectorIORouter(VectorIO):
             params.model_extra = {}
         params.model_extra["provider_vector_db_id"] = registered_vector_db.provider_resource_id
         params.model_extra["provider_id"] = registered_vector_db.provider_id
-        params.model_extra["embedding_model"] = embedding_model
-        params.model_extra["embedding_dimension"] = embedding_dimension
+        if embedding_model is not None:
+            params.model_extra["embedding_model"] = embedding_model
+        if embedding_dimension is not None:
+            params.model_extra["embedding_dimension"] = embedding_dimension
 
         return await provider.openai_create_vector_store(params)
 

llama_stack/core/stack.py

@@ -98,6 +98,30 @@ REGISTRY_REFRESH_TASK = None
 TEST_RECORDING_CONTEXT = None
 
 
+async def validate_default_embedding_model(impls: dict[Api, Any]):
+    """Validate that at most one embedding model is marked as default."""
+    if Api.models not in impls:
+        return
+
+    models_impl = impls[Api.models]
+    response = await models_impl.list_models()
+    models_list = response.data if hasattr(response, "data") else response
+
+    default_embedding_models = []
+    for model in models_list:
+        if model.model_type == "embedding" and model.metadata.get("default_configured") is True:
+            default_embedding_models.append(model.identifier)
+
+    if len(default_embedding_models) > 1:
+        raise ValueError(
+            f"Multiple embedding models marked as default_configured=True: {default_embedding_models}. "
+            "Only one embedding model can be marked as default."
+        )
+
+    if default_embedding_models:
+        logger.info(f"Default embedding model configured: {default_embedding_models[0]}")
+
+
 async def register_resources(run_config: StackRunConfig, impls: dict[Api, Any]):
     for rsrc, api, register_method, list_method in RESOURCES:
         objects = getattr(run_config, rsrc)
@@ -128,6 +152,8 @@ async def register_resources(run_config: StackRunConfig, impls: dict[Api, Any]):
                 f"{rsrc.capitalize()}: {obj.identifier} served by {obj.provider_id}",
             )
 
+    await validate_default_embedding_model(impls)
+
 
 class EnvVarError(Exception):
     def __init__(self, var_name: str, path: str = ""):

llama_stack/providers/inline/inference/sentence_transformers/sentence_transformers.py

@@ -59,6 +59,7 @@ class SentenceTransformersInferenceImpl(
                 provider_id=self.__provider_id__,
                 metadata={
                     "embedding_dimension": 768,
+                    "default_configured": True,
                 },
                 model_type=ModelType.embedding,
             ),

llama_stack/providers/inline/vector_io/chroma/__init__.py

@@ -16,6 +16,11 @@ async def get_provider_impl(config: ChromaVectorIOConfig, deps: dict[Api, Any]):
         ChromaVectorIOAdapter,
     )
 
-    impl = ChromaVectorIOAdapter(config, deps[Api.inference], deps.get(Api.files))
+    impl = ChromaVectorIOAdapter(
+        config,
+        deps[Api.inference],
+        deps[Api.models],
+        deps.get(Api.files),
+    )
     await impl.initialize()
     return impl

llama_stack/providers/inline/vector_io/faiss/__init__.py

@@ -16,6 +16,11 @@ async def get_provider_impl(config: FaissVectorIOConfig, deps: dict[Api, Any]):
 
     assert isinstance(config, FaissVectorIOConfig), f"Unexpected config type: {type(config)}"
 
-    impl = FaissVectorIOAdapter(config, deps[Api.inference], deps.get(Api.files, None))
+    impl = FaissVectorIOAdapter(
+        config,
+        deps[Api.inference],
+        deps[Api.models],
+        deps.get(Api.files),
+    )
     await impl.initialize()
     return impl

llama_stack/providers/inline/vector_io/faiss/faiss.py

@@ -17,6 +17,7 @@ from numpy.typing import NDArray
 from llama_stack.apis.common.errors import VectorStoreNotFoundError
 from llama_stack.apis.files import Files
 from llama_stack.apis.inference import Inference, InterleavedContent
+from llama_stack.apis.models import Models
 from llama_stack.apis.vector_dbs import VectorDB
 from llama_stack.apis.vector_io import (
     Chunk,
@@ -199,10 +200,17 @@ class FaissIndex(EmbeddingIndex):
 
 
 class FaissVectorIOAdapter(OpenAIVectorStoreMixin, VectorIO, VectorDBsProtocolPrivate):
-    def __init__(self, config: FaissVectorIOConfig, inference_api: Inference, files_api: Files | None) -> None:
+    def __init__(
+        self,
+        config: FaissVectorIOConfig,
+        inference_api: Inference,
+        models_api: Models,
+        files_api: Files | None,
+    ) -> None:
         super().__init__(files_api=files_api, kvstore=None)
         self.config = config
         self.inference_api = inference_api
+        self.models_api = models_api
         self.cache: dict[str, VectorDBWithIndex] = {}
 
     async def initialize(self) -> None:

llama_stack/providers/inline/vector_io/milvus/__init__.py

@@ -14,6 +14,11 @@ from .config import MilvusVectorIOConfig
 async def get_provider_impl(config: MilvusVectorIOConfig, deps: dict[Api, Any]):
     from llama_stack.providers.remote.vector_io.milvus.milvus import MilvusVectorIOAdapter
 
-    impl = MilvusVectorIOAdapter(config, deps[Api.inference], deps.get(Api.files, None))
+    impl = MilvusVectorIOAdapter(
+        config,
+        deps[Api.inference],
+        deps[Api.models],
+        deps.get(Api.files),
+    )
     await impl.initialize()
     return impl

llama_stack/providers/inline/vector_io/qdrant/__init__.py

@@ -15,7 +15,11 @@ async def get_provider_impl(config: QdrantVectorIOConfig, deps: dict[Api, Any]):
     from llama_stack.providers.remote.vector_io.qdrant.qdrant import QdrantVectorIOAdapter
 
     assert isinstance(config, QdrantVectorIOConfig), f"Unexpected config type: {type(config)}"
-    files_api = deps.get(Api.files)
-    impl = QdrantVectorIOAdapter(config, deps[Api.inference], files_api)
+    impl = QdrantVectorIOAdapter(
+        config,
+        deps[Api.inference],
+        deps[Api.models],
+        deps.get(Api.files),
+    )
     await impl.initialize()
     return impl

llama_stack/providers/inline/vector_io/sqlite_vec/__init__.py

@@ -15,6 +15,11 @@ async def get_provider_impl(config: SQLiteVectorIOConfig, deps: dict[Api, Any]):
     from .sqlite_vec import SQLiteVecVectorIOAdapter
 
     assert isinstance(config, SQLiteVectorIOConfig), f"Unexpected config type: {type(config)}"
-    impl = SQLiteVecVectorIOAdapter(config, deps[Api.inference], deps.get(Api.files, None))
+    impl = SQLiteVecVectorIOAdapter(
+        config,
+        deps[Api.inference],
+        deps[Api.models],
+        deps.get(Api.files),
+    )
     await impl.initialize()
     return impl

llama_stack/providers/inline/vector_io/sqlite_vec/sqlite_vec.py

@@ -17,6 +17,7 @@ from numpy.typing import NDArray
 from llama_stack.apis.common.errors import VectorStoreNotFoundError
 from llama_stack.apis.files import Files
 from llama_stack.apis.inference import Inference
+from llama_stack.apis.models import Models
 from llama_stack.apis.vector_dbs import VectorDB
 from llama_stack.apis.vector_io import (
     Chunk,
@@ -409,11 +410,19 @@ class SQLiteVecVectorIOAdapter(OpenAIVectorStoreMixin, VectorIO, VectorDBsProtoc
     and creates a cache of VectorDBWithIndex instances (each wrapping a SQLiteVecIndex).
     """
 
-    def __init__(self, config, inference_api: Inference, files_api: Files | None) -> None:
+    def __init__(
+        self,
+        config,
+        inference_api: Inference,
+        models_api: Models,
+        files_api: Files | None,
+    ) -> None:
         super().__init__(files_api=files_api, kvstore=None)
         self.config = config
         self.inference_api = inference_api
+        self.models_api = models_api
         self.cache: dict[str, VectorDBWithIndex] = {}
+        self.vector_db_store = None
 
     async def initialize(self) -> None:
         self.kvstore = await kvstore_impl(self.config.kvstore)

llama_stack/providers/registry/vector_io.py

@@ -26,7 +26,7 @@ def available_providers() -> list[ProviderSpec]:
             config_class="llama_stack.providers.inline.vector_io.faiss.FaissVectorIOConfig",
             deprecation_warning="Please use the `inline::faiss` provider instead.",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="Meta's reference implementation of a vector database.",
         ),
         InlineProviderSpec(
@@ -36,7 +36,7 @@ def available_providers() -> list[ProviderSpec]:
             module="llama_stack.providers.inline.vector_io.faiss",
             config_class="llama_stack.providers.inline.vector_io.faiss.FaissVectorIOConfig",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="""
 [Faiss](https://github.com/facebookresearch/faiss) is an inline vector database provider for Llama Stack. It
 allows you to store and query vectors directly in memory.
@@ -89,7 +89,7 @@ more details about Faiss in general.
             module="llama_stack.providers.inline.vector_io.sqlite_vec",
             config_class="llama_stack.providers.inline.vector_io.sqlite_vec.SQLiteVectorIOConfig",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="""
 [SQLite-Vec](https://github.com/asg017/sqlite-vec) is an inline vector database provider for Llama Stack. It
 allows you to store and query vectors directly within an SQLite database.
@@ -297,7 +297,7 @@ See [sqlite-vec's GitHub repo](https://github.com/asg017/sqlite-vec/tree/main) f
             config_class="llama_stack.providers.inline.vector_io.sqlite_vec.SQLiteVectorIOConfig",
             deprecation_warning="Please use the `inline::sqlite-vec` provider (notice the hyphen instead of underscore) instead.",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="""
 Please refer to the sqlite-vec provider documentation.
 """,
@@ -310,7 +310,7 @@ Please refer to the sqlite-vec provider documentation.
             module="llama_stack.providers.remote.vector_io.chroma",
             config_class="llama_stack.providers.remote.vector_io.chroma.ChromaVectorIOConfig",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="""
 [Chroma](https://www.trychroma.com/) is an inline and remote vector
 database provider for Llama Stack. It allows you to store and query vectors directly within a Chroma database.
@@ -352,7 +352,7 @@ See [Chroma's documentation](https://docs.trychroma.com/docs/overview/introducti
             module="llama_stack.providers.inline.vector_io.chroma",
             config_class="llama_stack.providers.inline.vector_io.chroma.ChromaVectorIOConfig",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="""
 [Chroma](https://www.trychroma.com/) is an inline and remote vector
 database provider for Llama Stack. It allows you to store and query vectors directly within a Chroma database.
@@ -396,7 +396,7 @@ See [Chroma's documentation](https://docs.trychroma.com/docs/overview/introducti
             module="llama_stack.providers.remote.vector_io.pgvector",
             config_class="llama_stack.providers.remote.vector_io.pgvector.PGVectorVectorIOConfig",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="""
 [PGVector](https://github.com/pgvector/pgvector) is a remote vector database provider for Llama Stack. It
 allows you to store and query vectors directly in memory.
@@ -508,7 +508,7 @@ See [PGVector's documentation](https://github.com/pgvector/pgvector) for more de
             config_class="llama_stack.providers.remote.vector_io.weaviate.WeaviateVectorIOConfig",
             provider_data_validator="llama_stack.providers.remote.vector_io.weaviate.WeaviateRequestProviderData",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="""
 [Weaviate](https://weaviate.io/) is a vector database provider for Llama Stack.
 It allows you to store and query vectors directly within a Weaviate database.
@@ -548,7 +548,7 @@ See [Weaviate's documentation](https://weaviate.io/developers/weaviate) for more
             module="llama_stack.providers.inline.vector_io.qdrant",
             config_class="llama_stack.providers.inline.vector_io.qdrant.QdrantVectorIOConfig",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description=r"""
 [Qdrant](https://qdrant.tech/documentation/) is an inline and remote vector database provider for Llama Stack. It
 allows you to store and query vectors directly in memory.
@@ -601,7 +601,7 @@ See the [Qdrant documentation](https://qdrant.tech/documentation/) for more deta
             module="llama_stack.providers.remote.vector_io.qdrant",
             config_class="llama_stack.providers.remote.vector_io.qdrant.QdrantVectorIOConfig",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="""
 Please refer to the inline provider documentation.
 """,
@@ -614,7 +614,7 @@ Please refer to the inline provider documentation.
             module="llama_stack.providers.remote.vector_io.milvus",
             config_class="llama_stack.providers.remote.vector_io.milvus.MilvusVectorIOConfig",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="""
 [Milvus](https://milvus.io/) is an inline and remote vector database provider for Llama Stack. It
 allows you to store and query vectors directly within a Milvus database.
@@ -820,7 +820,7 @@ For more details on TLS configuration, refer to the [TLS setup guide](https://mi
             module="llama_stack.providers.inline.vector_io.milvus",
             config_class="llama_stack.providers.inline.vector_io.milvus.MilvusVectorIOConfig",
             api_dependencies=[Api.inference],
-            optional_api_dependencies=[Api.files],
+            optional_api_dependencies=[Api.files, Api.models],
             description="""
 Please refer to the remote provider documentation.
 """,

llama_stack/providers/remote/inference/gemini/gemini.py

@@ -4,6 +4,14 @@
 # This source code is licensed under the terms described in the LICENSE file in
 # the root directory of this source tree.
 
+from openai import NOT_GIVEN
+
+from llama_stack.apis.inference import (
+    OpenAIEmbeddingData,
+    OpenAIEmbeddingsRequestWithExtraBody,
+    OpenAIEmbeddingsResponse,
+    OpenAIEmbeddingUsage,
+)
 from llama_stack.providers.utils.inference.openai_mixin import OpenAIMixin
 
 from .config import GeminiConfig
@@ -14,8 +22,61 @@ class GeminiInferenceAdapter(OpenAIMixin):
 
     provider_data_api_key_field: str = "gemini_api_key"
     embedding_model_metadata: dict[str, dict[str, int]] = {
-        "text-embedding-004": {"embedding_dimension": 768, "context_length": 2048},
+        "models/text-embedding-004": {"embedding_dimension": 768, "context_length": 2048},
+        "models/gemini-embedding-001": {"embedding_dimension": 3072, "context_length": 2048},
     }
 
     def get_base_url(self):
         return "https://generativelanguage.googleapis.com/v1beta/openai/"
+
+    async def openai_embeddings(
+        self,
+        params: OpenAIEmbeddingsRequestWithExtraBody,
+    ) -> OpenAIEmbeddingsResponse:
+        """
+        Override embeddings method to handle Gemini's missing usage statistics.
+        Gemini's embedding API doesn't return usage information, so we provide default values.
+        """
+        # Prepare request parameters
+        request_params = {
+            "model": await self._get_provider_model_id(params.model),
+            "input": params.input,
+            "encoding_format": params.encoding_format if params.encoding_format is not None else NOT_GIVEN,
+            "dimensions": params.dimensions if params.dimensions is not None else NOT_GIVEN,
+            "user": params.user if params.user is not None else NOT_GIVEN,
+        }
+
+        # Add extra_body if present
+        extra_body = params.model_extra
+        if extra_body:
+            request_params["extra_body"] = extra_body
+
+        # Call OpenAI embeddings API with properly typed parameters
+        response = await self.client.embeddings.create(**request_params)
+
+        data = []
+        for i, embedding_data in enumerate(response.data):
+            data.append(
+                OpenAIEmbeddingData(
+                    embedding=embedding_data.embedding,
+                    index=i,
+                )
+            )
+
+        # Gemini doesn't return usage statistics - use default values
+        if hasattr(response, "usage") and response.usage:
+            usage = OpenAIEmbeddingUsage(
+                prompt_tokens=response.usage.prompt_tokens,
+                total_tokens=response.usage.total_tokens,
+            )
+        else:
+            usage = OpenAIEmbeddingUsage(
+                prompt_tokens=0,
+                total_tokens=0,
+            )
+
+        return OpenAIEmbeddingsResponse(
+            data=data,
+            model=params.model,
+            usage=usage,
+        )

llama_stack/providers/remote/vector_io/chroma/__init__.py

@@ -12,6 +12,11 @@ from .config import ChromaVectorIOConfig
 async def get_adapter_impl(config: ChromaVectorIOConfig, deps: dict[Api, ProviderSpec]):
     from .chroma import ChromaVectorIOAdapter
 
-    impl = ChromaVectorIOAdapter(config, deps[Api.inference], deps.get(Api.files))
+    impl = ChromaVectorIOAdapter(
+        config,
+        deps[Api.inference],
+        deps[Api.models],
+        deps.get(Api.files),
+    )
     await impl.initialize()
     return impl

llama_stack/providers/remote/vector_io/chroma/chroma.py

@@ -138,12 +138,14 @@ class ChromaVectorIOAdapter(OpenAIVectorStoreMixin, VectorIO, VectorDBsProtocolP
         self,
         config: RemoteChromaVectorIOConfig | InlineChromaVectorIOConfig,
         inference_api: Api.inference,
+        models_apis: Api.models,
         files_api: Files | None,
     ) -> None:
         super().__init__(files_api=files_api, kvstore=None)
         log.info(f"Initializing ChromaVectorIOAdapter with url: {config}")
         self.config = config
         self.inference_api = inference_api
+        self.models_api = models_apis
         self.client = None
         self.cache = {}
         self.vector_db_store = None

llama_stack/providers/remote/vector_io/milvus/__init__.py

@@ -14,6 +14,11 @@ async def get_adapter_impl(config: MilvusVectorIOConfig, deps: dict[Api, Provide
 
     assert isinstance(config, MilvusVectorIOConfig), f"Unexpected config type: {type(config)}"
 
-    impl = MilvusVectorIOAdapter(config, deps[Api.inference], deps.get(Api.files, None))
+    impl = MilvusVectorIOAdapter(
+        config,
+        deps[Api.inference],
+        deps[Api.models],
+        deps.get(Api.files),
+    )
     await impl.initialize()
     return impl

llama_stack/providers/remote/vector_io/milvus/milvus.py

@@ -12,8 +12,9 @@ from numpy.typing import NDArray
 from pymilvus import AnnSearchRequest, DataType, Function, FunctionType, MilvusClient, RRFRanker, WeightedRanker
 
 from llama_stack.apis.common.errors import VectorStoreNotFoundError
-from llama_stack.apis.files.files import Files
+from llama_stack.apis.files import Files
 from llama_stack.apis.inference import Inference, InterleavedContent
+from llama_stack.apis.models import Models
 from llama_stack.apis.vector_dbs import VectorDB
 from llama_stack.apis.vector_io import (
     Chunk,
@@ -307,6 +308,7 @@ class MilvusVectorIOAdapter(OpenAIVectorStoreMixin, VectorIO, VectorDBsProtocolP
         self,
         config: RemoteMilvusVectorIOConfig | InlineMilvusVectorIOConfig,
         inference_api: Inference,
+        models_api: Models,
         files_api: Files | None,
     ) -> None:
         super().__init__(files_api=files_api, kvstore=None)
@@ -314,6 +316,7 @@ class MilvusVectorIOAdapter(OpenAIVectorStoreMixin, VectorIO, VectorDBsProtocolP
         self.cache = {}
         self.client = None
         self.inference_api = inference_api
+        self.models_api = models_api
         self.vector_db_store = None
         self.metadata_collection_name = "openai_vector_stores_metadata"
 

llama_stack/providers/remote/vector_io/pgvector/__init__.py

@@ -12,6 +12,6 @@ from .config import PGVectorVectorIOConfig
 async def get_adapter_impl(config: PGVectorVectorIOConfig, deps: dict[Api, ProviderSpec]):
     from .pgvector import PGVectorVectorIOAdapter
 
-    impl = PGVectorVectorIOAdapter(config, deps[Api.inference], deps.get(Api.files, None))
+    impl = PGVectorVectorIOAdapter(config, deps[Api.inference], deps[Api.models], deps.get(Api.files, None))
     await impl.initialize()
     return impl

llama_stack/providers/remote/vector_io/pgvector/pgvector.py

@@ -14,8 +14,9 @@ from psycopg2.extras import Json, execute_values
 from pydantic import BaseModel, TypeAdapter
 
 from llama_stack.apis.common.errors import VectorStoreNotFoundError
-from llama_stack.apis.files.files import Files
-from llama_stack.apis.inference import InterleavedContent
+from llama_stack.apis.files import Files
+from llama_stack.apis.inference import Inference, InterleavedContent
+from llama_stack.apis.models import Models
 from llama_stack.apis.vector_dbs import VectorDB
 from llama_stack.apis.vector_io import (
     Chunk,
@@ -23,7 +24,7 @@ from llama_stack.apis.vector_io import (
     VectorIO,
 )
 from llama_stack.log import get_logger
-from llama_stack.providers.datatypes import Api, VectorDBsProtocolPrivate
+from llama_stack.providers.datatypes import VectorDBsProtocolPrivate
 from llama_stack.providers.utils.inference.prompt_adapter import (
     interleaved_content_as_str,
 )
@@ -342,12 +343,14 @@ class PGVectorVectorIOAdapter(OpenAIVectorStoreMixin, VectorIO, VectorDBsProtoco
     def __init__(
         self,
         config: PGVectorVectorIOConfig,
-        inference_api: Api.inference,
+        inference_api: Inference,
+        models_api: Models,
         files_api: Files | None = None,
     ) -> None:
         super().__init__(files_api=files_api, kvstore=None)
         self.config = config
         self.inference_api = inference_api
+        self.models_api = models_api
         self.conn = None
         self.cache = {}
         self.vector_db_store = None

llama_stack/providers/remote/vector_io/qdrant/__init__.py

@@ -12,7 +12,11 @@ from .config import QdrantVectorIOConfig
 async def get_adapter_impl(config: QdrantVectorIOConfig, deps: dict[Api, ProviderSpec]):
     from .qdrant import QdrantVectorIOAdapter
 
-    files_api = deps.get(Api.files)
-    impl = QdrantVectorIOAdapter(config, deps[Api.inference], files_api)
+    impl = QdrantVectorIOAdapter(
+        config,
+        deps[Api.inference],
+        deps[Api.models],
+        deps.get(Api.files),
+    )
     await impl.initialize()
     return impl

llama_stack/providers/remote/vector_io/qdrant/qdrant.py

@@ -15,7 +15,8 @@ from qdrant_client.models import PointStruct
 
 from llama_stack.apis.common.errors import VectorStoreNotFoundError
 from llama_stack.apis.files import Files
-from llama_stack.apis.inference import InterleavedContent
+from llama_stack.apis.inference import Inference, InterleavedContent
+from llama_stack.apis.models import Models
 from llama_stack.apis.vector_dbs import VectorDB
 from llama_stack.apis.vector_io import (
     Chunk,
@@ -25,7 +26,7 @@ from llama_stack.apis.vector_io import (
     VectorStoreFileObject,
 )
 from llama_stack.log import get_logger
-from llama_stack.providers.datatypes import Api, VectorDBsProtocolPrivate
+from llama_stack.providers.datatypes import VectorDBsProtocolPrivate
 from llama_stack.providers.inline.vector_io.qdrant import QdrantVectorIOConfig as InlineQdrantVectorIOConfig
 from llama_stack.providers.utils.kvstore import kvstore_impl
 from llama_stack.providers.utils.memory.openai_vector_store_mixin import OpenAIVectorStoreMixin
@@ -159,7 +160,8 @@ class QdrantVectorIOAdapter(OpenAIVectorStoreMixin, VectorIO, VectorDBsProtocolP
     def __init__(
         self,
         config: RemoteQdrantVectorIOConfig | InlineQdrantVectorIOConfig,
-        inference_api: Api.inference,
+        inference_api: Inference,
+        models_api: Models,
         files_api: Files | None = None,
     ) -> None:
         super().__init__(files_api=files_api, kvstore=None)
@@ -167,6 +169,7 @@ class QdrantVectorIOAdapter(OpenAIVectorStoreMixin, VectorIO, VectorDBsProtocolP
         self.client: AsyncQdrantClient = None
         self.cache = {}
         self.inference_api = inference_api
+        self.models_api = models_api
         self.vector_db_store = None
         self._qdrant_lock = asyncio.Lock()
 

llama_stack/providers/remote/vector_io/weaviate/__init__.py

@@ -12,6 +12,11 @@ from .config import WeaviateVectorIOConfig
 async def get_adapter_impl(config: WeaviateVectorIOConfig, deps: dict[Api, ProviderSpec]):
     from .weaviate import WeaviateVectorIOAdapter
 
-    impl = WeaviateVectorIOAdapter(config, deps[Api.inference], deps.get(Api.files, None))
+    impl = WeaviateVectorIOAdapter(
+        config,
+        deps[Api.inference],
+        deps[Api.models],
+        deps.get(Api.files),
+    )
     await impl.initialize()
     return impl

llama_stack/providers/remote/vector_io/weaviate/weaviate.py

@@ -14,12 +14,14 @@ from weaviate.classes.query import Filter, HybridFusion
 
 from llama_stack.apis.common.content_types import InterleavedContent
 from llama_stack.apis.common.errors import VectorStoreNotFoundError
-from llama_stack.apis.files.files import Files
+from llama_stack.apis.files import Files
+from llama_stack.apis.inference import Inference
+from llama_stack.apis.models import Models
 from llama_stack.apis.vector_dbs import VectorDB
 from llama_stack.apis.vector_io import Chunk, QueryChunksResponse, VectorIO
 from llama_stack.core.request_headers import NeedsRequestProviderData
 from llama_stack.log import get_logger
-from llama_stack.providers.datatypes import Api, VectorDBsProtocolPrivate
+from llama_stack.providers.datatypes import VectorDBsProtocolPrivate
 from llama_stack.providers.utils.kvstore import kvstore_impl
 from llama_stack.providers.utils.kvstore.api import KVStore
 from llama_stack.providers.utils.memory.openai_vector_store_mixin import (
@@ -281,12 +283,14 @@ class WeaviateVectorIOAdapter(
     def __init__(
         self,
         config: WeaviateVectorIOConfig,
-        inference_api: Api.inference,
+        inference_api: Inference,
+        models_api: Models,
         files_api: Files | None,
     ) -> None:
         super().__init__(files_api=files_api, kvstore=None)
         self.config = config
         self.inference_api = inference_api
+        self.models_api = models_api
         self.client_cache = {}
         self.cache = {}
         self.vector_db_store = None

llama_stack/providers/utils/memory/openai_vector_store_mixin.py

@@ -17,6 +17,7 @@ from pydantic import TypeAdapter
 
 from llama_stack.apis.common.errors import VectorStoreNotFoundError
 from llama_stack.apis.files import Files, OpenAIFileObject
+from llama_stack.apis.models import Model, Models
 from llama_stack.apis.vector_dbs import VectorDB
 from llama_stack.apis.vector_io import (
     Chunk,
@@ -52,6 +53,8 @@ from llama_stack.providers.utils.memory.vector_store import (
     make_overlapped_chunks,
 )
 
+EMBEDDING_DIMENSION = 768
+
 logger = get_logger(name=__name__, category="providers::utils")
 
 # Constants for OpenAI vector stores
@@ -77,11 +80,14 @@ class OpenAIVectorStoreMixin(ABC):
 
     # Implementing classes should call super().__init__() in their __init__ method
     # to properly initialize the mixin attributes.
-    def __init__(self, files_api: Files | None = None, kvstore: KVStore | None = None):
+    def __init__(
+        self, files_api: Files | None = None, kvstore: KVStore | None = None, models_api: Models | None = None
+    ):
         self.openai_vector_stores: dict[str, dict[str, Any]] = {}
         self.openai_file_batches: dict[str, dict[str, Any]] = {}
         self.files_api = files_api
         self.kvstore = kvstore
+        self.models_api = models_api
         self._last_file_batch_cleanup_time = 0
         self._file_batch_tasks: dict[str, asyncio.Task[None]] = {}
 
@@ -349,19 +355,60 @@ class OpenAIVectorStoreMixin(ABC):
         created_at = int(time.time())
 
         # Extract llama-stack-specific parameters from extra_body
-        extra = params.model_extra or {}
-        provider_vector_db_id = extra.get("provider_vector_db_id")
-        embedding_model = extra.get("embedding_model")
-        embedding_dimension = extra.get("embedding_dimension", 768)
+        extra_body = params.model_extra or {}
+        metadata = params.metadata or {}
+
+        provider_vector_db_id = extra_body.get("provider_vector_db_id")
+
+        # Use embedding info from metadata if available, otherwise from extra_body
+        if metadata.get("embedding_model"):
+            # If either is in metadata, use metadata as source
+            embedding_model = metadata.get("embedding_model")
+            embedding_dimension = (
+                int(metadata["embedding_dimension"]) if metadata.get("embedding_dimension") else EMBEDDING_DIMENSION
+            )
+            logger.debug(
+                f"Using embedding config from metadata (takes precedence over extra_body): model='{embedding_model}', dimension={embedding_dimension}"
+            )
+
+            # Check for conflicts with extra_body
+            if extra_body.get("embedding_model") and extra_body["embedding_model"] != embedding_model:
+                raise ValueError(
+                    f"Embedding model inconsistent between metadata ('{embedding_model}') and extra_body ('{extra_body['embedding_model']}')"
+                )
+            if extra_body.get("embedding_dimension") and extra_body["embedding_dimension"] != embedding_dimension:
+                raise ValueError(
+                    f"Embedding dimension inconsistent between metadata ({embedding_dimension}) and extra_body ({extra_body['embedding_dimension']})"
+                )
+        else:
+            embedding_model = extra_body.get("embedding_model")
+            embedding_dimension = extra_body.get("embedding_dimension", EMBEDDING_DIMENSION)
+            logger.debug(
+                f"Using embedding config from extra_body: model='{embedding_model}', dimension={embedding_dimension}"
+            )
+
         # use provider_id set by router; fallback to provider's own ID when used directly via --stack-config
-        provider_id = extra.get("provider_id") or getattr(self, "__provider_id__", None)
+        provider_id = extra_body.get("provider_id") or getattr(self, "__provider_id__", None)
         # Derive the canonical vector_db_id (allow override, else generate)
         vector_db_id = provider_vector_db_id or generate_object_id("vector_store", lambda: f"vs_{uuid.uuid4()}")
 
         if embedding_model is None:
-            raise ValueError("Embedding model is required")
+            result = await self._get_default_embedding_model_and_dimension()
+            if result is None:
+                raise ValueError(
+                    "embedding_model is required in extra_body when creating a vector store. "
+                    "No default embedding model could be determined automatically."
+                )
+            embedding_model, embedding_dimension = result
+        elif embedding_dimension is None:
+            # Embedding model was provided but dimension wasn't, look it up
+            embedding_dimension = await self._get_embedding_dimension_for_model(embedding_model)
+            if embedding_dimension is None:
+                raise ValueError(
+                    f"Could not determine embedding dimension for model '{embedding_model}'. "
+                    "Please provide embedding_dimension in extra_body or ensure the model metadata contains embedding_dimension."
+                )
 
-        # Embedding dimension is required (defaulted to 768 if not provided)
         if embedding_dimension is None:
             raise ValueError("Embedding dimension is required")
 
@@ -406,7 +453,6 @@ class OpenAIVectorStoreMixin(ABC):
         }
 
         # Add provider information to metadata if provided
-        metadata = params.metadata or {}
         if provider_id:
             metadata["provider_id"] = provider_id
         if provider_vector_db_id:
@@ -428,6 +474,85 @@ class OpenAIVectorStoreMixin(ABC):
         store_info = self.openai_vector_stores[vector_db_id]
         return VectorStoreObject.model_validate(store_info)
 
+    async def _get_embedding_models(self) -> list[Model]:
+        """Get list of embedding models from the models API."""
+        if not self.models_api:
+            return []
+
+        models_response = await self.models_api.list_models()
+        models_list = models_response.data if hasattr(models_response, "data") else models_response
+
+        embedding_models = []
+        for model in models_list:
+            if not isinstance(model, Model):
+                logger.warning(f"Non-Model object found in models list: {type(model)} - {model}")
+                continue
+            if model.model_type == "embedding":
+                embedding_models.append(model)
+
+        return embedding_models
+
+    async def _get_embedding_dimension_for_model(self, model_id: str) -> int | None:
+        """Get embedding dimension for a specific model by looking it up in the models API.
+
+        Args:
+            model_id: The identifier of the embedding model (supports both prefixed and non-prefixed)
+
+        Returns:
+            The embedding dimension for the model, or None if not found
+        """
+        embedding_models = await self._get_embedding_models()
+
+        for model in embedding_models:
+            # Check for exact match first
+            if model.identifier == model_id:
+                embedding_dimension = model.metadata.get("embedding_dimension")
+                if embedding_dimension is not None:
+                    return int(embedding_dimension)
+                else:
+                    logger.warning(f"Model {model_id} found but has no embedding_dimension in metadata")
+                    return None
+
+            # Check for prefixed/unprefixed variations
+            # If model_id is unprefixed, check if it matches the resource_id
+            if model.provider_resource_id == model_id:
+                embedding_dimension = model.metadata.get("embedding_dimension")
+                if embedding_dimension is not None:
+                    return int(embedding_dimension)
+
+        return None
+
+    async def _get_default_embedding_model_and_dimension(self) -> tuple[str, int] | None:
+        """Get default embedding model from the models API.
+
+        Looks for embedding models marked with default_configured=True in metadata.
+        Returns None if no default embedding model is found.
+        Raises ValueError if multiple defaults are found.
+        """
+        embedding_models = await self._get_embedding_models()
+
+        default_models = []
+        for model in embedding_models:
+            if model.metadata.get("default_configured") is True:
+                default_models.append(model.identifier)
+
+        if len(default_models) > 1:
+            raise ValueError(
+                f"Multiple embedding models marked as default_configured=True: {default_models}. "
+                "Only one embedding model can be marked as default."
+            )
+
+        if default_models:
+            model_id = default_models[0]
+            embedding_dimension = await self._get_embedding_dimension_for_model(model_id)
+            if embedding_dimension is None:
+                raise ValueError(f"Embedding model '{model_id}' has no embedding_dimension in metadata")
+            logger.info(f"Using default embedding model: {model_id} with dimension {embedding_dimension}")
+            return model_id, embedding_dimension
+
+        logger.info("DEBUG: No default embedding models found")
+        return None
+
     async def openai_list_vector_stores(
         self,
         limit: int | None = 20,