app.py

# ===========================================
# ver01.01-5.workload-----app.py
# ===========================================

import asyncio
import os
import re
import time
import json

import chainlit as cl

from langchain import hub
from langchain_openai import OpenAI
from langchain.chains import LLMChain, APIChain
from langchain_core.prompts import PromptTemplate
from langchain.memory.buffer import ConversationBufferMemory

from api_docs_mck import api_docs_str 

OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")

daysoff_assistant_template = """
You are a customer support assistant (’kundeservice AI assistent’) for Daysoff.no
By default, you respond in Norwegian language, using a warm, direct and professional tone. 
You are equipped to assist users by providing detailed information linked to specific 
booking IDs (bestillingskode), offering general insights about DaysOff's services, addressing 
questions related to the company's privacy policy (personvernspolicy), and answering frequently 
asked questions about DaysOff's firmahytteordning.
Chat History: {chat_history}
Question: {question}
Answer:
"""
daysoff_assistant_prompt = PromptTemplate(
    input_variables=['chat_history', 'question'],
    template=daysoff_assistant_template
)

api_url_template = """
Given the following API Documentation for Daysoff's official
booking information API: {api_docs}
Your task is to construct the most efficient API URL to answer
the user's question, ensuring the
call is optimized to include only the necessary information.
Question: {question}
API URL:
"""
api_url_prompt = PromptTemplate(input_variables=['api_docs', 'question'],
                                template=api_url_template)

api_response_template = """
With the API Documentation for Daysoff's official API: {api_docs} in mind,
and  the specific user question: {question} in mind,
and given this API URL: {api_url} for querying,
here is the response from Daysoff's API: {api_response}.
Please provide an summary (in Norwegian) that directly addresses the user's question,
and focusing on delivering the answer with clarity and conciseness,
as if a human customer service agent is providing this information.
Summary:
"""

api_response_prompt = PromptTemplate(
    input_variables=['api_docs', 'question', 'api_url', 'api_response'],
    template=api_response_template
)

@cl.on_chat_start
def setup_multiple_chains():

    llm = OpenAI(
        model='gpt-3.5-turbo-instruct',
        temperature=0.7, 
        openai_api_key=OPENAI_API_KEY,
        #max_tokens=512, 
        top_p=0.9,  
        frequency_penalty=0.5,
        presence_penalty=0.3   
    )
    
    conversation_memory = ConversationBufferMemory(memory_key="chat_history",
                                                   max_len=300,
                                                   return_messages=True,
                                                   )
    llm_chain = LLMChain(llm=llm,
                         prompt=daysoff_assistant_prompt,
                         memory=conversation_memory
                        )

    cl.user_session.set("llm_chain", llm_chain)

    api_chain = APIChain.from_llm_and_api_docs(
        llm=llm,
        api_docs=api_docs_str,
        api_url_prompt=api_url_prompt,
        api_response_prompt=api_response_prompt,
        verbose=True,
        limit_to_domains=None 
    )

    cl.user_session.set("api_chain", api_chain)

@cl.on_message
async def handle_message(message: cl.Message):
    user_message = message.content
    llm_chain = cl.user_session.get("llm_chain")
    api_chain = cl.user_session.get("api_chain")
    
    booking_pattern = r'\b[A-Z]{6}\d{6}\b' 
    base_url = "https://670dccd0073307b4ee447f2f.mockapi.io/daysoff/api/V1/booking"

    if re.search(booking_pattern, user_message):  
        bestillingskode = re.search(booking_pattern, user_message).group(0)  
        question = f"Retrieve information for booking ID {base_url}?search={bestillingskode}"
   
        response = await api_chain.acall(
            {
                "bestillingskode": bestillingskode,
                "question": question
              
            },
            callbacks=[cl.AsyncLangchainCallbackHandler()])

    elif any(keyword in user_message for keyword in ["firmahytteordning", "personvernspolicy",
                                                   "faq_ansatte", "faq_utleiere"]): 
        
        response = await api_chain.acall(user_message,
                                         callbacks=[cl.AsyncLangchainCallbackHandler()])
    
    else:    
        response = await llm_chain.acall(user_message, callbacks=[cl.AsyncLangchainCallbackHandler()])

    response_key = "output" if "output" in response else "text"
    await cl.Message(response.get(response_key, "")).send()
    return message.content