feat: [wip] native AI chat interface

Author: jakeaturner

README.md

@@ -30,7 +30,7 @@ Project N.O.M.A.D. is now installed on your device! Open a browser and navigate
 
 ## How It Works
 From a technical standpoint, N.O.M.A.D. is primarily a management UI ("Command Center") and API that orchestrates a goodie basket of containerized offline archive tools and resources such as 
-[Kiwix](https://kiwix.org/), [OpenStreetMap](https://www.openstreetmap.org/), [Ollama](https://ollama.com/), [OpenWebUI](https://openwebui.com/), and more.
+[Kiwix](https://kiwix.org/), [ProtoMaps](https://protomaps.com), [Ollama](https://ollama.com/), and more.
 
 By abstracting the installation of each of these awesome tools, N.O.M.A.D. makes getting your offline survival computer up and running a breeze! N.O.M.A.D. also includes some additional built-in handy tools, such as a ZIM library managment interface, calculators, and more.
 

admin/app/controllers/chats_controller.ts

@@ -0,0 +1,85 @@
+import { inject } from '@adonisjs/core'
+import type { HttpContext } from '@adonisjs/core/http'
+import { ChatService } from '#services/chat_service'
+import { createSessionSchema, updateSessionSchema, addMessageSchema } from '#validators/chat'
+
+@inject()
+export default class ChatsController {
+  constructor(private chatService: ChatService) {}
+
+  async index({}: HttpContext) {
+    return await this.chatService.getAllSessions()
+  }
+
+  async show({ params, response }: HttpContext) {
+    const sessionId = parseInt(params.id)
+    const session = await this.chatService.getSession(sessionId)
+
+    if (!session) {
+      return response.status(404).json({ error: 'Session not found' })
+    }
+
+    return session
+  }
+
+  async store({ request, response }: HttpContext) {
+    try {
+      const data = await request.validateUsing(createSessionSchema)
+      const session = await this.chatService.createSession(data.title, data.model)
+      return response.status(201).json(session)
+    } catch (error) {
+      return response.status(500).json({
+        error: error instanceof Error ? error.message : 'Failed to create session',
+      })
+    }
+  }
+
+  async update({ params, request, response }: HttpContext) {
+    try {
+      const sessionId = parseInt(params.id)
+      const data = await request.validateUsing(updateSessionSchema)
+      const session = await this.chatService.updateSession(sessionId, data)
+      return session
+    } catch (error) {
+      return response.status(500).json({
+        error: error instanceof Error ? error.message : 'Failed to update session',
+      })
+    }
+  }
+
+  async destroy({ params, response }: HttpContext) {
+    try {
+      const sessionId = parseInt(params.id)
+      await this.chatService.deleteSession(sessionId)
+      return response.status(204)
+    } catch (error) {
+      return response.status(500).json({
+        error: error instanceof Error ? error.message : 'Failed to delete session',
+      })
+    }
+  }
+
+  async addMessage({ params, request, response }: HttpContext) {
+    try {
+      const sessionId = parseInt(params.id)
+      const data = await request.validateUsing(addMessageSchema)
+      const message = await this.chatService.addMessage(sessionId, data.role, data.content)
+      return response.status(201).json(message)
+    } catch (error) {
+      return response.status(500).json({
+        error: error instanceof Error ? error.message : 'Failed to add message',
+      })
+    }
+  }
+
+  async destroyAll({ response }: HttpContext) {
+    try {
+      const result = await this.chatService.deleteAllSessions()
+      return response.status(200).json(result)
+    } catch (error) {
+      return response.status(500).json({
+        error: error instanceof Error ? error.message : 'Failed to delete all sessions',
+      })
+    }
+  }
+}

admin/app/controllers/ollama_controller.ts

@@ -0,0 +1,92 @@
+import { OllamaService } from '#services/ollama_service'
+import { RagService } from '#services/rag_service'
+import { modelNameSchema } from '#validators/download'
+import { chatSchema, getAvailableModelsSchema } from '#validators/ollama'
+import { inject } from '@adonisjs/core'
+import type { HttpContext } from '@adonisjs/core/http'
+import { SYSTEM_PROMPTS } from '../../constants/ollama.js'
+
+@inject()
+export default class OllamaController {
+  constructor(
+    private ollamaService: OllamaService,
+    private ragService: RagService
+  ) {}
+
+  async availableModels({ request }: HttpContext) {
+    const reqData = await request.validateUsing(getAvailableModelsSchema)
+    return await this.ollamaService.getAvailableModels({
+      sort: reqData.sort,
+      recommendedOnly: reqData.recommendedOnly,
+    })
+  }
+
+  async chat({ request }: HttpContext) {
+    const reqData = await request.validateUsing(chatSchema)
+
+    /**If there are no system messages in the chat
+     *(i.e. first message from the user)inject system prompts
+     **/
+    const hasSystemMessage = reqData.messages.some((msg) => msg.role === 'system')
+    if (!hasSystemMessage) {
+      const systemPrompt = {
+        role: 'system' as const,
+        content: SYSTEM_PROMPTS.default,
+      }
+      reqData.messages.unshift(systemPrompt)
+    }
+
+    // Get the last user message to use for RAG context retrieval
+    const lastUserMessage = [...reqData.messages].reverse().find((msg) => msg.role === 'user')
+
+    if (lastUserMessage) {
+      // Search for relevant context in the knowledge base
+      const relevantDocs = await this.ragService.searchSimilarDocuments(
+        lastUserMessage.content,
+        5, // Retrieve top 5 most relevant chunks
+        0.7 // Minimum similarity score of 0.7
+      )
+
+      // If relevant context is found, inject as a system message
+      if (relevantDocs.length > 0) {
+        const contextText = relevantDocs
+          .map((doc, idx) => `[Context ${idx + 1}]\n${doc.text}`)
+          .join('\n\n')
+
+        const systemMessage = {
+          role: 'system' as const,
+          content: SYSTEM_PROMPTS.rag_context(contextText),
+        }
+
+        // Insert system message at the beginning (after any existing system messages)
+        const firstNonSystemIndex = reqData.messages.findIndex((msg) => msg.role !== 'system')
+        const insertIndex = firstNonSystemIndex === -1 ? 0 : firstNonSystemIndex
+        reqData.messages.splice(insertIndex, 0, systemMessage)
+      }
+    }
+
+    return await this.ollamaService.chat(reqData)
+  }
+
+  async deleteModel({ request }: HttpContext) {
+    const reqData = await request.validateUsing(modelNameSchema)
+    await this.ollamaService.deleteModel(reqData.model)
+    return {
+      success: true,
+      message: `Model deleted: ${reqData.model}`,
+    }
+  }
+
+  async dispatchModelDownload({ request }: HttpContext) {
+    const reqData = await request.validateUsing(modelNameSchema)
+    await this.ollamaService.dispatchModelDownload(reqData.model)
+    return {
+      success: true,
+      message: `Download job dispatched for model: ${reqData.model}`,
+    }
+  }
+
+  async installedModels({}: HttpContext) {
+    return await this.ollamaService.getModels()
+  }
+}

admin/app/controllers/openwebui_controller.ts

@@ -1,18 +1,41 @@
-import { cuid } from '@adonisjs/core/helpers'
+import { RagService } from '#services/rag_service'
+import { inject } from '@adonisjs/core'
 import type { HttpContext } from '@adonisjs/core/http'
 import app from '@adonisjs/core/services/app'
+import { randomBytes } from 'node:crypto'
+import { sanitizeFilename } from '../utils/fs.js'
+
+@inject()
+export default class RagController {
+  constructor(private ragService: RagService) {}
 
-export default class RagsController {
   public async upload({ request, response }: HttpContext) {
     const uploadedFile = request.file('file')
     if (!uploadedFile) {
       return response.status(400).json({ error: 'No file uploaded' })
     }
 
-    const fileName = `${cuid()}.${uploadedFile.extname}`
+    const randomSuffix = randomBytes(6).toString('hex')
+    const sanitizedName = sanitizeFilename(uploadedFile.clientName)
+
+    const fileName = `${sanitizedName}-${randomSuffix}.${uploadedFile.extname || 'txt'}`
+    const fullPath = app.makePath('storage/uploads', fileName)
 
     await uploadedFile.move(app.makePath('storage/uploads'), {
       name: fileName,
     })
+
+    // Don't await this - process in background
+    this.ragService.processAndEmbedFile(fullPath)
+
+    return response.status(200).json({
+      message: 'File has been uploaded and queued for processing.',
+      file_path: `/uploads/${fileName}`,
+    })
+  }
+
+  public async getStoredFiles({ response }: HttpContext) {
+    const files = await this.ragService.getStoredFiles()
+    return response.status(200).json({ files })
   }
 }

admin/app/controllers/rag_controller.ts

@@ -1,6 +1,6 @@
 import { BenchmarkService } from '#services/benchmark_service';
 import { MapService } from '#services/map_service';
-import { OpenWebUIService } from '#services/openwebui_service';
+import { OllamaService } from '#services/ollama_service';
 import { SystemService } from '#services/system_service';
 import { inject } from '@adonisjs/core';
 import type { HttpContext } from '@adonisjs/core/http'
@@ -10,8 +10,8 @@ export default class SettingsController {
     constructor(
         private systemService: SystemService,
         private mapService: MapService,
-        private openWebUIService: OpenWebUIService,
-        private benchmarkService: BenchmarkService
+        private benchmarkService: BenchmarkService,
+        private ollamaService: OllamaService
     ) { }
 
     async system({ inertia }: HttpContext) {
@@ -48,8 +48,8 @@ export default class SettingsController {
     }
 
     async models({ inertia }: HttpContext) {
-        const availableModels = await this.openWebUIService.getAvailableModels();
-        const installedModels = await this.openWebUIService.getInstalledModels();
+        const availableModels = await this.ollamaService.getAvailableModels({ sort: 'pulls', recommendedOnly: false });
+        const installedModels = await this.ollamaService.getModels();
         return inertia.render('settings/models', {
             models: {
                 availableModels: availableModels || [],

admin/app/controllers/settings_controller.ts

@@ -1,9 +1,8 @@
 import { Job } from 'bullmq'
 import { QueueService } from '#services/queue_service'
-import { OpenWebUIService } from '#services/openwebui_service'
 import { createHash } from 'crypto'
 import logger from '@adonisjs/core/services/logger'
-import { DockerService } from '#services/docker_service'
+import { OllamaService } from '#services/ollama_service'
 
 export interface DownloadModelJobParams {
   modelName: string
@@ -27,26 +26,23 @@ export class DownloadModelJob {
 
     logger.info(`[DownloadModelJob] Attempting to download model: ${modelName}`)
 
-    // Check if OpenWebUI/Ollama services are ready
-    const dockerService = new DockerService()
-    const openWebUIService = new OpenWebUIService(dockerService)
+    const ollamaService = new OllamaService()
 
-    // Use getInstalledModels to check if the service is ready
     // Even if no models are installed, this should return an empty array if ready
-    const existingModels = await openWebUIService.getInstalledModels()
+    const existingModels = await ollamaService.getModels()
     if (!existingModels) {
       logger.warn(
-        `[DownloadModelJob] OpenWebUI service not ready yet for model ${modelName}. Will retry...`
+        `[DownloadModelJob] Ollama service not ready yet for model ${modelName}. Will retry...`
       )
-      throw new Error('OpenWebUI service not ready yet')
+      throw new Error('Ollama service not ready yet')
     }
 
     logger.info(
-      `[DownloadModelJob] OpenWebUI service is ready. Initiating download for ${modelName}`
+      `[DownloadModelJob] Ollama service is ready. Initiating download for ${modelName}`
     )
 
     // Services are ready, initiate the download with progress tracking
-    const result = await openWebUIService._downloadModel(modelName, (progress) => {
+    const result = await ollamaService._downloadModel(modelName, (progress) => {
       // Update job progress in BullMQ
       const progressData = {
         status: progress.status,

admin/app/jobs/download_model_job.ts

@@ -0,0 +1,29 @@
+import { DateTime } from 'luxon'
+import { BaseModel, column, belongsTo, SnakeCaseNamingStrategy } from '@adonisjs/lucid/orm'
+import type { BelongsTo } from '@adonisjs/lucid/types/relations'
+import ChatSession from './chat_session.js'
+
+export default class ChatMessage extends BaseModel {
+  static namingStrategy = new SnakeCaseNamingStrategy()
+
+  @column({ isPrimary: true })
+  declare id: number
+
+  @column()
+  declare session_id: number
+
+  @column()
+  declare role: 'system' | 'user' | 'assistant'
+
+  @column()
+  declare content: string
+
+  @belongsTo(() => ChatSession, { foreignKey: 'id', localKey: 'session_id' })
+  declare session: BelongsTo<typeof ChatSession>
+
+  @column.dateTime({ autoCreate: true })
+  declare created_at: DateTime
+
+  @column.dateTime({ autoCreate: true, autoUpdate: true })
+  declare updated_at: DateTime
+}