My Weekend Project: Building an AI Agent App with Jetpack Compose

🌱 The Idea

Building an AI Agent in Jetpack Compose (with Gemini, Room & Custom Tools)

🧩 What’s an AI Agent?

⚙️ The Tech Stack

🛠️ Core Features

🖥️ How It Works

💡 Example Conversations

📱 Why Build It in Jetpack Compose?

🚀 Where to Take This Next

Steps Building an AI Agent in Jetpack Compose (12):

1. Create a New Project in the Latest Android Studio

2. Change the Main Activity

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()
        setContent {
            OpenAiAgentTheme {
            /*    Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
                    Greeting(
                        name = "Android",
                        modifier = Modifier.padding(innerPadding)
                    )
                }*/
                val db = DBModule.provideDatabase(applicationContext)
                val messageDao = db.messageDao()

                val weatherService = NetworkModule.weatherService
                val newsService = NetworkModule.newsService
                val aiService = NetworkModule.aiService

                val apiKeys = ApiKeys(
                    openWeatherKey = "your api key",
                    newsApiKey = "your api key",
                    aiKey = "your api key"
                )
                val repo = AiChatRepository(
                    messageDao = messageDao,
                    aiService = aiService,
                    weatherService = weatherService,
                    newsService = newsService,
                    apiKeys = apiKeys
                )

                val vm = remember { AiChatViewModel(repo) }

                AiAgentScreen(viewModel = vm)
            }
        }
    }
}

3. AiAgentScreen

package com.codingbihar.openaiagent

import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.imePadding
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.systemBarsPadding
import androidx.compose.foundation.layout.widthIn
import androidx.compose.foundation.lazy.LazyColumn
import androidx.compose.foundation.lazy.items
import androidx.compose.foundation.lazy.rememberLazyListState
import androidx.compose.foundation.shape.RoundedCornerShape
import androidx.compose.material.icons.Icons
import androidx.compose.material.icons.filled.Delete
import androidx.compose.material.icons.filled.PlayArrow
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Icon
import androidx.compose.material3.IconButton
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.Text
import androidx.compose.material3.TextField
import androidx.compose.material3.TextFieldDefaults
import androidx.compose.material3.TopAppBar
import androidx.compose.material3.TopAppBarDefaults
import androidx.compose.runtime.Composable
import androidx.compose.runtime.LaunchedEffect
import androidx.compose.runtime.collectAsState
import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.draw.shadow
import androidx.compose.ui.graphics.Brush
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.unit.dp
import kotlinx.coroutines.delay
import java.text.DateFormat
import java.util.Date


@OptIn(ExperimentalMaterial3Api::class)
@Composable
fun AiAgentScreen(viewModel: AiChatViewModel) {
    val messages by viewModel.messages.collectAsState()
    val isTyping by viewModel.isTyping.collectAsState()
    val listState = rememberLazyListState()
    var input by remember { mutableStateOf("") }

    // Background gradient
    Box(
        modifier = Modifier
            .fillMaxSize()
            .systemBarsPadding()
            .imePadding() // 👈 important fix for keyboard overlap
            .background(
                Brush.verticalGradient(
                    listOf(Color(0xFF0F2027), Color(0xFF203A43), Color(0xFF2C5364))
                )
            )
    ) {
        Column(
            Modifier
                .fillMaxSize()
        ) {
            // Top Bar
            TopAppBar(
                title = { Text("🤖 AI Agent", color = Color.White) },
                colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Transparent),
                actions = {
                    IconButton(onClick = { viewModel.clearAllChats() }) {
                        Icon(
                            Icons.Default.Delete,
                            contentDescription = "Clear All",
                            tint = Color.Red
                        )
                    }
                }
            )

            // Messages
            LazyColumn(
                modifier = Modifier.weight(1f),
                state = listState,
                contentPadding = PaddingValues(12.dp)
            ) {
                items(messages) { msg ->
                    ModernMessageRow(msg)
                }
                if (isTyping) {
                    item { TypingIndicatorModern() }
                }
            }

            // Input area
            Row(
                Modifier
                    .fillMaxWidth()
                    .padding(8.dp)
                    .background(Color(0xAA000000), shape = RoundedCornerShape(30.dp))
                    .padding(horizontal = 12.dp, vertical = 6.dp),
                verticalAlignment = Alignment.CenterVertically
            ) {
                TextField(
                    value = input,
                    onValueChange = { input = it },
                    modifier = Modifier.weight(1f),
                    placeholder = { Text("Ask anything...", color = Color.Gray) },
                    colors = TextFieldDefaults.colors(
                        focusedContainerColor = Color.Transparent,
                        unfocusedContainerColor = Color.Transparent,
                        focusedIndicatorColor = Color.Transparent,
                        unfocusedIndicatorColor = Color.Transparent,
                        focusedTextColor = Color.White,
                        unfocusedTextColor = Color.White
                    )
                )
                IconButton(onClick = {
                    if (input.isNotBlank()) {
                        viewModel.sendMessage(input.trim())
                        input = ""
                    }
                }) {
                    Icon(
                        Icons.Default.PlayArrow,
                        contentDescription = "Send",
                        tint = Color(0xFF00FFAA)
                    )
                }
            }
        }
    }

    // Auto-scroll (with delay for keyboard)
    LaunchedEffect(messages.size, isTyping) {
        if (messages.isNotEmpty()) {
            // small delay to let layout/keyboard adjust
            delay(100)
            listState.animateScrollToItem(messages.size - 1)
        }
    }
}
@Composable
fun ModernMessageRow(msg: Message) {
    val bubbleColor = if (msg.isUser) Color(0xFF0066FF) else Color(0xFF2E2E2E)
    val textColor = if (msg.isUser) Color.White else Color.LightGray
    val avatar = if (msg.isUser) "👤" else "🤖"

    Row(
        modifier = Modifier.fillMaxWidth(),
        horizontalArrangement = if (msg.isUser) Arrangement.End else Arrangement.Start
    ) {
        if (!msg.isUser) {
            Text(avatar, modifier = Modifier.padding(end = 6.dp))
        }
        Column {
            Box(
                modifier = Modifier
                    .shadow(4.dp, RoundedCornerShape(18.dp))
                    .background(bubbleColor, RoundedCornerShape(18.dp))
                    .padding(12.dp)
                    .widthIn(max = 280.dp)
            ) {
                Text(msg.text, color = textColor)
            }
            Text(
                DateFormat.getTimeInstance(DateFormat.SHORT).format(Date(msg.timestamp)),
                style = MaterialTheme.typography.labelSmall.copy(color = Color.Gray),
                modifier = Modifier.padding(top = 4.dp, start = 8.dp)
            )
        }
        if (msg.isUser) {
            Text(avatar, modifier = Modifier.padding(start = 6.dp))
        }
    }
}

@Composable
fun TypingIndicatorModern() {
    val dotCount = remember { mutableStateOf(1) }
    LaunchedEffect(Unit) {
        while (true) {
            dotCount.value = (dotCount.value % 3) + 1
            delay(400)
        }
    }
    Row(
        modifier = Modifier
            .padding(8.dp)
            .background(Color(0xFF2E2E2E), RoundedCornerShape(18.dp))
            .padding(10.dp)
    ) {
        Text("🤖 " + ".".repeat(dotCount.value), color = Color.LightGray)
    }
}

4. AiChatRepository

package com.codingbihar.openaiagent

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class AiChatRepository(
    private val messageDao: MessageDao,
    private val aiService: AiService,
    private val weatherService: WeatherService,
    private val newsService: NewsService,
    private val apiKeys: ApiKeys
) {
    suspend fun sendUserMessageAndGetReply(sessionId: Long, text: String): String {
        messageDao.insert(Message(sessionId = sessionId, isUser = true, text = text))
        val trimmed = text.trim()

        return when {
            trimmed.startsWith("calc:", true) -> {
                val expr = trimmed.removePrefix("calc:").trim()
                val result = evaluateExpression(expr)
                insertAndReturn(sessionId, "Result: $result")
            }
            trimmed.startsWith("math:", true) -> {
                val expr = trimmed.removePrefix("math:").trim()
                val result = evaluateExpression(expr)
                insertAndReturn(sessionId, "Math result: $result")
            }
            trimmed.startsWith("weather:", true) -> {
                val city = trimmed.removePrefix("weather:").trim()
                val resp = withContext(Dispatchers.IO) { weatherService.getWeather(city, apiKeys.openWeatherKey) }
                insertAndReturn(sessionId, "${resp.name}: ${resp.main.temp}°C, ${resp.weather.firstOrNull()?.description}")
            }
            // Inside AiChatRepository
            trimmed.startsWith("news:", ignoreCase = true) -> {
                val country = trimmed.removePrefix("news:").trim().ifEmpty { "in" }
                val newsTop = try {
                    newsService.getTopHeadlines(country, apiKeys.newsApiKey)
                } catch (_: Exception) {
                    null
                }

                if (newsTop?.articles.isNullOrEmpty()) {
                    insertAndReturn(sessionId, "Sorry, news not available right now.")
                } else {
                    val top = newsTop.articles.take(5).joinToString("\n") { "• ${it.title}" }
                    insertAndReturn(sessionId, "Top news for $country:\n$top")
                }
            }
            else -> {
                val aiReq = AiRequest(messages = listOf(MessageRequest("user", text)))
                val resp = withContext(Dispatchers.IO) { aiService.sendPrompt("Bearer ${apiKeys.aiKey}", aiReq) }
                val aiText = resp.choices?.firstOrNull()?.message?.content?.trim() ?: "No response from AI"
                insertAndReturn(sessionId, aiText)
            }
        }
    }

    private suspend fun insertAndReturn(sessionId: Long, reply: String): String {
        messageDao.insert(Message(sessionId = sessionId, isUser = false, text = reply))
        return reply
    }

    private fun evaluateExpression(expr: String): String {
        return try {
            val e = net.objecthunter.exp4j.ExpressionBuilder(expr).build()
            val result = e.evaluate()
            if (result % 1.0 == 0.0) result.toLong().toString() else result.toString()
        } catch (t: Throwable) {
            "Error: ${t.message}"
        }
    }

    suspend fun clearAllChats() = messageDao.deleteAll()
}

5. AiChatViewModel

package com.codingbihar.openaiagent

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.launch

class AiChatViewModel(private val repo: AiChatRepository) : ViewModel() {
    private val _messages = MutableStateFlow>(emptyList())
    val messages: StateFlow> = _messages

    private val _isTyping = MutableStateFlow(false)
    val isTyping: StateFlow = _isTyping

    fun sendMessage(text: String) {
        _messages.value = _messages.value + Message(text = text, isUser = true)
        viewModelScope.launch {
            _isTyping.value = true
            try {
                val reply = repo.sendUserMessageAndGetReply(1L, text)
                _messages.value = _messages.value + Message(text = reply, isUser = false)
            } catch (e: Exception) {
                _messages.value = _messages.value + Message(text = "Error: ${e.message}", isUser = false)
            } finally { _isTyping.value = false }
        }
    }

    fun clearAllChats() {
        viewModelScope.launch {
            repo.clearAllChats()
            _messages.value = emptyList()
        }
    }
}

6. NetworkModule

package com.codingbihar.openaiagent

import com.squareup.moshi.Moshi
import com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory
import okhttp3.OkHttpClient
import okhttp3.logging.HttpLoggingInterceptor
import retrofit2.Retrofit
import retrofit2.converter.moshi.MoshiConverterFactory

object NetworkModule {

    private val moshi = Moshi.Builder()
        .add(KotlinJsonAdapterFactory())
        .build()

    private val client = OkHttpClient.Builder()
        .addInterceptor(HttpLoggingInterceptor().apply {
            level = HttpLoggingInterceptor.Level.BODY
        })
        .build()

    // Weather Service
    private val weatherRetrofit = Retrofit.Builder()
        .baseUrl("https://api.openweathermap.org/")
        .client(client)
        .addConverterFactory(MoshiConverterFactory.create(moshi))
        .build()
    val weatherService: WeatherService = weatherRetrofit.create(WeatherService::class.java)

    // News Service
    private val newsRetrofit = Retrofit.Builder()
        .baseUrl("https://newsapi.org/v2/")
        .client(client)
        .addConverterFactory(MoshiConverterFactory.create(moshi))
        .build()
    val newsService: NewsService = newsRetrofit.create(NewsService::class.java)

    // AI Service
    private val aiRetrofit = Retrofit.Builder()
        .baseUrl("https://api.openai.com/")
        .client(client)
        .addConverterFactory(MoshiConverterFactory.create(moshi))
        .build()
    val aiService: AiService = aiRetrofit.create(AiService::class.java)
}

7. DBModule

package com.codingbihar.openaiagent

import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase

@Database(entities = [Message::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun messageDao(): MessageDao
}

object DBModule {
    private var dbInstance: AppDatabase? = null

    fun provideDatabase(context: Context): AppDatabase {
        return dbInstance ?: synchronized(this) {
            val instance = Room.databaseBuilder(
                context.applicationContext,
                AppDatabase::class.java,
                "ai_agent_db"
            ).build()
            dbInstance = instance
            instance
        }
    }
}

8. Message

package com.codingbihar.openaiagent

import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "messages")
data class Message(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val sessionId: Long = 0,   // अगर multi-session चाहिए
    val isUser: Boolean,
    val text: String,
    val timestamp: Long = System.currentTimeMillis()
)

9. MessageDao

package com.codingbihar.openaiagent

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query
import kotlinx.coroutines.flow.Flow

@Dao
interface MessageDao {
    @Insert
    suspend fun insert(message: Message)

    @Query("SELECT * FROM messages WHERE sessionId = :sessionId ORDER BY timestamp ASC")
    fun getMessagesForSession(sessionId: Long): Flow>

    @Query("DELETE FROM messages WHERE sessionId = :sessionId")
    suspend fun deleteSessionMessages(sessionId: Long)

    @Query("DELETE FROM messages")
    suspend fun deleteAll()
}

10. DataModel

package com.codingbihar.openaiagent

import com.squareup.moshi.Json

data class WeatherResponse(
    val name: String,
    val main: Main,
    val weather: List
)

data class Main(
    val temp: Double,
    @Json(name = "feels_like") val feelsLike: Double,
    @Json(name = "temp_min") val tempMin: Double,
    @Json(name = "temp_max") val tempMax: Double,
    val pressure: Int,
    val humidity: Int
)

data class Weather(
    val id: Int,
    val main: String,
    val description: String,
    val icon: String
)

data class AiResponse(
    val choices: List?
)

data class AiChoice(
    val message: AiMessage?
)

data class AiMessage(
    val content: String?
)

fun AiResponse.outputText(): String {
    return choices?.firstOrNull()?.message?.content?.trim() ?: "No response from AI"
}

data class NewsResponse(
    val status: String,
    val totalResults: Int,
    val articles: List

) {
    data class Article(
        val source: Source?,
        val author: String?,
        val title: String?,
        val description: String?,
        val url: String?,
        val urlToImage: String?,
        val publishedAt: String?,
        val content: String?
    )

    data class Source(
        val id: String?,
        val name: String?
    )
}
data class AiRequest(
    val model: String = "gpt-3.5-turbo", // या "gpt-4o-mini"
    val messages: List
)

data class MessageRequest(
    val role: String,   // "user" | "system" | "assistant"
    val content: String
)
data class ApiKeys(
    val openWeatherKey: String,
    val newsApiKey: String,
    val aiKey: String
)

11. ApiService

package com.codingbihar.openaiagent

import retrofit2.http.Body
import retrofit2.http.GET
import retrofit2.http.Header
import retrofit2.http.POST
import retrofit2.http.Query


// -------------------- Retrofit Interfaces --------------------
interface WeatherService {
    @GET("data/2.5/weather")
    suspend fun getWeather(
        @Query("q") city: String,
        @Query("appid") apiKey: String,
        @Query("units") units: String = "metric"
    ): WeatherResponse
}

interface NewsService {
    @GET("top-headlines")
    suspend fun getTopHeadlines(
        @Query("country") country: String,
        @Query("apiKey") apiKey: String
    ): NewsResponse
}

interface AiService {
    @POST("https://openrouter.ai/api/v1/chat/completions")
    suspend fun sendPrompt(
        @Header("Authorization") apiKey: String,
        @Body request: AiRequest
    ): AiResponse
}

12. Dependencies

 
// in build.gradleProject
id("com.google.devtools.ksp") version "2.0.21-1.0.27" apply false
// use in plugins
id("com.google.devtools.ksp")
// use inside dependencies {
implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.9.2")
    implementation("io.coil-kt:coil-compose:2.7.0")
    // Retrofit + Moshi
    implementation("com.squareup.retrofit2:retrofit:2.9.0")
    implementation("com.squareup.retrofit2:converter-moshi:2.9.0")
    implementation("com.squareup.okhttp3:logging-interceptor:4.11.0")
    implementation("com.squareup.moshi:moshi:1.15.0")
    implementation("com.squareup.moshi:moshi-kotlin:1.15.0")
    ksp("com.squareup.moshi:moshi-kotlin-codegen:1.15.0")

    // Room with KSP
    implementation("androidx.room:room-runtime:2.6.1")
    implementation("androidx.room:room-ktx:2.6.1")
    ksp("androidx.room:room-compiler:2.6.1")

    // Optional: expression evaluator for calculator
    implementation("net.objecthunter:exp4j:0.4.8")

Output:

🎯 Final Thoughts