# Automate Your Customer Support: Integrating ChatGPT with Freshdesk

## **Introduction**

**Overview of Freshdesk and its API**

Freshdesk, a leading customer support platform, transforms how businesses engage with customers. With its user-friendly interface and powerful features, Freshdesk streamlines support processes, enhances customer interactions, and delivers outstanding service.

The Freshdesk API acts as a powerful bridge, enabling seamless integration and automation between the Freshdesk platform and external applications. It's a collection of web-based protocols and tools, allowing developers to programmatically engage with the Freshdesk customer support platform. This facilitates the exchange of data for creating, retrieving, updating, and deleting various entities.

Automating Freshdesk Support Using Chatgpt presents a comprehensive guide on streamlining customer support processes within the Freshdesk platform. By integrating ChatGPT, a powerful language model, into Freshdesk, businesses can enhance their customer service capabilities. This blog explores various use cases, including summarizing ticket conversations, extracting order details, and retrieving knowledge base answers. By automating routine tasks and leveraging the capabilities of ChatGPT, companies can provide more efficient and personalized customer support experiences. **Let's get started!**

## **Getting Started**

### **Key Features and Capabilities:**

To harness the full potential of the Freshdesk API, it's essential to explore its key features and capabilities.

##### **Key Features:**

1. **Ticket CRUD Operations:**
    
    * An acronym for Create, Read, Update, and Delete. In the context of Freshdesk, these operations helps for managing support tickets.
        
2. **Real-time Ticket Management**
    
    * Enables real-time ticket management for efficient support operations.
        
3. **Seamless Integration**
    
    * Facilitates seamless integration of Freshdesk support functionalities with ChatGPT.
        

##### **Capabilities:**

1. **RESTful Architecture**
    
    * The Freshdesk API adheres to RESTful principles, ensuring simplicity, scalability, and ease of integration.
        
2. **Authentication and Security**
    
    * Secure API key-based authentication ensures data integrity and confidentiality.
        
3. **Data Retrieval and Filtering**
    
    * Retrieve specific data sets using flexible filtering options. Optimize data retrieval based on parameters such as date, status, and priority.
        

### **Prerequisites**

### **Obtaining a Freshdesk API Key:**

To interact with the Freshdesk API, acquiring an API key is a fundamental step. The API key serves as an authentication mechanism, allowing secure access to your Freshdesk account programmatically.

###### Steps to Obtain Freshdesk API Key:

1. **Log in to Freshdesk:**
    
    * Accessing my Freshdesk account involves using my credentials. If I don't have a Freshdesk account, I can sign up for a free trial on [the Freshdesk website](https://www.freshdesk.com/)
        
        ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1702274281382/abff3022-becf-4015-bad6-2af7d42d3b34.png align="center")
        
    
    To do this, I need to complete a registration form, activate my account through a verification email, and then log in to Freshdesk using my email address and password.
    
2. **After Login to Freshdesk account navigate to Profile Settings:**
    
    ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1702309814418/72ea13a8-6a3c-4715-8df7-41bfbdbd2804.png align="center")
    
3. **Navigate to the 'View API Key' and we can see API Key Generated**:
    
    ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1702310015128/53edca72-21d3-4cff-91fd-785a820f01b1.png align="center")
    

### **Setting up the development environment:**

Once I've obtained my Freshdesk API key, the next critical step is to set up my development environment. This ensures that I have the necessary tools and configurations to interact seamlessly with Freshdesk API endpoints. Here's a step-by-step guide to help me establish an environment conducive to efficient API integration

1. **Install Required Libraries:**
    
    * Ensure that I have the required libraries installed, with a primary emphasis on using the 'requests' library for handling HTTP requests in Python. I can install it using:
        
        ```python
        pip install requests
        ```
        
2. **Access to a Python Environment:**
    
    * Make sure to set up a Python environment on our machine, as Python scripts are frequently used for Freshdesk API interactions, making Python an essential prerequisite.
        
3. **Freshdesk API Documentation:**
    
    * Get to know the [Freshdesk API documentation](https://developers.freshdesk.com/api/) to understand the available endpoints, request/response formats, and any specific requirements.
        

## **Making Requests**

**Function explanation:**

The `make_freshdesk_request` function is a versatile tool for interacting with the Freshdesk API. Let's delve into the details

```python
import requests

FRESHDESK_API_KEY = 'Your Freshdesk API Key'
FRESHDESK_API_URL = 'https://domain.freshdesk.com/api/v2/'

def make_freshdesk_request(FRESHDESK_API_KEY, FRESHDESK_API_URL, method, endpoint, json_data=None):
    url = FRESHDESK_API_URL + endpoint
    headers = {"Authorization": f"Basic {FRESHDESK_API_KEY}", "Content-Type": "application/json"}

    try:
        response = requests.request(method, url, headers=headers, json=json_data)
        response.raise_for_status()
        return {"data": response.json(), "response_text": response.text}
    except requests.RequestException as e:
        return {"error": f"Error accessing Freshdesk API: {str(e)}", "response_text": response.text}
```

This function serves as our intermediary for communication with Freshdesk. Whether we're creating a ticket, fetching details, or performing other tasks, this function handles the back-and-forth with Freshdesk seamlessly.

**Handling Authentication with API Key:**

```python
    headers = {"Authorization": f"Basic {FRESHDESK_API_KEY}", "Content-Type": "application/json"}
```

Before we make any requests to Freshdesk, we need to prove our identity. The function accomplishes this by including our Freshdesk API key in the request headers. This key is like our secret password, allowing Freshdesk to recognize and authorize our requests.

**Making requests using requests library:**

```python
    response = requests.request(method, url, headers=headers, json=json_data)
    response.raise_for_status()
    return {"data": response.json(), "response_text": response.text}
```

To communicate effectively with Freshdesk, we need a reliable courier. The `requests` library serves as our postman, handling the intricacies of delivering our requests and receiving the responses. This function orchestrates the entire process, making it easy for us to interact with Freshdesk through Python code.

In essence, the `make_freshdesk_request` function acts as our messenger, including our special key (Freshdesk API key) in the message and utilizing the trusty `requests` library to facilitate smooth communication with Freshdesk. It streamlines the process, making it user-friendly and accessible.

## **Ticket Management**

### **Listing Tickets:**

This section process the retrieving a list of tickets from Freshdesk.

```python
def list_tickets(FRESHDESK_API_KEY, FRESHDESK_API_URL):
    result = make_freshdesk_request(FRESHDESK_API_KEY, FRESHDESK_API_URL, "GET", "tickets")
    tickets = result.get("data", [])
    print("Result (List Tickets):" if tickets else "No tickets found.")
    for ticket in tickets:
        print(f"Ticket ID: {ticket['id']}, Subject: {ticket['subject']}, Priority: {ticket['priority']}, Status: {ticket['status']}")
```

To retrieve a list of tickets from Freshdesk, the `list_tickets` function is utilized. This function takes two parameters, `FRESHDESK_API_KEY` and `FRESHDESK_API_URL`, enabling authentication and specifying the Freshdesk domain. Upon making a GET request to the Freshdesk API, it fetches ticket data.

The result is then processed, and if tickets are found, relevant details such as Ticket ID, Subject, Priority, and Status are printed for user visibility. This function facilitates the efficient retrieval and display of ticket information.

**Response:**

```json
{
  "Result (List Tickets)": [
    {
      "Ticket ID": 11,
      "Subject": "Quality issue",
      "Priority": 1,
      "Status": 2
    },
    {
      "Ticket ID": 10,
      "Subject": "Delay in my order",
      "Priority": 1,
      "Status": 2
    }
  ]
}
```

### **Creating a Ticket:**

Creating a ticket involves initiating a new ticket in Freshdesk.

```python
def create_ticket(FRESHDESK_API_KEY, FRESHDESK_API_URL):
    ticket_data = {
        "description": input("Enter issue description: "),
        "subject": input("Enter ticket subject: "),
        "email": input("Enter user email: "),
        "priority": int(input("Enter priority (1, 2, 3, etc.): ")),
        "status": int(input("Enter status (2 for open, 3 for pending, etc.): "))
    }
    result = make_freshdesk_request(FRESHDESK_API_KEY, FRESHDESK_API_URL, "POST", "tickets", json_data=ticket_data)
    print("Result (Create Ticket):", result)
```

This function `create_ticket`, allows users to input details for a new Freshdesk ticket, including the issue description, ticket subject, user email, priority, and status. It leverages the provided parameters, `FRESHDESK_API_KEY` and `FRESHDESK_API_URL`, to authenticate and send a POST request to the Freshdesk API, for creating a new ticket. Finally, the ticket will be created.

We can observe the ticket creation on our Freshdesk User Interface.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1703069019131/2bd3c6c4-4cb8-415e-85cc-3bdf47249a54.png align="center")

### **Getting Ticket Details:**

This section outlines the process of obtaining comprehensive information on a particular ticket in Freshdesk.

```python
def get_ticket_details(FRESHDESK_API_KEY, FRESHDESK_API_URL):
    ticket_id = input("Enter ticket ID: ")
    result = make_freshdesk_request(FRESHDESK_API_KEY, FRESHDESK_API_URL, "GET", f"tickets/{ticket_id}")
    print("Result (Get Ticket Details):", result)
```

The `get_ticket_details` function helps users to retrieve specific details about a Freshdesk ticket by providing the ticket ID as an input. Leveraging the parameters `FRESHDESK_API_KEY` and `FRESHDESK_API_URL`, this function securely authenticates and sends a GET request to the Freshdesk API, fetching detailed information about the specified ticket.

Response:

```json
{
  "Result (Get Ticket Details)": {
    "data": {
      "cc_emails": [],
      "fwd_emails": [],
      "reply_cc_emails": [],
      "ticket_cc_emails": [],
      "fr_escalated": false,
      "spam": false,
      "email_config_id": 1070000038299,
      "group_id": null,
      "priority": 1,
      "requester_id": 1070012864262,
      "responder_id": null,
      "source": 2,
      "company_id": null,
      "status": 2,
      "subject": "Cancel order",
      "association_type": null,
      "support_email": null,
      "to_emails": null,
      "product_id": 1070000031097,
      "id": 12,
      "type": null,
      "due_by": "2023-12-22T22:00:00Z",
      "fr_due_by": "2023-12-20T22:00:00Z",
      "is_escalated": false,
      "description": "<div>can you try to cancel my order with order id 18</div>",
      "description_text": "can you try to cancel my order with order id 18",
      "custom_fields": {
        "cf_reference_number": null
      },
      "created_at": "2023-12-20T10:38:40Z",
      "updated_at": "2023-12-20T10:38:40Z",
      "tags": [],
      "attachments": [],
      "source_additional_info": null,
      "form_id": 1070000103738,
      "nr_due_by": null,
      "nr_escalated": false
    },
    "response_text": "{\"cc_emails\":[],\"fwd_emails\":[],\"reply_cc_emails\":[],\"ticket_cc_emails\":[],\"fr_escalated\":false,\"spam\":false,\"email_config_id\":1070000038299,\"group_id\":null,\"priority\":1,\"requester_id\":1070012864262,\"responder_id\":null,\"source\":2,\"company_id\":null,\"status\":2,\"subject\":\"Cancel order\",\"association_type\":null,\"support_email\":null,\"to_emails\":null,\"product_id\":1070000031097,\"id\":12,\"type\":null,\"due_by\":\"2023-12-22T22:00:00Z\",\"fr_due_by\":\"2023-12-20T22:00:00Z\",\"is_escalated\":false,\"description\":\"<div>can you try to cancel my order with order id 18</div>\",\"description_text\":\"can you try to cancel my order with order id 18\",\"custom_fields\":{\"cf_reference_number\":null},\"created_at\":\"2023-12-20T10:38:40Z\",\"updated_at\":\"2023-12-20T10:38:40Z\",\"tags\":[],\"attachments\":[],\"source_additional_info\":null,\"form_id\":1070000103738,\"nr_due_by\":null,\"nr_escalated\":false}"
  }
}
```

### **Updating a Ticket:**

This section provides insights into the process of updating a ticket within Freshdesk.

```python
def update_ticket(FRESHDESK_API_KEY, FRESHDESK_API_URL):
    ticket_id = input("Enter ticket ID to update: ")
    updated_ticket_data = {
        "description": input("Enter updated issue description: "),
        "subject": input("Enter updated ticket subject: "),
        "email": input("Enter updated user email: "),
        "priority": int(input("Enter updated priority (1, 2, 3, etc.): ")),
        "status": int(input("Enter updated status (2 for open, 3 for pending, etc.): "))
    }
    result = make_freshdesk_request(FRESHDESK_API_KEY, FRESHDESK_API_URL, "PUT", f"tickets/{ticket_id}", json_data=updated_ticket_data)
    print("Result (Update Ticket):", result)
```

The `update_ticket` function helps users to modify existing Freshdesk tickets with ease. By inputting the desired ticket ID, users can then provide updated details such as the issue description, ticket subject, user email, priority, and status. Leveraging the parameters `FRESHDESK_API_KEY` and `FRESHDESK_API_URL`, this function utilizes a PUT request to the Freshdesk API, it update the specified ticket. The result of the update will be displayed.

we can also observe the updating existing ticket on our Freshdesk User Interface.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1703069632845/d8001896-c102-4ef8-85ba-ae64faa77cf5.png align="center")

### **Deleting a Ticket:**

This section outlines the process of deleting a ticket.

```python
def delete_ticket(FRESHDESK_API_KEY, FRESHDESK_API_URL):
    ticket_id = input("Enter ticket ID to delete: ")
    result = make_freshdesk_request(FRESHDESK_API_KEY, FRESHDESK_API_URL, "DELETE", f"tickets/{ticket_id}")
    print("Result (Delete Ticket): Ticket successfully deleted.")
```

The `delete_ticket` function helps users to effortlessly remove unwanted tickets from Freshdesk. By prompting users to input the ticket ID they wish to delete, this function utilizes the `FRESHDESK_API_KEY` and `FRESHDESK_API_URL` parameters to authenticate and send a DELETE request to the Freshdesk API, initiating the ticket deletion process. Upon successful deletion, a confirmation message will be displayed.

**Response:**

```json
{
  "Result": "Ticket successfully deleted."
}
```

If you'd like to **Prefer a Visual Guide?** for building APIs powered by ChatGPT. you can watch the **video tutorial :**

[Beginner's Guide to FastAPI & OpenAI ChatGPT API Integration](https://youtu.be/KVdP4SpWcc4?si=DSZLMmiF3_Y0YdGx)

## **Use Case: Automating Freshdesk Support with ChatGPT**

**Installing the required modules:**

```bash
pip install openai -q
pip install requests
```

### **Extracting Order Details, Summarizing Ticket Conversation and Retrieving Knowledge base answers.**

### **Defining** `get_ticket_text` **Function:**

The `get_ticket_text` function retrieves ticket information from Freshdesk

```python
import requests
from openai import OpenAI 
import json

client = OpenAI(api_key="Your API Key") # Replace with your OpenAI API key

def get_ticket_text(ticket_id: int):
    try:
        FRESHDESK_API_KEY = 'Your Freshdesk API Key'
        url = f'https://domain.freshdesk.com/api/v2/tickets/{ticket_id}'
        headers = {'Authorization': f'Basic {FRESHDESK_API_KEY}'}

        response = requests.get(url, headers=headers)
        response.raise_for_status()

        ticket_info = response.json()
        return ticket_info.get("description", "")
    except requests.exceptions.RequestException as e:
        print(f"Error fetching ticket information: {e}")
        return ""
```

### **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.

```python
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 :**

[https://youtu.be/eCCHDxMaFIk?si=sM0whXw2Qk6b1bbX](https://youtu.be/eCCHDxMaFIk?si=sM0whXw2Qk6b1bbX)

### **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.

```python
def get_order_details(order_id):
    url = "http://your_api_endpoint/order_info"  # Replace with your actual endpoint
    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=12)
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 associated with the query.

```python
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.

```python
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=12) 
            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'd like to **Prefer a Visual Guide?** for ChatGPT Function calling. you can watch the **video tutorial :**

[https://youtu.be/pI1yUiNKyDA?si=BrkMNclGb-YmRvhd](https://youtu.be/pI1yUiNKyDA?si=BrkMNclGb-YmRvhd)

### Defining `get_chatgpt_summary_orderID_details` Function:

```python
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 out this helpful **video tutorial**:

[https://youtu.be/RALmm6flXII?si=f2QTY2nB1dZTUGjz](https://youtu.be/RALmm6flXII?si=f2QTY2nB1dZTUGjz)

### 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.

```python
def gpt_function(ticket_id: int):
    ticket_text = get_ticket_text(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_ticket_text` 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

```python
ticket_id = 10
gpt_function(ticket_id)
```

The gpt response will retrieve order details, summarizing conversation and knowledge base answer.

```bash
{'order_details': 'Customer Name: Alex\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 ordered an SSD CARD on 14-12-2023 and has not received any updates for a week. The order ID mentioned is 12, and the customer is inquiring about the expected delivery date.', 'topics': ['SSD CARD', 'order status', 'delivery date'], 'order_id': 12}
{'response': 'The return policy allows for items to be returned within 7 days of purchase.','status': True}
```

### **Conclusion**

In conclusion, integrating advanced NLP solutions like ChatGPT into customer support systems can significantly enhance efficiency and customer satisfaction. Our deep dive into Freshdesk's APIs demonstrates the seamless connection between these technologies, allowing for automated ticket management and knowledgeable customer interactions.

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**](mailto: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!

For further exploration and references, don't forget to check the [Freshdesk API Documentation](https://developers.freshdesk.com/api/).

**Stay Connected with FutureSmart AI for the Latest in AI Insights -** [**FutureSmart AI**](https://blog.futuresmart.ai/)

Eager to stay informed about the cutting-edge advancements and captivating insights in the field of AI? Explore [**AI Demos**](https://www.aidemos.com/), your ultimate destination for staying abreast of the newest AI tools and applications. AI Demos serves as your premier resource for education and inspiration. Immerse yourself in the future of AI today by visiting [**aidemos.com**](http://aidemos.com/).