File: initCaseTemplate.py

The initCaseTemplate.py script is the foundation for CASE's conversational mode. This script initializes and manages a chat session with the GPT4All model, enabling CASE to respond to user inputs in a conversational context. Let’s go through each part of the script:

from gpt4all import GPT4All

This imports the GPT4All library, which is necessary for interfacing with the GPT model. It allows CASE to utilize the conversational capabilities provided by GPT4All.

import time

The time module is imported to track execution times, which can be useful for performance monitoring and debugging.

import os

The os module is imported to execute system commands, such as clearing the console screen, which enhances the user interaction experience.

model = GPT4All('{model}', allow_download=False, n_ctx={AI.ReceivedTokens}, ngl={AI.GPULayers}{device})

This line initializes the GPT4All model with specific configurations:

• {model}: Placeholder for the model's name, which will be replaced at runtime.
• allow_download=False: Ensures that the model will not be downloaded if it’s not available locally.
• n_ctx={AI.ReceivedTokens}: Sets the context size, which is the number of tokens the model can process at once.
• ngl={AI.GPULayers}{device}: Configures the GPU layers and device to optimize performance based on available hardware.

sysPrompt = ""

This initializes an empty string for sysPrompt, which will later be populated with the system prompt from a text file.

with open("{trainingPath}", "r") as file:

This line opens the system prompt file specified by {trainingPath}. This path will be dynamically inserted during runtime.

    sysPrompt = file.read().replace("\n", "")

The system prompt is read from the file, and any newline characters are removed to create a continuous string. This prompt guides the model’s behavior during the conversation.

clear = lambda: os.system('cls')

This lambda function is defined to clear the console screen on Windows systems using the cls command. It’s called whenever the screen needs to be refreshed.

model_load_time = time.time()

This records the current time to track how long it takes to load the model, providing insight into the model's initialization performance.

with model.chat_session(sysPrompt):

This begins a chat session with the model, using the system prompt as the initial context. The chat session manages the conversation flow.

    initModelResponse = model.generate("")

Here, the model generates an initial response based on the system prompt. The response may be empty, serving to initialize the chat session properly.

    print("ML:%s" % (time.time() - model_load_time))

This prints the model load time to the console, which is useful for monitoring how long it took to set up the AI model.

    while (True):

This starts an infinite loop that continuously prompts the user for input, allowing for an ongoing conversation.

        consoleInput = input(f"UserPrompt>")

This captures user input from the console, simulating an interactive conversation with the AI.

        clear()

After receiving input, the screen is cleared to refresh the console and prepare for the next interaction.

        if consoleInput == "exit":

This conditional statement checks if the user wants to exit the conversation. If the input is "exit," the loop breaks, ending the session.

            break

If the condition to exit is met, the loop is terminated.

        else:

If the user does not input "exit," the conversation continues with the AI generating a response.

            start_time = time.time()

This records the start time of the AI response generation for performance monitoring.

            response = model.generate(consoleInput, max_tokens={AI.MaxTokensSent}, temp={AI.Temperature}, top_k={AI.Top_K}, top_p={AI.Top_P}, min_p={AI.Min_P}, repeat_penalty={AI.Penalty}, repeat_last_n={AI.Repeat_Last_N}, n_batch={AI.ConsumptionBatch})

The model generates a response to the user's input, using various parameters that control the AI's behavior:

• max_tokens: The maximum number of tokens to generate.
• temp: The temperature setting, which controls the randomness of the output.
• top_k, top_p, min_p: Sampling parameters that influence the diversity of the generated text.
• repeat_penalty, repeat_last_n: Penalty settings to avoid repetitive outputs.
• n_batch: The batch size for token processing.

            print("--- %s seconds ---" % (time.time() - start_time))

This prints the time taken to generate the response, providing real-time performance feedback.

            print(response)

File: initAnalysisTemplate.py

The initAnalysisTemplate.py script is the foundation for the CASE application's analysis mode. This script is designed to process and analyze user-provided data using the GPT4All model. Below is a detailed breakdown of the script:

from gpt4all import GPT4All

As with the conversational mode script, this imports the GPT4All library, enabling the script to utilize GPT models for data analysis tasks.

import os

The os module is imported to handle system operations, such as file handling, which might be required during the analysis.

import time

The time module is imported to measure the time taken for various operations, which is useful for performance tracking.

model = GPT4All('{model}', allow_download=False, n_ctx={AI.ReceivedTokens}, ngl={AI.GPULayers}{device})

This initializes the GPT4All model with specific parameters tailored for analysis:

• {model}: The AI model name, dynamically inserted at runtime.
• allow_download=False: Prevents downloading the model if it's not available locally.
• n_ctx={AI.ReceivedTokens}: Sets the context size, determining how much data the model can process at one time.
• ngl={AI.GPULayers}{device}: Configures GPU layers and device, optimizing the model for the available hardware.

sysPrompt = ""

This initializes an empty string for sysPrompt, which will be populated with the system prompt from a text file.

with open("{trainingPath}", "r") as file:

This line opens the system prompt file specified by {trainingPath}, reading it into memory for use during analysis.

    sysPrompt = file.read().replace("\n", "")

The system prompt is read and any newline characters are removed to create a single, continuous string. This prompt provides the AI with the necessary context to guide its analysis.

clear = lambda: os.system('cls')

This lambda function clears the console screen on Windows systems using the cls command, ensuring a clean interface for output.

model_load_time = time.time()

This records the current time to measure how long it takes to load the model, which can help optimize the initialization process.

with model.chat_session(sysPrompt):

This initiates a session with the model, using the system prompt to provide context for the analysis task.

    print("ML:%s" % (time.time() - model_load_time))

This prints the time taken to load the model, offering feedback on the initialization performance.

    def analyze(prompt, data):

This defines the analyze function, which takes a user-defined prompt and the data to be analyzed as input parameters.

        start_time = time.time()

This records the start time of the analysis, which will be used to measure the performance of the operation.

        analysis = model.generate(prompt + data, max_tokens={AI.MaxTokensSent}, temp={AI.Temperature}, top_k={AI.Top_K}, top_p={AI.Top_P}, min_p={AI.Min_P}, repeat_penalty={AI.Penalty}, repeat_last_n={AI.Repeat_Last_N}, n_batch={AI.ConsumptionBatch})

The model generates an analysis based on the combined user prompt and data, using the following parameters:

• max_tokens: The maximum number of tokens the model can generate in the output.
• temp: Controls the randomness of the output; a higher temperature results in more diverse responses.
• top_k, top_p, min_p: Sampling parameters that influence the diversity and focus of the output.
• repeat_penalty, repeat_last_n: Penalty parameters to prevent repetition in the generated text.
• n_batch: Batch size for processing the tokens.

        print("--- %s seconds ---" % (time.time() - start_time))

This prints the time taken to complete the analysis, providing real-time feedback on the performance.

        return analysis

This returns the generated analysis to the user, concluding the function.

The initAnalysisTemplate.py script is structured to handle the analysis tasks efficiently, leveraging the GPT4All model to process and interpret user-provided data within the given context.

File: initCase.Conversational.txt

The initCase.Conversational.txt file contains the system prompt used to guide the conversational mode of CASE. This prompt sets the context for interactions, ensuring that the AI responds in a manner consistent with its role as a professional assistant in the automation field.

### System:
CASE is a conversational Large Language Model (LLM) interface designed to facilitate user interaction with the objective of returning correct information regarding a system as well as to relay professional information in the automation field. Below is information regarding the system you will be reporting information on.

If there is no data beyond this point, maintain as a functional chatbot known as "CASE".

This prompt ensures that the AI remains focused on its intended purpose, providing accurate and relevant information during conversations.

File: initCase.Analysis.Empty.txt

The initCase.Analysis.Empty.txt file contains the system prompt for the analysis mode. It instructs the AI on how to process and analyze the provided data, guiding the model to generate insightful responses based on the user's prompt and data context.

### System:
You are CASE. This is the Analysis method. The user will provide a prompt and a large amount of text, please analyze this text with the goal of the prompt. 

The user has requested you to Analyze the following text, and provide the following input for their analysis request, which states: "{Prompt}". If the data is a SQL table, it will be represented as a comma separated table, with the columns at the top, and the row numbers on the left. Here is the data they would like analyzed:

This prompt is designed to instruct the AI on how to approach the analysis of the provided data. It ensures that the AI understands the context of the analysis request and is prepared to generate output that is aligned with the user's goals. The prompt also provides specific instructions on how to handle structured data, such as SQL tables, ensuring that the AI's output is well-organized and relevant.