nvidia-nat 1.2.0rc5__py3-none-any.whl

aiq/data_models/interactive.py

@@ -0,0 +1,246 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import re
+import typing
+from enum import Enum
+
+from pydantic import BaseModel
+from pydantic import Discriminator
+from pydantic import Field
+from pydantic import field_validator
+
+
+class HumanPromptModelType(str, Enum):
+    """
+    Represents the type of an interaction model.
+    """
+    TEXT = "text"
+    NOTIFICATION = "notification"
+    BINARY_CHOICE = "binary_choice"
+    RADIO = "radio"
+    CHECKBOX = "checkbox"
+    DROPDOWN = "dropdown"
+    OAUTH_CONSENT = "oauth_consent"
+
+
+class BinaryChoiceOptionsType(str, Enum):
+    """
+    Represents the types of system interaction binary choice content
+    """
+    CONTINUE = "continue"
+    CANCEL = "cancel"
+
+
+class MultipleChoiceOptionType(str, Enum):
+    """
+    Represents the types of system interaction multiple choice content
+    """
+    EMAIL = "email"
+    SMS = "sms"
+    PUSH = "push"
+
+
+class BinaryHumanPromptOption(BaseModel):
+    """
+    Represents a choice for a binary interaction.
+    """
+    id: str = Field(default="default", description="The ID of the choice.")
+    label: str = Field(default="default", description="Label of the choice")
+    value: typing.Any = Field(default="default", description="The value of the choice.")
+
+
+class MultipleChoiceOption(BaseModel):
+    id: str = Field(default="default", description="The ID of the choice.")
+    label: str = Field(default="default", description="The label for the multiple choice interaction.")
+    value: str = Field(default="default", description="The value for the multiple choice interaction.")
+    description: str = Field(default="default", description="The description for the multiple choice interaction.")
+
+
+class HumanResponseText(BaseModel):
+    """
+    Represents a text response to an interaction.
+    """
+    type: typing.Literal[HumanPromptModelType.TEXT] = HumanPromptModelType.TEXT
+    text: str = Field(description="The text of the response.")
+
+
+class HumanResponseNotification(BaseModel):
+    """
+    Represents a notification response to an interaction.
+    """
+    type: typing.Literal[HumanPromptModelType.NOTIFICATION] = HumanPromptModelType.NOTIFICATION
+    text: str = Field(default="Notification acknowledgement.", description="Default notification response text.")
+
+
+class HumanResponseBinary(BaseModel):
+    """
+    Represents a binary response to an interaction.
+    """
+    type: typing.Literal[HumanPromptModelType.BINARY_CHOICE] = HumanPromptModelType.BINARY_CHOICE
+    selected_option: BinaryHumanPromptOption = Field(description="The selected binary response.")
+
+
+class HumanResponseRadio(BaseModel):
+    """
+    Represents a multiple choice radio response to an interaction.
+    """
+    type: typing.Literal[HumanPromptModelType.RADIO] = HumanPromptModelType.RADIO
+    selected_option: MultipleChoiceOption = Field(description="The selected multiple choice radio response.")
+
+
+class HumanResponseCheckbox(BaseModel):
+    """
+    Represents a multiple choice checkbox response to an interaction.
+    """
+    type: typing.Literal[HumanPromptModelType.CHECKBOX] = HumanPromptModelType.CHECKBOX
+    selected_option: MultipleChoiceOption = Field(description="The selected multiple choice checkbox response.")
+
+
+class HumanResponseDropdown(BaseModel):
+    """
+    Represents a multiple choice dropdown response to an interaction.
+    """
+    type: typing.Literal[HumanPromptModelType.DROPDOWN] = HumanPromptModelType.DROPDOWN
+    selected_option: MultipleChoiceOption = Field(description="The selected multiple choice dropdown response.")
+
+
+HumanResponse = typing.Annotated[HumanResponseText | HumanResponseBinary | HumanResponseNotification
+                                 | HumanResponseRadio | HumanResponseCheckbox
+                                 | HumanResponseDropdown,
+                                 Discriminator("type")]
+
+
+class HumanPromptBase(BaseModel):
+    """
+    Base interaction model to derive from
+    """
+    text: str = Field(description="Text prompt that will be displayed to the user.")
+
+
+class HumanPromptText(HumanPromptBase):
+    """
+    Represents a text interaction.
+    """
+    input_type: typing.Literal[HumanPromptModelType.TEXT] = HumanPromptModelType.TEXT
+    placeholder: str | None = Field(description="The placeholder for the text.")
+    required: bool = Field(default=True, description="Whether the interaction is required.")
+
+
+class HumanPromptNotification(HumanPromptBase):
+    """
+    Represents a notification interaction.
+    """
+    input_type: typing.Literal[HumanPromptModelType.NOTIFICATION] = HumanPromptModelType.NOTIFICATION
+
+
+class _HumanPromptOAuthConsent(HumanPromptBase):
+    """
+    Represents an OAuth consent prompt interaction used to notify the UI to open the authentication page for completing
+    the consent flow.
+    """
+    input_type: typing.Literal[HumanPromptModelType.OAUTH_CONSENT] = HumanPromptModelType.OAUTH_CONSENT
+
+
+class HumanPromptBinary(HumanPromptBase):
+    """
+    Represents a binary interaction.
+    """
+    input_type: typing.Literal[HumanPromptModelType.BINARY_CHOICE] = HumanPromptModelType.BINARY_CHOICE
+    options: list[BinaryHumanPromptOption] = Field(description="The options for the binary interaction.")
+
+    # Field validator to make sure len(options) == 2
+    @field_validator("options", mode="before")
+    @classmethod
+    def validate_options(cls, options):
+        if len(options) != 2:
+            raise ValueError("Binary interactions must have exactly two options.")
+        return options
+
+
+class HumanPromptMultipleChoiceBase(HumanPromptBase):
+    """
+    Represents a multiple choice interaction.
+    """
+    options: list[MultipleChoiceOption] = Field(description="The options for the multiple choice interaction.")
+
+
+class HumanPromptRadio(HumanPromptMultipleChoiceBase):
+    """
+    Represents a radio interaction.
+    """
+    input_type: typing.Literal[HumanPromptModelType.RADIO] = HumanPromptModelType.RADIO
+
+
+class HumanPromptCheckbox(HumanPromptMultipleChoiceBase):
+    """
+    Represents a checkbox interaction.
+    """
+    input_type: typing.Literal[HumanPromptModelType.CHECKBOX] = HumanPromptModelType.CHECKBOX
+
+
+class HumanPromptDropdown(HumanPromptMultipleChoiceBase):
+    """
+    Represents a dropdown interaction.
+    """
+    input_type: typing.Literal[HumanPromptModelType.DROPDOWN] = HumanPromptModelType.DROPDOWN
+
+
+HumanPrompt = typing.Annotated[HumanPromptText | HumanPromptNotification | HumanPromptBinary | HumanPromptRadio
+                               | HumanPromptCheckbox | HumanPromptDropdown | _HumanPromptOAuthConsent,
+                               Discriminator("input_type")]
+
+
+class InteractionStatus(str, Enum):
+    """
+    Represents the status of an interaction.
+    """
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class InteractionBase(BaseModel):
+    """
+    Represents a system-human interaction.
+    """
+    id: str = Field(description="The ID of the interaction.")
+    type: str = Field(default="system_human_interaction", description="The type of the interaction.")
+    thread_id: str | None = Field(description="The thread ID of the interaction.", default=None)
+    parent_id: str | None = Field(description="The parent ID of the interaction.", default=None)
+    status: InteractionStatus = Field(description="The status of the interaction.", default=InteractionStatus.PENDING)
+    timestamp: str = Field(description="The timestamp of the interaction.")
+
+    @field_validator("timestamp", mode="before")
+    @classmethod
+    def validate_timestamp(cls, timestamp):
+        if not re.match(r"\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z", timestamp):
+            raise ValueError("Timestamp must be in the format 2025-01-13T10:00:03Z")
+        return timestamp
+
+
+class InteractionPrompt(InteractionBase):
+    """
+    Represents a system-human interaction with a prompt.
+    """
+    content: HumanPrompt = Field(description="The content of the interaction.")
+
+
+class InteractionResponse(InteractionBase):
+    """
+    Represents a system-human interaction with a response.
+    """
+    content: HumanResponse = Field(description="The content of the interaction.")

aiq/data_models/intermediate_step.py

@@ -0,0 +1,302 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import time
+import typing
+import uuid
+from enum import Enum
+from typing import Literal
+
+from pydantic import BaseModel
+from pydantic import ConfigDict
+from pydantic import Field
+from pydantic import model_validator
+
+from aiq.builder.framework_enum import LLMFrameworkEnum
+from aiq.data_models.invocation_node import InvocationNode
+from aiq.profiler.callbacks.token_usage_base_model import TokenUsageBaseModel
+
+
+class IntermediateStepCategory(str, Enum):
+    LLM = "LLM"
+    TOOL = "TOOL"
+    WORKFLOW = "WORKFLOW"
+    TASK = "TASK"
+    FUNCTION = "FUNCTION"
+    CUSTOM = "CUSTOM"
+    SPAN = "SPAN"
+
+
+class IntermediateStepType(str, Enum):
+    LLM_START = "LLM_START"
+    LLM_END = "LLM_END"
+    LLM_NEW_TOKEN = "LLM_NEW_TOKEN"
+    TOOL_START = "TOOL_START"
+    TOOL_END = "TOOL_END"
+    WORKFLOW_START = "WORKFLOW_START"
+    WORKFLOW_END = "WORKFLOW_END"
+    TASK_START = "TASK_START"
+    TASK_END = "TASK_END"
+    FUNCTION_START = "FUNCTION_START"
+    FUNCTION_END = "FUNCTION_END"
+    CUSTOM_START = "CUSTOM_START"
+    CUSTOM_END = "CUSTOM_END"
+    SPAN_START = "SPAN_START"
+    SPAN_CHUNK = "SPAN_CHUNK"
+    SPAN_END = "SPAN_END"
+
+
+class IntermediateStepState(str, Enum):
+    START = "START"
+    CHUNK = "CHUNK"
+    END = "END"
+
+
+class StreamEventData(BaseModel):
+    """
+    AIQStreamEventData is a data model that represents the data field in an streaming event.
+    """
+
+    # Allow extra fields in the model_config to support derived models
+    model_config = ConfigDict(extra="allow")
+
+    input: typing.Any | None = None
+    output: typing.Any | None = None
+    chunk: typing.Any | None = None
+
+
+class UsageInfo(BaseModel):
+    token_usage: TokenUsageBaseModel = TokenUsageBaseModel()
+    num_llm_calls: int = 0
+    seconds_between_calls: int = 0
+
+
+class ToolParameters(BaseModel):
+    properties: dict[str, typing.Any] = Field(..., description="The properties of the function parameters.")
+    required: list[str] = Field(default_factory=list, description="The required properties of the function parameters.")
+    type_: Literal["object"] = Field(default="object", description="The type of the function parameters.", alias="type")
+    additionalProperties: bool = Field(default=False,
+                                       description="Enable function parameters allow additional properties.")
+    strict: bool = Field(default=True, description="Ensure function calls reliably adhere to the function schema.")
+
+
+class ToolDetails(BaseModel):
+    name: str = Field(..., description="The name of the function.")
+    description: str = Field(..., description="The description of the function.")
+    parameters: ToolParameters = Field(..., description="The parameters of the function.")
+
+
+class ToolSchema(BaseModel):
+    type: Literal["function"] = Field(..., description="The type of the tool.")
+    function: ToolDetails = Field(..., description="The function details.")
+
+
+class TraceMetadata(BaseModel):
+    chat_responses: typing.Any | None = None
+    chat_inputs: typing.Any | None = None
+    tool_inputs: typing.Any | None = None
+    tool_outputs: typing.Any | None = None
+    tool_info: typing.Any | None = None
+    span_inputs: typing.Any | None = None
+    span_outputs: typing.Any | None = None
+    provided_metadata: typing.Any | None = None
+    tools_schema: list[ToolSchema] = Field(default_factory=list,
+                                           description="The schema of tools used in a tool calling request.")
+
+    # Allow extra fields in the model_config to support derived models
+    model_config = ConfigDict(extra="allow")
+
+
+class IntermediateStepPayload(BaseModel):
+    """
+    AIQIntermediateStep is a data model that represents an intermediate step in the AIQ Toolkit. Intermediate steps are
+    captured while a request is running and can be used to show progress or to evaluate the path a workflow took to get
+    a response.
+    """
+
+    # Allow extra fields in the model_config to support derived models
+    model_config = ConfigDict(extra="allow")
+
+    event_type: IntermediateStepType
+    # Create an event timestamp field with the default being a lambda that returns the current time
+    event_timestamp: float = Field(default_factory=lambda: time.time())
+    span_event_timestamp: float | None = None  # Used for tracking the start time of a task if this is end
+    framework: LLMFrameworkEnum | None = None
+    name: str | None = None
+    tags: list[str] | None = None
+    metadata: dict[str, typing.Any] | TraceMetadata | None = None
+    data: StreamEventData | None = None
+    usage_info: UsageInfo | None = None
+    UUID: str = Field(default_factory=lambda: str(uuid.uuid4()))
+
+    @property
+    def event_category(self) -> IntermediateStepCategory:  # pylint: disable=too-many-return-statements
+        match self.event_type:
+            case IntermediateStepType.LLM_START:
+                return IntermediateStepCategory.LLM
+            case IntermediateStepType.LLM_END:
+                return IntermediateStepCategory.LLM
+            case IntermediateStepType.LLM_NEW_TOKEN:
+                return IntermediateStepCategory.LLM
+            case IntermediateStepType.TOOL_START:
+                return IntermediateStepCategory.TOOL
+            case IntermediateStepType.TOOL_END:
+                return IntermediateStepCategory.TOOL
+            case IntermediateStepType.WORKFLOW_START:
+                return IntermediateStepCategory.WORKFLOW
+            case IntermediateStepType.WORKFLOW_END:
+                return IntermediateStepCategory.WORKFLOW
+            case IntermediateStepType.TASK_START:
+                return IntermediateStepCategory.TASK
+            case IntermediateStepType.TASK_END:
+                return IntermediateStepCategory.TASK
+            case IntermediateStepType.FUNCTION_START:
+                return IntermediateStepCategory.FUNCTION
+            case IntermediateStepType.FUNCTION_END:
+                return IntermediateStepCategory.FUNCTION
+            case IntermediateStepType.CUSTOM_START:
+                return IntermediateStepCategory.CUSTOM
+            case IntermediateStepType.CUSTOM_END:
+                return IntermediateStepCategory.CUSTOM
+            case IntermediateStepType.SPAN_START:
+                return IntermediateStepCategory.SPAN
+            case IntermediateStepType.SPAN_CHUNK:
+                return IntermediateStepCategory.SPAN
+            case IntermediateStepType.SPAN_END:
+                return IntermediateStepCategory.SPAN
+            case _:
+                raise ValueError(f"Unknown event type: {self.event_type}")
+
+    @property
+    def event_state(self) -> IntermediateStepState:  # pylint: disable=too-many-return-statements
+        match self.event_type:
+            case IntermediateStepType.LLM_START:
+                return IntermediateStepState.START
+            case IntermediateStepType.LLM_END:
+                return IntermediateStepState.END
+            case IntermediateStepType.LLM_NEW_TOKEN:
+                return IntermediateStepState.CHUNK
+            case IntermediateStepType.TOOL_START:
+                return IntermediateStepState.START
+            case IntermediateStepType.TOOL_END:
+                return IntermediateStepState.END
+            case IntermediateStepType.WORKFLOW_START:
+                return IntermediateStepState.START
+            case IntermediateStepType.WORKFLOW_END:
+                return IntermediateStepState.END
+            case IntermediateStepType.TASK_START:
+                return IntermediateStepState.START
+            case IntermediateStepType.TASK_END:
+                return IntermediateStepState.END
+            case IntermediateStepType.FUNCTION_START:
+                return IntermediateStepState.START
+            case IntermediateStepType.FUNCTION_END:
+                return IntermediateStepState.END
+            case IntermediateStepType.CUSTOM_START:
+                return IntermediateStepState.START
+            case IntermediateStepType.CUSTOM_END:
+                return IntermediateStepState.END
+            case IntermediateStepType.SPAN_START:
+                return IntermediateStepState.START
+            case IntermediateStepType.SPAN_CHUNK:
+                return IntermediateStepState.CHUNK
+            case IntermediateStepType.SPAN_END:
+                return IntermediateStepState.END
+            case _:
+                raise ValueError(f"Unknown event type: {self.event_type}")
+
+    @model_validator(mode="after")
+    def check_span_event_timestamp(self) -> "IntermediateStepPayload":
+        if self.event_state != IntermediateStepState.END and self.span_event_timestamp is not None:
+            raise ValueError("span_event_timestamp can only be provided for events with an END state")
+        return self
+
+
+class IntermediateStep(BaseModel):
+    """
+    AIQIntermediateStep is a data model that represents an intermediate step in the AIQ Toolkit. Intermediate steps are
+    captured while a request is running and can be used to show progress or to evaluate the path a workflow took to get
+    a response.
+    """
+
+    # Allow extra fields in the model_config to support derived models
+    model_config = ConfigDict(extra="forbid")
+
+    parent_id: str
+    """
+    The parent step ID for the current step. The parent ID is the ID of the last START step which has a different UUID
+    than the current step. This value is different from the function_ancestry.parent_id value which tracks the last
+    parent FUNCTION step. For the first START step, the parent_id is 'root'.
+    """
+
+    function_ancestry: InvocationNode
+    """
+    The function ancestry for the current step showing the current AIQ function that was being executed when the step
+    was created.
+    """
+
+    payload: IntermediateStepPayload
+    """
+    The payload for the current step.
+    """
+
+    # ===== Payload Properties =====
+    @property
+    def event_type(self) -> IntermediateStepType:
+        return self.payload.event_type
+
+    @property
+    def event_timestamp(self) -> float:
+        return self.payload.event_timestamp
+
+    @property
+    def span_event_timestamp(self) -> float | None:
+        return self.payload.span_event_timestamp
+
+    @property
+    def framework(self) -> LLMFrameworkEnum | None:
+        return self.payload.framework
+
+    @property
+    def name(self) -> str | None:
+        return self.payload.name
+
+    @property
+    def tags(self) -> list[str] | None:
+        return self.payload.tags
+
+    @property
+    def metadata(self) -> dict[str, typing.Any] | TraceMetadata | None:
+        return self.payload.metadata
+
+    @property
+    def data(self) -> StreamEventData | None:
+        return self.payload.data
+
+    @property
+    def usage_info(self) -> UsageInfo | None:
+        return self.payload.usage_info
+
+    @property
+    def UUID(self) -> str:  # pylint: disable=invalid-name
+        return self.payload.UUID
+
+    @property
+    def event_category(self) -> IntermediateStepCategory:
+        return self.payload.event_category
+
+    @property
+    def event_state(self) -> IntermediateStepState:
+        return self.payload.event_state

aiq/data_models/invocation_node.py

@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pydantic import BaseModel
+
+
+class InvocationNode(BaseModel):
+    """
+    Represents a node in an invocation call graph.
+
+    The InvocationNode class encapsulates the details of a specific function
+    invocation within a call graph. It stores the unique identifier of the
+    invocation, the function name, and optional details about the parent
+    node (if any). This class is useful for tracing the execution flow
+    in a system or application.
+
+    Attributes:
+        function_id (str): Unique identifier for the function invocation.
+        function_name (str): Name of the function invoked.
+        parent_id (str | None): Unique identifier of the parent invocation, if applicable. Defaults to None.
+        parent_name (str | None): Name of the parent function invoked, if applicable. Defaults to None.
+    """
+    function_id: str
+    function_name: str
+    parent_id: str | None = None
+    parent_name: str | None = None

aiq/data_models/llm.py

@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+from .common import BaseModelRegistryTag
+from .common import TypedBaseModel
+
+
+class LLMBaseConfig(TypedBaseModel, BaseModelRegistryTag):
+    """Base configuration for LLM providers."""
+    pass
+
+
+LLMBaseConfigT = typing.TypeVar("LLMBaseConfigT", bound=LLMBaseConfig)

aiq/data_models/logging.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+from .common import BaseModelRegistryTag
+from .common import TypedBaseModel
+
+
+class LoggingBaseConfig(TypedBaseModel, BaseModelRegistryTag):
+    pass
+
+
+LoggingMethodConfigT = typing.TypeVar("LoggingMethodConfigT", bound=LoggingBaseConfig)

aiq/data_models/memory.py

@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import typing
+
+from .common import BaseModelRegistryTag
+from .common import TypedBaseModel
+
+
+class MemoryBaseConfig(TypedBaseModel, BaseModelRegistryTag):
+    """ The base level config object for a memory object. Memories provide an interface for storing and retrieving. """
+    pass
+
+
+MemoryBaseConfigT = typing.TypeVar("MemoryBaseConfigT", bound=MemoryBaseConfig)