feat(clients): replace openai-client with langchain4j

Author: Blarc

build.gradle.kts

@@ -6,6 +6,7 @@ fun properties(key: String) = project.findProperty(key).toString()
 plugins {
     id("org.jetbrains.kotlin.jvm") version "2.0.0"
     id("org.jetbrains.intellij") version "1.17.3"
+    kotlin("plugin.serialization") version "1.9.23"
 
     // Gradle Changelog Plugin
     id("org.jetbrains.changelog") version "2.2.0"
@@ -102,18 +103,27 @@ tasks.test {
 }
 
 dependencies {
-    implementation("com.aallam.openai:openai-client:3.7.2") {
-        exclude(group = "org.slf4j", module = "slf4j-api")
-        // Prevents java.lang.LinkageError: java.lang.LinkageError: loader constraint violation:when resolving method 'long kotlin.time.Duration.toLong-impl(long, kotlin.time.DurationUnit)'
-        exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
-    }
-    implementation("io.ktor:ktor-client-cio:2.3.11") {
-        exclude(group = "org.slf4j", module = "slf4j-api")
-        // Prevents java.lang.LinkageError: java.lang.LinkageError: loader constraint violation: when resolving method 'long kotlin.time.Duration.toLong-impl(long, kotlin.time.DurationUnit)'
-        exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
-    }
-
-    implementation("com.knuddels:jtokkit:1.0.0")
+//    implementation("com.aallam.openai:openai-client:3.7.2") {
+//        exclude(group = "org.slf4j", module = "slf4j-api")
+//        // Prevents java.lang.LinkageError: java.lang.LinkageError: loader constraint violation:when resolving method 'long kotlin.time.Duration.toLong-impl(long, kotlin.time.DurationUnit)'
+//        exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
+//    }
+//    implementation("io.ktor:ktor-client-cio:2.3.11") {
+//        exclude(group = "org.slf4j", module = "slf4j-api")
+//        // Prevents java.lang.LinkageError: java.lang.LinkageError: loader constraint violation: when resolving method 'long kotlin.time.Duration.toLong-impl(long, kotlin.time.DurationUnit)'
+//        exclude(group = "org.jetbrains.kotlin", module = "kotlin-stdlib")
+//    }
+//
+//    implementation("com.knuddels:jtokkit:1.0.0")
+
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
+
+    // langchain4j integrations
+    implementation("dev.langchain4j:langchain4j-open-ai:0.29.1")
+    implementation("dev.langchain4j:langchain4j-ollama:0.29.1")
+//    implementation("dev.langchain4j:langchain4j-hugging-face:0.28.0")
+//    implementation("dev.langchain4j:langchain4j-milvus:0.28.0")
+//    implementation("dev.langchain4j:langchain4j-local-ai:0.28.0")
 
     // tests
     testImplementation("org.junit.jupiter:junit-jupiter-params:5.10.2")

src/main/kotlin/com/github/blarc/ai/commits/intellij/plugin/AICommitAction.kt

@@ -51,10 +51,10 @@ class AICommitAction : AnAction(), DumbAware {
                 return@runBackgroundableTask
             }
 
-            val openAIService = OpenAIService.instance
+            val llmClient = AppSettings2.instance.getActiveLLMClient()
             runBlocking(Dispatchers.Main) {
                 try {
-                    val generatedCommitMessage = openAIService.generateCommitMessage(prompt)
+                    val generatedCommitMessage = llmClient.generateCommitMessage(prompt)
                     commitMessage.setCommitMessage(generatedCommitMessage)
                     AppSettings2.instance.recordHit()
                 } catch (e: Exception) {

src/main/kotlin/com/github/blarc/ai/commits/intellij/plugin/OpenAIService.kt

@@ -1,6 +1,5 @@
 package com.github.blarc.ai.commits.intellij.plugin.settings
 
-import com.aallam.openai.api.model.ModelId
 import com.github.blarc.ai.commits.intellij.plugin.settings.clients.LLMClient
 import com.github.blarc.ai.commits.intellij.plugin.settings.prompts.Prompt
 import java.awt.Component
@@ -26,10 +25,6 @@ class AICommitsListCellRenderer : DefaultListCellRenderer() {
                 text = value.name
             }
 
-            is ModelId -> {
-                text = value.id
-            }
-
             is LLMClient -> {
                 text = value.displayName
             }

src/main/kotlin/com/github/blarc/ai/commits/intellij/plugin/settings/AICommitsListCellRenderer.kt

@@ -1,6 +1,5 @@
 package com.github.blarc.ai.commits.intellij.plugin.settings
 
-import com.aallam.openai.client.OpenAIHost
 import com.github.blarc.ai.commits.intellij.plugin.settings.prompts.DefaultPrompts
 import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.components.PersistentStateComponent
@@ -29,8 +28,8 @@ class AppSettings : PersistentStateComponent<AppSettings> {
 
     var requestSupport = true
     var lastVersion: String? = null
-    var openAIHost = OpenAIHost.OpenAI.baseUrl
-    var openAIHosts = mutableSetOf(OpenAIHost.OpenAI.baseUrl)
+    var openAIHost = "https://api.openai.com/v1"
+    var openAIHosts = mutableSetOf("https://api.openai.com/v1")
     var openAISocketTimeout = "30"
     var proxyUrl: String? = null
 

src/main/kotlin/com/github/blarc/ai/commits/intellij/plugin/settings/AppSettings.kt

@@ -30,7 +30,7 @@ abstract class LLMClient(
 
     abstract suspend fun generateCommitMessage(prompt: String): String
 
-    abstract suspend fun refreshModels()
+    abstract fun getRefreshModelFunction(): (suspend () -> Unit)?
 
     public abstract override fun clone(): LLMClient
 
@@ -39,6 +39,7 @@ abstract class LLMClient(
         newHost: String,
         newProxy: String?,
         newTimeout: String,
+        newModelId: String,
         newToken: String
     )
 

src/main/kotlin/com/github/blarc/ai/commits/intellij/plugin/settings/clients/LLMClient.kt

@@ -112,19 +112,23 @@ class LLMClientTable {
         }
 
         override fun doOKAction() {
-            (cardLayout.findComponentById(llmClient.displayName) as DialogPanel).apply()
+            if (newLlmClient == null) {
+                (cardLayout.findComponentById(llmClient.displayName) as DialogPanel).apply()
+            }
             super.doOKAction()
         }
 
         override fun createCenterPanel() = if (newLlmClient == null) {
             createCardSplitter()
         } else {
             llmClient.panel().create()
+        }.apply {
+            isResizable = false
         }
 
         private fun getLlmClients(newLLMClient: LLMClient?): List<LLMClient> {
             return if (newLLMClient == null) {
-                // TODO: Find a better way to create the list of all possible LLM Clients that implement LLMClient abstract class
+                // TODO(@Blarc): Is there a better way to create the list of all possible LLM Clients that implement LLMClient abstract class
                 listOf(
                     OpenAIClient(),
                     TestAIClient()

src/main/kotlin/com/github/blarc/ai/commits/intellij/plugin/settings/clients/LLMClientTable.kt

@@ -1,23 +1,20 @@
 package com.github.blarc.ai.commits.intellij.plugin.settings.clients
 
-import com.aallam.openai.api.chat.ChatCompletion
-import com.aallam.openai.api.chat.ChatCompletionRequest
-import com.aallam.openai.api.chat.ChatMessage
-import com.aallam.openai.api.chat.ChatRole
-import com.aallam.openai.api.http.Timeout
-import com.aallam.openai.api.model.ModelId
-import com.aallam.openai.client.OpenAI
-import com.aallam.openai.client.OpenAIConfig
-import com.aallam.openai.client.OpenAIHost
-import com.aallam.openai.client.ProxyConfig
 import com.github.blarc.ai.commits.intellij.plugin.Icons
+import com.github.blarc.ai.commits.intellij.plugin.settings.AppSettings
 import com.intellij.util.xmlb.annotations.Attribute
+import dev.langchain4j.data.message.UserMessage
+import dev.langchain4j.model.openai.OpenAiChatModel
+import dev.langchain4j.model.openai.OpenAiChatModelName
+import java.net.InetSocketAddress
+import java.net.Proxy
+import java.net.URI
+import java.time.Duration
 import javax.swing.Icon
-import kotlin.time.Duration.Companion.seconds
 
 class OpenAIClient(displayName: String = "OpenAI") : LLMClient(
     displayName,
-    OpenAIHost.OpenAI.baseUrl,
+    "https://api.openai.com/v1",
     null,
     30,
     "gpt-3.5-turbo",
@@ -27,9 +24,12 @@ class OpenAIClient(displayName: String = "OpenAI") : LLMClient(
     companion object {
         // TODO @Blarc: Static fields probably can't be attributes...
         @Attribute
-        val hosts = mutableSetOf(OpenAIHost.OpenAI.baseUrl)
+        val hosts = mutableSetOf("https://api.openai.com/v1")
         @Attribute
-        val modelIds = mutableSetOf("gpt-3.5-turbo", "gpt-4")
+        val modelIds = OpenAiChatModelName.entries.stream()
+            .map { it.toString() }
+            .toList()
+            .toMutableSet()
     }
 
     override fun getIcon(): Icon {
@@ -47,33 +47,28 @@ class OpenAIClient(displayName: String = "OpenAI") : LLMClient(
     override suspend fun generateCommitMessage(
         prompt: String
     ): String {
+        val openAI = OpenAiChatModel.builder()
+            .apiKey(token)
+            .modelName(modelId)
+            .temperature(temperature.toDouble())
+            .timeout(Duration.ofSeconds(timeout.toLong()))
+            .baseUrl(AppSettings.instance.openAIHost)
+            .build()
 
-        val openAI = OpenAI(openAIConfig())
-        val chatCompletionRequest = ChatCompletionRequest(
-            ModelId(modelId),
+        val response = openAI.generate(
             listOf(
-                ChatMessage(
-                    role = ChatRole.User,
-                    content = prompt
+                UserMessage.from(
+                    "user",
+                    prompt
                 )
-            ),
-            temperature = temperature.toDouble(),
-            topP = 1.0,
-            frequencyPenalty = 0.0,
-            presencePenalty = 0.0,
-            maxTokens = 200,
-            n = 1
+            )
         )
-
-        val completion: ChatCompletion = openAI.chatCompletion(chatCompletionRequest)
-        return completion.choices[0].message.content ?: "API returned an empty response."
+        return response.content().text()
     }
 
-    override suspend fun refreshModels() {
-        val openAI = OpenAI(openAIConfig())
-        openAI.models()
-            .map { it.id.id }
-            .forEach { modelIds.add(it) }
+    override fun getRefreshModelFunction(): (suspend () -> Unit)? {
+        // Model names are retrieved from Enum and do not need to be refreshed.
+        return null
     }
 
     override fun clone(): LLMClient {
@@ -86,32 +81,38 @@ class OpenAIClient(displayName: String = "OpenAI") : LLMClient(
         return copy
     }
 
-    @Throws(Exception::class)
     override suspend fun verifyConfiguration(
         newHost: String,
         newProxy: String?,
         newTimeout: String,
+        newModelId: String,
         newToken: String
     ) {
 
-        val newConfig = OpenAIConfig(
-            newToken,
-            host = newHost.takeIf { it.isNotBlank() }?.let { OpenAIHost(it) } ?: OpenAIHost.OpenAI,
-            proxy = newProxy?.takeIf { it.isNotBlank() }?.let { ProxyConfig.Http(it) },
-            timeout = Timeout(socket = newTimeout.toInt().seconds)
+        val openAiBuilder = OpenAiChatModel.builder()
+            .apiKey(newToken)
+            .modelName(newModelId)
+            .temperature(temperature.toDouble())
+            .timeout(Duration.ofSeconds(newTimeout.toLong()))
+
+        newHost.takeIf { it.isNotBlank() }?.let { openAiBuilder.baseUrl(it) }
+        newProxy?.takeIf { it.isNotBlank() }?.let {
+            val uri = URI(it)
+            openAiBuilder.proxy(Proxy(Proxy.Type.HTTP, InetSocketAddress(uri.host, uri.port)))
+        }
+
+        val openAi = openAiBuilder.build()
+        openAi.generate(
+            listOf(
+                UserMessage.from(
+                    "user",
+                    "t"
+                )
+            )
         )
-        val openAI = OpenAI(newConfig)
-        openAI.models()
     }
 
     override fun panel(): LLMClientPanel {
         return OpenAIClientPanel(this)
     }
-
-    private fun openAIConfig() = OpenAIConfig(
-        token,
-        host = host.takeIf { it.isNotBlank() }?.let { OpenAIHost(it) } ?: OpenAIHost.OpenAI,
-        proxy = proxyUrl?.takeIf { it.isNotBlank() }?.let { ProxyConfig.Http(it) },
-        timeout = Timeout(socket = timeout.seconds)
-    )
 }