adk-kotlin

0.4.0indexed

Code-first toolkit for building, evaluating, and deploying sophisticated AI agents; offers rich tool ecosystem, modular multi-agent orchestration, built-in development UI and cloud integrations.

AndroidJVM·google/adk-kotlin

119

Stars

—

Used by

dependents

—

Health

/ 100

Agent Development Kit (ADK) for Kotlin

An open-source, code-first Kotlin toolkit for building, evaluating, and deploying sophisticated AI agents with flexibility and control.

Important Links: Docs & Samples & Python ADK & Java ADK.

Agent Development Kit (ADK) is designed for developers seeking fine-grained control and flexibility when building advanced AI agents that are tightly integrated with services in Google Cloud. It allows you to define agent behavior, orchestration, and tool use directly in code, enabling robust debugging, versioning, and deployment anywhere – from your laptop to the cloud.

ADK for Kotlin now follows a stable release cycle, with regular releases published to Maven Central under semantic versioning.

✨ Key Features

🚀 Installation

If you're using Maven, add the following to your dependencies:

<dependency>
  <groupId>com.google.adk</groupId>
  <artifactId>google-adk-kotlin-core-jvm</artifactId>
  <version>1.3.0</version>
</dependency>

If you're using Gradle:

implementation("com.google.adk:google-adk-kotlin-core:1.3.0")

📦 Modules

Every module is published under the com.google.adk group and shares the version shown above.

📚 Documentation

For building, evaluating, and deploying agents by follow the Kotlin documentation & samples:

Documentation
Samples

🏁 Feature Highlight

Same Features & Familiar Interface As Python ADK:

import com.google.adk.kt.agents.LlmAgent
import com.google.adk.kt.agents.Instruction
import com.google.adk.kt.models.Gemini
import com.google.adk.kt.tools.GoogleSearchTool

val rootAgent = LlmAgent(
    name = "search_assistant",
    description = "An assistant that can search the web.",
    model = Gemini(name = "gemini-3.1-flash-lite-preview"),
    instruction = Instruction("You are a helpful assistant. Answer user questions using Google Search when needed."),
    tools = listOf(GoogleSearchTool())
)

GenAI SDK based Gemini currently prevents usage of API_KEY and GoogleCredentials on Android. Use Firebase AI instead.

☕ Using ADK from Java

ADK Kotlin is built to be called from plain Java too, not only from Kotlin. Every builder-style API mirrors the Kotlin one, so the search agent above is the same agent in Java:

import com.google.adk.kt.agents.BaseAgent;
import com.google.adk.kt.agents.LlmAgent;
import com.google.adk.kt.models.Gemini;
import com.google.adk.kt.tools.GoogleSearchTool;

BaseAgent rootAgent =
    LlmAgent.builder()
        .name("search_assistant")
        .description("An assistant that can search the web.")
        .model(new Gemini("gemini-3.1-flash-lite-preview"))
        .instruction(
            "You are a helpful assistant. Answer user questions using Google Search when needed.")
        .tools(GoogleSearchTool.builder().build())
        .build();

Coroutines stay out of the way. The com.google.adk.kt.interop package exposes Java-facing base types that replace the engine's suspend functions and Flow with CompletableFuture and Reactive Streams Publisher:

See examples/java/ for runnable ports of this repository's agents written entirely in Java.

📱 On-device and Cloud Agents on Android

ADK Kotlin agents run on Android either fully on-device — no API key and no network at inference time, for offline, low-latency, or privacy-sensitive use — or against the cloud. Every backend is a Model behind the same LlmAgent API, so switching between them is a one-line change.

Hybrid on-device + cloud systems

Because on-device and cloud models are interchangeable Model implementations, you can compose them into a single multi-agent system: an on-device agent can handle offline, cheap, or privacy-sensitive turns and delegate harder tasks to a cloud agent, all within one LlmAgent hierarchy. See Modular Multi-Agent Systems for how agents are composed.

All three backends have runnable multi-turn chat examples in the examples/android/ Compose app — LiteRT-LM chat, ML Kit chat, and Firebase AI. See the Android examples README for how to build and run the app, obtain the on-device models, and configure Firebase.

Serving agents over HTTP

Add com.google.adk:google-adk-kotlin-webserver alongside the core artifact. AdkApiServer then serves the agent runtime contract — app discovery, sessions, artifacts, the run endpoints, health and version — without the development surface, so it can be deployed headlessly:

import com.google.adk.kt.webserver.AdkApiServer
import com.google.adk.kt.webserver.AdkServerConfig

fun main() = AdkApiServer(AdkServerConfig.inMemory(rootAgent)).start(wait = true)

That listens on port 8080. inMemory keeps session and artifact state in the process, so it suits a local run; build AdkServerConfig directly to serve several agents or to persist state.

Run it however you run any other main class. With the Gradle application plugin that is mainClass = "com.example.MainKt" — a top-level main in Main.kt compiles to MainKt, not Main — and then ./gradlew run.

The server binds loopback, because these endpoints are unauthenticated. Put your own authentication in front of it before widening that:

import com.google.adk.kt.webserver.AdkApiServer
import com.google.adk.kt.webserver.AdkServerConfig

fun main() =
  AdkApiServer(AdkServerConfig.inMemory(rootAgent).copy(host = "0.0.0.0")).start(wait = true)

Development UI

Same as the beloved Python Development UI. A built-in development UI to help you test, evaluate, debug, and showcase your agent(s).

AdkDevServer takes the same config and adds the UI at http://localhost:8080/dev-ui, together with the trace and agent-graph endpoints it drives:

import com.google.adk.kt.webserver.AdkServerConfig
import com.google.adk.kt.webserver.dev.AdkDevServer

fun main() = AdkDevServer(AdkServerConfig.inMemory(rootAgent)).start(wait = true)

To leave the UI unmounted, set the webUiEnabled field on AdkServerConfig:

import com.google.adk.kt.webserver.AdkServerConfig
import com.google.adk.kt.webserver.dev.AdkDevServer

fun main() =
  AdkDevServer(AdkServerConfig.inMemory(rootAgent).copy(webUiEnabled = false)).start(wait = true)

Three things decide whether the UI is mounted. Highest wins:

the adk.web.ui.enabled , when it is set to or in any casing — any other value is ignored with a warning

So the system property is not an alternative to the field, it outranks it: a stray -Dadk.web.ui.enabled=true in the launch environment re-mounts the UI even though the config says webUiEnabled = false. It ranks highest so that a deployment which cannot change code can still turn the UI off.

To try a few of this repository's own agents rather than your own:

GOOGLE_API_KEY=... ./gradlew :google-adk-kotlin-examples:runServer --args="--dev"

📂 Examples

The agent snippet above is the short version. Every runnable example lives under the examples directory of this repository.

examples/ — JVM examples.
examples/java/ — the same agents written in plain Java, compiled against the published JVM artifacts to exercise the Java-facing surface.

🤝 Contributing

We welcome contributions from the community! Whether it's bug reports, feature requests, documentation improvements, or code contributions, please see our CONTRIBUTING.md to get started.

📄 License

This project is licensed under the Apache 2.0 License - see the LICENSE file for details.

Preview

This feature is subject to the "Pre-GA Offerings Terms" in the General Service Terms section of the Service Specific Terms. Pre-GA features are available "as is" and might have limited support. For more information, see the launch stage descriptions.

Happy Agent Building!

Related libraries

Surfaced from shared tags and platforms — no rankings paid for.

koog★ 4.4k

JetBrainsFramework designed for building AI agents with tool interaction, complex workflows, semantic search, and persistent memory. Offers modular architecture, real-time processing, and comprehensive tracing.Shared: llm, ai, agents

mcp4k★ 70

ondrshCompiler-driven framework builds clients and servers using the Model Context Protocol, implementing JSON-RPC handlers, schema metadata, and lifecycle management. Features resource exposure, parameterized prompts, and transport logging.Shared: llm, ai, agents

xemantic-ai-tool-schema★ 51

xemanticGenerates JSON Schema for serializable classes, enabling seamless integration with AI agents and large language models. Supports automatic instantiation from JSON input, facilitating complex data structure development.Shared: llm, ai, agents

aigentic★ 27

flock-communityEmpowers developers to create and manage AI agents with a streamlined DSL, offering error handling, logging, and integration with the ecosystem to transition from PoC to production.Shared: llm, ai, agents

xemantic-ai-tool-schema-mdc★ 8

xemanticAdapts Model Context Protocol to enable automatic MDC-compatible JSON Schema generation from serializable classes, overcoming limitations in expressing JSON Schema definitions.Shared: llm, ai, agents

koog-compose★ 15

BrianMwasSingle-block agent runtime orchestrating LLM conversation, native device tools and phases; streams tokens to Compose UI, enforces guardrails with confirmations, audit logging, circuit breakers and shared state.Shared: llm, agents, agentic-ai

`core`	`google-adk-kotlin-core`	Agents, models, tools, sessions, memory, artifacts and runners. The only dependency most projects need.
`processor`	`google-adk-kotlin-processor`	KSP processor that generates tools from `@Tool`-annotated functions. Add it with `ksp(...)`.
`webserver`	`google-adk-kotlin-webserver`	HTTP serving for your agents, headless or with the Development UI.
`integrations`	`google-adk-kotlin-integrations`	Plugins and integrations with external services (e.g. BigQuery agent analytics).
`integrations/spring`	`google-adk-kotlin-integrations-spring`	Use any Spring AI `ChatModel` (OpenAI, Anthropic, Vertex, ...) to drive an ADK agent. JVM only.
`a2a`	`google-adk-kotlin-a2a`	Agent2Agent (A2A) support for talking to remote agents.
`litertlm`	`google-adk-kotlin-litertlm`	On-device models through LiteRT-LM. Requires JDK 21+; see litertlm/README.md.
`firebase`	`google-adk-kotlin-firebase-android`	Android-only model backed by Firebase AI Logic.
`mlkit`	`google-adk-kotlin-mlkit-android`	Android-only on-device Gemini Nano through the ML Kit GenAI Prompt API. Published as a `-beta` pre-release.

LiteRT-LM	`google-adk-kotlin-litertlm`	On-device	✅ Yes
ML Kit	`google-adk-kotlin-mlkit-android`	On-device	❌ Not yet
Firebase AI	`google-adk-kotlin-firebase-android`	Cloud	✅ Yes