Introduction
In the dynamic landscape of business management, Odoo stands out as a comprehensive solution, offering a versatile platform that caters to diverse organizational needs. The Odoo Helpdesk module is a crucial component for managing customer inquiries, issues, and feedback.
Odoo Helpdesk serves as the nerve center for efficient customer support within the Odoo ecosystem. It empowers organizations to streamline their customer interactions, providing a centralized hub for managing tickets, resolving issues, and ensuring customer satisfaction.
As businesses seek innovative ways to enhance customer support, the fusion of ChatGPT with Odoo Helpdesk using Python emerges as a revolutionary approach. ChatGPT places a strong emphasis on natural language processing. The integration of ChatGPT with Odoo Helpdesk signifies a shift towards automated, intelligent responses that not only address customer queries but also elevate the overall support experience.
Setting up the development environment
Access to a Python Environment: Make sure to set up a Python environment on a machine.
Initializing the odoorpc library :
The odoorpc library facilitates communication with an Odoo instance, allowing you to perform various operations programmatically.
pip install odoorpc
Connecting to Odoo Helpdesk:
import odoorpc
db_name = "Your Odoo Helpdesk database name"
username = "Your Odoo Helpdesk username"
password = "Your Odoo Helpdesk password"
odoo = odoorpc.ODOO('Your Odoo Helpdesk domain', protocol='jsonrpc+ssl', port=443)
odoo.login(db_name, username, password)
The odoo variable is created as an instance of the ODOO class from the odoorpc library.
The ODOO class takes the Odoo Helpdesk URL, the protocol used (JSON-RPC with SSL in this case), and the port number.
The login method is then called to authenticate and log in to the Odoo instance using the provided database name, username, and password.
Odoo helpdesk models :
-
-
Creating Helpdesk Team:
To effectively manage customer inquiries and support tickets, establishing teams within the helpdesk module is crucial.
team_data = {
'name': 'Sales order team',
'description': 'Sales order team to handling order issue given by customer.',
}
team_id = helpdesk_team_model.create(team_data)
print(f"Sales order team (ID: {team_id}) is created!")
team_data encapsulates essential information about the new helpdesk team, such as its name and a brief description. The helpdesk_team_model.create() method is then utilized to create a new team in the Odoo helpdesk module, with the provided data. The unique identifier (ID) assigned to the newly created team is stored in the variable team_id.
We can observe that helpdesk team as been created on our Odoo Helpdesk.
Ticket Management
Creating a Ticket:
The creation of a new helpdesk ticket within the Odoo platform.
ticket_data = {
'name': 'Delay in order',
'team_id': team_id,
'description': 'I have ordered a product with order id 46 but still i didnt receive my order',
}
ticket_id = helpdesk_ticket_model.create(ticket_data)
print(f"New Ticket (ID: {ticket_id}) is created!")
The ticket_data holds essential information about the ticket, such as its name, associated team ID, and a description of the reported issue. The helpdesk_ticket_model.create(ticket_data) function is then invoked, initiating the creation process of the new ticket. The unique identifier (ID) assigned to the newly created ticket is stored in the variable ticket_id.
We can observe that Ticket as been created on our Odoo Helpdesk.
Reading a Ticket :
Retrieving information about a specific helpdesk ticket within the Odoo system.
read_ticket = helpdesk_ticket_model.read(ticket_id, ['name', 'description'])
print("Read Ticket Information:", read_ticket)
The helpdesk_ticket_model.read(ticket_id, ['name', 'description']) function is employed to extract specific details associated with the identified ticket, referenced by its unique identifier stored in the variable ticket_id. The parameters passed to the function, namely ['name', 'description'], indicate the specific fields of the ticket that should be included in the retrieval.
Updating a Ticket :
Updating the information associated with a specific helpdesk ticket.
update_ticket_id = ticket_id
update_values = {'name' : 'Updated Ticket name',
'description': 'Updated Tiket description' }
helpdesk_ticket_model.write(update_ticket_id, update_values)
print("Ticket Updated Successfully")
The update_ticket_id as the identifier of the ticket that needs to be modified, and update_values containing the new information to be applied. The helpdesk_ticket_model.write(update_ticket_id, update_values) function is to execute the update. It takes the ticket's ID (update_ticket_id) and the updated values (update_values) as parameters, making the necessary modifications to the ticket's details.
Deleting a Ticket :
The process of deleting a helpdesk ticket within the Odoo platform.
helpdesk_ticket_model.unlink([ticket_id])
print("Ticket Deleted Successfully")
The helpdesk_ticket_model.unlink([ticket_id]) function is utilized to initiate the deletion of the specified ticket, identified by its ticket ID (ticket_id). The unlink method is the mechanism employed by Odoo to remove records from the database, and in this case, it targets the ticket identified by the provided ID.
Use case: Automating odoo helpdesk with chatgpt
Installing the OpenAI Python Package: To interact with OpenAI's APIs, start by installing the OpenAI Python package.
pip install openai -q
Extracting Order Details, Summarizing Ticket Conversation and Retrieving Knowledge base answers
Setting up odoo helpdesk connection :
Please refer to the above explanation for connecting to Odoo Helpdesk.
from openai import OpenAI
import json
import odoorpc
client = OpenAI(api_key="Your API Key")
db_name = "Your odoo helpdesk database name"
username = "Your odoo helpdesk username"
password = "Your odoo helpdesk password"
odoo = odoorpc.ODOO('Your odoo helpdesk domain', protocol='jsonrpc+ssl', port=443)
odoo.login(db_name, username, password)
Defining get_odoo_ticket_description Function:
The get_odoo_ticket_description function is to retrieve the description of a helpdesk ticket from odoo using the provided ticket ID.
def get_odoo_ticket_description(ticket_id : int):
try:
helpdesk_ticket_model = odoo.env['helpdesk.ticket']
ticket_info = helpdesk_ticket_model.read(ticket_id, ['description'])
if isinstance(ticket_info, list) and ticket_info:
ticket_info = ticket_info[0]
return ticket_info.get('description', "")
except Exception as e:
print(f"Error fetching ticket information from Odoo: {e}")
return ""
The function uses the Odoo environment to access the helpdesk.ticket model, reads the description field for the specified ticket, and returns the description.
Defining the get_knowledge_chromadb Function:
The get_knowledge_chromadb function used to get knowledge base data from chromadb, this function takes single argument called query. It utilizes the Sentence Transformer to encode the query and uses chromadb to query the encoded query. The function concludes by returning the top 2 similar data points obtained from the query results.
def get_knowledge_chromadb(query):
import chromadb
from sentence_transformers import SentenceTransformer
model_name = "multi-qa-MiniLM-L6-cos-v1"
client = chromadb.PersistentClient(path="chromadb_index")
collection = client.get_collection("index_name")
model = SentenceTransformer(model_name)
query_embedding = model.encode(query)
results = collection.query(query_embedding, n_results=2)
if results['metadatas'][0]:
context =results['metadatas'][0][0]['knowledge']+"\n"+results['metadatas'][0][1]['knowledge']
else:
context=""
return results
If you want to learn more about Chroma vector database and Semantic search you can watch this video tutorial :
Semantic Search with Open-Source Vector DB: Chroma DB
Defining the get_order_details Function:
We define a function get_order_details, which makes an API request to retrieve information for a given order.
def get_order_details(order_id):
url = "http://your_api_endpoint/order_info"
params = {'order_id': order_id}
response = requests.post(url, params=params)
if response.status_code == 200:
return response.json()['Result'][0]
else:
return f"Error: Unable to fetch order details. Status code: {response.status_code}"
order_details = get_order_details(order_id=46)
print(order_details)
Describing Functions:
get_order_info function takes an argument called "order_id" and it returns the order details associated with the order_id.
knowledge_base function takes an arguments called "query" and it returns the knowledge base data from Chromadb using the query provided.
functions = [
{
"name": "get_order_info",
"description": "The function retrieves all the Order specific information associated with the provided Order ID.",
"parameters": {
"type": "object",
"properties": {
"order_id": {
"type": "string",
"description": "unique id of the order",
}
},
"required": ["order_id"],
}
},
{"name": "knowledge_base",
"description": "The function retrieves the knowledge from chromadb using the query provided.",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "query to search in chromadb",
}
},
"required": ["query"],
}
}
]
Defining the generate_ticket_response Function:
while the generate_ticket_response function utilizes ChatGPT for extracting order details.
def generate_ticket_response(text):
conversation_str = f"""Given conversation : {text}"""
response = client.chat.completions.create(
model="gpt-3.5-turbo-1106",
response_format={ "type": "json_object" },
messages=[
{"role": "system", "content": "You are a helpful assistant designed to output JSON. 'Order ID' is of numeric type. 'Order ID' can sometimes be followed by '#' symbol, please extract the 'Order ID' by removing the symbol. Order details can be fetched by 'get_order_info' function call."},
{"role": "user", "content": conversation_str},
],
temperature=0,
functions=functions,
function_call="auto",
)
saved_response = response
response = response.choices[0].message
if response.function_call:
function_name = response.function_call.name
if function_name == "get_order_info":
order_id = json.loads(response.function_call.arguments)["order_id"]
order_details = get_order_details(order_id=46)
if order_details:
return {"order_details": order_details, "status": True }
elif function_name == "knowledge_base":
query = json.loads(response.function_call.arguments)["query"]
data = get_knowledge_chromadb(query)
response = client.chat.completions.create(
model="gpt-3.5-turbo-1106",
response_format={ "type": "text" },
messages=[
{"role": "system", "content": "You are a helpful assistant. Provide response in formal language."} ,
{"role": "user", "content": f"""Here is the knowledge base data for the given conversation: {data}""" },
{"role": "user", "content": f"Given conversation : \n{query}"},
],
temperature=0,
)
return {"response": response.choices[0].message.content, "status": True}
return {"order_details": "", "status":False}
In generate_ticket_response function we use function_call parameter to call a function in the prompt. There are two functions defined in the prompt, get_order_info and knowledge_base. The function_call parameter is set to "auto" to automatically call the function.
GPT calls the function in the prompt and returns the order details in JSON format and the order details are extracted from the JSON response and returned.
If you want to learn more about the ChatGPT Function calling. you can watch this video tutorial :
OpenAI Function Calling Explained: Chat Completions & Assistants API
Defining get_chatgpt_summary_orderID_details Function:
def get_chatgpt_summary_orderID_details(text):
conversation_str = f"""Given conversation : {text}"""
response = client.chat.completions.create(
model="gpt-3.5-turbo-1106",
response_format={ "type": "json_object" },
messages=[
{"role": "system", "content": "You are a helpful assistant designed to output JSON.Please generate summary of given conversation in 'summary' . Also extract topics from given conversation in 'topics' tag. 'Order ID' is of numeric type. 'Order ID' can sometimes be followed by '#' symbol, please extract the 'Order ID' by removing the symbol. Extract order ID in 'order_id'"},
{"role": "user", "content": conversation_str},
],
temperature=0,
)
return response.choices[0].message.content
The get_chatgpt_summary_orderID_details function demonstrates how to use the function_call parameter to call a function in the prompt and this function is to generate summary of given conversation and extract topics from given conversation and extract order ID from given conversation.
If you'd like to Prefer a Visual Guide? on how to implement OpenAI's ChatGPT API in your projects and how to use OpenAI's ChatGPT API to Build a Conversational AI Chatbot check this video tutorial:
Using OpenAI's ChatGPT API to Build a Conversational AI Chatbot
Defining gpt_function Function
Introducing the gpt_function function that integrates with GPT to handle ticket-related information and user queries, providing meaningful responses based on the context of the conversation.
def gpt_function(ticket_id: int):
ticket_text = get_odoo_ticket_description(ticket_id)
output = generate_ticket_response(ticket_text)
print(output)
out = get_chatgpt_summary_orderID_details(ticket_text)
print(json.loads(out))
ticket_conversation = "what is your return policy?"
output = generate_ticket_response(ticket_conversation)
print(output)
It begins by retrieving the ticket text using the get_odoo_ticket_description function. Subsequently, it leverages ChatGPT through the generate_ticket_response function to extract order details and generate comprehensive summaries of ticket conversations. Furthermore, the code demonstrates the model's capability by simulating user inquiries, such as querying the return policy, and showcases ChatGPT's responses.
Generating GPT Response
ticket_id = 16
gpt_function(ticket_id)
The gpt response will retrieve order details, summarizing conversation and knowledge base answer.
{'order_details': 'Customer Name: John Doe\nOrder Date:2023-12-05 21:15:01\nOrder status:payment_accepted\nCarrier:UPS - Gratis Vans\nDelivery Date: 2023-12-20 00:00:00', 'status': True}
{'summary': 'The customer has mentioned that they have ordered a product with order id 46 but have not received the order yet.', 'topics': ['order status', 'product delivery'], 'order_id': 46}
{'response': 'The return policy allows for items to be returned within 7 days of purchase', 'status': True}
Conclusion
In conclusion, the Odoo helpdesk and its integration with ChatGPT has illuminated the effective ticket management for customer support. The Odoo helpdesk module, with its versatile capabilities, serves a businesses seeking to provide exceptional customer service by managing inquiries and concerns efficiently.
The ChatGPT, a powerful language model, introduces a new era in customer interactions. With natural language processing at its core, ChatGPT enables intelligent, human like responses for customer support.
if you wish to integrate ChatGPT with Freshdesk for customer support you can refer this Freshdesk Blog.
If your company is looking to embark on a similar journey of transformation and you're in need of a tailored NLP solution, we're here to guide you every step of the way. Our team at FutureSmart AI specializes in crafting custom NLP applications, including generative NLP, RAG, and ChatGPT integrations, tailored to your specific needs.
Don't let your customer support lag behind. Embrace the future of automated, intelligent customer interactions. Reach out to us at contact@futuresmart.ai, and let's discuss how we can build a smarter, more responsive customer support system for your business. Join the ranks of forward-thinking companies leveraging the best of AI, and see the difference for yourself!
Stay Connected with FutureSmart AI for the Latest in AI Insights - FutureSmart AI
Keep up with the latest breakthroughs and fascinating insights in the world of AI by staying connected with FutureSmart AI. Discover AI Demos, for staying updated on the newest AI tools and applications. AI Demos is your top resource for both education and inspiration. Dive into the future of AI now by visiting aidemos.com.
