Mobile KMP Client for Ollama Server / Habr

TAG314@@“By default, Kotlinx.Serialization does not serialize fields whose values match the default values (in this case, false). Ollama, not finding an explicit stream: false in the JSON, enables streaming mode by default. The encodeDefaults = true setting saves the situation.”TAG330@@

If you make a request to the chat, you need to specify a role.In /api/chat, the role is required for every message. In /api/generate, there are no roles at all—there is simply a prompt

The magic is here

package com.kmp.ollamechat.repository import com.example.chatkmpdontshareui.repository.model.OllamaRequest import com.example.chatkmpdontshareui.repository.model.OllamaResponse import io.ktor.client.HttpClient import io.ktor.client.call.body import io.ktor.client.request.post import io.ktor.client.request.setBody import io.ktor.http.ContentType import io.ktor.http.contentType class OllamaClient( private val settings: Settings, private val client: HttpClient ) { suspend fun sendPrompt(serverUrl: String, prompt: String): Result<String> { return try { val response: OllamaResponse = client.post("$serverUrl/api/generate") { contentType(ContentType.Application.Json) // Insert the request object. Ktor serializes it to JSON automatically. setBody( OllamaRequest( model = settings.getCurrentModel().id, prompt = prompt, stream = false ) ) // If you are using Ollama Cloud, uncomment: // header(HttpHeaders.Authorization, "Bearer YOUR_KEY") }.body() // Receive and deserialize the response Result.success(response.response ?: "Unknown Error") } catch (e: Exception) { Result.failure(e) } } }

Stream responses

Hello

{"model":"gemma4:e4b-mlx","created_at":"2026-11-09T03:41:29.399462Z","message":{"role":"assistant","content":"Hello"},"done":false}! How can I help? 😊

Flow Magic

package com.kmp.ollamechat.client import com.kmp.ollamechat.chat.ChatRequest import com.kmp.ollamechat.chat.OllamaChatChunk import com.kmp.ollamechat.chat.OllamaChatRequest import com.kmp.ollamechat.repository.Settings import com.kmp.ollamechat.repository.model.StreamOllamaEvent import io.ktor.client.HttpClient import io.ktor.client.plugins.ResponseException import io.ktor.client.request.preparePost import io.ktor.client.request.setBody import io.ktor.client.statement.bodyAsChannel import io.ktor.http.ContentType import io.ktor.http.contentType import io.ktor.utils.io.readLine import kotlinx.coroutines.flow.Flowimport kotlinx.coroutines.flow.flow import kotlinx.serialization.json.Json /** * streamChat() * Streaming request to /api/chat. * Returns Flow: tokens as they are generated + Done/Error. * The Flow is cancellable—cancelling the coroutine closes the connection and stops generation. */ class StreamOllamaClient( private val settings: Settings, private val client: HttpClient, private val json: Json ) { fun streamChat( serverUrl: String, messages: List, modelId: String, ): Flow = flow { // Variable for tracking the final status: SUCCESS, ERROR, or PREMATURE_CLOSE var finalEvent: StreamOllamaEvent? = null try { client.preparePost("$serverUrl/api/chat") { contentType(ContentType.Application.Json) setBody( OllamaChatRequest( model = modelId, messages = messages, keepAlive = "10m", stream = true ) ) }.execute { response -> val channel = response.bodyAsChannel() while (!channel.isClosedForRead) { val line = channel.readLine() ?: break if (line.isBlank()) continue val chunk = try { json.decodeFromString(line) } catch (e: Exception) { finalEvent = StreamOllamaEvent.Error("Failed to parse chunk: $line", e) break // Just exit the loop; execution will continue below } if (chunk.error != null) {finalEvent = StreamOllamaEvent.Error(chunk.error) break } val msg = chunk.message msg?.thinking?.takeIf { it.isNotEmpty() }?.let { emit(StreamOllamaEvent.Thinking(it)) } msg?.content?.takeIf { it.isNotEmpty() }?.let { emit(StreamOllamaEvent.Token(it)) } if (chunk.done) { finalEvent = StreamOllamaEvent.Done(chunk.evalCount) break } } // If the loop was interrupted but finalEvent was not set (for example, the server closed the channel prematurely) val eventToSend = finalEvent ?: StreamOllamaEvent.Done(null) emit(eventToSend) } } catch (e: ResponseException) { emit(StreamOllamaEvent.Error("HTTP ${e.response.status.value}", e)) } catch (e: Exception) { emit(StreamOllamaEvent.Error(e.message ?: "Unknown error", e)) } } }

On screen, it looks like this:

Streaming response

The streaming response did not work right away. I quickly found out that the data was being sent all at once rather than in chunks. Everything was updated at the very end of the response. I spent a long time trying to solve it. Several hours, actually. At first, I thought OkHttp was buffering the data. I remembered expect/actual and split the implementation by platform. That did not help.

Turned out I was using the wrong method: instead of post(), I needed to use preparePost(). Although post() also has execute() under the hood.

After switching to preparePost(), the output started working.

In addition to the main response, the Thinking response is also processed.

View the code on Git:

https://github.com/app-z/OllameChatKmp

The UI needs some polishing, and chat history saving needs to be added.

All that’s left is to feed the model the company’s documentation—and the perfect AI support chatbot is ready. Well, almost...

I also wrote a client for cloud.ru’s cloud models (with image and audio uploading). Though, that’s a whole other story. The main thing to know is that cloud tokens burn very quickly. But the speed is also impressive—for a project renaming task, the model took only 5 minutes and about 50 rubles. The final cost and speed depend directly on the selected model.

Write!