feat: initial implement end-to-end business with mock-chat-agent-client response and validation logic.

app/agent/chat_agent_client.py

@@ -0,0 +1,14 @@
+from app.agent.chat_agent_scheme import UserChatAgentRequest, AssistantChatAgentResponse
+
+
+class ChatAgentClient:
+    def __init__(self):
+        self.agent_name = "ChatAgentClient"
+
+    def process(self, user_chat_agent_request: UserChatAgentRequest) -> AssistantChatAgentResponse:
+        # TODO implement the logic to process the chat
+        agent_name = self.agent_name
+        return AssistantChatAgentResponse(
+            message=f"Here is the {agent_name} Processed message: This is a placeholder response for the user-question",
+            figure=None,  # Placeholder for any figure data if needed
+        )

app/agent/chat_agent_scheme.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+
+class UserChatAgentRequest(BaseModel):
+    message: str
+
+
+class AssistantChatAgentResponse(BaseModel):
+    message: str
+    figure: dict | None = None

app/api/chat_api.py

@@ -3,7 +3,7 @@
 from typing import Any, List, Optional
 from fastapi import APIRouter, HTTPException, Depends, Request
 from pydantic import BaseModel
-from app.schema.chat_schema import ChatCompletionRequest, ChatCompletionResponse, MessageResponse
+from app.schema.chat_schema import ChatCompletionRequest, ChatCompletionResponse, ChatMessageResponse
 from app.schema.conversation_schema import ConversationResponse, ConversationItemResponse
 from app.service.chat_service import ChatService
 from app.security.auth_service import AuthService
@@ -57,7 +57,7 @@ async def list_chat_completions(request: Request, username: str = Depends(auth_s
     page: int = 1
     limit: int = 10
     sort: dict = {"created_date": -1}
-    project: dict = None
+    project: dict = {}
 
     try:
         query = {"created_by": username}
@@ -80,7 +80,7 @@ async def retrieve_chat_completion(completion_id: str, request: Request, usernam
 
 
 # get all messages for a chat completion
-@router.get("/chat/completions/{completion_id}/messages", response_model=List[MessageResponse], deprecated=True)
+@router.get("/chat/completions/{completion_id}/messages", response_model=List[ChatMessageResponse], deprecated=True)
 async def list_messages(completion_id: str, request: Request, username: str = Depends(auth_service.verify_credentials)):
     """
     Get all messages for a chat completion

app/mapper/chat_mapper.py

@@ -1,6 +1,6 @@
 from app.mapper.base_mapper import BaseMapper
-from app.model.chat_model import ChatCompletion, ChatMessage
-from app.schema.chat_schema import ChatCompletionResponse, ChatCompletionRequest, MessageResponse, ChoiceResponse
+from app.model.chat_model import ChatCompletion, ChatMessageModel
+from app.schema.chat_schema import ChatCompletionResponse, ChatCompletionRequest, ChatMessageResponse, ChoiceResponse
 
 
 class ChatMapper(BaseMapper[ChatCompletion, ChatCompletionResponse]):
@@ -15,11 +15,12 @@ class ChatMapper(BaseMapper[ChatCompletion, ChatCompletionResponse]):
         last_message = model.messages[-1] if model.messages else None
         message_response = None
         if last_message:
-            message_response = MessageResponse(
+            message_response = ChatMessageResponse(
                 message_id=last_message.message_id,
                 role=last_message.role,
                 content=last_message.content,
                 figure=last_message.figure,
+                created_date=last_message.created_date,
             )
 
         # Create choice response
@@ -35,11 +36,19 @@ class ChatMapper(BaseMapper[ChatCompletion, ChatCompletionResponse]):
         messages = []
         if schema.messages:
             for msg in schema.messages:
-                messages.append(ChatMessage(role=msg.role, content=msg.content))
+                messages.append(ChatMessageModel(role=msg.role, content=msg.content, figure=None, message_id=None))
 
         return ChatCompletion(
+            title=schema.title,
             completion_id=schema.completion_id,
-            model=schema.model or "gpt-4o",  # Default model
+            model=schema.model,
             messages=messages,
-            stream=schema.stream or False,
+            stream=schema.stream,
+            created_by=schema.created_by,
+            created_date=schema.created_date,
+            object_field=schema.object_field,
+            is_archived=schema.archived,
+            is_starred=schema.starred,
+            last_updated_by=schema.last_updated_by,
+            last_updated_date=schema.last_updated_date,
         )

app/model/chat_model.py

@@ -51,13 +51,13 @@ from typing import List, Optional, Any
 # }
 
 
-class ChatMessage(BaseModel):
+class ChatMessageModel(BaseModel):
     """
     A message in a chat completion.
     """
 
-    message_id: str = Field(..., description="The unique identifier for the message")
-    role: Optional[str] = Field(None, description="The role of the message sender", examples=["user", "assistant", "system"])
+    message_id: Optional[str] = Field(None, description="The unique identifier for the message")
+    role: str = Field(..., description="The role of the message sender", examples=["user", "assistant", "system"])
     content: str = Field(..., description="The content of the message")
     figure: Optional[dict[str, Any]] = Field(None, description="The figure data for visualization")
     created_date: datetime = Field(default_factory=datetime.now, description="The timestamp of the message")
@@ -89,7 +89,7 @@ class ChatCompletion(BaseModel):
 
     # openai compatible fields
     model: Optional[str] = Field(None, description="The model used for the chat completion", examples=["gpt-4o-mini", "gpt-4o", "gpt-3.5-turbo"])
-    messages: Optional[List[ChatMessage]] = Field(None, description="The messages in the chat completion")
+    messages: Optional[List[ChatMessageModel]] = Field(None, description="The messages in the chat completion")
 
     # not implemented yet
     # temperature: float = Field(default=0.7,ge=0.0, le=1.0, description="What sampling temperature to use, between 0 and 1. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic.")

app/repository/chat_repository.py

@@ -1,8 +1,7 @@
 from typing import Any, List, Optional
 from app.db.factory import db_client
-from app.model.chat_model import ChatMessage, ChatCompletion
+from app.model.chat_model import ChatMessageModel, ChatCompletion
 from loguru import logger
-import uuid
 import pymongo
 
 
@@ -21,7 +20,7 @@ class ChatRepository:
         self.db = db_client.db
         self.collection = "chat_completion"
 
-    async def _create(self, entity: ChatCompletion) -> ChatCompletion:
+    async def create(self, entity: ChatCompletion) -> ChatCompletion:
         """
         Create a new chat completion in the database.
 
@@ -48,7 +47,7 @@ class ChatRepository:
         logger.info(f"Successfully created new chat completion with ID: {entity.completion_id}")
         return await self.find_by_id(entity.completion_id)
 
-    async def _update(self, entity: ChatCompletion) -> ChatCompletion:
+    async def update(self, entity: ChatCompletion) -> ChatCompletion:
         """
         Update an existing chat completion in the database.
 
@@ -108,9 +107,9 @@ class ChatRepository:
         try:
             result = await self.find_by_id(entity.completion_id)
             if result:
-                return await self._update(entity)
+                return await self.update(entity)
             else:
-                return await self._create(entity)
+                return await self.create(entity)
         except Exception as e:
             logger.error(f"Error saving chat completion: {e}")
             raise
@@ -118,7 +117,7 @@ class ChatRepository:
             logger.debug("END REPO: save chat completion")
 
     async def find(
-        self, query: dict = {}, page: int = 1, limit: int = 10, sort: dict = {"created_date": -1}, projection: dict = None
+        self, query: dict = {}, page: int = 1, limit: int = 10, sort: dict = {"created_date": -1}, projection: dict = {}
     ) -> List[ChatCompletion]:
         """
         Find a chat completion by a given query. with pagination
@@ -147,7 +146,7 @@ class ChatRepository:
         logger.debug(f"END REPO: find, returning {len(result_models)} models.")
         return result_models
 
-    async def find_by_id(self, completion_id: str, projection: dict = None) -> ChatCompletion:
+    async def find_by_id(self, completion_id: str, projection: dict = None) -> ChatCompletion | None:
         """
         Find a chat completion by a given id.
         Example : completion_id = "123"
@@ -169,7 +168,7 @@ class ChatRepository:
             logger.info(f"Chat completion with ID {completion_id} not found in DB.")
             return None
 
-    async def find_messages(self, completion_id: str) -> List[ChatMessage]:
+    async def find_messages(self, completion_id: str) -> List[ChatMessageModel]:
         """
         Find all messages for a given chat completion id.
         Example : completion_id = "123"
@@ -181,7 +180,7 @@ class ChatRepository:
         if chat_doc and "messages" in chat_doc and chat_doc["messages"]:
             try:
                 messages_list = [
-                    ChatMessage(
+                    ChatMessageModel(
                         message_id=item["message_id"],
                         role=item["role"],
                         content=item["content"],
@@ -215,16 +214,8 @@ class ChatRepository:
             logger.error(f"Error finding plot by message id: {e}")
             return None
 
-        # Mesajları Python tarafında filtreleyelim
         if entity_doc and "messages" in entity_doc and entity_doc["messages"]:
             try:
-                # İstenen message_id'ye sahip mesajı bul
-                # for message in entity_doc["messages"]:
-                #     if message["message_id"] == message_id:
-                #         figure = message.get("figure")
-                #         logger.debug(f"REPO find figure: {figure}")
-                #         return figure
-
                 match = next((message for message in entity_doc["messages"] if message["message_id"] == message_id), None)
                 if match:
                     figure = match.get("figure")

app/schema/chat_schema.py

@@ -3,7 +3,7 @@ from pydantic import BaseModel, Field
 from datetime import datetime
 
 
-class MessageRequest(BaseModel):
+class ChatMessageRequest(BaseModel):
     """
     Represents a message in a chat completion.
     """
@@ -22,11 +22,11 @@ class ChatCompletionRequest(BaseModel):
         description="The unique identifier for the chat completion. When starting a new chat, this will be a new UUID. When continuing a previous chat, this will be the same as the previous chat completion id.",
     )
     model: Optional[str] = Field(None, description="The model to use for the chat completion")
-    messages: Optional[List[MessageRequest]] = Field(None, description="The messages to use for the chat completion")
+    messages: Optional[List[ChatMessageRequest]] = Field(None, description="The messages to use for the chat completion")
     stream: Optional[bool] = Field(None, description="Whether to stream the chat completion")
 
 
-class MessageResponse(BaseModel):
+class ChatMessageResponse(BaseModel):
     """
     A chat completion message generated by the model.
     """
@@ -45,7 +45,7 @@ class ChoiceResponse(BaseModel):
         examples=["stop", "length", "content_filter"],
     )
     index: Optional[int] = Field(None, description="The index of the choice in the list of choices.")
-    message: Optional[MessageResponse] = Field(None, description="The message to use for the chat completion")
+    message: Optional[ChatMessageResponse] = Field(None, description="The message to use for the chat completion")
     # logprobs: str = None # not implemented yet
 
 
@@ -54,7 +54,7 @@ class ChatCompletionResponse(BaseModel):
     Represents a chat completion response returned by model, based on the provided input.
     """
 
-    completion_id: Optional[str] = Field(None, description="The unique identifier for the chat completion")
+    completion_id: str = Field(None, description="The unique identifier for the chat completion")
     choices: Optional[List[ChoiceResponse]] = Field(None, description="A list of chat completion choices.")
     created: Optional[int] = Field(None, description="The Unix timestamp (in seconds) of when the chat completion was created.")
     model: Optional[str] = Field(None, description="The model used for the chat completion")

app/service/chat_service.py

@@ -1,12 +1,17 @@
 import datetime
-from typing import Any, List, Optional
+from typing import Any, List
+
+from app.agent.chat_agent_scheme import UserChatAgentRequest
+from app.model.chat_model import ChatMessageModel
 from app.repository.chat_repository import ChatRepository
-from app.schema.chat_schema import ChatCompletionRequest, ChatCompletionResponse, MessageResponse
+from app.schema.chat_schema import ChatCompletionRequest, ChatCompletionResponse, ChatMessageResponse, ChatMessageRequest
 from app.mapper.chat_mapper import ChatMapper
 from app.mapper.conversation_mapper import ConversationMapper
 import uuid
 from loguru import logger
 from app.schema.conversation_schema import ConversationResponse
+from app.service.chat_validation import ChatValidation
+from app.agent.chat_agent_client import ChatAgentClient
 
 
 class ChatService:
@@ -14,6 +19,8 @@ class ChatService:
         self.chat_repository = ChatRepository()
         self.chat_mapper = ChatMapper()
         self.conversation_mapper = ConversationMapper()
+        self.chat_validation = ChatValidation()
+        self.chat_agent_client = ChatAgentClient()
 
     async def find(self, query: dict, page: int, limit: int, sort: dict, project: dict = None) -> List[ChatCompletionResponse]:
         logger.debug(f"BEGIN SERVICE: find for query: {query}, page: {page}, limit: {limit}, sort: {sort}, project: {project}")
@@ -24,12 +31,12 @@ class ChatService:
         entity = await self.chat_repository.find_by_id(completion_id, project)
         return self.chat_mapper.to_schema(entity) if entity else None
 
-    async def find_messages(self, completion_id: str) -> List[MessageResponse]:
+    async def find_messages(self, completion_id: str) -> List[ChatMessageResponse]:
         logger.debug(f"BEGIN SERVICE: find_messages for completion_id: {completion_id}")
         messages = await self.chat_repository.find_messages(completion_id)
         logger.debug(f"END SERVICE: find_messages for completion_id: {completion_id}, messages: {len(messages)}")
         messages_response = [
-            MessageResponse(
+            ChatMessageResponse(
                 message_id=message.message_id,
                 role=message.role,
                 content=message.content,
@@ -41,7 +48,7 @@ class ChatService:
         return messages_response
 
     # conversation service
-    async def find_all_conversations(self, username: str) -> List[ConversationResponse]:
+    async def find_all_conversations(self, username: str) -> ConversationResponse:
         """Find all conversations for a given username."""
         query = {"created_by": username}
         sort = {"last_updated_date": -1}  # Sort by last updated date in descending order
@@ -50,7 +57,8 @@ class ChatService:
         result = self.conversation_mapper.to_schema_list(entities)
         return ConversationResponse(items=result, total=len(result), limit=100, offset=0)
 
-    async def find_conversation_by_id(self, completion_id: str) -> ConversationResponse:
+    # conversation service
+    async def find_conversation_by_id(self, completion_id: str) -> ConversationResponse | None:
         """Find a conversation by its completion ID."""
         logger.debug(f"BEGIN SERVICE: find_conversation_by_id for completion_id: {completion_id}")
         projection = {"messages": 0, "_id": 0}
@@ -58,13 +66,13 @@ class ChatService:
         logger.debug(f"END SERVICE: find_conversation_by_id for completion_id: {completion_id}, entity: {entity}")
 
         if entity:
-            # Tekil kayıt için doğrudan dönüşüm yapıyoruz
-            result = self.conversation_mapper.to_schema(entity)
+            conversation_item = self.conversation_mapper.to_schema(entity)
+            result = ConversationResponse(items=[conversation_item], total=1, limit=1, offset=0)
             return result
         else:
             return None
 
-    async def find_plot_by_message(self, completion_id: str, message_id: str) -> Optional[dict[str, Any]]:
+    async def find_plot_by_message(self, completion_id: str, message_id: str) -> dict[str, Any]:
         logger.debug(f"BEGIN SERVICE: find_plot_by_message for completion_id: {completion_id}, message_id: {message_id}")
         figure = await self.chat_repository.find_plot_by_message(completion_id, message_id)
 
@@ -77,26 +85,94 @@ class ChatService:
         logger.debug(f"END SERVICE: find_plot_by_message for completion_id: {completion_id}, message_id: {message_id} with figure")
         return result
 
+    async def _save_chat_completion(self, request: ChatCompletionRequest, username: str) -> ChatCompletionResponse:
+        """
+        Save a chat completion to the database.
+        """
+        logger.debug(f"BEGIN SERVICE: for request: {request}, username: {username}")
+        try:
+            # Convert request to model
+            entity = self.chat_mapper.to_model(request)
+
+            entity.last_updated_by = username
+            entity.last_updated_date = datetime.datetime.now()
+            if entity.completion_id:
+                # generate a new chat completion
+                entity.completion_id = str(uuid.uuid4())
+            last_user_request_message = request.messages[-1]
+            current_entity = await self.chat_repository.find_by_id(entity.completion_id)
+            if not current_entity:
+                # create new chat completion with new user request message
+                entity.created_by = username
+                entity.created_date = datetime.datetime.now()
+                entity.last_updated_by = username
+                entity.last_updated_date = datetime.datetime.now()
+                # title can generate with LLM from user request message.content
+                entity.title = last_user_request_message.content[:20]
+                final_entity = await self.chat_repository.create(entity)
+            else:
+                # update existing chat completion with new user request message
+
+                message_model = ChatMessageModel(
+                    message_id=str(uuid.uuid4()),
+                    role=last_user_request_message.role,
+                    content=last_user_request_message.content,
+                    figure=None,
+                    created_date=datetime.datetime.now(),
+                )
+                current_entity.messages.append(message_model)
+                current_entity.last_updated_date = datetime.datetime.now()
+                final_entity = await self.chat_repository.update(current_entity)
+
+            # Convert model to response
+            result = self.chat_mapper.to_schema(final_entity)
+            logger.debug("END SERVICE")
+            return result
+        except Exception as e:
+            logger.error(f"Error saving chat completion: {e}")
+            raise
+
+    async def chat_agent_client_process(self, user_chat_completion: ChatCompletionRequest, username: str):
+        logger.debug(f"BEGIN SERVICE: Agentic Chat AI process. username: {username}")
+        last_user_message = user_chat_completion.messages[-1].content
+        user_chat_agent_request = UserChatAgentRequest(message=last_user_message)
+        result = self.chat_agent_client.process(user_chat_agent_request)
+        logger.debug("END SERVICE: Agentic Chat AI process")
+        return result
 
-
-
-    async def handle_chat_completion(self, request: ChatCompletionRequest, username: str) -> ChatCompletionResponse:
-        last_user_message = request.messages[-1].content
-        logger.debug(f"TODO implement ai-agent response for this message: {last_user_message}")
-
-        # Convert request to model
-        entity = self.chat_mapper.to_model(request)
-
-        if entity.completion_id:
-            entity.completion_id = str(uuid.uuid4())
-            entity.created_by = username
-            entity.created_date = datetime.datetime.now()
-
-        entity.last_updated_by = username
-        entity.last_updated_date = datetime.datetime.now()
-
-        # Save to database
-        entity = await self.chat_repository.save(entity)
-
-        # Convert model to response
-        return self.chat_mapper.to_schema(entity)
+    async def handle_chat_completion(self, user_chat_completion: ChatCompletionRequest, username: str) -> ChatCompletionResponse:
+        last_user_message = user_chat_completion
+        logger.debug(f"BEGIN SERVICE: last_user_message: {last_user_message}, username: {username}")
+
+        # validate user message
+        self.chat_validation.validate_request(user_chat_completion)
+
+        # save user message to database
+        logger.info("Saving user message to database")
+        repo_user_message = await self._save_chat_completion(user_chat_completion, username)
+        logger.info(f"Saved user message to database with completion_id: {repo_user_message.completion_id}")
+
+        # region agentic-ai process start #########################################################
+        try:
+            logger.info("Agentic Chat AI process started")
+            agent_result = await self.chat_agent_client_process(user_chat_completion, username)
+            assistant_message = ChatMessageRequest(role="assistant", content=agent_result.message)
+            assistant_chat_completion = user_chat_completion
+            assistant_chat_completion.messages = [assistant_message]  # replace user messages with assistant message
+            logger.info(f"Agentic Chat AI process completed. Part of Assistant Message...: {assistant_message.content[:50]}...")
+        except Exception as e:
+            logger.error(f"Error agentic-ai process: {e}")
+            raise
+        # endregion agentic-ai process start ######################################################
+
+        # validate agent response
+        self.chat_validation.validate_response(agent_result)
+
+        # save assistant message to database
+        repo_assistant_message = await self._save_chat_completion(assistant_chat_completion, username)
+
+        # generate api response with user, agent, db etc... TBD
+        result = repo_assistant_message
+
+        logger.debug("END SERVICE")
+        return result

app/service/chat_validation.py

@@ -0,0 +1,11 @@
+class ChatValidation:
+    def __init__(self):
+        pass
+
+    def validate_request(self, completion):
+        # TODO implement request validation logic
+        pass
+
+    def validate_response(self, agent_result):
+        # TODO implement response validation logic
+        pass

gradio_chatbot.py

@@ -2,7 +2,7 @@ import json
 import gradio as gr
 import environs
 import httpx
-from typing import List, Tuple, Optional
+from typing import List, Tuple, Optional, Any
 from dataclasses import dataclass
 from enum import Enum
 import os
@@ -125,7 +125,7 @@ class MessageStatus(Enum):
 
 
 @dataclass
-class MessageResponse:
+class ChatMessageResponse:
     """Data class for message response"""
 
     status: MessageStatus
@@ -142,7 +142,7 @@ class ChatAPI:
         self.api_key = api_key
         self.endpoint = f"{base_url}/v1/chat/completions"
 
-    async def send_message(self, prompt: str) -> MessageResponse:
+    async def send_message(self, prompt: str) -> ChatMessageResponse:
         """
         Send a message to the chat API
 
@@ -150,7 +150,7 @@ class ChatAPI:
             prompt (str): The message to send
 
         Returns:
-            MessageResponse: The response from the API
+            ChatMessageResponse: The response from the API
         """
         logger.trace(f"Calling chat API with prompt: {prompt}")
         try:
@@ -169,7 +169,7 @@ class ChatAPI:
 
                 if response.status_code != 200:
                     logger.error(f"API Error: {response.text}")
-                    return MessageResponse(
+                    return ChatMessageResponse(
                         status=MessageStatus.ERROR,
                         content="",
                         figure=None,
@@ -187,14 +187,14 @@ class ChatAPI:
                     logger.trace(f"Figure: {figure}")
                     content = message.get("content", "Content not found")
                     logger.trace(f"Last message: {content}")
-                    return MessageResponse(
+                    return ChatMessageResponse(
                         status=MessageStatus.SUCCESS,
                         content=content,
                         figure=figure,
                     )
                 else:
                     logger.error("Invalid API response")
-                    return MessageResponse(
+                    return ChatMessageResponse(
                         status=MessageStatus.ERROR,
                         content="",
                         error="Invalid API response",
@@ -202,14 +202,14 @@ class ChatAPI:
 
         except httpx.TimeoutException:
             logger.error("API request timed out")
-            return MessageResponse(
+            return ChatMessageResponse(
                 status=MessageStatus.ERROR,
                 content="",
                 error="Request timed out. Please try again.",
             )
         except Exception as e:
             logger.error(f"Error: {str(e)}")
-            return MessageResponse(
+            return ChatMessageResponse(
                 status=MessageStatus.ERROR,
                 content="",
                 error=f"Error: {str(e)}",
@@ -319,13 +319,13 @@ class ChatInterface:
                         None,
                     )
 
-            def clear_history() -> Tuple[List[List[str]], str, str, str, dict]:
+            def clear_history() -> tuple[list[Any], str, str, str, None]:
                 """Clear chat history"""
                 return [], "", "Chat cleared.", "", None
 
             def retry_last_message(
                 history: List[List[str]],
-            ) -> Tuple[List[List[str]], str, str, str, dict]:
+            ) -> tuple[list[list[str]], str, str, str, None]:
                 """Retry the last message"""
                 if not history:
                     return history, "", "No message to retry.", "", None