unique_toolkit 1.38.4__py3-none-any.whl → 1.39.0__py3-none-any.whl

unique_toolkit/app/schemas.py

@@ -120,11 +120,15 @@ class McpServer(BaseModel):
 class ChatEventUserMessage(BaseModel):
     model_config = model_config
 
-    id: str
-    text: str
-    original_text: str
-    created_at: str
-    language: str
+    id: str = Field(
+        description="The id of the user message. On an event this corresponds to the user message that created the event."
+    )
+    text: str = Field(description="The text of the user message.")
+    original_text: str = Field(description="The original text of the user message.")
+    created_at: str = Field(
+        description="The creation date and time of the user message."
+    )
+    language: str = Field(description="The language of the user message.")
 
 
 @deprecated(
@@ -140,8 +144,12 @@ class EventUserMessage(ChatEventUserMessage):
 class ChatEventAssistantMessage(BaseModel):
     model_config = model_config
 
-    id: str
-    created_at: str
+    id: str = Field(
+        description="The id of the assistant message. On an event this corresponds to the assistant message that will be returned by the process handling the event."
+    )
+    created_at: str = Field(
+        description="The creation date and time of the assistant message."
+    )
 
 
 @deprecated(

unique_toolkit/services/chat_service.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Sequence
+from typing import Any, Sequence, overload
 
 import unique_sdk
 from openai.types.chat import ChatCompletionToolChoiceOptionParam
@@ -13,6 +13,7 @@ from openai.types.responses import (
     response_create_params,
 )
 from openai.types.shared_params import Metadata, Reasoning
+from pydantic import BaseModel
 from typing_extensions import deprecated
 
 from unique_toolkit._common.utils.files import is_file_content, is_image_content
@@ -93,6 +94,13 @@ from unique_toolkit.language_model.schemas import (
     LanguageModelToolDescription,
     ResponsesLanguageModelStreamResponse,
 )
+from unique_toolkit.short_term_memory.functions import (
+    create_memory,
+    create_memory_async,
+    find_latest_memory,
+    find_latest_memory_async,
+)
+from unique_toolkit.short_term_memory.schemas import ShortTermMemory
 
 logger = logging.getLogger(f"toolkit.{DOMAIN_NAME}.{__name__}")
 
@@ -1654,3 +1662,403 @@ class ChatService(ChatServiceDeprecated):
             if is_image_content(filename=c.key):
                 images.append(c)
         return images, files
+
+    # Short Term Memories
+    ############################################################################
+
+    def create_chat_memory_by_id(
+        self, *, chat_id: str, key: str, value: str | dict | BaseModel
+    ) -> ShortTermMemory:
+        """Creates a short-term memory for a specific chat synchronously.
+
+        Args:
+            chat_id (str): The chat ID
+            key (str): The memory key
+            value (str | dict | BaseModel): The memory value
+
+        Returns:
+            ShortTermMemory: The created short-term memory
+
+        Raises:
+            Exception: If the creation fails
+        """
+        # Convert BaseModel to JSON string if needed
+        if isinstance(value, BaseModel):
+            value = value.model_dump_json()
+
+        return create_memory(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            key=key,
+            value=value,
+            chat_id=chat_id,
+        )
+
+    async def create_chat_memory_by_id_async(
+        self, *, chat_id: str, key: str, value: str | dict | BaseModel
+    ) -> ShortTermMemory:
+        """Creates a short-term memory for a specific chat asynchronously.
+
+        Args:
+            chat_id (str): The chat ID
+            key (str): The memory key
+            value (str | dict | BaseModel): The memory value
+
+        Returns:
+            ShortTermMemory: The created short-term memory
+
+        Raises:
+            Exception: If the creation fails
+        """
+        # Convert BaseModel to JSON string if needed
+        if isinstance(value, BaseModel):
+            value = value.model_dump_json()
+
+        return await create_memory_async(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            key=key,
+            value=value,
+            chat_id=chat_id,
+        )
+
+    def create_message_memory_by_id(
+        self, *, message_id: str, key: str, value: str | dict | BaseModel
+    ) -> ShortTermMemory:
+        """Creates a short-term memory for a specific message synchronously.
+
+        Args:
+            message_id (str): The message ID
+            key (str): The memory key
+            value (str | dict | BaseModel): The memory value
+
+        Returns:
+            ShortTermMemory: The created short-term memory
+
+        Raises:
+            Exception: If the creation fails
+        """
+        # Convert BaseModel to JSON string if needed
+        if isinstance(value, BaseModel):
+            value = value.model_dump_json()
+
+        return create_memory(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            key=key,
+            value=value,
+            message_id=message_id,
+        )
+
+    async def create_message_memory_by_id_async(
+        self, *, message_id: str, key: str, value: str | dict | BaseModel
+    ) -> ShortTermMemory:
+        """Creates a short-term memory for a specific message asynchronously.
+
+        Args:
+            message_id (str): The message ID
+            key (str): The memory key
+            value (str | dict | BaseModel): The memory value
+
+        Returns:
+            ShortTermMemory: The created short-term memory
+
+        Raises:
+            Exception: If the creation fails
+        """
+        # Convert BaseModel to JSON string if needed
+        if isinstance(value, BaseModel):
+            value = value.model_dump_json()
+
+        return await create_memory_async(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            key=key,
+            value=value,
+            message_id=message_id,
+        )
+
+    def find_chat_memory_by_id(self, *, chat_id: str, key: str) -> ShortTermMemory:
+        """Finds the latest short-term memory for a specific chat synchronously.
+
+        Args:
+            chat_id (str): The chat ID
+            key (str): The memory key
+
+        Returns:
+            ShortTermMemory: The latest short-term memory
+
+        Raises:
+            Exception: If the retrieval fails
+        """
+        return find_latest_memory(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            key=key,
+            chat_id=chat_id,
+        )
+
+    async def find_chat_memory_by_id_async(
+        self, *, chat_id: str, key: str
+    ) -> ShortTermMemory:
+        """Finds the latest short-term memory for a specific chat asynchronously.
+
+        Args:
+            chat_id (str): The chat ID
+            key (str): The memory key
+
+        Returns:
+            ShortTermMemory: The latest short-term memory
+
+        Raises:
+            Exception: If the retrieval fails
+        """
+        return await find_latest_memory_async(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            key=key,
+            chat_id=chat_id,
+        )
+
+    def find_message_memory_by_id(
+        self, *, message_id: str, key: str
+    ) -> ShortTermMemory:
+        """Finds the latest short-term memory for a specific message synchronously.
+
+        Args:
+            message_id (str): The message ID
+            key (str): The memory key
+
+        Returns:
+            ShortTermMemory: The latest short-term memory
+
+        Raises:
+            Exception: If the retrieval fails
+        """
+        return find_latest_memory(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            key=key,
+            message_id=message_id,
+        )
+
+    async def find_message_memory_by_id_async(
+        self, *, message_id: str, key: str
+    ) -> ShortTermMemory:
+        """Finds the latest short-term memory for a specific message asynchronously.
+
+        Args:
+            message_id (str): The message ID
+            key (str): The memory key
+
+        Returns:
+            ShortTermMemory: The latest short-term memory
+
+        Raises:
+            Exception: If the retrieval fails
+        """
+        return await find_latest_memory_async(
+            user_id=self._user_id,
+            company_id=self._company_id,
+            key=key,
+            message_id=message_id,
+        )
+
+    # Convenience methods using current chat/message IDs
+    ############################################################################
+
+    def create_chat_memory(
+        self, *, key: str, value: str | dict | BaseModel
+    ) -> ShortTermMemory:
+        """Creates a short-term memory for the current chat synchronously.
+
+        Args:
+            key (str): The memory key
+            value (str | dict | BaseModel): The memory value
+
+        Returns:
+            ShortTermMemory: The created short-term memory
+
+        Raises:
+            Exception: If the creation fails
+        """
+        return self.create_chat_memory_by_id(
+            chat_id=self._chat_id,
+            key=key,
+            value=value,
+        )
+
+    async def create_chat_memory_async(
+        self, *, key: str, value: str | dict | BaseModel
+    ) -> ShortTermMemory:
+        """Creates a short-term memory for the current chat asynchronously.
+
+        Args:
+            key (str): The memory key
+            value (str | dict | BaseModel): The memory value
+
+        Returns:
+            ShortTermMemory: The created short-term memory
+
+        Raises:
+            Exception: If the creation fails
+        """
+        return await self.create_chat_memory_by_id_async(
+            chat_id=self._chat_id,
+            key=key,
+            value=value,
+        )
+
+    @overload
+    def create_message_memory(
+        self,
+        *,
+        key: str,
+        value: str | dict | BaseModel,
+    ) -> ShortTermMemory: ...
+
+    @overload
+    def create_message_memory(
+        self, *, key: str, value: str | dict | BaseModel, message_id: str
+    ) -> ShortTermMemory: ...
+
+    def create_message_memory(
+        self, *, key: str, value: str | dict | BaseModel, message_id: str | None = None
+    ) -> ShortTermMemory:
+        """Creates a short-term memory for the current assistant message synchronously.
+
+        Args:
+            key (str): The memory key
+            value (str | dict | BaseModel): The memory value
+
+        Returns:
+            ShortTermMemory: The created short-term memory
+
+        Raises:
+            Exception: If the creation fails
+        """
+        return self.create_message_memory_by_id(
+            key=key,
+            value=value,
+            message_id=message_id or self._assistant_message_id,
+        )
+
+    @overload
+    async def create_message_memory_async(
+        self,
+        *,
+        key: str,
+        value: str | dict | BaseModel,
+    ) -> ShortTermMemory: ...
+
+    @overload
+    async def create_message_memory_async(
+        self, *, key: str, value: str | dict | BaseModel, message_id: str
+    ) -> ShortTermMemory: ...
+
+    async def create_message_memory_async(
+        self, *, key: str, value: str | dict | BaseModel, message_id: str | None = None
+    ) -> ShortTermMemory:
+        """Creates a short-term memory for the current assistant message asynchronously.
+
+        Args:
+            key (str): The memory key
+            value (str | dict | BaseModel): The memory value
+
+        Returns:
+            ShortTermMemory: The created short-term memory
+
+        Raises:
+            Exception: If the creation fails
+        """
+        return await self.create_message_memory_by_id_async(
+            message_id=message_id or self._assistant_message_id,
+            key=key,
+            value=value,
+        )
+
+    def find_chat_memory(self, *, key: str) -> ShortTermMemory:
+        """Finds the latest short-term memory for the current chat synchronously.
+
+        Args:
+            key (str): The memory key
+
+        Returns:
+            ShortTermMemory: The latest short-term memory
+
+        Raises:
+            Exception: If the retrieval fails
+        """
+        return self.find_chat_memory_by_id(
+            chat_id=self._chat_id,
+            key=key,
+        )
+
+    async def find_chat_memory_async(self, *, key: str) -> ShortTermMemory:
+        """Finds the latest short-term memory for the current chat asynchronously.
+
+        Args:
+            key (str): The memory key
+
+        Returns:
+            ShortTermMemory: The latest short-term memory
+
+        Raises:
+            Exception: If the retrieval fails
+        """
+        return await self.find_chat_memory_by_id_async(
+            chat_id=self._chat_id,
+            key=key,
+        )
+
+    @overload
+    def find_message_memory(self, *, key: str) -> ShortTermMemory: ...
+
+    @overload
+    def find_message_memory(self, *, key: str, message_id: str) -> ShortTermMemory: ...
+
+    def find_message_memory(
+        self, *, key: str, message_id: str | None = None
+    ) -> ShortTermMemory:
+        """Finds the latest short-term memory for the current assistant message synchronously.
+
+        Args:
+            key (str): The memory key
+
+        Returns:
+            ShortTermMemory: The latest short-term memory
+
+        Raises:
+            Exception: If the retrieval fails
+        """
+        return self.find_message_memory_by_id(
+            message_id=message_id or self._assistant_message_id,
+            key=key,
+        )
+
+    @overload
+    async def find_message_memory_async(self, *, key: str) -> ShortTermMemory: ...
+
+    @overload
+    async def find_message_memory_async(
+        self, *, key: str, message_id: str
+    ) -> ShortTermMemory: ...
+
+    async def find_message_memory_async(
+        self, *, key: str, message_id: str | None = None
+    ) -> ShortTermMemory:
+        """Finds the latest short-term memory for the current assistant message asynchronously.
+
+        Args:
+            key (str): The memory key
+
+        Returns:
+            ShortTermMemory: The latest short-term memory
+
+        Raises:
+            Exception: If the retrieval fails
+        """
+        return await self.find_message_memory_by_id_async(
+            message_id=message_id or self._assistant_message_id,
+            key=key,
+        )

unique_toolkit/short_term_memory/functions.py

@@ -2,6 +2,7 @@ import json
 import logging
 
 import unique_sdk
+from typing_extensions import Any
 
 from unique_toolkit.short_term_memory.constants import DOMAIN_NAME
 from unique_toolkit.short_term_memory.schemas import ShortTermMemory
@@ -41,7 +42,7 @@ async def find_latest_memory_async(
             chatId=chat_id,
             messageId=message_id,
         )
-        return ShortTermMemory(**stm)
+        return ShortTermMemory.model_validate(stm, by_alias=True, by_name=True)
     except Exception as e:
         logger.error(f"Error finding latest short term memory: {e}")
         raise e
@@ -79,7 +80,7 @@ def find_latest_memory(
             chatId=chat_id,
             messageId=message_id,
         )
-        return ShortTermMemory(**stm)
+        return ShortTermMemory.model_validate(stm, by_alias=True, by_name=True)
     except Exception as e:
         logger.error(f"Error finding latest short term memory: {e}")
         raise e
@@ -124,13 +125,14 @@ async def create_memory_async(
             messageId=message_id,
             data=value,
         )
-        return ShortTermMemory(**stm)
+        return ShortTermMemory.model_validate(stm, by_alias=True, by_name=True)
     except Exception as e:
         logger.error(f"Error creating short term memory: {e}")
         raise e
 
 
 def create_memory(
+    *,
     user_id: str,
     company_id: str,
     key: str,
@@ -169,7 +171,127 @@ def create_memory(
             messageId=message_id,
             data=value,
         )
-        return ShortTermMemory(**stm)
+        return ShortTermMemory.model_validate(stm, by_alias=True, by_name=True)
     except Exception as e:
         logger.error(f"Error creating short term memory: {e}")
         raise e
+
+
+def find_last_chat_memory(
+    *,
+    user_id: str,
+    company_id: str,
+    key: str,
+    chat_id: str,
+) -> ShortTermMemory:
+    """
+    Find the last chat short term memory.
+    """
+    stm = unique_sdk.ShortTermMemory.find_latest(
+        user_id=user_id,
+        company_id=company_id,
+        memoryName=key,
+        chatId=chat_id,
+    )
+    return ShortTermMemory.model_validate(stm, by_alias=True, by_name=True)
+
+
+async def find_last_chat_memory_async(
+    *,
+    user_id: str,
+    company_id: str,
+    key: str,
+    chat_id: str,
+) -> ShortTermMemory:
+    """
+    Find the last chat short term memory.
+    """
+    stm = await unique_sdk.ShortTermMemory.find_latest_async(
+        user_id=user_id,
+        company_id=company_id,
+        memoryName=key,
+        chatId=chat_id,
+    )
+    return ShortTermMemory.model_validate(stm, by_alias=True, by_name=True)
+
+
+def find_last_message_memory(
+    *,
+    user_id: str,
+    company_id: str,
+    key: str,
+    message_id: str,
+) -> ShortTermMemory:
+    """
+    Find the last message short term memory.
+    """
+    stm = unique_sdk.ShortTermMemory.find_latest(
+        user_id=user_id,
+        company_id=company_id,
+        chatId=None,
+        memoryName=key,
+        messageId=message_id,
+    )
+    return ShortTermMemory.model_validate(stm, by_alias=True, by_name=True)
+
+
+async def find_last_message_memory_async(
+    *,
+    user_id: str,
+    company_id: str,
+    key: str,
+    message_id: str,
+) -> ShortTermMemory:
+    """
+    Find the last message short term memory.
+    """
+    stm = await unique_sdk.ShortTermMemory.find_latest_async(
+        user_id=user_id,
+        company_id=company_id,
+        chatId=None,
+        memoryName=key,
+        messageId=message_id,
+    )
+    return ShortTermMemory.model_validate(stm, by_alias=True, by_name=True)
+
+
+def create_chat_memory(
+    *,
+    user_id: str,
+    company_id: str,
+    key: str,
+    value: dict[str, Any] | str,
+    chat_id: str,
+) -> ShortTermMemory:
+    """
+    Create a chat short term memory.
+    """
+    stm = unique_sdk.ShortTermMemory.create(
+        user_id=user_id,
+        company_id=company_id,
+        memoryName=key,
+        chatId=chat_id,
+        data=json.dumps(value) if isinstance(value, dict) else value,
+    )
+    return ShortTermMemory.model_validate(stm, by_alias=True, by_name=True)
+
+
+async def create_chat_memory_async(
+    *,
+    user_id: str,
+    company_id: str,
+    key: str,
+    value: dict[str, Any] | str,
+    chat_id: str,
+) -> ShortTermMemory:
+    """
+    Create a chat short term memory.
+    """
+    stm = await unique_sdk.ShortTermMemory.create_async(
+        user_id=user_id,
+        company_id=company_id,
+        memoryName=key,
+        chatId=chat_id,
+        data=json.dumps(value) if isinstance(value, dict) else value,
+    )
+    return ShortTermMemory.model_validate(stm, by_alias=True, by_name=True)

unique_toolkit/short_term_memory/schemas.py

@@ -1,7 +1,8 @@
 import json
+from typing import Any
 
 from humps import camelize
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 model_config = ConfigDict(
     alias_generator=camelize,
@@ -17,27 +18,31 @@ class ShortTermMemory(BaseModel):
     key: str = Field(alias="object")
     chat_id: str | None
     message_id: str | None
-    data: str | dict | int | float | bool | list | None
-
-    @field_validator("chat_id", "message_id", mode="before")
-    def validate_chat_id_or_message_id(cls, v, info):
-        field_name = info.field_name
-        data = info.data
-
-        # Get the other field's value
-        other_field = "message_id" if field_name == "chat_id" else "chat_id"
-        other_value = data.get(other_field)
-
-        # Check if both are None
-        if v is None and other_value is None:
-            camel_name = camelize(field_name)
-            raise ValueError(
-                f"Either {camel_name} or messageId must be provided"
-                if field_name == "chat_id"
-                else f"Either chatId or {camel_name} must be provided"
-            )
-
-        return v
+    data: str | dict | int | float | bool | list | None = Field(deprecated=True)
+    value: str | dict[str, Any] = Field(default_factory=dict)
+
+    @model_validator(mode="after")
+    def _data_to_value(self) -> "ShortTermMemory":
+        if isinstance(self.data, dict):
+            self.value = self.data
+        elif isinstance(self.data, str):
+            try:
+                self.value = json.loads(self.data)
+            except json.JSONDecodeError:
+                self.value = self.data
+        elif self.data is None:
+            self.value = ""
+        else:
+            self.value = str(self.data)
+        return self
+
+    @model_validator(mode="after")
+    def validate_message_id_and_chat_id(self):
+        if (self.message_id is None and self.chat_id is None) or (
+            self.message_id is not None and self.chat_id is not None
+        ):
+            raise ValueError("Either message_id or chat_id must be provided")
+        return self
 
     @field_validator("data", mode="before")
     def validate_data(cls, v):

{unique_toolkit-1.38.4.dist-info → unique_toolkit-1.39.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: unique_toolkit
-Version: 1.38.4
+Version: 1.39.0
 Summary: 
 License: Proprietary
 Author: Cedric Klinkert
@@ -41,9 +41,25 @@ The Toolkit is structured along the following domains:
 - `unique_toolkit.language_model`
 - `unique_toolkit.short_term_memory`
 
-Each domain comprises a set of functions (in `functions.py`) and a service class (in `service.py`) which encapsulates the basic functionalities to interact with the domain entities, the schemas (in `schemas.py`) used in the service and required for interacting with the service functions, utility functions (in `utils.py`) which give additional functionality to interact with the domain entities (all domains except embedding) and other domain specific functionalities which are explained in the respective domain documentation.
+Each domain comprises a set of schemas (in `schemas.py`) are used in functions (in `functions.py`) which encapsulates the basic functionalities to interact with the plattform. 
+The above domains represent the internal structure of the Unique platform.
 
-In addition, the `unique_toolkit.app` module provides functions to initialize apps that interact with the Unique platform. It also includes some utility functions to run async tasks in parallel (async webserver and app implementation required).
+For the `developers` we expose interfaces via `services` classes that correspond directly to an frontend or an entity the `user` interacts with. 
+
+The following services are currently available:
+
+| Service | Responsability |
+|--|--|
+| ChatService | All interactions with the chat interface | 
+| KnowledgeBaseService | All interaction with the knowledgebase |
+
+The services can be directly import as 
+
+```
+from unique_toolkit import ChatService, KnowledgeBaseService
+
+
+In addition, the `unique_toolkit.app` module provides functions to initialize apps and dev utilities to interact with the Unique platform. 
 
 ## Changelog
 
@@ -65,7 +81,6 @@ The `unique_toolkit.app` module encompasses functions for initializing and secur
 The `unique_toolkit.chat` module encompasses all chat related functionality.
 
 - `functions.py` comprises the functions to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
-- `service.py` comprises the ChatService and provides an interface to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message and stream complete.
 - `schemas.py` comprises all relevant schemas, e.g., ChatMessage, used in the ChatService.
 - `utils.py` comprises utility functions to use and convert ChatMessage objects in assistants, e.g., convert_chat_history_to_injectable_string converts the chat history to a string that can be injected into a prompt. 
 
@@ -74,11 +89,10 @@ The `unique_toolkit.chat` module encompasses all chat related functionality.
 The `unique_toolkit.content` module encompasses all content related functionality. Content can be any type of textual data that is stored in the Knowledgebase on the Unique platform. During the ingestion of the content, the content is parsed, split in chunks, indexed, and stored in the database.
 
 - `functions.py` comprises the functions to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
-- `service.py` comprises the ContentService and provides an interface to interact with the content, e.g., search content, search content chunks, upload and download content.
 - `schemas.py` comprises all relevant schemas, e.g., Content and ContentChunk, used in the ContentService.
 - `utils.py` comprise utility functions to manipulate Content and ContentChunk objects, e.g., sort_content_chunks and merge_content_chunks.
 
-## Embedding
+## Embedding (To be Deprecated)
 
 The `unique_toolkit.embedding` module encompasses all embedding related functionality. Embeddings are used to represent textual data in a high-dimensional space. The embeddings can be used to calculate the similarity between two texts, for instance.
 
@@ -86,34 +100,22 @@ The `unique_toolkit.embedding` module encompasses all embedding related function
 - `service.py` encompasses the EmbeddingService and provides an interface to interact with the embeddings, e.g., embed text and calculate the similarity between two texts.
 - `schemas.py` comprises all relevant schemas, e.g., Embeddings, used in the EmbeddingService.
 
-## Language Model
+## Language Model 
 
 The `unique_toolkit.language_model` module encompasses all language model related functionality and information on the different language models deployed through the 
 Unique platform.
 
 - `infos.py` comprises the information on all language models deployed through the Unique platform. We recommend to use the LanguageModel class, initialized with the LanguageModelName, e.g., LanguageModel(LanguageModelName.AZURE_GPT_4o_2024_1120) to get the information on the specific language model like the name, version, token limits or retirement date.
 - `functions.py` comprises the functions to complete and stream complete to chat.
-- `service.py` comprises the LanguageModelService and provides an interface to interact with the language models, e.g., complete. 
 - `schemas.py` comprises all relevant schemas, e.g., LanguageModelResponse, used in the LanguageModelService.
 - `utils.py` comprises utility functions to parse the output of the language model, e.g., convert_string_to_json finds and parses the last json object in a string.
 
-## Short Term Memory
+## Short Term Memory 
 
 The `unique_toolkit.short_term_memory` module encompasses all short term memory related functionality.
 
 - `functions.py` comprises the functions to manage and load the chat history and interact with the chat ui, e.g., creating a new assistant message.
-- `service.py` comprises the ShortTermMemoryService and provides an interface to interact with the short term memory, e.g., create memory.
 - `schemas.py` comprises all relevant schemas, e.g., ShortTermMemory, used in the ShortTermMemoryService.
-
-# Development instructions
-
-1. Install poetry on your system (through `brew` or `pipx`).
-
-2. Install `pyenv` and install python 3.11. `pyenv` is recommended as otherwise poetry uses the python version used to install itself and not the user preferred python version.
-
-3. If you then run `python --version` in your terminal, you should be able to see python version as specified in `.python-version`.
-
-4. Then finally run `poetry install` to install the package and all dependencies.
 # Changelog
 
 All notable changes to this project will be documented in this file.
@@ -121,6 +123,9 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.39.0] - 2025-12-17
+- Adding simpler shortterm message abilities to chat service
+
 ## [1.38.4] - 2025-12-17
 - Improving handling of tool calls with Qwen models
 

{unique_toolkit-1.38.4.dist-info → unique_toolkit-1.39.0.dist-info}/RECORD

@@ -144,7 +144,7 @@ unique_toolkit/app/init_logging.py,sha256=Sh26SRxOj8i8dzobKhYha2lLrkrMTHfB1V4jR3
 unique_toolkit/app/init_sdk.py,sha256=5_oDoETr6akwYyBCb0ivTdMNu3SVgPSkrXcDS6ELyY8,2269
 unique_toolkit/app/performance/async_tasks.py,sha256=H0l3OAcosLwNHZ8d2pd-Di4wHIXfclEvagi5kfqLFPA,1941
 unique_toolkit/app/performance/async_wrapper.py,sha256=yVVcRDkcdyfjsxro-N29SBvi-7773wnfDplef6-y8xw,1077
-unique_toolkit/app/schemas.py,sha256=1KziC9FzPtjOJ1R2ZoeJqVV9PNjGuKJ9uIMvPpA2yus,10159
+unique_toolkit/app/schemas.py,sha256=17Olyqc58LjFaZ6kYtPThWsGmRM0qGzDwRTekDNNw-E,10825
 unique_toolkit/app/unique_settings.py,sha256=NTfa3a8wWzBDx4_4Irqyhy4mpXyPU6Munqs41ozPFnE,12366
 unique_toolkit/app/verification.py,sha256=GxFFwcJMy25fCA_Xe89wKW7bgqOu8PAs5y8QpHF0GSc,3861
 unique_toolkit/app/webhook.py,sha256=k7DP1UTR3p7D4qzuKPKVmGMAkDVHfALrnMIzTZqj_OI,2320
@@ -202,17 +202,17 @@ unique_toolkit/language_model/service.py,sha256=fI2S5JLawJRRkKg086Ysz2Of4AOBHPN-
 unique_toolkit/language_model/utils.py,sha256=bPQ4l6_YO71w-zaIPanUUmtbXC1_hCvLK0tAFc3VCRc,1902
 unique_toolkit/protocols/support.py,sha256=ZEnbQL5w2-T_1AeM8OHycZJ3qbdfVI1nXe0nL9esQEw,5544
 unique_toolkit/services/__init__.py,sha256=90-IT5FjMcnlqxjp5kme9Fqgp_on46rggctIqHMdqsw,195
-unique_toolkit/services/chat_service.py,sha256=tHFmpbDiooYIvM5vZePsnwHdYUEcIBeD3db4lcsMJ_s,60941
+unique_toolkit/services/chat_service.py,sha256=EdeHseyBXBtXWx2gK5jXoGWBYjG6uyoLusQpGH8I6x0,73065
 unique_toolkit/services/knowledge_base.py,sha256=uc89GL_NZXeFkJKkdHSSh2y1Wx0tmgasWk6uyGi4G_M,36210
 unique_toolkit/short_term_memory/__init__.py,sha256=2mI3AUrffgH7Yt-xS57EGqnHf7jnn6xquoKEhJqk3Wg,185
 unique_toolkit/short_term_memory/constants.py,sha256=698CL6-wjup2MvU19RxSmQk3gX7aqW_OOpZB7sbz_Xg,34
-unique_toolkit/short_term_memory/functions.py,sha256=3WiK-xatY5nh4Dr5zlDUye1k3E6kr41RiscwtTplw5k,4484
-unique_toolkit/short_term_memory/schemas.py,sha256=OhfcXyF6ACdwIXW45sKzjtZX_gkcJs8FEZXcgQTNenw,1406
+unique_toolkit/short_term_memory/functions.py,sha256=-3xEIAnHL4x5cuuWS_yUNB3f2F4HGkTT6nyMjbgtMq4,7555
+unique_toolkit/short_term_memory/schemas.py,sha256=rS8Vvly-FZMiFTn_eGcSQJq_CP5AV-MDNDEmHSReCeI,1637
 unique_toolkit/short_term_memory/service.py,sha256=5PeVBu1ZCAfyDb2HLVvlmqSbyzBBuE9sI2o9Aajqjxg,8884
 unique_toolkit/smart_rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 unique_toolkit/smart_rules/compile.py,sha256=Ozhh70qCn2yOzRWr9d8WmJeTo7AQurwd3tStgBMPFLA,1246
 unique_toolkit/test_utilities/events.py,sha256=_mwV2bs5iLjxS1ynDCjaIq-gjjKhXYCK-iy3dRfvO3g,6410
-unique_toolkit-1.38.4.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
-unique_toolkit-1.38.4.dist-info/METADATA,sha256=fRZxzhXh974Ju0N6ugjU2PqqrdDbf22IL3sjyzHoElI,46797
-unique_toolkit-1.38.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-unique_toolkit-1.38.4.dist-info/RECORD,,
+unique_toolkit-1.39.0.dist-info/LICENSE,sha256=GlN8wHNdh53xwOPg44URnwag6TEolCjoq3YD_KrWgss,193
+unique_toolkit-1.39.0.dist-info/METADATA,sha256=DTmUY_QVEo70IW79vzgIZb436Ptf917vl8JtwCqm8r4,45869
+unique_toolkit-1.39.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+unique_toolkit-1.39.0.dist-info/RECORD,,