ิcreate package specifying agent

Author: chatrtham

src/fastapi_app/postgres_searcher.py

@@ -35,7 +35,7 @@ def build_filter_clause(self, filters) -> tuple[str, str]:
             return f"WHERE {filter_clause}", f"AND {filter_clause}"
         return "", ""
 
-    async def search(
+    async def hybrid_search(
         self,
         query_text: str | None,
         query_vector: list[float] | list,
@@ -281,4 +281,33 @@ async def search_and_embed(
         if not enable_text_search:
             query_text = None
 
-        return await self.search(query_text, vector, top, filters)
+        return await self.hybrid_search(query_text, vector, top, filters)
+
+    async def simple_sql_search(
+        self, 
+        filters: list[dict]
+    ) -> list[Item]:
+        """
+        Search items by simple SQL query with filters.
+        """
+        filter_clause_where, _ = self.build_filter_clause(filters)
+        sql = f"""
+        SELECT id FROM packages
+        {filter_clause_where}
+        LIMIT 1
+        """
+        
+        async with self.async_session_maker() as session:
+            results = (
+                await session.execute(
+                    text(sql).columns(id=Integer)
+                )
+            ).fetchall()
+
+            # Convert results to Item models
+            items = []
+            for result in results:
+                item_id = result.id
+                item = await session.execute(select(Item).where(Item.id == item_id))
+                items.append(item.scalar())
+            return items

src/fastapi_app/prompts/answer.txt

@@ -1,9 +1,11 @@
 You are a woman name Jib (จิ๊บ), a sales consultant from HDmall which you need to convince the customers to buy some products from our store name HDmall, Please answer in casual and friendly manner. Don't recommend any product yet on the first conversation before the customer asking. You can use Emoji to make the conversation more friendly if you want.
 Represent youself as จิ๊บ and the customer as คุณลูกค้า when the conversation is in Thai language.
-Represent youself as Jib and the customer as you when the conversation is in English language.
-When the customer asks about any packages, please make sure to provide brand, price , URL and location every time.
-If customer wants to talk with admin, please provide the URL link in the datasource.
-Note that some packages may have additional cost.
+Represent youself as Jib and the customer as you when the conversation is in English or Non-Thai language. 
+Answer the customer's question in the same language as the customer's question.
+It's not important whether the customer is male or female, you are woman named Jib, please end with "ค่ะ" when you chat with customer in Thai language.
+If the customer want to  buy a product or book a service, or having an strong intent of interested in some package, respond "QISCUS_INTEGRATION_TO_CX" to handover to customer service.
+When the customer asks about any packages, please make sure to provide brand, price ,URL which in a new line, location with google maps link every time.
 If the user is asking a question regarding location, proximity, or area, query relevant document from the source and ask where the user is at. please try to suggest services or answers closest to the location the user is asking as much as possible.
-Answer ONLY with the facts listed in the list of sources below. If there isn't enough information below, say sorry you don't know. Do not generate answers that don't use the sources below. If asking a clarifying question to the user would help, ask the question.
-Answer in well-structured plain text, not a markdown.
+Answer ONLY with the facts listed in the list of sources below. If there isn't enough information below, say sorry you don't know (in users' language). Do not generate answers that don't use the sources below. If asking a clarifying question to the user would help, ask the question.
+Since this is a text-based conversation in a chatroom, do not use markdown or any similar rich formatting. Also, don't wrap URL in a parentheses.
+Note that some packages may have additional cost.

src/fastapi_app/prompts/specify_package.txt

@@ -0,0 +1 @@
+Please specify the exact URL or package name from past messages only if the user's message directly references a known package. Do not attempt to identify packages based on general inquiries or price-related requests. If the user's message does not clearly match a previously mentioned package, respond accordingly without specifying a package name.

src/fastapi_app/query_rewriter.py

@@ -6,7 +6,7 @@
 )
 
 
-def build_search_function() -> list[ChatCompletionToolParam]:
+def build_hybrid_search_function() -> list[ChatCompletionToolParam]:
     return [
         {
             "type": "function",
@@ -26,39 +26,21 @@ def build_search_function() -> list[ChatCompletionToolParam]:
                             "properties": {
                                 "comparison_operator": {
                                     "type": "string",
-                                    "description": "Operator to compare the column value, either '>', '<', '>=', '<=', '='",  # noqa
+                                    "description": "Operator to compare the column value, either '>', '<', '>=', '<=', '='",
                                 },
                                 "value": {
                                     "type": "number",
                                     "description": "Value to compare against, e.g. 30",
                                 },
                             },
                         },
-                        "url_filter": {
-                            "type": "object",
-                            "description": "Filter search results based on url of the package. The url is package specific.",
-                            "properties": {
-                                "comparison_operator": {
-                                    "type": "string",
-                                    "description": "Operator to compare the column value, either '=' or '!='",
-                                },
-                                "value": {
-                                    "type": "string",
-                                    "description": """
-                                    The package URL to compare against.
-                                    Don't pass anything if you can't specify the exact URL from user query.
-                                    """,
-                                },
-                            },
-                        },
                     },
-                    "required": ["search_query", "url_filter"],
+                    "required": ["search_query"],
                 },
             },
         }
     ]
 
-
 def extract_search_arguments(chat_completion: ChatCompletion):
     response_message = chat_completion.choices[0].message
     search_query = None
@@ -70,7 +52,6 @@ def extract_search_arguments(chat_completion: ChatCompletion):
             function = tool.function
             if function.name == "search_database":
                 arg = json.loads(function.arguments)
-                print(arg)
                 search_query = arg.get("search_query")
                 if "price_filter" in arg and arg["price_filter"]:
                     price_filter = arg["price_filter"]
@@ -81,16 +62,70 @@ def extract_search_arguments(chat_completion: ChatCompletion):
                             "value": price_filter["value"],
                         }
                     )
-                if "url_filter" in arg and arg["url_filter"]:
-                    url_filter = arg["url_filter"]
-                    if url_filter["value"] != "https://hdmall.co.th":
-                        filters.append(
-                            {
-                                "column": "url",
-                                "comparison_operator": url_filter["comparison_operator"],
-                                "value": url_filter["value"],
-                            }
-                        )
     elif query_text := response_message.content:
         search_query = query_text.strip()
     return search_query, filters
+
+
+def build_specify_package_function() -> list[ChatCompletionToolParam]:
+    return [
+        {
+            "type": "function",
+            "function": {
+                "name": "specify_package",
+                "description": """
+                Specify the exact URL or package name from past messages if they are relevant to the most recent user's message.
+                This tool is intended to find specific packages previously mentioned and should not be used for general inquiries or price-based requests.
+                """,
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "url": {
+                            "type": "string",
+                            "description": """
+                            The exact URL of the package from past messages,
+                            e.g. 'https://hdmall.co.th/dental-clinics/xray-for-orthodontics-1-csdc'
+                            """
+                        },
+                        "package_name": {
+                            "type": "string",
+                            "description": """
+                            The exact package name from past messages,
+                            always contains the package name and the hospital name,
+                            e.g. 'เอกซเรย์สำหรับการจัดฟัน ที่ CSDC'
+                            """
+                        }
+                    },
+                    "required": [],
+                },
+            },
+        }
+    ]
+
+def handle_specify_package_function_call(chat_completion: ChatCompletion):
+    response_message = chat_completion.choices[0].message
+    filters = []
+    if response_message.tool_calls:
+        for tool in response_message.tool_calls:
+            if tool.type == "function" and tool.function.name == "specify_package":
+                args = json.loads(tool.function.arguments)
+                url = args.get("url")
+                package_name = args.get("package_name")
+                if url:
+                    filters.append(
+                        {
+                            "column": "url",
+                            "comparison_operator": "=",
+                            "value": url,
+                        }
+                    )
+                if package_name:
+                    filters.append(
+                        {
+                            "column": "package_name",
+                            "comparison_operator": "=",
+                            "value": package_name,
+                        }
+                    )
+    return filters
+

src/fastapi_app/rag_advanced.py

@@ -13,7 +13,12 @@
 
 from .api_models import ThoughtStep
 from .postgres_searcher import PostgresSearcher
-from .query_rewriter import build_search_function, extract_search_arguments
+from .query_rewriter import (
+    build_hybrid_search_function,
+    extract_search_arguments,
+    build_specify_package_function,
+    handle_specify_package_function_call
+)
 
 
 class AdvancedRAGChat:
@@ -31,6 +36,7 @@ def __init__(
         self.chat_deployment = chat_deployment
         self.chat_token_limit = get_token_limit(chat_model, default_to_minimum=True)
         current_dir = pathlib.Path(__file__).parent
+        self.specify_package_prompt_template = open(current_dir / "prompts/specify_package.txt").read()
         self.query_prompt_template = open(current_dir / "prompts/query.txt").read()
         self.answer_prompt_template = open(current_dir / "prompts/answer.txt").read()
 
@@ -47,40 +53,95 @@ async def run(
         vector_search = overrides.get("retrieval_mode") in ["vectors", "hybrid", None]
         top = overrides.get("top", 3)
 
+        # Generate a prompt to specify the package if the user is referring to a specific package
+        specify_package_messages = copy.deepcopy(messages)
+        specify_package_messages.insert(0, {"role": "system", "content": self.specify_package_prompt_template})
+        specify_package_token_limit = 300
 
-        # Generate an optimized keyword search query based on the chat history and the last question
-        query_messages = copy.deepcopy(messages)
-        query_messages.insert(0, {"role": "system", "content": self.query_prompt_template})
-        query_response_token_limit = 500
-
-        chat_completion: ChatCompletion = await self.openai_chat_client.chat.completions.create(
-            messages=query_messages,  # type: ignore
-            # Azure OpenAI takes the deployment name as the model name
+        specify_package_chat_completion: ChatCompletion = await self.openai_chat_client.chat.completions.create(
+            messages=specify_package_messages,
             model=self.chat_deployment if self.chat_deployment else self.chat_model,
-            temperature=0.0,  # Minimize creativity for search query generation
-            max_tokens=query_response_token_limit,  # Setting too low risks malformed JSON, too high risks performance
+            temperature=0.0,
+            max_tokens=specify_package_token_limit,
             n=1,
-            tools=build_search_function(),
-            tool_choice="auto",
+            tools=build_specify_package_function()
         )
 
-        query_text, filters = extract_search_arguments(chat_completion)
+        specify_package_filters = handle_specify_package_function_call(specify_package_chat_completion)
 
-        # Retrieve relevant items from the database with the GPT optimized query
-        results = await self.searcher.search_and_embed(
-            query_text,
-            top=top,
-            enable_vector_search=vector_search,
-            enable_text_search=text_search,
-            filters=filters,
-        )
-        
-        # Check if the url_filter is used to determine the context to send to the LLM
-        if any(f['column'] == 'url' and f['value'] != '' for f in filters):
-            sources_content = [f"[{(item.id)}]:{item.to_str_for_narrow_rag()}\n\n" for item in results] # all details
+        if specify_package_filters:
+            # Pass specify_package_filters to simple SQL search function
+            results = await self.searcher.simple_sql_search(filters=specify_package_filters)
+            sources_content = [f"[{(item.id)}]:{item.to_str_for_narrow_rag()}\n\n" for item in results]
+
+            thought_steps = [
+                ThoughtStep(
+                    title="Prompt to specify package",
+                    description=[str(message) for message in specify_package_messages],
+                    props={"model": self.chat_model, "deployment": self.chat_deployment} if self.chat_deployment else {"model": self.chat_model}
+                ),
+                ThoughtStep(
+                    title="Specified package filters",
+                    description=specify_package_filters,
+                    props={}
+                ),
+                ThoughtStep(
+                    title="SQL search results",
+                    description=[result.to_dict() for result in results],
+                    props={}
+                )
+            ]
         else:
-            sources_content = [f"[{(item.id)}]:{item.to_str_for_broad_rag()}\n\n" for item in results] # important details
-        
+            # Generate an optimized keyword search query based on the chat history and the last question
+            query_messages = copy.deepcopy(messages)
+            query_messages.insert(0, {"role": "system", "content": self.query_prompt_template})
+            query_response_token_limit = 500
+
+            query_chat_completion: ChatCompletion = await self.openai_chat_client.chat.completions.create(
+                messages=query_messages,
+                model=self.chat_deployment if self.chat_deployment else self.chat_model,
+                temperature=0.0,
+                max_tokens=query_response_token_limit,
+                n=1,
+                tools=build_hybrid_search_function(),
+                tool_choice="auto",
+            )
+
+            query_text, filters = extract_search_arguments(query_chat_completion)
+
+            # Retrieve relevant items from the database with the GPT optimized query
+            results = await self.searcher.search_and_embed(
+                query_text,
+                top=top,
+                enable_vector_search=vector_search,
+                enable_text_search=text_search,
+                filters=filters,
+            )
+
+            sources_content = [f"[{(item.id)}]:{item.to_str_for_broad_rag()}\n\n" for item in results]
+
+            thought_steps = [
+                ThoughtStep(
+                    title="Prompt to generate search arguments",
+                    description=[str(message) for message in query_messages],
+                    props={"model": self.chat_model, "deployment": self.chat_deployment} if self.chat_deployment else {"model": self.chat_model}
+                ),
+                ThoughtStep(
+                    title="Generated search arguments",
+                    description=query_text,
+                    props={"filters": filters}
+                ),
+                ThoughtStep(
+                    title="Hybrid Search results",
+                    description=[result.to_dict() for result in results],
+                    props={
+                        "top": top,
+                        "vector_search": vector_search,
+                        "text_search": text_search
+                    }
+                )
+            ]
+
         content = "\n".join(sources_content)
 
         # Build messages for the final chat completion
@@ -89,7 +150,6 @@ async def run(
         response_token_limit = 1024
 
         chat_completion_response = await self.openai_chat_client.chat.completions.create(
-            # Azure OpenAI takes the deployment name as the model name
             model=self.chat_deployment if self.chat_deployment else self.chat_model,
             messages=messages,
             temperature=overrides.get("temperature", 0.3),
@@ -101,39 +161,6 @@ async def run(
 
         chat_resp["choices"][0]["context"] = {
             "data_points": {"text": sources_content},
-            "thoughts": [
-                ThoughtStep(
-                    title="Prompt to generate search arguments",
-                    description=[str(message) for message in query_messages],
-                    props=(
-                        {"model": self.chat_model, "deployment": self.chat_deployment}
-                        if self.chat_deployment
-                        else {"model": self.chat_model}
-                    ),
-                ),
-                ThoughtStep(
-                    title="Search using generated search arguments",
-                    description=query_text,
-                    props={
-                        "top": top,
-                        "vector_search": vector_search,
-                        "text_search": text_search,
-                        "filters": filters,
-                    },
-                ),
-                ThoughtStep(
-                    title="Search results",
-                    description=[result.to_dict() for result in results],
-                ),
-                ThoughtStep(
-                    title="Prompt to generate answer",
-                    description=[str(message) for message in messages],
-                    props=(
-                        {"model": self.chat_model, "deployment": self.chat_deployment}
-                        if self.chat_deployment
-                        else {"model": self.chat_model}
-                    ),
-                ),
-            ],
+            "thoughts": thought_steps
         }
         return chat_resp