2023 ha sido el año de la IA y de la IA generativa en particular. La IA no es un tema nuevo, por supuesto. De hecho es bastante antiguo. Pero desde que OpenAI lanzó ChatGPT en noviembre de 2022, el ritmo de la innovación en IA se ha disparado y no hay signos de desaceleración en el corto plazo.

Por lo tanto, probablemente no fue una gran sorpresa cuando Jürgen Müller anunció en su discurso de apertura de SAP TechEd 2023 que SAP está integrando IA generativa en SAP Integration Suite.

(Me referiré a la IA generativa como GenAI en el resto de esta publicación de blog).

Una de las áreas en las que GenAI está teniendo un gran impacto es en los asistentes de codificación. Es decir, un copiloto de IA que ayuda a los desarrolladores generando código, documentación, etc. Aún no conocemos los detalles de cómo SAP pretende integrar GenAI en SAP Integration Suite, pero un copiloto de IA para crear flujos de integración parece una apuesta bastante segura.

GenAI se destaca en la creación de texto, por lo que generar scripts en SAP Cloud Integration es otra área donde un copiloto de IA tendría mucho sentido. Y la generación de scripts es algo con lo que ya podemos experimentar, sin tener que esperar a que se lance el copiloto de IA de SAP.

La creación de scripts Groovy con GenAI es un área que quería investigar desde hace tiempo, así que cuando OpenAI lanzó su función GPT personalizada, decidí intentarlo.

Los GPT personalizados se anunciaron en la conferencia DevDay de OpenAI en San Francisco en noviembre de 2023. Puede consultar el anuncio aquí. Los GPT personalizados son una forma de especializar ChatGPT en un campo o tema en particular. Están construidos sobre el modelo básico GPT-4, el modelo más potente de OpenAI hasta el momento. El modelo se especializa mediante indicaciones y los llamados archivos de conocimiento; no hay codificación ni ajustes complejos (y costosos) involucrados en el proceso. Esto hizo que un GPT personalizado se adaptara perfectamente a mi proyecto.

Los GPT personalizados se pueden compartir, pero por el momento solo están disponibles para miembros de ChatGPT Plus (una suscripción paga) y clientes empresariales de OpenAI. OpenAI planea lanzar una tienda para GPT personalizados en una fecha posterior.

Un asistente de IA necesita un nombre propio, por supuesto, y yo llamé al mío GroovyScriptinator. Mi enfoque de capacitación fue iterativo: pruebe un mensaje, identifique cualquier cosa que deba modificarse en la respuesta, actualice las instrucciones en consecuencia y repita.

Fuera de la caja, GPT-4 ya es muy capaz de generar código Groovy. Por ese motivo, centré mis esfuerzos formativos en las siguientes tres áreas más específicas:

• El entorno de integración de SAP Cloud
• Mejores prácticas
• Creando código Groovy idiomático

A continuación se muestran algunos ejemplos de instrucciones de la primera categoría:

• Todo el código generado debe ser compatible con Groovy versión 2.4
• No utilice bibliotecas de Java que requieran una versión de Java posterior a Java 8
• La función de script generada debe llamarse processData o el paso de guión debe configurarse con el nombre de función no predeterminado

A continuación se muestran algunos ejemplos de instrucciones de la segunda categoría:

• Pase siempre la carga útil como Reader oponerse a XmlSlurper y JsonSlurper
• No imprima XML y JSON a menos que haya una razón para hacerlo.
• Utilice el nivel de registro en tiempo de ejecución o un parámetro externalizado para controlar el registro

A continuación se muestran algunos ejemplos de instrucciones de la tercera categoría:

• No agregue un punto y coma al final de una declaración
• No uses ambos def y un tipo al declarar una variable
• No importe clases que ya se importen automáticamente en Groovy

Por el momento, mis instrucciones para GroovyScriptinator tienen alrededor de 1800 palabras, pero es probable que ese número siga creciendo. 1800 palabras es aproximadamente la longitud de esta publicación de blog sin las listas de códigos.

Mientras trabajaba en mi GPT personalizado, utilicé una serie de indicaciones para probar su rendimiento. He elegido cuatro ejemplos para esta publicación de blog para demostrar lo que es posible. Para cada ejemplo, he vinculado la conversación para que puedas ver la respuesta completa por ti mismo.

Ejemplo 1: procesamiento JSON

El primer ejemplo se basa en esta pregunta de la comunidad SAP. Edité la parte sobre un script existente porque quería que GroovyScriptinator encontrara una solución completa al problema. Este es el script que generó en respuesta:

import com.sap.gateway.ip.core.customdev.util.Message
import groovy.json.JsonSlurper
import groovy.json.JsonOutput

def Message processData(Message message) {
    // Parse the JSON payload
    def jsonPayload = new JsonSlurper().parseText(message.getBody(String))

    // Remove the 'shippingPackages' object
    jsonPayload.remove('shippingPackages')

    // Set the modified JSON back to the message body
    message.setBody(JsonOutput.toJson(jsonPayload))

    return message
}

Este script funciona y genera el resultado solicitado. Tiene un formato agradable e incluso tiene comentarios decentes. En realidad es bastante similar a mi propia respuesta a la misma pregunta.

Sin embargo, los dos scripts difieren en un aspecto: la carga útil realmente debería pasarse a JsonSlurper como un Reader objeto en lugar de un String objeto (de esa manera una carga útil grande no se lee innecesariamente en la memoria). Esta mejor práctica es en realidad parte de mis instrucciones de GroovyScriptinator, pero parece haberlo olvidado temporalmente (más sobre eso a continuación).

Le pedí que corrigiera esto y recibí el siguiente script en respuesta:

import com.sap.gateway.ip.core.customdev.util.Message
import groovy.json.JsonSlurper
import groovy.json.JsonOutput

def Message processData(Message message) {
    // Access the JSON payload as a Reader
    def payloadReader = message.getBody(Reader)

    // Parse the JSON payload
    def jsonPayload = new JsonSlurper().parse(payloadReader)

    // Remove the 'shippingPackages' object
    jsonPayload.remove('shippingPackages')

    // Set the modified JSON back to the message body
    message.setBody(JsonOutput.toJson(jsonPayload))

    return message
}

Este script también genera la salida solicitada y accede correctamente a la carga útil a través del método más eficiente. Reader. Puedes ver la conversación completa aquí.

Ejemplo 2: más JSON

Mi segundo ejemplo se basa en este Pregunta de la comunidad SAP (JSON es un tema popular de secuencias de comandos de Groovy). Una vez más edité la parte sobre un script existente para ver la propia solución al problema de GroovyScriptinator. Este es el script que generó para mí:

import com.sap.gateway.ip.core.customdev.util.Message
import groovy.json.JsonSlurper
import groovy.json.JsonOutput

def Message processData(Message message) {
    // Parse the JSON payload
    def jsonParser = new JsonSlurper()
    def jsonPayload = message.getBody(Reader)
    def parsedJson = jsonParser.parse(jsonPayload)

    // Add the new root node
    def modifiedJson = [data: parsedJson]

    // Convert the modified JSON back to String
    String jsonString = JsonOutput.toJson(modifiedJson)

    // Set the modified JSON as the new payload
    message.setBody(jsonString)

    return message
}

El script funciona correctamente y esta vez, GroovyScriptinator utilizó correctamente un Reader para acceder a la carga útil. Incluso señaló que el JSON de entrada proporcionado, de hecho, no es válido y que el script solo funciona cuando la entrada es válida.

Lo único que señalaría es que es un poco extraño declarar todas las variables con def excepto jsonStringque se declara con su tipo (String). Aunque es un pequeño detalle. Puedes ver la conversación completa aquí.

Ejemplo 3: variables de entorno

Mi tercer ejemplo es un guión que necesitaba para mí. Este es el mensaje que utilicé:

“Necesito un script que cree una carga útil de texto sin formato que contenga los nombres de todas las variables de entorno y sus valores. Me gustaría que el resultado tuviera el formato “NOMBRE = VALOR”, un par de nombre/valor en cada línea”.

Este es el guión que recibí en respuesta:

import com.sap.gateway.ip.core.customdev.util.Message

def Message processData(Message message) {
    // StringBuilder for constructing the output
    def output = new StringBuilder()

    // Iterate over all environment variables and append them to the output
    System.env.each { key, value ->
        output << key << " = " << value << '\n'
    }

    // Set the generated string as the message payload
    message.setBody(output.toString())

    return message
}

Este script funciona y es una solución muy decente a mi problema. Corto, dulce y al punto. Utiliza un StringBuilder para componer la carga útil de manera eficiente e incluso utiliza la forma Groovy de agregar al StringBuilder con el << operador. Lo único que señalaría es que la cadena adjunta con el signo igual realmente debería estar entre comillas simples, pero esa es una queja menor. Puedes ver la conversación completa aquí.

Ejemplo 4: formato de longitud fija a CSV

El último ejemplo es un requisito que creé específicamente para probar GroovyScriptinator. Utilicé el siguiente mensaje:

“Necesito un script que convierta una carga útil de texto con formato de longitud fija en una carga útil de texto separado por comas.

La carga útil contiene varias líneas. Las columnas del archivo tienen las siguientes longitudes: 3, 6, 3, 5, 2

Los espacios finales deben eliminarse de la cuarta columna (pero sólo de la cuarta columna).

A continuación se muestra una línea de entrada de ejemplo:

xyz123456abcdef 99

Aquí está la línea de salida correspondiente:

xyz,123456,abc,def,99

Puedes suponer que cada línea tiene la misma longitud y que esta longitud es la suma de las longitudes de las columnas”.

Aquí está el guión con el que respondió GroovyScriptinator:

import com.sap.gateway.ip.core.customdev.util.Message

def Message processData(Message message) {
    // Define column lengths
    def columnLengths = [3, 6, 3, 5, 2]

    // Get the payload as a string
    def payload = message.getBody(String)
    def lines = payload.split('\n')
    def newLines = []

    lines.each { line ->
        def start = 0
        def columns = columnLengths.collect { length ->
            def column = line.substring(start, start + length)
            start += length
            column
        }

        // Trim trailing spaces from the fourth column
        columns[3] = columns[3].trim()

        // Join columns with commas
        newLines << columns.join(',')
    }

    // Set the modified payload back into the message
    message.setBody(newLines.join('\n'))

    return message
}

Este script resuelve el problema como se indicó y es realmente bastante bueno. Básicamente no tengo ninguna nota. Mantuvo las longitudes de las columnas en una estructura de datos adecuada, en lugar de codificarlas en el script. Incluso acertó en que la cuarta columna tiene índice 3. Puedes ver la conversación completa. aquí.

Los ejemplos anteriores no están preparados ni han sido manipulados de ninguna manera. Son representativos del estándar del código creado por el GPT personalizado. Comete errores (consulte las preguntas frecuentes a continuación), pero en general la calidad de las respuestas es muy alta. Muchos de los scripts generados son tan buenos que pueden agregarse a su flujo de integración tal cual o con modificaciones mínimas. ¡Me gustaría que hicieras una pausa por un momento y pensaras en lo poderoso que es eso!

Entonces, mi conclusión es bastante obvia: un copiloto de IA es perfecto para las secuencias de comandos Groovy en SAP Cloud Integration y no hay duda alguna sobre su viabilidad. No tengo dudas de que GenAI será parte de tu trabajo diario como desarrollador de SAP Cloud Integration. Y probablemente sucederá más temprano que tarde.

¡Probablemente tengas muchas preguntas! Intenté responder algunas de ellas en las siguientes preguntas frecuentes, pero no dudes en hacer preguntas también en los comentarios. Si me perdí alguno obvio, lo agregaré a las preguntas frecuentes.

¿Significa esto que no tengo que aprender Groovy?

No. Puede desarrollar SAP Cloud Integration sin conocer Groovy, pero si desea agregar scripts de Groovy a su caja de herramientas (¡y definitivamente creo que debería hacerlo!), entonces necesita aprender el idioma.

¿Pero por quéaaa? ¿No puedo simplemente usar GenAI para escribir todo el código?

Tú podría, por supuesto. Pero, ¿qué sucede una vez generado el guión? En primer lugar, no sabrás si realmente funciona. E incluso si parece funcionar, no sabrá por qué ni en qué circunstancias. Si luego dejas de lado la precaución, implementas el guión en producción y se rompe, será tu responsabilidad arreglarlo, pero no tendrás idea. cómo arreglarlo.

Esta es la razón por la que generalmente es una muy, muy mala idea agregar código que no comprende a su solución de integración. Volverá a morderte en el perseguirte más adelante.

¿GenAI comete errores?

Sí. Si ha utilizado ChatGPT o chatbots GenAI similares antes, es muy probable que también lo haya experimentado usted mismo.

Estoy realmente impresionado con la calidad del código generado por mi GPT personalizado. ¡Pero eso no significa que sea infalible! A veces, todavía le presentará con gusto y confianza código que tiene errores de sintaxis o código que es sintácticamente correcto pero que simplemente no funciona. A veces también olvida partes de sus instrucciones.

Entonces, si GenAI comete errores, ¿eso significa que apesta y que puedo ignorarlo con seguridad?

Absolutamente no. En realidad, simplemente enfatiza el papel de copiloto de los asistentes de codificación GenAI. Todavía se necesita un ser humano en el asiento del piloto y con GenAI esa persona tiene una poderosa herramienta de productividad a su disposición.

Si ignora GenAI en este momento, lo hace bajo su propio riesgo. Esta no es otra moda tecnológica que pueda esperarse con un poco de paciencia. Lo ames o lo odies, necesitas comprender qué es GenAI, qué puede y qué no puede hacer y cómo se puede aplicar en tu contexto.

¿Lanzarás GroovyScriptinator?

Si hay interés, podría hacerlo en algún momento. Aunque primero me gustaría retocarlo un poco más.