@cpwc/node-red-contrib-ai-intent 3.1.0-alpha

package/geminiai-chat/index.html

@@ -0,0 +1,189 @@
+<script type="text/javascript">
+   (() => {
+         const DYNAMIC_OPTIONS = [
+           { value: "auto", label: "Automatic" },
+           { value: "any", label: "Any" },
+           { value: "none", label: "None" }
+       ]
+         const removeDuplicates = (data) => {
+           const intents = {}
+           const tools = []
+
+           data.forEach((intent => {
+               if (intent.type === "OpenAI Tool") {
+                   if (!intents[intent.name]) {
+                       intents[intent.name] = true
+                       tools.push(intent)
+                   }
+               } else {
+                   tools.push(intent)
+               }
+           }))
+           return tools
+       }
+       
+       $.getJSON('registered-intents', function (data = RED.settings.callIntentRegistry) {
+           const tools = removeDuplicates(data)
+           window.__tools = getToolOptions(tools)
+           initialize()
+       });
+
+      const getToolOptions = (intents = []) => {
+           const options = intents.map(intent => {
+               const suffix = intent.type === "Register Intent" ? " (Registered Intent)" : ""
+               return { value: intent.id, label: `${intent.name}${suffix}` }
+           })
+
+           return [...DYNAMIC_OPTIONS, ...options]
+       }
+
+       RED.nodes.registerType("GeminiAI Chat", {
+           category: 'AI Intent',
+           color: 'rgba(255, 0, 119, .75)',
+           icon: "gemini-icon.svg",
+           defaults: {
+               name: { value: "" },
+               tool_choice: {
+                   value: getToolOptions(RED.settings.callIntentRegistry),
+               },
+               conversation_id: { value: "" },
+               token: { value: "", type: "geminiai-configuration", required: false },
+               model: { value: "gemini-1.5-flash", required: true },
+               temperature: { value: .7, required: true },
+               max_tokens: { value: 1200, required: true },
+               top_p: { value: 1, required: true },
+               top_k: { value: 16, required: true },
+           },
+           inputs: 1,
+           outputs: 1,
+           paletteLabel: "Gemini (Deprecated)",
+           label: function () {
+               return this.name +" (Deprecated)" || "GeminiAI (Deprecated)";
+           },
+
+           oneditprepare: function (x) {
+               $("#node-input-temperature").typedInput({
+                   type: "num",
+               })
+               $("#node-input-max_tokens").typedInput({
+                   type: "num",
+               })
+               $("#node-input-top_p").typedInput({
+                   type: "num",
+               })
+               $("#node-input-top_k").typedInput({
+                   type: "num",
+               })
+
+               $.getJSON('registered-intents', function (data = RED.settings.callIntentRegistry) {
+                   const tools = removeDuplicates(data)
+                   window.__tools = getToolOptions(tools)
+
+                   $("#node-input-tool_choice").typedInput({
+                       types: [
+                           {
+                               value: "",
+                               options: window.__tools
+                           }
+                       ]
+                   })
+               });
+           }
+       });
+   })()
+
+</script>
+
+<script type="text/html" data-template-name="GeminiAI Chat">
+    <div class="form-row">
+        <label for="node-input-name"> Name</label>
+        <input type="text" id="node-input-name" placeholder="Name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-token"> Token</label>
+        <input type="text" id="node-input-token" placeholder="0a1b2c3b4d5e6f">
+    </div>
+    <div class="form-row">
+        <label for="node-input-conversation_id"><i class="fa fa-tag"></i> Conversation Id</label>
+        <input type="text" id="node-input-conversation_id" placeholder="any arbitrary name">
+    </div>
+    <div class="form-row">
+        <label for="node-input-model"> Model</label>
+        <input type="text" id="node-input-model" placeholder="gpt-3.5-turbo">
+    </div>
+    <div class="form-row">
+        <label for="node-input-tool_choice"> Tool Choice</label>
+        <input type="text" id="node-input-tool_choice" placeholder="Automatic">
+    </div>
+    <div class="form-row">
+        <label for="node-input-temperature"> Temperature</label>
+        <input type="number" id="node-input-temperature" placeholder="0.7">
+    </div>
+    <div class="form-row">
+        <label for="node-input-max_tokens"> Max Tokens</label>
+        <input type="number" id="node-input-max_tokens" placeholder="1200">
+    </div>
+    <div class="form-row">
+        <label for="node-input-top_p"> Top P</label>
+        <input type="number" id="node-input-top_p" placeholder="0">
+    </div>
+    <div class="form-row">
+        <label for="node-input-top_k">Top K</label>
+        <input type="number" id="node-input-top_k" placeholder="16">
+    </div>
+
+   
+</script>
+
+<script type="text/html" data-help-name="GeminiAI Chat">
+    <p>Calls Gemini and returns the response</p>
+    
+    <h3>Important</h3>
+    <p>To use this node you need an API Key from Gemini. Add the API Key to the settings.js file in the node-red folder under
+    the functonGlobalContext section using the key "geminiaiAPIKey"</p>
+    <pre>
+    functionGlobalContext: {
+        geminiaiAPIKey: "Your Key Goes Here",
+    }
+    </pre>
+
+    Alternatively, you can add the token via the token configuration dropdown. 
+    See the <a href="https://github.com/montaque22/node-red-contrib-ai-intent" target="_blank">Read Me</a> for more information 
+
+    <h3>Inputs</h3>
+    <dl class="message-properties">
+        <dt class="optional">Conversation ID
+            <span class="property-type">string</span>
+        </dt>
+        <dd> By including this identifier, AI-Intent will save the conversation in the global context 
+            and will pass the entire conversation to the LLM when any Chat node with the same conversation id 
+        is triggered. This mean that you can have many Chat nodes in different flows with the same conversation id
+    and AI-Intent will ensure that conversation context is maintained between them. It should be noted that only 
+    <b>one</b> System message will be maintained. As a result the flow with the current System node will 
+overwrite any system prompt that was previously saved.</dd>
+    </dl>
+    <dl class="message-properties">
+        <dt class="required">model
+            <span class="property-type">string</span>
+        </dt>
+        <dd> Required field that dictates the model to use when calling Gemini </dd>
+    </dl>
+   
+    <h3>Details</h3>
+    <p>At minimum the User node should be used before this node. The OpenAI User node adds necessary
+        information to the msg object to allow the chat to work.</p>
+
+    <dl class="message-properties">
+        <dt class="required">Tool Choice
+            <span class="property-type">Dropdown</span>
+        </dt>
+        <dd> This setting controls how GPT uses the provided functions to respond.
+            If you want to force GPT to use a specific function, selected it from the dropdown.
+            <b>Automatic</b> lets GPT decides what is best (This is the default). <b>None</b> disables the use of functions.
+            to further optimize the API call, AI-Intent will not pass any of the tools
+            to save tokens if "None" is selected. Check documentation for more detail on
+            how tools work: <a href="https://ai.google.dev/gemini-api/docs/function-calling" target="_blank">Function Calling & Tools</a>
+        </dd>
+    </dl>
+
+</script>

package/geminiai-chat/index.js

@@ -0,0 +1,92 @@
+const { GEMINI_AI_KEY, TYPES } = require("../constants");
+const { end } = require("../globalUtils");
+const { GoogleGenerativeAI } = require("@google/generative-ai");
+const { GlobalContext } = require("../utilities/global-context");
+const { GeminiController } = require("../utilities/gemini-controller");
+
+module.exports = function (RED) {
+  function GeminiAIChatHandlerNode(config) {
+    RED.nodes.createNode(this, config);
+    // Retrieve the config node with API token data.
+    this.token = RED.nodes.getNode(config.token);
+    const node = this;
+
+    this.on("input", function (msg, send, done = () => {}) {
+      const controller = new GeminiController(node, config, msg, RED);
+      const nodeDB = new GlobalContext(node);
+      const apiKey =
+        node.token?.api || nodeDB.getValueFromGlobalContext(GEMINI_AI_KEY);
+
+      send =
+        send ||
+        function () {
+          config.send.apply(node, arguments);
+        };
+
+      if (!apiKey) {
+        return end(
+          done,
+          `Api key missing for Gemini. Please add ${GEMINI_AI_KEY} key-value pair to the functionGlobalContext.
+          Or add it to the config within the GeminiAI-Chat node`
+        );
+      }
+
+      const { apiProperties, toolProperties } = controller;
+
+      const generationConfig = {
+        maxOutputTokens: apiProperties.max_tokens,
+        temperature: apiProperties.temperature,
+        topP: apiProperties.top_p,
+        topK: apiProperties.top_k,
+      };
+
+      const finalProps = {
+        ...apiProperties,
+        ...toolProperties,
+      };
+
+      // Access your API key as an environment variable (see "Set up your API key" above)
+      const genAI = new GoogleGenerativeAI(apiKey);
+
+      // ...
+
+      const modelParams = {
+        model: finalProps.model,
+        generationConfig,
+        tools: finalProps.tools,
+        tool_config: {
+          function_calling_config: {
+            mode: finalProps.tool_choice.toUpperCase(),
+            allowed_function_names: finalProps.allowFunctionNames,
+          },
+        },
+      };
+
+      // The Gemini 1.5 models are versatile and work with most use cases
+      const model = genAI.getGenerativeModel(modelParams);
+
+      const chat = model.startChat({
+        history: finalProps.history,
+      });
+
+      chat
+        .sendMessage(finalProps.message)
+        .then((result) => result.response)
+        .then((response) => {
+          return {
+            functions: response.functionCalls(),
+            text: response.text(),
+          };
+        })
+        .then((payload) => {
+          send(controller.mergeResponseWithMessage(payload, finalProps));
+          end(done);
+        })
+        .catch((err) => {
+          end(done, err);
+        });
+    });
+  }
+
+  RED.nodes.registerType(TYPES.GeminiaiChat, GeminiAIChatHandlerNode);
+};

package/globalUtils.js

@@ -0,0 +1,39 @@
+const { INTENT_STORE, LOCAL_STORAGE_PATH} = require("./constants");
+const { getStorageAtLocation } = require("./database");
+
+function end(done, error) {
+  if (done) {
+    done(error);
+  }
+}
+
+class ContextDatabase {
+  constructor(RED) {
+    const {functionGlobalContext = {} } = RED.settings
+    const path = functionGlobalContext[LOCAL_STORAGE_PATH]
+
+    this.globalContext = getStorageAtLocation(path);
+  }
+
+  getNodeStore() {
+    const stringStore = this.globalContext.getItem(INTENT_STORE) || "{}";
+
+    return JSON.parse(stringStore);
+  }
+
+  saveIntent(config) {
+    const nodeStore = this.getNodeStore();
+    nodeStore[config.id] = config;
+
+    this.globalContext.setItem(INTENT_STORE, JSON.stringify(nodeStore));
+  }
+
+  removeIntent(config) {
+    const nodeStore = this.getNodeStore();
+    delete nodeStore[config.id];
+
+    this.globalContext.setItem(INTENT_STORE, JSON.stringify(nodeStore));
+  }
+}
+
+module.exports = { end, ContextDatabase };

package/llm-chat/AzureOpenAIHelper.js

@@ -0,0 +1,204 @@
+const { GlobalContext } = require("../utilities/global-context");
+const { TOOL_CHOICE } = require("../constants");
+const AzureOpenAI = require("openai");
+const { ContextDatabase } = require("../globalUtils");
+const { ConversationHistory } = require("../utilities/conversationHistory");
+const { Format } = require("../utilities/format");
+
+const azureOpenAIHelper = (props, callback) => {
+    const { node, config, msg, RED } = props
+    const nodeDB = new GlobalContext(node);
+    const { model, credentials } = node.platform
+    const apiKey = credentials.api
+    const endpoint = credentials.endpoint
+    const apiVersion = "2025-01-01-preview"
+
+    if (!apiKey) {
+        node.status({ fill: "red", shape: "dot", text: "Error" });
+        return callback("API key missing for AzureOpenAI. Please add openaiAPIKey key-value pair to the functionGlobalContext.");
+    }
+    if (!endpoint) {
+        node.status({ fill: "red", shape: "dot", text: "Error" });
+        return callback("Endpoint missing for AzureOpenAI. Please add openaiAPIKey key-value pair to the functionGlobalContext.");
+    }
+
+    const openai = new AzureOpenAI({ endpoint, apiKey, apiVersion });
+    const { options = {}, system = "", user = "" } = msg?.payload || {}
+    const conversation_id = config.conversation_id;
+    const conversationHistory = new ConversationHistory(nodeDB, conversation_id)
+
+    if (msg.clearChatHistory) {
+        conversationHistory.clearHistory()
+        node.warn("Conversation history cleared")
+    }
+
+    if (!user) {
+        node.status({ fill: "red", shape: "dot", text: "Stopped" });
+        return node.warn("payload.user is empty. Stopping the flow ")
+    }
+
+    conversationHistory.addSystemMessage(system)
+    conversationHistory.addUserMessage(user)
+
+    if (conversation_id) {
+        conversationHistory.saveHistory()
+    }
+
+    const toolProperties = getToolProperties(config, msg.tools, RED)
+    const finalProps = {
+        ...options,
+        ...toolProperties,
+        model,
+        messages: conversationHistory.conversation
+    };
+
+    openai.chat.completions
+        .create(finalProps)
+        .then((response) => {
+
+            response.choices.forEach(choice => {
+                conversationHistory.addAssistantMessage(choice.message.content)
+            })
+            conversationHistory.saveHistory()
+
+            return createPayload(finalProps, response, msg, conversationHistory.conversation)
+        })
+        .then(msg => {
+            callback(null, msg)
+        })
+        .catch((err) => {
+            callback(err)
+        });
+}
+
+const createPayload = (request, response, previousMsg, conversationHistory) => {
+    const format = new Format()
+    const payload = format.formatPayloadForOpenAI(response.choices)
+
+    return {
+        ...previousMsg,
+        payload,
+        apiResponse: response,
+        _debug: {
+            ...request,
+            messages: conversationHistory
+        },
+    }
+}
+
+const getAllTools = (RED) => {
+    const context = new ContextDatabase(RED);
+    const intents = context.getNodeStore() || {};
+    return createFunctionsFromContext(intents)
+}
+
+/**
+ * Converts the raw intents into functions that the LLM can use.
+ * @param {*} node
+ * @returns
+ */
+getRegisteredIntentFunctions = (RED) => {
+    const intents = getRawIntents(RED);
+    return createFunctionsFromContext(intents);
+};
+
+/**
+ * This will return all stored Registered Intents throughout the entire system
+ * and Tool Nodes that are attached directly to this flow
+ * This will return:
+ *  type RawIntent = {
+ *    [node_id]: node // could be Registered Intent or Tool node
+ *  }
+ */
+getRawIntents = (RED) => {
+    const context = new ContextDatabase(RED);
+    return context.getNodeStore() || {};
+};
+
+/**
+ * converts the registered intents stored in the context into functions that can be used by the LLM.
+ * The registered intent will be ignored if excludeFromOpenAi is set to true.
+ * rawIntents may have tool nodes included so the values need to be filtered by the node type.
+ * rawIntents have the following shape:
+ *
+ * type RawIntents = {
+ *  [node_id]: node // node could be Registered Intent or Tool node
+ * }
+ */
+const createFunctionsFromContext = (rawIntents = {}) => {
+    return (
+        Object.values(rawIntents)
+            .filter((payload) => {
+                return payload.type === "Register Intent";
+            })
+            .map((payload) => {
+                if (payload.excludeFromOpenAi) {
+                    return undefined;
+                }
+
+                const parameters = payload.code?.trim() ?
+                    JSON.parse(payload.code) : { type: "object", properties: {}, required: [] };
+
+
+                //TODO -  Remove after all the old versions are deprecated
+                const { properties = {}, required = [] } = parameters
+                required.push("isRegisteredIntent")
+                properties.isRegisteredIntent = { type: "boolean", const: true }
+
+                return {
+                    type: "function",
+                    function: {
+                        name: payload.name,
+                        description: payload.description,
+                        parameters: {
+                            ...parameters,
+                            properties,
+                            required,
+                            additionalProperties: false
+                        },
+                        strict: true
+                    },
+                };
+            })
+            .filter(Boolean) || []
+    );
+};
+
+
+/**
+ *
+ * @param config
+ * @param deprecatedTools
+ * @returns {{}}
+ */
+const getToolProperties = (
+    config,
+    deprecatedTools = [],
+    deprecatedTools = [],
+    RED
+) => {
+
+    const tool_choice = config.tool_choice
+    const tool_string_ids = config.tools;
+    const tool_ids = tool_string_ids.split(",");
+    const toolProperties = {}
+    const allTools = getAllTools(RED)
+    const tools = []
+
+    if (tool_choice !== TOOL_CHOICE.None) {
+        [...deprecatedTools, ...allTools].forEach(tool => {
+            if (tool_ids.includes(tool.function.name)) {
+                tools.push(tool);
+            }
+        })
+
+        toolProperties.tools = tools
+        toolProperties.tool_choice = tool_choice
+    }
+
+    return toolProperties
+}
+
+module.exports = {
+    azureOpenAIHelper
+}