🎨 Update chatbot client (#8664)

bisgaard-itis · web-flow · commit 3d5e1bd34f71 · 2025-12-05T22:03:53.000Z
diff --git a/services/web/server/src/simcore_service_webserver/chatbot/_client.py b/services/web/server/src/simcore_service_webserver/chatbot/_client.py
@@ -1,18 +1,44 @@
 import logging
-from typing import Annotated, Any, Final
+from typing import Annotated, Any, Final, Literal
 
 import httpx
 from aiohttp import web
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 from servicelib.mimetype_constants import MIMETYPE_APPLICATION_JSON
 
+from .exceptions import NoResponseFromChatbotError
 from .settings import ChatbotSettings, get_plugin_settings
 
 _logger = logging.getLogger(__name__)
 
 
+class ResponseMessage(BaseModel):
+    content: str
+
+
+class ResponseItem(BaseModel):
+    index: int  # 0-based index of the response
+    message: ResponseMessage
+
+
 class ChatResponse(BaseModel):
-    answer: Annotated[str, Field(description="Answer from the chatbot")]
+    id: str  # unique identifier for the chat response
+    choices: Annotated[list[ResponseItem], Field(description="Answer from the chatbot")]
+
+
+class Message(BaseModel):
+    role: Literal["user", "assistant", "developer"]
+    content: Annotated[str, Field(description="Content of the message")]
+    name: Annotated[
+        str | None, Field(description="Optional name of the message sender")
+    ] = None
+
+    @model_validator(mode="after")
+    def check_name_requires_user_role(self) -> "Message":
+        if self.name is not None and self.role != "user":
+            msg = "Currently the chatbot only supports name for the user role"
+            raise ValueError(msg)
+        return self
 
 
 class ChatbotRestClient:
@@ -38,17 +64,19 @@ async def _request() -> httpx.Response:
             )
             raise
 
-    async def ask_question(self, question: str) -> ChatResponse:
-        """Asks a question to the chatbot"""
-        url = httpx.URL(self._chatbot_settings.base_url).join("/v1/chat")
+    async def send(self, messages: list[Message]) -> ResponseMessage:
+        """Send a list of messages to the chatbot and returns the chatbot's response message."""
+        url = httpx.URL(self._chatbot_settings.base_url).join("/v1/chat/completions")
 
         async def _request() -> httpx.Response:
             return await self._client.post(
                 url,
                 json={
-                    "question": question,
-                    "llm": self._chatbot_settings.CHATBOT_LLM_MODEL,
-                    "embedding_model": self._chatbot_settings.CHATBOT_EMBEDDING_MODEL,
+                    "messages": [
+                        msg.model_dump(mode="json", exclude_none=True)
+                        for msg in messages
+                    ],
+                    "model": self._chatbot_settings.CHATBOT_MODEL,
                 },
                 headers={
                     "Content-Type": MIMETYPE_APPLICATION_JSON,
@@ -60,7 +88,11 @@ async def _request() -> httpx.Response:
         try:
             response = await _request()
             response.raise_for_status()
-            return ChatResponse.model_validate(response.json())
+            chat_response = ChatResponse.model_validate(response.json())
+            if len(chat_response.choices) == 0:
+                raise NoResponseFromChatbotError(chat_completion_id=chat_response.id)
+            return chat_response.choices[0].message
+
         except Exception:
             _logger.error(  # noqa: TRY400
                 "Failed to ask question to chatbot at %s", url
diff --git a/services/web/server/src/simcore_service_webserver/chatbot/_process_chatbot_trigger_service.py b/services/web/server/src/simcore_service_webserver/chatbot/_process_chatbot_trigger_service.py
@@ -1,21 +1,25 @@
 import functools
 import logging
 from collections.abc import AsyncIterator
-from typing import Final
+from typing import Final, Literal, NamedTuple
 
 from aiohttp import web
 from models_library.basic_types import IDStr
 from models_library.conversations import ConversationMessageType, ConversationUserType
+from models_library.groups import GroupID
 from models_library.rabbitmq_messages import WebserverChatbotRabbitMessage
 from models_library.rest_ordering import OrderBy, OrderDirection
 from pydantic import TypeAdapter
-from servicelib.logging_utils import log_context
+from servicelib.logging_utils import log_catch, log_context, log_decorator
 from servicelib.rabbitmq import RabbitMQClient
 
 from ..conversations import conversations_service
 from ..conversations.errors import ConversationErrorNotFoundError
+from ..groups.api import list_group_members
 from ..products import products_service
 from ..rabbitmq import get_rabbitmq_client
+from ..users import users_service
+from ._client import Message
 from .chatbot_service import get_chatbot_rest_client
 
 _logger = logging.getLogger(__name__)
@@ -28,60 +32,113 @@
 _CHATBOT_PROCESS_MESSAGE_TTL_IN_MS = 2 * 60 * 60 * 1000  # 2 hours
 
 
+class _Role(NamedTuple):
+    role: Literal["user", "assistant", "developer"]
+    name: str | None = None
+
+
+_SUPPORT_ROLE_NAME: Final[str] = "support-team-member"
+
+_CHATBOT_INSTRUCTION_MESSAGE: Final[
+    str
+] = """
+    This conversation takes place in the context of the {product} product. Only answer questions related to this product.
+    The user '{support_role_name}' is a support team member and is assisting users of the {product} product
+    with their inquiries. Help the user by providing answers to their questions. Make your answers concise and to the point.
+    Address users by their name. Be friendly and accommodating.
+    """
+
+
+async def _get_role(
+    *,
+    app: web.Application,
+    message_gid: GroupID,
+    chatbot_primary_gid: GroupID,
+    support_group_primary_gids: set[GroupID],
+) -> _Role:
+    if message_gid == chatbot_primary_gid:
+        return _Role(role="assistant")
+    if message_gid in support_group_primary_gids:
+        return _Role(role="user", name=_SUPPORT_ROLE_NAME)
+    user_id = await users_service.get_user_id_from_gid(app=app, primary_gid=message_gid)
+    user_full_name = await users_service.get_user_fullname(app=app, user_id=user_id)
+    return _Role(role="user", name=user_full_name["first_name"])
+
+
+@log_decorator(_logger, logging.DEBUG)
 async def _process_chatbot_trigger_message(app: web.Application, data: bytes) -> bool:
     rabbit_message = TypeAdapter(WebserverChatbotRabbitMessage).validate_json(data)
     assert app  # nosec
 
-    with log_context(
-        _logger,
-        logging.DEBUG,
-        msg=f"Processing chatbot trigger message for conversation ID {rabbit_message.conversation.conversation_id}",
-    ):
-        _product_name = rabbit_message.conversation.product_name
-        _product = products_service.get_product(app, product_name=_product_name)
+    with log_catch(logger=_logger, reraise=False):
+        product_name = rabbit_message.conversation.product_name
+        product = products_service.get_product(app, product_name=product_name)
 
-        if _product.support_chatbot_user_id is None:
+        if product.support_chatbot_user_id is None:
             _logger.error(
                 "Product %s does not have support_chatbot_user_id configured, cannot process chatbot message. (This should not happen)",
-                _product_name,
+                product_name,
             )
             return True  # return true to avoid re-processing
+        support_group_primary_gids = set()
+        if product.support_standard_group_id is not None:
+            support_group_primary_gids = {
+                elm.primary_gid
+                for elm in await list_group_members(
+                    app, product.support_standard_group_id
+                )
+            }
+
+        chatbot_primary_gid = await users_service.get_user_primary_group_id(
+            app=app, user_id=product.support_chatbot_user_id
+        )
 
         # Get last 20 messages for the conversation ID
         with log_context(
             _logger,
             logging.DEBUG,
             msg=f"Listed messages for conversation ID {rabbit_message.conversation.conversation_id}",
         ):
-            _, messages = await conversations_service.list_messages_for_conversation(
-                app=app,
-                conversation_id=rabbit_message.conversation.conversation_id,
-                offset=0,
-                limit=20,
-                order_by=OrderBy(field=IDStr("created"), direction=OrderDirection.DESC),
+            _, messages_in_db = (
+                await conversations_service.list_messages_for_conversation(
+                    app=app,
+                    conversation_id=rabbit_message.conversation.conversation_id,
+                    offset=0,
+                    limit=20,
+                    order_by=OrderBy(
+                        field=IDStr("created"), direction=OrderDirection.DESC
+                    ),
+                )
             )
 
-        _question_for_chatbot = ""
-        for inx, msg in enumerate(messages):
-            if inx == 0:
-                # Make last message stand out as the question
-                _question_for_chatbot += (
-                    "User last message: \n"
-                    f"{msg.content.strip()} \n\n"
-                    "Previous messages in the conversation: \n"
-                )
-            else:
-                _question_for_chatbot += f"{msg.content.strip()}\n"
+        messages = []
+        for msg in messages_in_db:
+            role = await _get_role(
+                app=app,
+                message_gid=msg.user_group_id,
+                chatbot_primary_gid=chatbot_primary_gid,
+                support_group_primary_gids=support_group_primary_gids,
+            )
+            messages.append(
+                Message(role=role.role, name=role.name, content=msg.content)
+            )
+        context_message = Message(
+            role="developer",
+            content=_CHATBOT_INSTRUCTION_MESSAGE.format(
+                product=product_name,
+                support_role_name=_SUPPORT_ROLE_NAME,
+            ),
+        )
+        messages.append(context_message)
 
         # Talk to the chatbot service
-
         with log_context(
             _logger,
             logging.DEBUG,
             msg=f"Asking question from chatbot conversation ID {rabbit_message.conversation.conversation_id}",
         ):
             chatbot_client = get_chatbot_rest_client(app)
-            chat_response = await chatbot_client.ask_question(_question_for_chatbot)
+            response_message = await chatbot_client.send(messages)
 
         try:
             with log_context(
@@ -92,10 +149,10 @@ async def _process_chatbot_trigger_message(app: web.Application, data: bytes) ->
                 await conversations_service.create_support_message(
                     app=app,
                     product_name=rabbit_message.conversation.product_name,
-                    user_id=_product.support_chatbot_user_id,
+                    user_id=product.support_chatbot_user_id,
                     conversation_user_type=ConversationUserType.CHATBOT_USER,
                     conversation=rabbit_message.conversation,
-                    content=chat_response.answer,
+                    content=response_message.content,
                     type_=ConversationMessageType.MESSAGE,
                 )
         except ConversationErrorNotFoundError:
diff --git a/services/web/server/src/simcore_service_webserver/chatbot/exceptions.py b/services/web/server/src/simcore_service_webserver/chatbot/exceptions.py
@@ -0,0 +1,11 @@
+from common_library.errors_classes import OsparcErrorMixin
+
+
+class BaseChatbotException(OsparcErrorMixin, Exception):
+    """Base exception for chatbot errors"""
+
+
+class NoResponseFromChatbotError(BaseChatbotException):
+    msg_template = (
+        "No response received from chatbot for chat completion {chat_completion_id}"
+    )
diff --git a/services/web/server/src/simcore_service_webserver/chatbot/settings.py b/services/web/server/src/simcore_service_webserver/chatbot/settings.py
@@ -14,8 +14,7 @@ class ChatbotSettings(BaseCustomSettings, MixinServiceSettings):
 
     CHATBOT_HOST: str
     CHATBOT_PORT: PortInt
-    CHATBOT_LLM_MODEL: str = "gpt-3.5-turbo"
-    CHATBOT_EMBEDDING_MODEL: str = "openai/text-embedding-3-large"
+    CHATBOT_MODEL: str = "gpt-4o-mini"
 
     @cached_property
     def base_url(self) -> str:
diff --git a/services/web/server/tests/unit/with_dbs/04/chatbot/conftest.py b/services/web/server/tests/unit/with_dbs/04/chatbot/conftest.py
@@ -4,14 +4,22 @@
 # pylint: disable=too-many-arguments
 # pylint: disable=too-many-statements
 
-from collections.abc import Iterator
+from collections.abc import AsyncIterator, Iterator
 
 import httpx
 import pytest
 import respx
+from aiohttp.test_utils import TestClient
+from faker import Faker
 from pytest_mock import MockerFixture, MockType
 from pytest_simcore.helpers.monkeypatch_envs import setenvs_from_dict
 from pytest_simcore.helpers.typing_env import EnvVarsDict
+from pytest_simcore.helpers.webserver_users import NewUser, UserInfoDict
+from simcore_service_webserver.chatbot._client import (
+    ChatResponse,
+    ResponseItem,
+    ResponseMessage,
+)
 from simcore_service_webserver.products import products_service
 
 
@@ -30,29 +38,56 @@ def app_environment(
 
 
 @pytest.fixture
-def mocked_chatbot_api() -> Iterator[respx.MockRouter]:
+def mocked_chatbot_api(faker: Faker) -> Iterator[respx.MockRouter]:
     _BASE_URL = "http://chatbot:8000"
 
     # Define responses in the order they will be called during the test
     chatbot_answer_responses = [
-        {"answer": "42"},
+        ChatResponse(
+            id=f"{faker.uuid4()}",
+            choices=[ResponseItem(index=0, message=ResponseMessage(content="42"))],
+        )
     ]
 
     with respx.mock(base_url=_BASE_URL) as mock:
         # Create a side_effect that returns responses in sequence
-        mock.post(path="/v1/chat").mock(
+        mock.post(path="/v1/chat/completions").mock(
             side_effect=[
-                httpx.Response(200, json=response)
+                httpx.Response(200, json=response.model_dump(mode="json"))
                 for response in chatbot_answer_responses
             ]
         )
         yield mock
 
 
 @pytest.fixture
-def mocked_get_current_product(mocker: MockerFixture) -> MockType:
+async def chatbot_user(client: TestClient) -> AsyncIterator[UserInfoDict]:
+    async with NewUser(
+        user_data={
+            "name": "chatbot user",
+        },
+        app=client.app,
+    ) as user_info:
+        yield user_info
+
+
+@pytest.fixture
+async def support_team_user(client: TestClient) -> AsyncIterator[UserInfoDict]:
+    async with NewUser(
+        user_data={
+            "name": "support team user",
+        },
+        app=client.app,
+    ) as user_info:
+        yield user_info
+
+
+@pytest.fixture
+def mocked_get_current_product(
+    chatbot_user: UserInfoDict, mocker: MockerFixture
+) -> MockType:
     mock = mocker.patch.object(products_service, "get_product")
     mocked_product = mocker.Mock()
-    mocked_product.support_chatbot_user_id = 123
+    mocked_product.support_chatbot_user_id = chatbot_user["id"]
     mock.return_value = mocked_product
     return mock
diff --git a/services/web/server/tests/unit/with_dbs/04/chatbot/test_chatbot_client.py b/services/web/server/tests/unit/with_dbs/04/chatbot/test_chatbot_client.py
diff --git a/services/web/server/tests/unit/with_dbs/04/chatbot/test_process_chatbot_trigger_message.py b/services/web/server/tests/unit/with_dbs/04/chatbot/test_process_chatbot_trigger_message.py
