Integrate LLM services

def systemPreamble = """You are C.A.R.L. (Content Server Artificial intelligence Resource and Liaison), an LLM designed to help users working with OpenText Extended ECM"""
def defaultTemperature = 0.7
def model = "gpt-4"
def maxTokens = 2000

try {
    // Our services are implemented using fluent APIs and builders to simplify their usage
    // Use the auto-completion feature of the editor (CTRL+Space) to explore available configuration options
    def reqBuilder = openai.newChatCompletionRequestBuilder()
        .model(model)
        .temperature(defaultTemperature)
        .maxTokens(maxTokens)
        .n(1) // Request only one completion (most common use case)

    def req = reqBuilder.build()

    // Instruct the agent about its purpose and constraints using a system message
    req.addChatMessage("system", systemPreamble)

    // Add user request or message
    req.addChatMessage("user", "Does xECM support the concept of metadata?")

    // Submit the request and synchronously wait for the response
    def result = openai.createChatCompletion(req)

    // Extract and output the content of the first (and only) choice
    out << result.choices[0].message.content
} catch (Exception e) {
    out << "An error occurred: " + e.getMessage()
}

def systemPreamble = """You are C.A.R.L. (Content Server Artificial intelligence Resource and Liaison), an LLM designed to help users working with OpenText Extended ECM"""
def defaultTemperature = 0.7
def model = "llama3"
def maxTokens = 2000
def msgID = "MyMessage"

try {
    // Use the llm service with a LangChain-based builder for Ollama
    def reqBuilder = llm.newLangChainChatCompletionRequestBuilder("ollama")
        .model(model)
        .temperature(0.0)
        .logRequestsAndResponses(true)

    // Set a custom timeout for non-OpenAI services
    reqBuilder.builder.timeout(java.time.Duration.ofSeconds(180))

    def req = reqBuilder.build()

    // Add system message to define C.A.R.L.'s role
    req.addChatMessage("system", systemPreamble)

    // Add user query
    req.addChatMessage("user", "Does xECM support the concept of metadata?")

    // Submit the request and wait for the response
    def result = llm.createChatCompletion(req)

    // Output the AI-generated response
    out << result.choices[0].message.content
} catch (Exception e) {
    out << "An error occurred: " + e.getMessage()
}

def systemPreamble = """You are C.A.R.L. (Content Server Artificial intelligence Resource and Liaison), an LLM designed to help users working with OpenText Extended ECM"""
def defaultTemperature = 0.7
def model = "gpt-4"
def maxTokens = 2000
def msgID = "MyMessage"

try {
    def reqBuilder = openai.newChatCompletionRequestBuilder()
        .model(model)
        .temperature(defaultTemperature)
        .n(1)

    def req = reqBuilder.build()
    req.addChatMessage("system", systemPreamble)
    req.addChatMessage("user", "Does xECM support the concept of metadata?")

    def iterator = 0
    result = openai.streamChatCompletion(req, { block ->
        // This closure is invoked with streaming chunks as they become available
        def map = [
            content: block.choices?[0]?.message?.content,
            role:    block.choices?[0]?.message?.role,
            finishReason: (block.choices?[0]?.message?.content != null) ? block.choices?[0]?.finishReason : 'stop'
        ]
        log.debug("GOT {}", map) // Log for debugging
        cache.put(msgID + "_" + iterator++, 500, map)
    })

    out << result.choices
} catch (Exception e) {
    out << "An error occurred: " + e.getMessage()
}

def systemPreamble = """You are C.A.R.L. (Content Server Artificial intelligence Resource and Liaison), an LLM designed to help users working with OpenText Extended ECM"""
def defaultTemperature = 0.7
def model = "gpt-4"
def maxTokens = 2000
def msgID = "MyMessage"

try {
    def reqBuilder = openai.newChatCompletionRequestBuilder()
        .model(model)
        .temperature(defaultTemperature)
        .n(1)

    def req = reqBuilder.build()
    req.addChatMessage("system", systemPreamble)
    req.addChatMessage("user", "Create a folder for each month of the year in ${self.parent.ID}")

    // Define the function for creating a folder
    def func = openai.newChatFunctionBuilder()
        .name("createFolder")
        .description("Create a folder in the given space (identified by its ID)")
        .build()

    func.addStringParameter("folderName", "The name of the folder", true)
    func.addNumberParameter("parentID", "Parent Space Identifier", true)

    // Implement the function executor
    func.executor = { jsonArguments ->
        try {    
            def slurper = new JsonSlurper()
            def args = slurper.parseText(jsonArguments)
            def newNode = docman.createFolder(docman.getNode(args.parentID as Long), args.folderName)
            return "Created <a data-ampw='am-action' data-action='am_goTo' data-params='${newNode.ID}' data-toggle='click' href='#'>${newNode.name}</a>"
        } catch(e) {
            log.error("Unable to handle the request", e)
            return "Something went wrong"
        }
    }

    req.setFunctions([func])

    result = openai.createChatCompletion(req)
    out << result.choices[0].message
} catch (Exception e) {
    log.error("An error occurred ", e)
    out << "An error occurred: " + e.getMessage()
}

def systemPreamble = """You are C.A.R.L. (Content Server Artificial intelligence Resource and Liaison), an LLM designed to help users working with OpenText Extended ECM"""
def defaultTemperature = 0.7
def model = "gpt-4"
def maxTokens = 2000
def msgID = "MyMessage"

try {
    def reqBuilder = openai.newChatCompletionRequestBuilder()
        .model(model)
        .temperature(defaultTemperature)
        .n(1)

    def req = reqBuilder.build()
    req.addChatMessage("system", systemPreamble)
    req.addChatMessage("user", "Create a folder for each month of the year in ${self.parent.ID}")

    // Define the function for creating a folder
    def func = openai.newChatFunctionBuilder()
        .name("createFolder")
        .description("Create a folder in the given space (identified by its ID)")
        .build()

    func.addStringParameter("folderName", "The name of the folder", true)
    func.addNumberParameter("parentID", "Parent Space Identifier", true)

    // Implement the function executor
    func.executor = { jsonArguments ->
        try {    
            def slurper = new JsonSlurper()
            def args = slurper.parseText(jsonArguments)
            def newNode = docman.createFolder(docman.getNode(args.parentID as Long), args.folderName)
            return "Created <a data-ampw='am-action' data-action='am_goTo' data-params='${newNode.ID}' data-toggle='click' href='#'>${newNode.name}</a>"
        } catch(e) {
            log.error("Unable to handle the request", e)
            return "Something went wrong"
        }
    }

    req.setFunctions([func])

    result = openai.streamChatCompletion(req, { block->  //This is an asyncrnous method, meaning that the script execution
                                                        // won't wait for the completion to be terminated. The method accept 
                                                        // as its second parameter a closure that will be invoked with the streaming
                                                        // chunks as they become available

        def map = [
            content:block.choices?[0]?.message?.content,
            role:   block.choices?[0]?.message?.role,
            finishReason:(block.choices?[0]?.message?.content != null)?block.choices?[0]?.finishReason:'stop'
        ]
        log.debug("GOT {}", map) // Let's also print it into the log file for debugging
        cache.put(msgID+"_"+iterator++, 500, map) 

    })
    out << result*.content
} catch (Exception e) {
    log.error("An error occurred ", e)
    out << "An error occurred: " + e.getMessage()
}

def systemPreamble = "You are D.O.C.S. (Document Organizing and Creation System) an AI agent tasked to support users in creating documents.The content of the document MUST always be passed to the 'createDocument' function as valid X-HTML code (example: <b>DEMO</b>). Always wrap the content in a single 'div' element. Avoid the usage of HTML tag such as (BR). The font family for every text must be: font-family: Poppins, sans-serif tables must have a borders: 1px solid #fff;"

data = [:]
data.company = [name:"CreativeAnswer SA", address:"Via Penate 4, 6850 Mendrisio Switzerland", description:"""
At CreativeAnswer, we are a united marketing agency & software house blending creative brilliance with tech mastery.

We have developed a unique human-AI approach to help you create standout, cost-effective AI-driven marketing solutions with a competitive edge.

This isn't your typical AI tool. We don't settle for generic AI apps, nor do we just churn out text or images. Our creative and tech teams work in perfect sync, shaping ideas with proprietary AI, adapting and customizing them to your needs, and delivering the personal experience your customers want… effortlessly.

We bring you the most valuable approach to GenAI marketing, tailored exclusively for you. Just give it a try.

CreativeAnswer is a proud part of:
- AnswerModules Group, the award-winning Swiss tech company delivering personalized ECM software to 120+ enterprises, including 10 Global Fortune's 500
- Microsoft for Startups Founders Hub
"""]

data.user    = [name:"Patrick Vitali", role:"CTO"]

def defaultTemperature = 0.7
def model = "gpt-4o"
def maxTokens = 2000
def msgID = "MyMessage"
try{

    def reqBuilder  = openai.newChatCompletionRequestBuilder()
    .model(model)
    .temperature(defaultTemperature)
    .n(1) 

    def req = reqBuilder.build()

    func =  llm.newOpenAIChatFunctionBuilder().name("createDocument")
            .description("Given a title, creates a new document, matching user's requests with content generated by the AI agent").build()

    func.parameters = []
    func.addStringParameter("title",   "The document title", true)
    func.addStringParameter("content", "The document's content. The content must be a valid  X-HTML code (example: <b>DEMO</b>)", true)

    func.executor = { jsonArguments ->
        try{
            def slurper = new JsonSlurper()
            def args = slurper.parseText(jsonArguments)

            if(!args.title.endsWith('.docx')){
                args.title = "${args.title}.docx"
            }

            docTemplate = docman.getNodeByPath("CreativeAnswer:Marketing:Corporate Identity:Template.docx")
            newNode = docman.getNodeByName(docTemplate.parent, args.title)

            //Load contents from a Docx file for processing
            def doc = docx.loadWordDoc(docTemplate)

            //Creates a temporary resouce
            def res = docman.getTempResource("out", "docx") 

            //Updates the custom-xml databinding based on the OpenDoPE standard. Since: 2.3.0
            //Notice the combined used of multiple Content Script services: docx, docman, html, cache
            def xml = ""
            if(newNode){
                //Update xml with custom values
                xml = """<doc>
                            <content>&lt;div&gt;${html.escapeXML(html.htmlToXhtml(args.content))}&lt;/div&gt;</content>
                            <docID>${newNode.ID}</docID>
                        </doc>"""
                doc.updateOpenDoPEBindings(xml, true, true)
                doc.save(newNode)
            }else{
                newNode = doc.save(docTemplate.parent, args.title)
                xml = """<doc>
                            <content>&lt;div&gt;${html.escapeXML(html.htmlToXhtml(args.content))}&lt;/div&gt;</content>
                            <docID>${newNode.ID}</docID>
                        </doc>"""
                doc.updateOpenDoPEBindings(xml, true, true)
                doc.save(newNode)
            }
            ulrEditTemplate = "${url}?func=Edit.Edit&nodeid=${newNode.ID}&uiType=1&viewType=1&nexturl=${params.nextUrl}" 

            return "The requested document has been created with title: ${args.title}. <br>You can finalize the draft using the link that follows:<a target='_blank' href='${ulrEditTemplate}'>Edit</a>"

        }catch(e){
            log.error("Error ",e)
            return "Something went wrong "+e.message
        }
    }

    req.setFunctions([func])

    req.addChatMessage("system", //one out: system, assistant, user
                    systemPreamble) //We instruct the agent about its purpose and constraints using system messages at the beginning
    //of the chat
    req.addChatMessage("system", "When creating documents you should consider the following context, expressed in the form of a JSON structure: ${JsonOutput.toJson(data)}")

    //The user request   
    req.addChatMessage("user", "Create a presentation letter to be sent to John Doe, ACME's CMO") //Add user request or message

    result = openai.streamChatCompletion(req, { block->
        def map = [
            content:block.choices?[0]?.message?.content,
            role:   block.choices?[0]?.message?.role,
            finishReason:(block.choices?[0]?.message?.content != null)?block.choices?[0]?.finishReason:'stop'
        ]
        log.debug("GOT {}", map) // Let's also print it into the log file for debugging
        cache.put(msgID+"_"+iterator++, 500, map) 

    })
    out << result*.content

} catch (Exception e) {
    out << "An error occurred: " + e.getMessage()
}

    try {
        // Retrieve the document node from the Enterprise Workspace
        def document = docman.getNodeByPath(docman.getEnterpriseWS(), "Documents:MS_3_7_0_Manual.pdf")
        def docID = document.ID as String
        def lastVersion = document.lastVersion
        def list = null
        def sources = [:]

        // Prepare document metadata for indexing
        // We store metadata instead of raw text for efficiency:
        // 1. Document ID
        // 2. Document type (pdf or raw)
        // 3. Chunk dimension (e.g., page number or word count)
        // 4. Chunk identifier
        if (lastVersion.mimeType == "application/pdf") {
            // For PDF documents: Extract text page by page
            def content = pdf.getTextForPages(document)
            sources = content.collectEntries { entry -> 
                [("${docID}_pdf_1_${entry.key}"): entry.value] 
            }
        } else {
            // For non-PDF documents: Split content into word-based chunks
            def content = docman.getContentAsRawText(document)
            def chunkSize = 100 // Number of words per chunk (adjustable)
            def index = 0
            sources = content.split("\\s").toList().collate(chunkSize) *.join(" ").collectEntries {
                val -> [("${docID}_raw_${chunkSize}_${index++}"): val]
            }
        }

        // Process sources in batches of 10
        list = sources.entrySet().toList().findAll { it.value }.collate(10)
        def chunk = 0

        list.each { subEnties ->
            log.debug("Processing Chunk ${chunk} {}", subEnties *.value)
            try {
                // Generate embeddings for the current batch
                def req = llm.newOpenAIEmbeddingRequestBuilder()
                            .model("text-embedding-ada-002")
                            .input(subEnties *.value)
                            .build()
                def embeddings = llm.createEmbeddings(req).data

                // Build vectorial index using embeddings and metadata
                llm.newCSVectorialIndexManager().buildIndex(docID, embeddings, subEnties *.key)
            } catch (e) {
                // Log errors for individual chunks without stopping the entire process
                log.error("Unable to process chunk ${chunk}", e)
            }
            log.debug("End processing Chunk ${chunk++}")
        }
    } catch (e) {
        // Log any overall process errors
        log.error("An error occurred during index generation.", e)
    }

try {
    // Retrieve the document node using the provided path
    def document = docman.getNode(2031317 )
    def docID = document.ID as String
    def lastVersion = document.lastVersion
    def list = null
    def sources = [:]

    if (lastVersion.mimeType == "application/pdf") {
        // If the document is a PDF, extract text for each page and create embeddings
        def content = pdf.getTextForPages(document)
        sources = content.collectEntries { entry -> [("${docID}_pdf_1_${entry.key}"): entry.value] }
    } else {
        // If not a PDF, split the content into chunks and generate embeddings
        def content = docman.getContentAsRawText(document)
        def chunkSize = 100 // The number of words each chunk should be made of
        def index = 0
        sources = content.split("\\s").toList().collate(chunkSize) *.join(" ").collectEntries {
            val -> [("${docID}_raw_${chunkSize}_${index++}"): val]
        }

    }

    list = sources.entrySet().toList().findAll { it.value }.collate(10)
    def chunk = 0
    list.each { subEnties ->
        log.debug("Processing Chunk ${chunk} {}", subEnties *.value)
        try {
            // Create an embedding request for the chunk

            model = llm.newCSEmbeddingModelBuilder("ollama")
            .modelName("llama3")
            .logRequests(true)
            .logResponses(true)
            .build();

            def embeddings = []
            subEnties.each{
                embeddings << llm.newCSEmbedding( model.embed(it.value) )
            }

            // Build a vectorial index for the document using the embeddings
            llm.newCSVectorialIndexManager().buildIndex(docID, embeddings, subEnties*.key)
        } catch (e) {
            log.error("Unable to process chunk ${chunk}", e)
        }
        log.debug("End processing Chunk ${chunk++}")
    }
} catch (e) {
    log.error("An error occurred. ", e)
}

// Configuration parameters for the RAG system
def numberOfSnippetToConsider = 1      // Number of relevant snippets to use for context
def distanceSnippetTrashold = 0.8      // Cosine similarity threshold for relevant snippets
def embeddingModel = "text-embedding-ada-002"  // Model used for generating embeddings
def defaultTemperature = 0.8           // Temperature for LLM response generation
def model = "gpt-4"                    // LLM model to use for generating responses
def maxTokens = 2000                   // Maximum number of tokens in the LLM response
def msgID = "msgID"                    // Unique identifier for the message (used in streaming scenarios)

// Function to retrieve relevant context based on the user's question
def getContext = { String prompt ->
    // Get all document IDs in the KB folder (assuming documents are of subtype 144)
    def indexes = docman.getNodeByPath("KB").childrenFast.findAll{it.subtype == 144}.collect{it.ID as String}

    // Generate embedding for the user's prompt
    def req = openai.newEmbeddingRequestBuilder().model(embeddingModel).input([prompt]).build()
    def promptEmbedding = openai.createEmbeddings(req).data

    // Search the vector indexes for similar content
    def context = llm.newCSVectorialIndexManager().getIndexesSearcher(*indexes)
                    .query(promptEmbedding[0], 100, 100)
                    .findAll{it.score >= distanceSnippetTrashold}

    def textContext = ""
    if(context) {
        // Parse the index key to extract document information
        // Format: DOCID_identifier_chunkDimension_chunkNumber
        def (docID, extMode, dimension, chunkNum) = context[0].text.split("_")

        // Retrieve the actual text content based on the extraction mode
        switch(extMode) {
            case "raw":
                // For raw text, split into words and retrieve the specific chunk
                textContext = docman.getContentAsRawText(docman.getNodeFast(docID as Long))
                                .split("\\s")
                                .toList()
                                .collate(dimension as int)
                                *.join(" ")[chunkNum as int]
                break
            case "pdf":
                // For PDFs, retrieve the specific page(s)
                textContext = pdf.getTextForPages(docman.getNodeFast(docID as Long), 
                                                chunkNum as int, 
                                                (chunkNum as int) + (dimension as int))[(chunkNum as int)]
                break
        }
    }
    return textContext
}

// Main execution
def question = "Which is the biggest update on Module Suite 3.2.0 ?"

// Set up the chat completion request
def builder = openai.newChatCompletionRequestBuilder()
def req = builder.model(model)
                .user("u" + users.current.ID)
                .temperature(defaultTemperature)
                .n(1)
                .build()

// Add system message to define CARL's role
req.addChatMessage("system", "You're C.A.R.L. (Content Server Artificial intelligence Resource and Liaison) an LLM designed to help users working with OpenText Extended ECM")

// Retrieve relevant context for the question
def context = getContext(question)

// Add user message with or without context
if(context) {
    req.addChatMessage("user", """Given the following context: ${context}
Answer the user question: ${question}""")
} else {
    req.addChatMessage("user", question)
}

// Generate and output the response
result = openai.createChatCompletion(req)
out << result.choices[0].message.content