Add remote MCP server support with settings UI

.github/workflows/build-debug-apk.yml

@@ -0,0 +1,35 @@
+name: Build Debug APK
+
+on:
+  pull_request:
+    branches: [ main, master ]
+  workflow_dispatch:
+
+jobs:
+  build:
+    name: Build Debug APK
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'
+          cache: gradle
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      - name: Build Debug APK
+        run: ./gradlew assembleDebug --no-daemon
+
+      - name: Upload Debug APK
+        uses: actions/upload-artifact@v4
+        with:
+          name: app-debug
+          path: app/build/outputs/apk/debug/app-debug.apk
+          retention-days: 14

app/src/main/java/com/dark/tool_neuron/activity/MainActivity.kt

@@ -26,6 +26,7 @@ import com.dark.tool_neuron.data.TermsDataStore
 import com.dark.tool_neuron.di.AppContainer
 import com.dark.tool_neuron.engine.EmbeddingEngine
 import com.dark.tool_neuron.ui.screen.EmbeddingSetupScreen
+import com.dark.tool_neuron.ui.screen.McpServersScreen
 import com.dark.tool_neuron.ui.screen.ModelConfigEditorScreen
 import com.dark.tool_neuron.ui.screen.ModelStoreScreen
 import com.dark.tool_neuron.ui.screen.TermsAndConditionsScreen
@@ -121,6 +122,7 @@ sealed class Screen(val route: String) {
     object Store : Screen("store")
     object Editor : Screen("editor")
     object VaultManager: Screen("vault_manager")
+    object McpServers: Screen("mcp_servers")
 }
 
 @Composable
@@ -176,6 +178,9 @@ fun AppNavigation(
                 onVaultManagerClick = {
                     navController.navigate(Screen.VaultManager.route)
                 },
+                onMcpServersClick = {
+                    navController.navigate(Screen.McpServers.route)
+                },
                 chatViewModel = chatViewModel,
                 llmModelViewModel = llmModelViewModel
             )
@@ -196,5 +201,11 @@ fun AppNavigation(
         composable(Screen.VaultManager.route) {
             VaultDashboard()
         }
+
+        composable(Screen.McpServers.route) {
+            McpServersScreen(onBackClick = {
+                navController.popBackStack()
+            })
+        }
     }
 }

app/src/main/java/com/dark/tool_neuron/database/AppDatabase.kt

@@ -7,24 +7,27 @@ import androidx.room.RoomDatabase
 import androidx.room.TypeConverters
 import androidx.room.migration.Migration
 import androidx.sqlite.db.SupportSQLiteDatabase
+import com.dark.tool_neuron.database.dao.McpServerDao
 import com.dark.tool_neuron.database.dao.ModelConfigDao
 import com.dark.tool_neuron.database.dao.ModelDao
 import com.dark.tool_neuron.database.dao.RagDao
 import com.dark.tool_neuron.models.converters.Converters
 import com.dark.tool_neuron.models.table_schema.InstalledRag
+import com.dark.tool_neuron.models.table_schema.McpServer
 import com.dark.tool_neuron.models.table_schema.Model
 import com.dark.tool_neuron.models.table_schema.ModelConfig
 
 @Database(
-    entities = [Model::class, ModelConfig::class, InstalledRag::class],
-    version = 4,
+    entities = [Model::class, ModelConfig::class, InstalledRag::class, McpServer::class],
+    version = 5,
     exportSchema = false
 )
 @TypeConverters(Converters::class)
 abstract class AppDatabase : RoomDatabase() {
     abstract fun modelDao(): ModelDao
     abstract fun modelConfigDao(): ModelConfigDao
     abstract fun ragDao(): RagDao
+    abstract fun mcpServerDao(): McpServerDao
 
     companion object {
         @Volatile
@@ -114,14 +117,36 @@ abstract class AppDatabase : RoomDatabase() {
             }
         }
 
+        private val MIGRATION_4_5 = object : Migration(4, 5) {
+            override fun migrate(db: SupportSQLiteDatabase) {
+                // Create mcp_servers table
+                db.execSQL("""
+                    CREATE TABLE IF NOT EXISTS mcp_servers (
+                        id TEXT PRIMARY KEY NOT NULL,
+                        name TEXT NOT NULL,
+                        url TEXT NOT NULL,
+                        transportType TEXT NOT NULL,
+                        apiKey TEXT,
+                        isEnabled INTEGER NOT NULL,
+                        lastError TEXT,
+                        createdAt INTEGER NOT NULL,
+                        updatedAt INTEGER NOT NULL,
+                        lastConnectedAt INTEGER,
+                        description TEXT NOT NULL,
+                        customHeadersJson TEXT
+                    )
+                """.trimIndent())
+            }
+        }
+
         fun getDatabase(context: Context): AppDatabase {
             return INSTANCE ?: synchronized(this) {
                 val instance = Room.databaseBuilder(
                     context.applicationContext,
                     AppDatabase::class.java,
                     "llm_models_database"
                 )
-                    .addMigrations(MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4)
+                    .addMigrations(MIGRATION_1_2, MIGRATION_2_3, MIGRATION_3_4, MIGRATION_4_5)
                     .fallbackToDestructiveMigration()
                     .build()
                 INSTANCE = instance

app/src/main/java/com/dark/tool_neuron/database/dao/McpServerDao.kt

@@ -0,0 +1,42 @@
+package com.dark.tool_neuron.database.dao
+
+import androidx.room.*
+import com.dark.tool_neuron.models.table_schema.McpServer
+import kotlinx.coroutines.flow.Flow
+
+@Dao
+interface McpServerDao {
+
+    @Query("SELECT * FROM mcp_servers ORDER BY name ASC")
+    fun getAllServers(): Flow<List<McpServer>>
+
+    @Query("SELECT * FROM mcp_servers WHERE isEnabled = 1 ORDER BY name ASC")
+    fun getEnabledServers(): Flow<List<McpServer>>
+
+    @Query("SELECT * FROM mcp_servers WHERE id = :id")
+    suspend fun getServerById(id: String): McpServer?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun insertServer(server: McpServer)
+
+    @Update
+    suspend fun updateServer(server: McpServer)
+
+    @Delete
+    suspend fun deleteServer(server: McpServer)
+
+    @Query("DELETE FROM mcp_servers WHERE id = :id")
+    suspend fun deleteServerById(id: String)
+
+    @Query("UPDATE mcp_servers SET isEnabled = :isEnabled, updatedAt = :updatedAt WHERE id = :id")
+    suspend fun updateServerEnabled(id: String, isEnabled: Boolean, updatedAt: Long)
+
+    @Query("UPDATE mcp_servers SET lastConnectedAt = :timestamp, updatedAt = :updatedAt WHERE id = :id")
+    suspend fun updateLastConnected(id: String, timestamp: Long, updatedAt: Long)
+
+    @Query("SELECT COUNT(*) FROM mcp_servers")
+    fun getServerCount(): Flow<Int>
+
+    @Query("SELECT COUNT(*) FROM mcp_servers WHERE isEnabled = 1")
+    fun getEnabledServerCount(): Flow<Int>
+}

app/src/main/java/com/dark/tool_neuron/di/HiltModules.kt

@@ -4,8 +4,10 @@
     import com.dark.tool_neuron.database.AppDatabase
     import com.dark.tool_neuron.engine.EmbeddingEngine
     import com.dark.tool_neuron.repo.ChatRepository
+    import com.dark.tool_neuron.repo.McpServerRepository
     import com.dark.tool_neuron.repo.ModelRepository
     import com.dark.tool_neuron.repo.RagRepository
+    import com.dark.tool_neuron.service.McpClientService
     import com.dark.tool_neuron.worker.ChatManager
     import com.dark.tool_neuron.worker.GenerationManager
     import com.dark.tool_neuron.worker.RagVaultIntegration
@@ -65,6 +67,14 @@
                 context = context
             )
         }
+
+        @Provides
+        @Singleton
+        fun provideMcpServerRepository(database: AppDatabase): McpServerRepository {
+            return McpServerRepository(
+                mcpServerDao = database.mcpServerDao()
+            )
+        }
     }
 
     @Module
@@ -78,6 +88,17 @@
         }
     }
 
+    @Module
+    @InstallIn(SingletonComponent::class)
+    object ServiceModule {
+
+        @Provides
+        @Singleton
+        fun provideMcpClientService(): McpClientService {
+            return McpClientService()
+        }
+    }
+
     @Module
     @InstallIn(SingletonComponent::class)
     object WorkerModule {

app/src/main/java/com/dark/tool_neuron/models/converters/Converters.kt

@@ -3,6 +3,7 @@ package com.dark.tool_neuron.models.converters
 import androidx.room.TypeConverter
 import com.dark.tool_neuron.models.enums.PathType
 import com.dark.tool_neuron.models.enums.ProviderType
+import com.dark.tool_neuron.models.table_schema.McpTransportType
 
 class Converters {
     @TypeConverter
@@ -16,4 +17,10 @@ class Converters {
 
     @TypeConverter
     fun toPathType(value: String): PathType = PathType.valueOf(value)
+
+    @TypeConverter
+    fun fromMcpTransportType(value: McpTransportType): String = value.name
+
+    @TypeConverter
+    fun toMcpTransportType(value: String): McpTransportType = McpTransportType.valueOf(value)
 }

app/src/main/java/com/dark/tool_neuron/models/table_schema/McpServer.kt

@@ -0,0 +1,69 @@
+package com.dark.tool_neuron.models.table_schema
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+
+/**
+ * Transport type for MCP server connections
+ */
+enum class McpTransportType {
+    SSE,  // Server-Sent Events (HTTP)
+    STREAMABLE_HTTP  // Streamable HTTP transport
+}
+
+/**
+ * Connection status of an MCP server (runtime only, not persisted)
+ */
+enum class McpConnectionStatus {
+    DISCONNECTED,
+    CONNECTING,
+    CONNECTED,
+    ERROR
+}
+
+/**
+ * Entity representing a remote MCP (Model Context Protocol) server configuration.
+ * MCP servers provide tools, resources, and prompts to LLM applications.
+ */
+@Entity(tableName = "mcp_servers")
+data class McpServer(
+    @PrimaryKey
+    val id: String,
+
+    /** Display name for the server */
+    val name: String,
+
+    /** Server URL (e.g., "https://api.example.com/mcp") */
+    val url: String,
+
+    /** Transport type for the connection */
+    val transportType: McpTransportType = McpTransportType.SSE,
+
+    /** Optional API key for authentication */
+    val apiKey: String? = null,
+
+    /** Whether the server is enabled */
+    val isEnabled: Boolean = true,
+
+    /** Last error message if connection failed */
+    val lastError: String? = null,
+
+    /** Timestamp when the server was added */
+    val createdAt: Long = System.currentTimeMillis(),
+
+    /** Timestamp when the server was last modified */
+    val updatedAt: Long = System.currentTimeMillis(),
+
+    /** Timestamp when last successfully connected */
+    val lastConnectedAt: Long? = null,
+
+    /** Optional description */
+    val description: String = "",
+
+    /** Custom headers as JSON string (e.g., for additional auth) */
+    val customHeadersJson: String? = null
+) {
+    companion object {
+        fun generateId(): String = java.util.UUID.randomUUID().toString()
+    }
+}