cheshirecat-python-sdk 1.3.9__tar.gz → 1.7.11__tar.gz

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/Makefile

@@ -13,16 +13,16 @@ args=
 help:  ## Show help
 	@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n  make \033[36m\033[0m\n"} /^[$$()% a-zA-Z_-]+:.*?##/ { printf "  \033[36m%-15s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST)
 
-sync-requirements: ## Update the local virtual environment with the latest requirements.
+install: ## Update the local virtual environment with the latest requirements.
 	$(PYTHON) -m pip install --upgrade pip-tools pip wheel
 	$(PIP_SYNC) requirements.txt
 	$(PYTHON) -m pip install -r requirements.txt
 
-compile-requirements: ## Compile requirements for the local virtual environment.
+compile: ## Compile requirements for the local virtual environment.
 	$(PYTHON) -m pip install --upgrade pip-tools pip wheel
 	$(PIP_COMPILE) --no-upgrade --output-file requirements.txt pyproject.toml
 
-update-requirements: ## Compile requirements for the local virtual environment.
+update: ## Update requirements for the local virtual environment.
 	$(PIP_COMPILE) --upgrade --output-file requirements.txt pyproject.toml
 
 publish:  ## Publish the package to PyPI.

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cheshirecat-python-sdk
-Version: 1.3.9
+Version: 1.7.11
 Summary: Python SDK for the Cloud-ready fork of the Cheshire Cat
 Project-URL: Repository, https://github.com/matteocacciola/cheshirecat-python-sdk
 Project-URL: Documentation, https://github.com/matteocacciola/cheshirecat-python-sdk#README
@@ -683,7 +683,7 @@ License:                     GNU GENERAL PUBLIC LICENSE
         <https://www.gnu.org/licenses/why-not-lgpl.html>.
 License-File: LICENSE
 Keywords: Cheshire-Cat,LLM,OpenAPI,OpenSource,RAG
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Framework :: FastAPI
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
@@ -767,7 +767,7 @@ result = asyncio.run(cheshire_cat_client.rabbit_hole.post_web(url, "agent"))
 Memory management utilities:
 
 ```python
-from cheshirecat_python_sdk import Collection, CheshireCatClient, Configuration, Message
+from cheshirecat_python_sdk import CheshireCatClient, Configuration, Message
 
 configuration = Configuration(host="localhost", port=1865, auth_key="test", secure_connection=False)
 cheshire_cat_client = CheshireCatClient(configuration)
@@ -778,5 +778,5 @@ cheshire_cat_client.memory.get_memory_recall("HELLO", "agent", "user")  # recall
 url = "https://www.google.com"
 
 # delete memory points by metadata, like this example delete by source
-cheshire_cat_client.memory.delete_memory_points_by_metadata(Collection.DECLARATIVE, "agent", {"source": url})
+cheshire_cat_client.memory.delete_memory_points_by_metadata("declarative", "agent", {"source": url})
 ```

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/README.md

@@ -66,7 +66,7 @@ result = asyncio.run(cheshire_cat_client.rabbit_hole.post_web(url, "agent"))
 Memory management utilities:
 
 ```python
-from cheshirecat_python_sdk import Collection, CheshireCatClient, Configuration, Message
+from cheshirecat_python_sdk import CheshireCatClient, Configuration, Message
 
 configuration = Configuration(host="localhost", port=1865, auth_key="test", secure_connection=False)
 cheshire_cat_client = CheshireCatClient(configuration)
@@ -77,5 +77,5 @@ cheshire_cat_client.memory.get_memory_recall("HELLO", "agent", "user")  # recall
 url = "https://www.google.com"
 
 # delete memory points by metadata, like this example delete by source
-cheshire_cat_client.memory.delete_memory_points_by_metadata(Collection.DECLARATIVE, "agent", {"source": url})
+cheshire_cat_client.memory.delete_memory_points_by_metadata("declarative", "agent", {"source": url})
 ```

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/cheshirecat_python_sdk/__init__.py

@@ -1,7 +1,6 @@
 from cheshirecat_python_sdk.client import CheshireCatClient
 from cheshirecat_python_sdk.clients import HttpClient, WSClient
 from cheshirecat_python_sdk.configuration import Configuration
-from cheshirecat_python_sdk.enums import Collection, Role
 
 
 from cheshirecat_python_sdk.builders import *

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/cheshirecat_python_sdk/builders/memory.py

@@ -6,31 +6,19 @@ from cheshirecat_python_sdk.models.dtos import Memory, MemoryPoint
 
 class MemoryBuilder(BaseBuilder):
     def __init__(self):
-        self.episodic: Dict[str, Any] | None = None
         self.declarative: Dict[str, Any] | None = None
-        self.procedural: Dict[str, Any] | None = None
 
     @staticmethod
     def create():
         return MemoryBuilder()
 
-    def set_episodic(self, episodic: Dict[str, Any] | None = None):
-        self.episodic = episodic or {}
-        return self
-
     def set_declarative(self, declarative: Dict[str, Any] | None = None):
         self.declarative = declarative or {}
         return self
 
-    def set_procedural(self, procedural: Dict[str, Any] | None = None):
-        self.procedural = procedural or {}
-        return self
-
     def build(self):
         memory = Memory()
-        memory.episodic = self.episodic
         memory.declarative = self.declarative
-        memory.procedural = self.procedural
 
         return memory
 

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/cheshirecat_python_sdk/builders/why.py

@@ -9,7 +9,6 @@ class WhyBuilder(BaseBuilder):
         self.input: str | None = None
         self.intermediate_steps: Dict[str, Any] | None = None
         self.memory: Memory | None = None
-        self.model_interactions: Dict[str, Any] | None = None
 
     @staticmethod
     def create() -> "WhyBuilder":
@@ -27,14 +26,9 @@ class WhyBuilder(BaseBuilder):
         self.memory = memory
         return self
 
-    def set_model_interactions(self, model_interactions: Dict[str, Any] | None = None) -> "WhyBuilder":
-        self.model_interactions = model_interactions
-        return self
-
     def build(self) -> Why:
         return Why(
             input=self.input,
             intermediate_steps=self.intermediate_steps,
             memory=self.memory,
-            model_interactions=self.model_interactions,
         )

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/cheshirecat_python_sdk/client.py

@@ -2,8 +2,10 @@ from cheshirecat_python_sdk.clients import HttpClient, WSClient
 from cheshirecat_python_sdk.configuration import Configuration
 from cheshirecat_python_sdk.endpoints import (
     AdminsEndpoint,
+    AuthEndpoint,
     AuthHandlerEndpoint,
     ChunkerEndpoint,
+    ConversationEndpoint,
     CustomEndpoint,
     EmbedderEndpoint,
     FileManagerEndpoint,
@@ -12,9 +14,10 @@ from cheshirecat_python_sdk.endpoints import (
     MessageEndpoint,
     PluginsEndpoint,
     RabbitHoleEndpoint,
-    SettingsEndpoint,
     UsersEndpoint,
+    UtilsEndpoint,
     VectorDatabaseEndpoint,
+    HealthCheckEndpoint,
 )
 
 
@@ -53,6 +56,10 @@ class CheshireCatClient:
     def admins(self):
         return AdminsEndpoint(self)
 
+    @property
+    def auth(self):
+        return AuthEndpoint(self)
+
     @property
     def auth_handler(self):
         return AuthHandlerEndpoint(self)
@@ -61,6 +68,10 @@ class CheshireCatClient:
     def chunker(self):
         return ChunkerEndpoint(self)
 
+    @property
+    def conversation(self):
+        return ConversationEndpoint(self)
+
     @property
     def embedder(self):
         return EmbedderEndpoint(self)
@@ -89,14 +100,14 @@ class CheshireCatClient:
     def rabbit_hole(self):
         return RabbitHoleEndpoint(self)
 
-    @property
-    def settings(self):
-        return SettingsEndpoint(self)
-
     @property
     def users(self):
         return UsersEndpoint(self)
 
+    @property
+    def utils(self):
+        return UtilsEndpoint(self)
+
     @property
     def custom(self):
         return CustomEndpoint(self)
@@ -104,3 +115,7 @@ class CheshireCatClient:
     @property
     def vector_database(self):
         return VectorDatabaseEndpoint(self)
+
+    @property
+    def health_check(self):
+        return HealthCheckEndpoint(self)

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/cheshirecat_python_sdk/clients/http_client.py

@@ -15,8 +15,9 @@ class HttpClient:
         self.port = port
         self.apikey = apikey
         self.token = None
-        self.user_id = None
         self.agent_id = None
+        self.user_id = None
+        self.chat_id = None
         self.is_https = is_https
         self.headers = {}
 
@@ -38,27 +39,40 @@ class HttpClient:
     def __before_secure_request(self):
         if self.apikey:
             self.headers["Authorization"] = f"Bearer {self.apikey}"
-        if self.user_id:
-            self.headers["user_id"] = self.user_id
         if self.agent_id:
-            self.headers["agent_id"] = self.agent_id
+            self.headers["X-Agent-ID"] = self.agent_id
+        if self.user_id:
+            self.headers["X-User-ID"] = self.user_id
+        if self.chat_id:
+            self.headers["X-Chat-ID"] = self.chat_id
 
     def __before_jwt_request(self):
         if self.token:
             self.headers["Authorization"] = f"Bearer {self.token}"
         if self.agent_id:
-            self.headers["agent_id"] = self.agent_id
+            self.headers["X-Agent-ID"] = self.agent_id
+        if self.chat_id:
+            self.headers["X-Chat-ID"] = self.chat_id
 
-    def get_client(self, agent_id: str | None = None, user_id: str | None = None) -> BaseUrlSession:
+    def get_client(
+        self,
+        agent_id: str | None = None,
+        user_id: str | None = None,
+        chat_id: str | None = None,
+    ) -> BaseUrlSession:
         if not self.apikey and not self.token:
             raise ValueError("You must provide an apikey or a token")
 
         self.agent_id = agent_id
         self.user_id = user_id
+        self.chat_id = chat_id
 
         for middleware in self.middlewares:
             middleware()
 
+        return self.get_base_session()
+
+    def get_base_session(self) -> BaseUrlSession:
         session = BaseUrlSession(base_url=self.get_http_uri())
         session.headers = self.headers
 

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/cheshirecat_python_sdk/clients/websocket_client.py

@@ -22,28 +22,37 @@ class WSClient:
         self.token = token
         return self
 
-    def get_ws_uri(self, agent_id: str, user_id: str) -> str:
+    def get_ws_uri(
+        self,
+        agent_id: str,
+        user_id: str,
+        chat_id: str | None = None,
+    ) -> str:
         query = {"user_id": user_id}
-        if self.token:
-            query["token"] = self.token
-        elif self.apikey:
-            query["apikey"] = self.apikey
-        else:
-            raise ValueError("You must provide an apikey or a token")
 
         scheme = "wss" if self.is_wss else "ws"
         path = f"ws/{agent_id}"
+        if chat_id:
+            path += f"/{chat_id}"
+
         query_string = urlencode(query)
         port_suffix = f":{self.port}" if self.port else ""
 
         return f"{scheme}://{self.host}{port_suffix}/{path}?{query_string}"
 
-    async def get_client(self, agent_id: str, user_id: str) -> ClientConnection:
-        uri = self.get_ws_uri(agent_id, user_id)
+    async def get_client(self, agent_id: str, user_id: str, chat_id: str | None = None) -> ClientConnection:
+        uri = self.get_ws_uri(agent_id, user_id, chat_id)
         if self.ws_client is None:
             try:
+                if self.token:
+                    headers = {"Authorization": f"Bearer {self.token}"}
+                elif self.apikey:
+                    headers = {"Authorization": f"Bearer {self.apikey}"}
+                else:
+                    raise ValueError("You must provide an apikey or a token")
+
                 # Create a WebSocket connection
-                websocket = await connect(uri, ping_interval=100000, ping_timeout=100000)
+                websocket = await connect(uri, ping_interval=100000, ping_timeout=100000, additional_headers=headers)
                 self.ws_client = websocket
             except InvalidURI as e:
                 raise ValueError(f"Invalid WebSocket URI: {uri}") from e

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/cheshirecat_python_sdk/configuration.py

@@ -7,5 +7,5 @@ class Configuration(BaseModel):
     """
     host: str = "localhost"
     port: int = 1865
-    auth_key: str = ""
+    auth_key: str | None = None
     secure_connection: bool = False

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/cheshirecat_python_sdk/endpoints/__init__.py

@@ -1,6 +1,8 @@
 from cheshirecat_python_sdk.endpoints.admins import AdminsEndpoint
+from cheshirecat_python_sdk.endpoints.auth import AuthEndpoint
 from cheshirecat_python_sdk.endpoints.auth_handler import AuthHandlerEndpoint
 from cheshirecat_python_sdk.endpoints.chunker import ChunkerEndpoint
+from cheshirecat_python_sdk.endpoints.conversation import ConversationEndpoint
 from cheshirecat_python_sdk.endpoints.custom_endpoint import CustomEndpoint
 from cheshirecat_python_sdk.endpoints.embedder import EmbedderEndpoint
 from cheshirecat_python_sdk.endpoints.file_manager import FileManagerEndpoint
@@ -9,6 +11,7 @@ from cheshirecat_python_sdk.endpoints.memory import MemoryEndpoint
 from cheshirecat_python_sdk.endpoints.message import MessageEndpoint
 from cheshirecat_python_sdk.endpoints.plugins import PluginsEndpoint
 from cheshirecat_python_sdk.endpoints.rabbit_hole import RabbitHoleEndpoint
-from cheshirecat_python_sdk.endpoints.settings import SettingsEndpoint
 from cheshirecat_python_sdk.endpoints.users import UsersEndpoint
+from cheshirecat_python_sdk.endpoints.utils import UtilsEndpoint
 from cheshirecat_python_sdk.endpoints.vector_database import VectorDatabaseEndpoint
+from cheshirecat_python_sdk.endpoints.health_check import HealthCheckEndpoint

cheshirecat_python_sdk-1.7.11/cheshirecat_python_sdk/endpoints/admins.py

@@ -0,0 +1,100 @@
+from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint, MultipartPayload
+from cheshirecat_python_sdk.models.api.admins import (
+    PluginInstallOutput,
+    PluginInstallFromRegistryOutput,
+    PluginDetailsOutput,
+    PluginDeleteOutput,
+)
+from cheshirecat_python_sdk.models.api.nested.plugins import PluginSettingsOutput
+from cheshirecat_python_sdk.models.api.plugins import PluginCollectionOutput, PluginsSettingsOutput, PluginToggleOutput
+from cheshirecat_python_sdk.utils import file_attributes
+
+
+class AdminsEndpoint(AbstractEndpoint):
+    def __init__(self, client: "CheshireCatClient"):
+        super().__init__(client)
+        self.prefix = "/plugins"
+
+    def get_available_plugins(self, plugin_name: str | None = None) -> PluginCollectionOutput:
+        """
+        Get a list of all available plugins.
+        :param plugin_name: The name of the plugin.
+        :return: PluginCollectionOutput, the details of the plugins.
+        """
+        return self.get(
+            self.format_url("/installed"),
+            self.system_id,
+            output_class=PluginCollectionOutput,
+            query={"query": plugin_name} if plugin_name else None,
+        )
+
+    def post_install_plugin_from_zip(self, path_zip: str) -> PluginInstallOutput:
+        payload = MultipartPayload()
+
+        with open(path_zip, "rb") as file:
+            payload.files = [("file", file_attributes(path_zip, file))]
+            result = self.post_multipart(
+                self.format_url("/install/upload"),
+                self.system_id,
+                output_class=PluginInstallOutput,
+                payload=payload,
+            )
+        return result
+
+    def post_install_plugin_from_registry(self, url: str) -> PluginInstallFromRegistryOutput:
+        """
+        Install a new plugin from a registry. The plugin is installed asynchronously.
+        :param url: The URL of the plugin.
+        :return: PluginInstallFromRegistryOutput, the details of the installation.
+        """
+        return self.post_json(
+            self.format_url("/install/registry"),
+            self.system_id,
+            output_class=PluginInstallFromRegistryOutput,
+            payload={"url": url},
+        )
+
+    def get_plugins_settings(self) -> PluginsSettingsOutput:
+        """
+        Get the default settings of all the plugins.
+        :return: PluginsSettingsOutput, the details of the settings.
+        """
+        return self.get(self.format_url("/system/settings"), self.system_id, output_class=PluginsSettingsOutput)
+
+    def get_plugin_settings(self, plugin_id: str) -> PluginSettingsOutput:
+        """
+        Get the default settings of a specific plugin.
+        :param plugin_id: The ID of the plugin.
+        :return: PluginSettingsOutput, the details of the settings.
+        """
+        return self.get(
+            self.format_url(f"/system/settings/{plugin_id}"), self.system_id, output_class=PluginSettingsOutput
+        )
+
+    def get_plugin_details(self, plugin_id: str) -> PluginDetailsOutput:
+        """
+        Get the details of a specific plugin.
+        :param plugin_id: The ID of the plugin.
+        :return: PluginDetailsOutput, the details of the plugin.
+        """
+        return self.get(self.format_url(f"/system/details/{plugin_id}"), self.system_id, output_class=PluginDetailsOutput)
+
+    def delete_plugin(self, plugin_id: str) -> PluginDeleteOutput:
+        """
+        Delete a specific plugin.
+        :param plugin_id: The ID of the plugin.
+        :return: PluginDeleteOutput, the details of the plugin.
+        """
+        return self.delete(self.format_url(f"/uninstall/{plugin_id}"), self.system_id, output_class=PluginDeleteOutput)
+
+    def put_toggle_plugin(self, plugin_id: str) -> PluginToggleOutput:
+        """
+        This endpoint toggles a plugin, on a system level
+        :param plugin_id: The id of the plugin to toggle
+        :return: PluginToggleOutput, the toggled plugin
+        """
+        return self.put(
+            self.format_url(f"/system/toggle/{plugin_id}"),
+            self.system_id,
+            output_class=PluginToggleOutput,
+        )

cheshirecat_python_sdk-1.7.11/cheshirecat_python_sdk/endpoints/auth.py

@@ -0,0 +1,54 @@
+from typing import Any
+
+from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
+from cheshirecat_python_sdk.models.api.tokens import TokenOutput, MeOutput
+from cheshirecat_python_sdk.utils import deserialize
+
+
+class AuthEndpoint(AbstractEndpoint):
+    def __init__(self, client: "CheshireCatClient"):
+        super().__init__(client)
+        self.prefix = "/auth"
+
+    def token(self, username: str, password: str) -> TokenOutput:
+        """
+        This endpoint is used to get a token for the user. The token is used to authenticate the user in the system. When
+        the token expires, the user must request a new token.
+        """
+        response = self.get_http_session().post(
+            self.format_url("/token"),
+            json={
+                "username": username,
+                "password": password,
+            },
+        )
+        response.raise_for_status()
+
+        result = deserialize(response.json(), TokenOutput)
+        self.client.add_token(result.access_token)
+
+        return result
+
+    def get_available_permissions(self) -> dict[int | str, Any]:
+        """
+        This endpoint is used to get a list of available permissions in the system. The permissions are used to define
+        the access rights of the users in the system. The permissions are defined by the system administrator.
+        :return array<int|string, Any>, the available permissions
+        """
+        response = self.get_http_client().get(self.format_url("/available-permissions"))
+        response.raise_for_status()
+
+        return response.json()
+
+    def me(self, token: str) -> MeOutput:
+        """
+        This endpoint is used to get the current user information. The user information includes the list of agents
+        the user has access to. This endpoint requires authentication.
+        """
+        self.client.add_token(token)
+
+        response = self.get_http_client().get("/me")
+        response.raise_for_status()
+
+        result = deserialize(response.json(), MeOutput)
+        return result

{cheshirecat_python_sdk-1.3.9 → cheshirecat_python_sdk-1.7.11}/cheshirecat_python_sdk/endpoints/base.py

@@ -2,6 +2,7 @@ from abc import ABC
 from typing import Dict, Any, List, Tuple, Type
 import requests
 from pydantic import BaseModel
+from requests_toolbelt.sessions import BaseUrlSession
 from websockets import ClientConnection
 
 from cheshirecat_python_sdk.utils import T, deserialize
@@ -21,11 +22,19 @@ class AbstractEndpoint(ABC):
     def format_url(self, endpoint: str) -> str:
         return f"/{self.prefix}/{endpoint}".replace("//", "/")
 
-    def get_http_client(self, agent_id: str | None = None, user_id: str | None = None) -> requests.Session:
-        return self.client.http_client.get_client(agent_id, user_id)
+    def get_http_client(
+        self,
+        agent_id: str | None = None,
+        user_id: str | None = None,
+        chat_id: str | None = None,
+    ) -> requests.Session:
+        return self.client.http_client.get_client(agent_id, user_id, chat_id)
 
-    async def get_ws_client(self, agent_id: str, user_id: str) -> ClientConnection:
-        return await self.client.ws_client.get_client(agent_id, user_id)
+    def get_http_session(self) -> BaseUrlSession:
+        return self.client.http_client.get_base_session()
+
+    async def get_ws_client(self, agent_id: str, user_id: str, chat_id: str | None = None) -> ClientConnection:
+        return await self.client.ws_client.get_client(agent_id, user_id, chat_id)
 
     def get(
         self,
@@ -53,12 +62,13 @@ class AbstractEndpoint(ABC):
         output_class: Type[T] | None = None,
         payload: Dict[str, Any] | None = None,
         user_id: str | None = None,
+        chat_id: str | None = None,
     ) -> T:
         options = {}
         if payload:
             options["json"] = payload
 
-        response = self.get_http_client(agent_id, user_id).post(endpoint, **options)
+        response = self.get_http_client(agent_id, user_id, chat_id).post(endpoint, **options)
         response.raise_for_status()
 
         if output_class is None:

cheshirecat_python_sdk-1.7.11/cheshirecat_python_sdk/endpoints/conversation.py

@@ -0,0 +1,83 @@
+from typing import List
+
+from cheshirecat_python_sdk.endpoints.base import AbstractEndpoint
+from cheshirecat_python_sdk.models.api.conversations import (
+    ConversationHistoryOutput,
+    ConversationDeleteOutput,
+    ConversationsResponse,
+    ConversationNameChangeOutput,
+)
+from cheshirecat_python_sdk.utils import deserialize
+
+
+class ConversationEndpoint(AbstractEndpoint):
+    def __init__(self, client: "CheshireCatClient"):
+        super().__init__(client)
+        self.prefix = "/conversation"
+
+    def get_conversation_history(self, agent_id: str, user_id: str, chat_id: str) -> ConversationHistoryOutput:
+        """
+        This endpoint returns the conversation history.
+        :param agent_id: The agent ID.
+        :param user_id: The user ID to filter the conversation history.
+        :param chat_id: The chat ID to filter the conversation history.
+        :return: ConversationHistoryOutput, a list of conversation history entries.
+        """
+        return self.get(
+            self.format_url(chat_id),
+            agent_id,
+            user_id=user_id,
+            output_class=ConversationHistoryOutput,
+        )
+
+    def get_conversations(self, agent_id: str, user_id: str) -> List[ConversationsResponse]:
+        """
+        This endpoint returns the attributes of the different conversations, given the `agent_id` and the `user_id`.
+        :param agent_id: The agent ID.
+        :param user_id: The user ID to filter the conversation history.
+        :return: List[ConversationsResponse], a list of conversation attributes.
+        """
+        response = self.get_http_client(agent_id, user_id).get(self.prefix)
+        response.raise_for_status()
+
+        return [deserialize(item, ConversationsResponse) for item in response.json()]
+
+    def delete_conversation(self, agent_id: str, user_id: str, chat_id: str) -> ConversationDeleteOutput:
+        """
+        This endpoint deletes the conversation.
+        :param agent_id: The agent ID.
+        :param user_id: The user ID to filter the conversation history.
+        :param chat_id: The chat ID to filter the conversation history.
+        :return: ConversationDeleteOutput, a message indicating whether the conversation was deleted.
+        """
+        return self.delete(
+            self.format_url(chat_id),
+            agent_id,
+            output_class=ConversationDeleteOutput,
+            user_id=user_id,
+        )
+
+    def post_conversation_name(
+        self,
+        name: str,
+        agent_id: str,
+        user_id: str,
+        chat_id: str,
+    ) -> ConversationNameChangeOutput:
+        """
+        This endpoint creates a new element in the conversation history.
+        :param name: The new name to assign to the conversation
+        :param agent_id: The agent ID.
+        :param user_id: The user ID to filter the conversation history.
+        :param chat_id: The chat ID to filter the conversation history.
+        :return: ConversationNameChangeOutput, a message indicating whether the conversation name was changed.
+        """
+        payload = {"name": name}
+
+        return self.post_json(
+            self.format_url(chat_id),
+            agent_id,
+            output_class=ConversationNameChangeOutput,
+            payload=payload,
+            user_id=user_id,
+        )