feat(dotAI): Dot AI LangChain4J integration (First provider/OpenAI)

bom/application/pom.xml

@@ -27,6 +27,7 @@
         <graalvm.polyglot.version>25.0.1</graalvm.polyglot.version>
         <micrometer.version>1.13.10</micrometer.version>
         <opensearch.version>3.3.0</opensearch.version>
+        <langchain4j.version>1.0.0</langchain4j.version>
     </properties>
     <dependencyManagement>
 
@@ -70,6 +71,14 @@
                 <scope>import</scope>
             </dependency>
 
+            <dependency>
+                <groupId>dev.langchain4j</groupId>
+                <artifactId>langchain4j-bom</artifactId>
+                <version>${langchain4j.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+
 
             <!-- Asynchronous NIO client server framework for the jvm -->
             <!-- <dependency>

dotCMS/pom.xml

@@ -503,6 +503,11 @@
             <groupId>io.vavr</groupId>
             <artifactId>vavr</artifactId>
         </dependency>
+        <dependency>
+            <!-- LangChain4J OpenAI provider: Chat, Embedding, Image models via OpenAI API -->
+            <groupId>dev.langchain4j</groupId>
+            <artifactId>langchain4j-open-ai</artifactId>
+        </dependency>
         <dependency>
             <groupId>jakarta.inject</groupId>
             <artifactId>jakarta.inject-api</artifactId>

dotCMS/src/main/java/com/dotcms/ai/AiKeys.java

@@ -62,6 +62,7 @@ public class AiKeys {
     public static final String COUNT = "count";
     public static final String INPUT = "input";
     public static final String RESPONSE_FORMAT = "response_format";
+    public static final String B64_JSON = "b64_json";
 
     private AiKeys() {}
 

dotCMS/src/main/java/com/dotcms/ai/api/EmbeddingsAPIImpl.java

@@ -343,9 +343,11 @@ public Tuple2<Integer, List<Float>> pullOrGenerateEmbeddings(final String conten
                 .getEncoding()
                 .map(encoding -> encoding.encode(content))
                 .orElse(List.of());
+        final int tokenCount = tokens.isEmpty() ? content.split("\\s+").length : tokens.size();
         if (tokens.isEmpty()) {
-            config.debugLogger(this.getClass(), () -> String.format("No tokens for content ID '%s' were encoded: %s", contentId, content));
-            return Tuple.of(0, List.of());
+            config.debugLogger(this.getClass(), () -> String.format(
+                    "Encoding unavailable for content ID '%s', using word count (%d) as token estimate",
+                    contentId, tokenCount));
         }
 
         final Tuple3<String, Integer, List<Float>> dbEmbeddings =
@@ -359,8 +361,8 @@ public Tuple2<Integer, List<Float>> pullOrGenerateEmbeddings(final String conten
         }
 
         final Tuple2<Integer, List<Float>> openAiEmbeddings = Tuple.of(
-                tokens.size(),
-                sendTokensToOpenAI(contentId, tokens, userId));
+                tokenCount,
+                sendTokensToOpenAI(contentId, tokens, content, userId));
         saveEmbeddingsForCache(content, openAiEmbeddings);
         EMBEDDING_CACHE.put(hashed, openAiEmbeddings);
 
@@ -436,10 +438,11 @@ private void saveEmbeddingsForCache(final String content, final Tuple2<Integer,
      */
     private List<Float> sendTokensToOpenAI(final String contentId,
                                            @NotNull final List<Integer> tokens,
+                                           @NotNull final String content,
                                            final String userId) {
         final JSONObject json = new JSONObject();
         json.put(AiKeys.MODEL, config.getEmbeddingsModel().getCurrentModel());
-        json.put(AiKeys.INPUT, tokens);
+        json.put(AiKeys.INPUT, content);
         config.debugLogger(this.getClass(), () -> String.format("Content tokens for content ID '%s': %s", contentId, tokens));
         final String responseString = AIProxyClient.get()
                 .callToAI(JSONObjectAIRequest.quickEmbeddings(config, json, userId))

dotCMS/src/main/java/com/dotcms/ai/api/OpenAIImageAPIImpl.java

@@ -25,8 +25,10 @@
 import io.vavr.control.Try;
 
 import javax.servlet.http.HttpServletRequest;
+import java.io.ByteArrayInputStream;
 import java.net.URL;
 import java.text.SimpleDateFormat;
+import java.util.Base64;
 import java.util.Date;
 
 public class OpenAIImageAPIImpl implements ImageAPI {
@@ -99,21 +101,30 @@ public JSONObject sendTextPrompt(final String textPrompt) {
     }
 
     private JSONObject createTempFile(final JSONObject imageResponse) {
-        final String url = imageResponse.optString(AiKeys.URL);
-        if (UtilMethods.isEmpty(() -> url)) {
-            Logger.warn(this.getClass(), "imageResponse does not include URL:" + imageResponse);
-            throw new DotRuntimeException("Image Response does not include URL:" + imageResponse);
-        }
-
         try {
             final String fileName = generateFileName(imageResponse.getString(AiKeys.ORIGINAL_PROMPT));
             imageResponse.put("tempFileName", fileName);
 
-            final DotTempFile file = tempFileApi.createTempFileFromUrl(fileName, getRequest(), new URL(url), 20);
+            final String url = imageResponse.optString(AiKeys.URL);
+            final String b64 = imageResponse.optString(AiKeys.B64_JSON);
+            final DotTempFile file;
+
+            if (!UtilMethods.isEmpty(() -> url)) {
+                file = tempFileApi.createTempFileFromUrl(fileName, getRequest(), new URL(url), 20);
+            } else if (!UtilMethods.isEmpty(() -> b64)) {
+                final byte[] imageBytes = Base64.getDecoder().decode(b64);
+                file = tempFileApi.createTempFile(fileName, getRequest(), new ByteArrayInputStream(imageBytes));
+            } else {
+                Logger.warn(this.getClass(), "imageResponse does not include URL or base64 data:" + imageResponse);
+                throw new DotRuntimeException("Image Response does not include URL or base64 data:" + imageResponse);
+            }
+
             imageResponse.put(AiKeys.RESPONSE, file.id);
             imageResponse.put("tempFile", file.file.getAbsolutePath());
 
             return imageResponse;
+        } catch (DotRuntimeException e) {
+            throw e;
         } catch (Exception e) {
             imageResponse.put(AiKeys.RESPONSE, e.getMessage());
             imageResponse.put(AiKeys.ERROR, e.getMessage());

dotCMS/src/main/java/com/dotcms/ai/app/AIModels.java

@@ -3,92 +3,40 @@
 import com.dotcms.ai.domain.Model;
 import com.dotcms.ai.domain.ModelStatus;
 import com.dotcms.ai.exception.DotAIModelNotFoundException;
-import com.dotcms.ai.model.OpenAIModel;
-import com.dotcms.ai.model.OpenAIModels;
 import com.dotcms.ai.model.SimpleModel;
-import com.dotcms.business.SystemTableUpdatedKeyEvent;
-import com.dotcms.http.CircuitBreakerUrl;
-import com.dotcms.system.event.local.model.EventSubscriber;
-import com.dotmarketing.business.APILocator;
-import com.dotmarketing.exception.DotRuntimeException;
-import com.dotmarketing.util.Config;
-import com.dotmarketing.util.Logger;
-import com.dotmarketing.util.UtilMethods;
-import com.github.benmanes.caffeine.cache.Cache;
-import com.github.benmanes.caffeine.cache.Caffeine;
-import com.google.common.annotations.VisibleForTesting;
 import io.vavr.Lazy;
 import io.vavr.Tuple;
 import io.vavr.Tuple2;
 import io.vavr.Tuple3;
-import org.apache.commons.collections4.CollectionUtils;
+import com.dotmarketing.util.Logger;
+import com.dotmarketing.util.UtilMethods;
 
-import java.time.Duration;
 import java.util.List;
-import java.util.Objects;
 import java.util.Optional;
-import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Collectors;
 
 /**
  * Manages the AI models used in the application. This class handles loading, caching,
- * and retrieving AI models based on the host and model type. It also fetches supported
- * models from external sources and maintains a cache of these models.
+ * and retrieving AI models based on the host and model type.
  *
  * @author vico
  */
-public class AIModels implements EventSubscriber<SystemTableUpdatedKeyEvent> {
+public class AIModels {
 
-    private static final String SUPPORTED_MODELS_KEY = "supportedModels";
-    private static final String AI_MODELS_FETCH_ATTEMPTS_KEY = "ai.models.fetch.attempts";
-    private static final String AI_MODELS_FETCH_TIMEOUT_KEY = "ai.models.fetch.timeout";
-    private static final String AI_MODELS_API_URL_KEY = "AI_MODELS_API_URL";
-    private static final String AI_MODELS_API_URL_DEFAULT = "https://api.openai.com/v1/models";
-    private static final int AI_MODELS_CACHE_TTL = 28800;  // 8 hours
-    private static final int AI_MODELS_CACHE_SIZE = 256;
     private static final Lazy<AIModels> INSTANCE = Lazy.of(AIModels::new);
-    public static final String BEARER = "Bearer ";
 
     private final ConcurrentMap<String, List<Tuple2<AIModelType, AIModel>>> internalModels;
     private final ConcurrentMap<Tuple3<String, Model, AIModelType>, AIModel> modelsByName;
-    private final Cache<String, Set<String>> supportedModelsCache;
-    private final AtomicInteger modelsFetchAttempts;
-    private final AtomicLong modelsFetchTimeout;
-    private final AtomicReference<String> aiModelsApiUrl;
 
     public static AIModels get() {
         return INSTANCE.get();
     }
 
-    private static int resolveModelsFetchAttempts() {
-        return Config.getIntProperty(AI_MODELS_FETCH_ATTEMPTS_KEY, 90);
-    }
-
-    private static long resolveModelsFetchTimeout() {
-        return Config.getLongProperty(AI_MODELS_FETCH_TIMEOUT_KEY, 4000);
-    }
-
-    private static String resolveAiModelsApiUrl() {
-        return Config.getStringProperty(AI_MODELS_API_URL_KEY, AI_MODELS_API_URL_DEFAULT);
-    }
-
     private AIModels() {
         internalModels = new ConcurrentHashMap<>();
         modelsByName = new ConcurrentHashMap<>();
-        supportedModelsCache =
-                Caffeine.newBuilder()
-                        .expireAfterWrite(Duration.ofSeconds(AI_MODELS_CACHE_TTL))
-                        .maximumSize(AI_MODELS_CACHE_SIZE)
-                        .build();
-        modelsFetchAttempts = new AtomicInteger(resolveModelsFetchAttempts());
-        modelsFetchTimeout = new AtomicLong(resolveModelsFetchTimeout());
-        aiModelsApiUrl = new AtomicReference<>(resolveAiModelsApiUrl());
-        APILocator.getLocalSystemEventsAPI().subscribe(SystemTableUpdatedKeyEvent.class, this);
     }
 
     /**
@@ -234,42 +182,6 @@ public void resetModels(final String host) {
                 .filter(key -> key._1.equals(host))
                 .collect(Collectors.toSet())
                 .forEach(modelsByName::remove);
-        cleanSupportedModelsCache();
-    }
-
-    /**
-     * Retrieves the list of supported models, either from the cache or by fetching them
-     * from an external source if the cache is empty or expired.
-     *
-     * @return a set of supported model names
-     */
-    public Set<String> getOrPullSupportedModels(final AppConfig appConfig) {
-        final Set<String> cached = supportedModelsCache.getIfPresent(SUPPORTED_MODELS_KEY);
-        if (CollectionUtils.isNotEmpty(cached)) {
-            return cached;
-        }
-
-        if (!appConfig.isEnabled()) {
-            appConfig.debugLogger(getClass(), () -> "dotAI is not enabled, returning empty set of supported models");
-            return Set.of();
-        }
-
-        final CircuitBreakerUrl.Response<OpenAIModels> response = fetchOpenAIModels(appConfig);
-
-         if (Objects.nonNull(response.getResponse().getError())) {
-            throw new DotRuntimeException("Found error in AI response: " + response.getResponse().getError().getMessage());
-        }
-
-        final Set<String> supported = response
-                .getResponse()
-                .getData()
-                .stream()
-                .map(OpenAIModel::getId)
-                .map(String::toLowerCase)
-                .collect(Collectors.toSet());
-        supportedModelsCache.put(SUPPORTED_MODELS_KEY, supported);
-
-        return supported;
     }
 
     /**
@@ -294,49 +206,6 @@ public List<SimpleModel> getAvailableModels() {
                 .collect(Collectors.toList());
     }
 
-    @Override
-    public void notify(final SystemTableUpdatedKeyEvent event) {
-        Logger.info(this, String.format("Notify for event [%s]", event.getKey()));
-        if (event.getKey().contains(AI_MODELS_FETCH_ATTEMPTS_KEY)) {
-            modelsFetchAttempts.set(resolveModelsFetchAttempts());
-        } else if (event.getKey().contains(AI_MODELS_FETCH_TIMEOUT_KEY)) {
-            modelsFetchTimeout.set(Config.getIntProperty(AI_MODELS_FETCH_TIMEOUT_KEY, 14));
-        } else if (event.getKey().contains(AI_MODELS_API_URL_KEY)) {
-            aiModelsApiUrl.set(resolveAiModelsApiUrl());
-        }
-    }
-
-    @VisibleForTesting
-    void cleanSupportedModelsCache() {
-        supportedModelsCache.invalidate(SUPPORTED_MODELS_KEY);
-    }
-
-    private CircuitBreakerUrl.Response<OpenAIModels> fetchOpenAIModels(final AppConfig appConfig) {
-        final CircuitBreakerUrl.Response<OpenAIModels> response = CircuitBreakerUrl.builder()
-                .setMethod(CircuitBreakerUrl.Method.GET)
-                .setUrl(aiModelsApiUrl.get())
-                .setTimeout(modelsFetchTimeout.get())
-                .setTryAgainAttempts(modelsFetchAttempts.get())
-                .setAuthHeaders(BEARER + appConfig.getApiKey())
-                .setThrowWhenError(true)
-                .build()
-                .doResponse(OpenAIModels.class);
-
-        if (response.getStatusCode() == 401) {
-            throw new InvalidAIKeyException("AI key authentication failed. Please ensure the key is valid, active, and correctly configured.");
-        } else if (!CircuitBreakerUrl.isSuccessResponse(response)) {
-            appConfig.debugLogger(
-                    AIModels.class,
-                    () -> String.format(
-                            "Error fetching OpenAI supported models from [%s] (status code: [%d])",
-                            aiModelsApiUrl.get(),
-                            response.getStatusCode()));
-            throw new DotRuntimeException("Error fetching OpenAI supported models");
-        }
-
-        return response;
-    }
-
     private void activateModels(final String host) {
         final List<AIModel> aiModels = internalModels.get(host)
                 .stream()
@@ -352,7 +221,7 @@ private void activateModels(final String host) {
                 }
                 Logger.debug(
                         this,
-                        String.format("Model [%s] is supported by OpenAI, marking it as [%s]", modelName, status));
+                        String.format("Model [%s] activated with status [%s]", modelName, status));
                 model.setStatus(status);
             }));
     }