Replace custom MCP client logic with Koog

AGENTS.md

@@ -0,0 +1,87 @@
+# AGENTS.md
+
+This file provides guidance to AI coding agents (Claude Code, Cursor, Codex, Gemini CLI, etc.) working in this repository.
+
+## Project Overview
+
+**CPG** is a code property graph library and analysis platform.
+
+Key modules:
+- **cpg-core** – Core library: AST nodes, graph structures, passes, type system
+- **cpg-analysis** – Higher-level analyses built on top of cpg-core (dataflow, control flow, call graphs, etc.)
+- **cpg-language-\*** – Language frontends, one module per language (e.g., `cpg-language-go`, `cpg-language-python`)
+- **cpg-concepts** – Concept and operation definitions
+- **cpg-mcp** – MCP (Model Context Protocol) server exposing CPG analysis tools to LLMs
+- **codyze-console** – Web-based analysis UI: Kotlin backend + Svelte 5 frontend
+
+## Technology Stack
+
+### Backend
+- **Language**: Kotlin (requires Java 21)
+- **Build**: Gradle with Kotlin DSL
+- **Testing**: JUnit 5, kotlin.test
+- **Formatting**: Google Java Style via spotless plugin
+
+### Frontend (`codyze-console/src/main/webapp`)
+- **Framework**: Svelte 5 with SvelteKit
+- **Styling**: Tailwind CSS
+- **Package Manager**: pnpm (not npm)
+
+## Development Commands
+
+### Build
+
+```bash
+# Full build (format + test + publish locally)
+./gradlew clean spotlessApply build publishToMavenLocal
+
+# Quick build
+./gradlew build
+
+# Build a single module
+./gradlew :cpg-core:build
+./gradlew :codyze-console:build
+```
+
+### Test & Quality
+
+```bash
+./gradlew test                  # Unit tests
+./gradlew integrationTest       # Integration tests
+./gradlew performanceTest       # Performance tests
+./gradlew spotlessApply         # Auto-format 
+./gradlew spotlessCheck         # Check formatting only
+```
+
+### Frontend (`codyze-console`)
+
+```bash
+cd codyze-console/src/main/webapp
+pnpm install        # Install dependencies
+pnpm run dev        # Dev server
+pnpm run build      # Production build
+pnpm run check      # Type check
+pnpm run lint       # Lint
+pnpm run format     # Format
+```
+
+### Backend (`codyze-console`)
+
+```bash
+./gradlew :codyze-console:compileKotlin --console=plain
+```
+
+### MCP Server (`cpg-mcp`)
+
+```bash
+./gradlew :cpg-mcp:installDist           # Build & install
+./gradlew :cpg-mcp:run                   # Run (stdio)
+./gradlew :cpg-mcp:run --args="--http 8080"  # Run with streamable HTTP on port 8080
+```
+
+## Code Conventions
+
+- Follow **Google Java Style** (enforced by spotless – run `./gradlew spotlessApply` before committing)
+- Kotlin idioms preferred over Java-style patterns
+- Use `kotlin.test` assertions in tests, not JUnit assertions directly
+- Frontend: use **Svelte 5 runes** exclusively (no legacy `$:` reactive syntax)

codyze-console/build.gradle.kts

@@ -14,13 +14,36 @@ mavenPublishing {
     }
 }
 
+val mcpEnabled = findProject(":cpg-mcp") != null
+
 dependencies {
     // CPG modules
     implementation(projects.cpgConcepts)
+    implementation(projects.cpgSerialization)
+
+    // MCP dependencies
+    if (mcpEnabled) {
+        implementation(project(":cpg-mcp"))
+        // MCP SDK
+        implementation(libs.mcp)
+        // MCP Client SDK - for custom MCP client implementation
+        implementation(libs.mcp.client)
+    } else {
+        // MCP SDK only available at compile time so the files in `/ai` compile,
+        compileOnly(libs.mcp)
+        compileOnly(libs.mcp.client)
+    }
 
     // Ktor server dependencies
     implementation(libs.bundles.ktor)
 
+    // Ktor client dependencies
+    implementation(libs.bundles.ktor.client)
+
+    // Koog AI agent framework
+    implementation(libs.koog.agents)
+    implementation(libs.koog.agents.mcp)
+
     // Serialization
     implementation(libs.kotlinx.serialization.json)
     implementation(libs.jacksonyml)

codyze-console/src/main/kotlin/de/fraunhofer/aisec/codyze/console/ConsoleService.kt

@@ -30,6 +30,7 @@ import com.fasterxml.jackson.databind.SerializationFeature
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory
 import de.fraunhofer.aisec.codyze.AnalysisProject
 import de.fraunhofer.aisec.codyze.AnalysisResult
+import de.fraunhofer.aisec.codyze.console.ai.McpServerHelper
 import de.fraunhofer.aisec.cpg.TranslationConfiguration
 import de.fraunhofer.aisec.cpg.graph.concepts.Concept
 import de.fraunhofer.aisec.cpg.graph.concepts.conceptBuildHelper
@@ -40,6 +41,8 @@ import de.fraunhofer.aisec.cpg.passes.concepts.LoadPersistedConcepts.PersistedCo
 import de.fraunhofer.aisec.cpg.passes.concepts.LoadPersistedConcepts.PersistedConcepts
 import de.fraunhofer.aisec.cpg.passes.concepts.config.python.PythonStdLibConfigurationPass
 import de.fraunhofer.aisec.cpg.query.QueryTree
+import de.fraunhofer.aisec.cpg.serialization.NodeJSON
+import de.fraunhofer.aisec.cpg.serialization.toJSON
 import java.io.File
 import java.nio.file.Path
 import kotlin.uuid.Uuid
@@ -125,6 +128,9 @@ class ConsoleService {
 
         val result = project.analyze()
 
+        // Update the global analysis result in the MCP server
+        McpServerHelper.setGlobalAnalysisResult(result.translationResult)
+
         // Populate QueryTree cache for lazy loading
         populateQueryTreeCache(result.requirementsResults)
 

codyze-console/src/main/kotlin/de/fraunhofer/aisec/codyze/console/Main.kt

@@ -25,14 +25,17 @@
  */
 package de.fraunhofer.aisec.codyze.console
 
-import io.ktor.http.HttpHeaders
+import de.fraunhofer.aisec.codyze.console.ai.ChatService
+import de.fraunhofer.aisec.codyze.console.ai.McpServerHelper
+import io.ktor.http.*
 import io.ktor.serialization.kotlinx.json.*
 import io.ktor.server.application.*
 import io.ktor.server.engine.*
 import io.ktor.server.netty.*
 import io.ktor.server.plugins.contentnegotiation.*
 import io.ktor.server.plugins.cors.routing.*
 import io.ktor.server.routing.*
+import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.json.Json
 
 /**
@@ -41,18 +44,48 @@ import kotlinx.serialization.json.Json
  * the [configureWebconsole] function.
  */
 fun ConsoleService.startConsole(host: String = "localhost", port: Int = 8080) {
-    embeddedServer(Netty, host = host, port = port) { configureWebconsole(this@startConsole) }
+    val chatService: ChatService? =
+        if (McpServerHelper.isEnabled) {
+            runBlocking { initChatService() }
+        } else {
+            println("MCP module not enabled, AI chat features will be disabled")
+            null
+        }
+
+    println("Starting main server on port $port...")
+    embeddedServer(Netty, host = host, port = port) {
+            configureWebconsole(this@startConsole, chatService)
+        }
         .start(wait = true)
 }
 
+private suspend fun ConsoleService.initChatService(): ChatService? {
+    val chatService = ChatService.createIfConfigExist() ?: return null
+
+    McpServerHelper.startMcpServer(8081)
+
+    val translationResult = getTranslationResult()?.analysisResult?.translationResult
+    if (translationResult != null) {
+        McpServerHelper.setGlobalAnalysisResult(translationResult)
+    }
+
+    println("Initializing ChatService...")
+    chatService.connect()
+    println("MCP client connected!")
+    return chatService
+}
+
 /**
  * This function takes care of configuring the web console based on the [service]. It sets up the
  * CORS policy, content negotiation, and routing.
  *
  * Note: Currently, the CORS policy allows any host. This should be restricted to specific hosts in
  * a production environment and will be made available as an option later.
  */
-fun Application.configureWebconsole(service: ConsoleService = ConsoleService()) {
+fun Application.configureWebconsole(
+    service: ConsoleService = ConsoleService(),
+    chatService: ChatService? = null,
+) {
     install(CORS) {
         anyHost()
         allowHeader(HttpHeaders.ContentType)
@@ -67,17 +100,21 @@ fun Application.configureWebconsole(service: ConsoleService = ConsoleService())
         )
     }
 
-    configureRouting(service)
+    configureRouting(service, chatService)
 }
 
 /**
  * This function sets up the routing for the web console. It defines the API routes and static
  * resources (for serving the single-page application frontend).
  */
-fun Application.configureRouting(service: ConsoleService) {
+fun Application.configureRouting(service: ConsoleService, chatService: ChatService? = null) {
     routing {
-        // We'll add routes here
         apiRoutes(service)
+        // If the cpg-mcp module is enabled, chatService won't be null, so the endpoints will be
+        // reachable
+        if (chatService != null) {
+            chatRoutes(chatService)
+        }
         frontendRoutes()
     }
 }

codyze-console/src/main/kotlin/de/fraunhofer/aisec/codyze/console/Nodes.kt

@@ -36,24 +36,18 @@ import de.fraunhofer.aisec.cpg.assumptions.Assumption
 import de.fraunhofer.aisec.cpg.graph.*
 import de.fraunhofer.aisec.cpg.graph.concepts.Concept
 import de.fraunhofer.aisec.cpg.graph.declarations.TranslationUnit
-import de.fraunhofer.aisec.cpg.graph.edges.Edge
 import de.fraunhofer.aisec.cpg.passes.concepts.LoadPersistedConcepts.*
 import de.fraunhofer.aisec.cpg.query.*
+import de.fraunhofer.aisec.cpg.serialization.*
 import io.github.detekt.sarif4k.ArtifactLocation
 import io.github.detekt.sarif4k.Result
 import java.net.URI
 import java.nio.file.Path
 import kotlin.io.path.Path
 import kotlin.io.path.toPath
 import kotlin.uuid.Uuid
-import kotlinx.serialization.KSerializer
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.Transient
-import kotlinx.serialization.descriptors.PrimitiveKind
-import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
 
 /**
  * JSON data class for an analysis request. It contains the source directory, an optional include
@@ -67,14 +61,6 @@ data class AnalyzeRequestJSON(
     val conceptsFile: String? = null,
 )
 
-/** JSON data class for an [Edge]. */
-@Serializable
-data class EdgeJSON(
-    var label: String,
-    @Serializable(with = UuidSerializer::class) var start: Uuid,
-    @Serializable(with = UuidSerializer::class) var end: Uuid,
-)
-
 /** JSON data class for a SARIF [Result]. */
 @Serializable
 data class FindingsJSON(
@@ -142,25 +128,6 @@ data class ConstructorArguments(
     val argumentType: String? = null, // currently not used
 )
 
-/** JSON data class for a [Node]. */
-@Serializable
-data class NodeJSON(
-    @Serializable(with = UuidSerializer::class) val id: Uuid,
-    val type: String,
-    val startLine: Int,
-    val startColumn: Int,
-    val endLine: Int,
-    val endColumn: Int,
-    val code: String,
-    val name: String,
-    val astChildren: List<NodeJSON>,
-    val prevDFG: List<EdgeJSON> = emptyList(),
-    val nextDFG: List<EdgeJSON> = emptyList(),
-    @Serializable(with = UuidSerializer::class) val translationUnitId: Uuid? = null,
-    val componentName: String? = null,
-    val fileName: String? = null,
-)
-
 /** JSON data class for a requirement category. */
 @Serializable
 data class RequirementsCategoryJSON(
@@ -309,7 +276,7 @@ fun AnalysisResult.toJSON(): AnalysisResultJSON =
             components = components.map { it.toJSON() },
             totalNodes = nodes.size,
             analysisResult = this@toJSON,
-            sourceDir = config.sourceLocations.first().absolutePath,
+            sourceDir = config.sourceLocations.firstOrNull()?.absolutePath ?: "",
             findings = sarif.runs.flatMap { it.results?.map { it.toJSON() } ?: emptyList() },
             requirementCategories =
                 project.requirementCategoriesToJSON(this@toJSON.requirementsResults),
@@ -357,42 +324,6 @@ fun Component.toJSON(): ComponentJSON {
     )
 }
 
-/** Converts a [Node] into its JSON representation. */
-fun Node.toJSON(noEdges: Boolean = false): NodeJSON {
-    return NodeJSON(
-        id = this.id,
-        type = this.javaClass.simpleName,
-        startLine = location?.region?.startLine ?: -1,
-        startColumn = location?.region?.startColumn ?: -1,
-        endLine = location?.region?.endLine ?: -1,
-        endColumn = location?.region?.endColumn ?: -1,
-        code = this.code ?: "",
-        name = this.name.toString(),
-        fileName =
-            this.location?.artifactLocation?.uri?.let { uri ->
-                // Extract filename from URI
-                val path = uri.toString()
-                path.substringAfterLast('/').substringAfterLast('\\')
-            },
-        astChildren =
-            if (noEdges) emptyList()
-            else (this as? AstNode)?.astChildren?.map { it.toJSON() } ?: emptyList(),
-        prevDFG = if (noEdges) emptyList() else this.prevDFGEdges.map { it.toJSON() },
-        nextDFG = if (noEdges) emptyList() else this.nextDFGEdges.map { it.toJSON() },
-        translationUnitId = this.translationUnit?.id,
-        componentName = this.component?.name?.toString(),
-    )
-}
-
-/** Converts an [Edge] into its JSON representation. */
-fun Edge<*>.toJSON(): EdgeJSON {
-    return EdgeJSON(
-        label = this.labels.firstOrNull() ?: "",
-        start = this.start.id,
-        end = this.end.id,
-    )
-}
-
 /** Converts an [Assumption] into its JSON representation. */
 fun Assumption.toJSON(): AssumptionJSON {
     return AssumptionJSON(
@@ -461,23 +392,6 @@ val ArtifactLocation.absolutePath: Path?
         }
     }
 
-/**
- * Custom serializer for [Uuid] to convert it to and from a string representation. This is used for
- * serialization and deserialization of [Uuid] in the JSON data classes.
- */
-object UuidSerializer : KSerializer<Uuid> {
-    override val descriptor: SerialDescriptor =
-        PrimitiveSerialDescriptor("Uuid", PrimitiveKind.STRING)
-
-    override fun serialize(encoder: Encoder, value: Uuid) {
-        encoder.encodeString(value.toString())
-    }
-
-    override fun deserialize(decoder: Decoder): Uuid {
-        return Uuid.parse(decoder.decodeString())
-    }
-}
-
 /** Converts the requirement categories of an [AnalysisProject] into their JSON representation. */
 fun AnalysisProject.requirementCategoriesToJSON(
     requirementsResults: Map<String, QueryTree<Boolean>>? = null