connection.client.addHeader("apiKey", "${secrets.apiKey}");

...
// url
endpointEmbeddings = "${template.endpoint}/openai/deployments/${template.model}/embeddings?api-version=${template.apiVersion}"

....
def getEmbeddingsFromSentence(endpointEmbeddings, sentence) {
  response = connection.client.executePost(endpointEmbeddings, 

def resp = connection.client.executeGet("url"));
if(resp.getStatusCode() == 429){
  long pauseSeedUntil = System.currentTimeMillis() + (Integer.valueOf(resp.getHeaders().get("Retry-After")) * 1000);
  throw new com.accenture.aspire.services.ThrottlingNotificationException(pauseSeedUntil);
}

import com.accenture.aspire.services.AspireObject;

utilities.textSplitter.initialize(getTextSplitterConfig("sentence"))
utilities.azure.embeddings.initialize(getEmbeddingsConfig())

def getEmbeddingsConfig() {
    AspireObject returnValue = new AspireObject("config");
    returnValue.add("endpoint", "${template.endpoint}");
    returnValue.add("model", "${template.model}");
    returnValue.add("apiVersion", "${template.apiVersion}");
    returnValue.add("apiKey", "${secrets.apiKey}");
    return returnValue;
}

def getTextSplitterConfig(String splitType) {
  .....
}

def sentences = utilities.textSplitter.process(doc);
embeddings = utilities.azure.embeddings.process(sentences);
doc.add(embeddings.toAspireObject());

import com.accenture.aspire.services.AspireException

// split field "content" and create "sentences"
def sentences = utilities.textSplitter.process(doc);

// url
endpointEmbeddings = "${template.endpoint}/openai/deployments/${template.model}/embeddings?api-version=${template.apiVersion}"

// generate and publish embeddings
sentences.eachWithIndex {currentSentence, sentencesCount ->
  embeddingVector = getEmbeddingsFromSentence(endpointEmbeddings, currentSentence)
  subJobAO = utilities.azure.embeddings.createSubDoc(embeddingVector, doc, sentencesCount);
  utilities.createSubJob(job, subJobAO)
}

def getEmbeddingsFromSentence(endpointEmbeddings, sentence) {
  response = connection.client.executePost(endpointEmbeddings, utilities.azure.embeddings.createPostBody(sentence));
  def embeddings = utilities.azure.embeddings.convertResponse(sentence, response)
  return embeddings
}

utilities.createSubJob(job, subJobAO)

client.addHeader("api-key", "${secrets.apiKey}");

def getEmbeddingsConfig() {
    AspireObject returnValue = new AspireObject("config");
    returnValue.add("endpoint", "${template.endpoint}");
    ....
}

// url
endpointEmbeddings = "${template.endpoint}/openai/deployments/${template.model}/embeddings?api-version=${template.apiVersion}"

import com.accenture.aspire.services.AspireObject;

utilities.azure.prompts.initialize(getPromptsConfig())

private AspireObject getPromptsConfig() {
    AspireObject configAO = new AspireObject("config");
    configAO.add("endpoint", "${template.endpoint}");
    configAO.add("model", "${template.model}");
    configAO.add("apiVersion", "${template.apiVersion}");
    configAO.add("apiKey", "${secrets.apiKey}");
    configAO.add("temperature", "${template.temperature}");
    configAO.add(getPromptsList());
    return configAO;
}

private AspireObject getPromptsList(){
    AspireObject prompts = new AspireObject("prompts");
    def returnValue = new ArrayList();
    AspireObject prompt = AspireObject.createFromJSON("prompt", "{\"prompt\":{\"promptType\":\"user\",\"useGroovy\":false,\"promptText\":\"Describe the paws of a polar bear named \\\"Thunder\\\"\"}}", false);
    returnValue.add(prompt);
    prompt = AspireObject.createFromJSON("prompt", "{\"prompt\":{\"promptType\":\"system\",\"useGroovy\":true,\"promptText\":\"return \\\"Describe it like you are \\\"+doc.getText(\\\"character\\\")+\\\"\\\";\"}}", false);
    returnValue.add(prompt);
    prompt = AspireObject.createFromJSON("prompt", "{\"prompt\":{\"promptType\":\"system\",\"useGroovy\":true,\"promptText\":\"return \\\"Describe it like it lived in the planet \\\"+doc.getText(\\\"planet\\\");\"}}", false);
    returnValue.add(prompt);
    prompts.add(returnValue);
    return prompts;
}

promptsResponse = utilities.azure.prompts.process(doc);
doc.add(promptsResponse.toAspireObject());

import com.accenture.aspire.services.AspireObject;

// url
endpointPrompts = "${template.endpoint}/openai/deployments/${template.model}/chat/completions?api-version=${template.apiVersion}"

...
for (String paragraph : small_piece_list) {
  answer = generateSummaryOfSummaries(endpointPrompts, paragraph.take(MODEL_MAX_MESSAGE_SIZE - MODEL_MAX_TOKENS))
  if (doc.get("summarizationError")?.getContent()) {
    component.info("%s", "summarization error detected on document: ${doc.get('summarizationError')}")
    searchFields.add("summarizationError", doc.getContent("summarizationError"))
    searchFields.add("generatedSummary", "")
    return
  } else {
    summaries.add(answer["summary"])
    keyphrases.addAll(answer["keyphrases"])
  }
}

def generateSummaryOfSummaries(endpointSummary, article) {
  def requestRetries = 0
  body = [
          "messages"         : [[
                                        "role"   : "system",
                                        "content": "You are a system that, given a text, extract a summary from it, and also a list of important keywords from it, based on the user input"],
                                [
                                        "role"   : "user",
                                        "content": "CONTENT={${article}}\
1.Clean [CONTENT] by removing formatting, special characters, and non-alphanumeric symbols.\
2. Read through the entire document to grasp its main points and arguments.\
3. Identify the key topics and supporting details presented in the document.\
4. Create an outline for the summary, noting the main sections or topics covered.\
5. Summarize each main section or topic in a clear and concise manner, using your own words, focusing on presenting the most significant and relevant information while leaving out unnecessary details.Aim for a summary length of 3-5 lines or a paragraph, depending on the document's size and complexity.\
6. Review the summary for accuracy and coherence with the original document, checking that the summary conveys the main points and ideas accurately.Respond as follows:\
SUMMARY:summary\
7. Provide the final list of max 100 important keyphrases without considering the frequency. Include all the abbreviations in the list, and do not repeat any keyphrases. Respond as follows:\
 KEYPHRASES:comma separated list of keyphrases"
                                ]
          ],
          "temperature"      : "${template.temperature}",
          "max_tokens"       : 1500,
          "top_p"            : 1.0,
          "frequency_penalty": 0.0,
          "presence_penalty" : 0.0
  ];
  response = connection.client.executePost(endpointSummary, utilities.azure.prompts.createPostBody(body));
  def request_result = getSummaryFromResponse(response)
  if (!request_result["isError"]) {
    return request_result
  } else {
    responseHeaders = response.getHeaders()
  }
  doc.add("summarizationError", "Errors on request for summary and keyphrases.")
  return ["isError": true, "summary": "", "keyphrases": []]
}

def getSummaryFromResponse(response) {
  def isError = true
  def summary = ""
  def keyphrases = []
  if (response.getStatusCode() == 200) {
    def content = response.getContent();
    def choices = content.get("choices");

    if (choices != null) {
      def finish_reason = choices.getText("finish_reason");
      if (finish_reason == "content_filter") {
        component.info("%s", "${doc.id}: Unable to generate summary. Document has content that was blocked by Azure content filter. Setting summarization error")
        doc.add("summarizationError", "Unable to generate summary due to Content Filtering Policy")
        summary = "";
        keyphrases = []
        isError = false
      } else {
        def message = choices.get("message");
        component.info("%s", "${doc.id}: message content: ${message}")
        def content_openai = message != null ? message.getText("content") : "";
        //the response from the AI has now 2 parts, one SUMMARY, and one KEYPHRASES. Parsing the message to get them and store in the value to return.
        def finder = (content_openai =~ /(SUMMARY|KEYPHRASES):\\s*(.+)/)
        finder.each { match ->
          if (match.size() == 3) {
            if (match[1] == "SUMMARY") {
              summary = match[2]
              component.info("%s", "${doc.id}: summary piece: ${summary}")
            }
            if (match[1] == "KEYPHRASES") {
              keyphrases = match[2].split(",")
              component.info("%s", "${doc.id}: keyphrases piece: ${keyphrases}")
            }
          }
        }
        isError = false
      }

    }
  } else {
   ....
  }
  return ["isError": isError, "summary": summary, "keyphrases": keyphrases]
}

import com.accenture.aspire.services.AspireObject;

utilities.textSplitter.initialize(getTextSplitterConfig("sentence"))

def getTextSplitterConfig(String splitType) {
    AspireObject returnValue = new AspireObject("config");
    returnValue.add("splitType", splitType);
    returnValue.add("fieldsToSplit", "content");
    returnValue.add("customSplitRegex", "\\|+");
    returnValue.add("characterThreshold", 4);
    return returnValue;
}

def sentences = utilities.textSplitter.process(doc);

variables.put("OPENAI_API_KEY_AZURE", "XXXXXXXXXXXXXXXXXXXXX")
variables.put("OPENAI_API_BASE_AZURE", "fi-so-openai-apim-latest.azure-api.net")
variables.put("DEPLOYMENT_NAME", "text-embedding-ada-002")
variables.put("REQUEST_ORIGIN", "Aspire-DEV")
variables.put("RANDOM_GENERATOR", new Random())
variables.put("ACCESS_SEMAPHORE", new Semaphore(1))