Class ReasoningEngine (1.50.0)

ReasoningEngine(reasoning_engine_name: str)

Represents a Vertex AI Reasoning Engine resource.



Time this resource was created.


Display name of this resource.


Customer-managed encryption key options for this Vertex AI resource.

If this is set, then all resources created by this Vertex AI resource will be encrypted with the provided encryption key.


The underlying resource proto representation.


User-defined labels containing metadata about this resource.

Read more about labels at


Name of this resource.


Fully-qualified resource name.


Time this resource was last updated.



ReasoningEngine(reasoning_engine_name: str)

Retrieves a Reasoning Engine resource.

Name Description
reasoning_engine_name str

Required. A fully-qualified resource name or ID such as "projects/123/locations/us-central1/reasoningEngines/456" or "456" when project and location are initialized or passed.


    reasoning_engine: vertexai.reasoning_engines._reasoning_engines.Queryable,
    requirements: typing.Optional[typing.Union[str, typing.Sequence[str]]] = None,
    reasoning_engine_name: typing.Optional[str] = None,
    display_name: typing.Optional[str] = None,
    description: typing.Optional[str] = None,
    gcs_dir_name: str = "reasoning_engine",
    sys_version: typing.Optional[str] = None,
    extra_packages: typing.Optional[typing.Sequence[str]] = None
) -> vertexai.reasoning_engines._reasoning_engines.ReasoningEngine

Creates a new ReasoningEngine.

The Reasoning Engine will be an instance of the reasoning_engine that was passed in, running remotely on Vertex AI.

Sample src_dir contents (e.g. ./user_src_dir):

|-- requirements.txt
|-- user_code/
|   |--
|   |-- ...
|-- ...

To build a Reasoning Engine:

remote_app = ReasoningEngine.create(
        # I.e. the PyPI dependencies listed in requirements.txt
        "./user_src_dir/", # a single file
        "./user_src_dir/user_code", # a directory
Name Description
reasoning_engine ReasoningEngineInterface

Required. The Reasoning Engine to be created.

requirements Union[str, Sequence[str]]

Optional. The set of PyPI dependencies needed. It can either be the path to a single file (requirements.txt), or an ordered list of strings corresponding to each line of the requirements file.

reasoning_engine_name str

Optional. A fully-qualified resource name or ID such as "projects/123/locations/us-central1/reasoningEngines/456" or "456" when project and location are initialized or passed. If specifying the ID, it should be 4-63 characters. Valid characters are lowercase letters, numbers and hyphens ("-"), and it should start with a number or a lower-case letter. If not provided, Vertex AI will generate a value for this ID.

display_name str

Optional. The user-defined name of the Reasoning Engine. The name can be up to 128 characters long and can comprise any UTF-8 character.

description str

Optional. The description of the Reasoning Engine.

gcs_dir_name CreateReasoningEngineOptions

Optional. The GCS bucket directory under staging_bucket to use for staging the artifacts needed.

sys_version str

Optional. The Python system version used. Currently supports any of "3.8", "3.9", "3.10", "3.11". If not specified, it defaults to the "{major}.{minor}" attributes of sys.version_info.

extra_packages Sequence[str]

Optional. The set of extra user-provided packages (if any).

Type Description
ValueError If sys.version is not supported by ReasoningEngine.
ValueError If the project was not set using vertexai.init.
ValueError If the location was not set using vertexai.init.
ValueError If the staging_bucket was not set using vertexai.init.
ValueError If the staging_bucket does not start with "gs://".
FileNotFoundError If extra_packages includes a file or directory
tha does not exist.:
Type Description
ReasoningEngine The Reasoning Engine that was created.


delete(sync: bool = True) -> None

Deletes this Vertex AI resource. WARNING: This deletion is permanent.

Name Description
sync bool

Whether to execute this deletion synchronously. If False, this method will be executed in concurrent Future and any downstream object will be immediately returned and synced when the Future has completed.


    filter: typing.Optional[str] = None,
    order_by: typing.Optional[str] = None,
    project: typing.Optional[str] = None,
    location: typing.Optional[str] = None,
    credentials: typing.Optional[google.auth.credentials.Credentials] = None,
    parent: typing.Optional[str] = None,
) -> typing.List[]

List all instances of this Vertex AI Resource.

Example Usage:

aiplatform.BatchPredictionJobs.list( filter='state="JOB_STATE_SUCCEEDED" AND display_name="my_job"', )

aiplatform.Model.list(order_by="create_time desc, display_name")

Name Description
filter str

Optional. An expression for filtering the results of the request. For field names both snake_case and camelCase are supported.

order_by str

Optional. A comma-separated list of fields to order by, sorted in ascending order. Use "desc" after a field name for descending. Supported fields: display_name, create_time, update_time

project str

Optional. Project to retrieve list from. If not set, project set in aiplatform.init will be used.

location str

Optional. Location to retrieve list from. If not set, location set in aiplatform.init will be used.

credentials auth_credentials.Credentials

Optional. Custom credentials to use to retrieve list. Overrides credentials set in aiplatform.init.

parent str

Optional. The parent resource name if any to retrieve list from.


operation_schemas() -> typing.Sequence[typing.Dict[str, typing.Any]]

Returns the (Open)API schemas for the Reasoning Engine.


query(**kwargs) -> typing.Dict[str, typing.Any]

Runs the Reasoning Engine to serve the user query.

This will be based on the .query(...) method of the python object that was passed in when creating the Reasoning Engine.

Type Description
dict[str, Any] The response from serving the user query.


to_dict() -> typing.Dict[str, typing.Any]

Returns the resource proto as a dictionary.



Helper method that blocks until all futures are complete.