Android SDK

The Android Assistant SDK puts a governed agent inside your own app: a streaming client to Metabind’s Agent Proxy, an MCP client for your project’s tools, and rendering of Interactive Tool results as native Jetpack Compose — not web views — through BindJS. Use the drop-in MetabindAssistantView for a complete chat surface, or build your own with the lower-level APIs.

SDK on GitHub

metabind-android — the Android SDK. The Assistant SDK is the :metabindai module.

Demo app

samples/assistant-demo — a complete Compose chat app built on MetabindAssistantView.

Requirements

Requirement	Version
Android	8.0 (API 26) or later
UI toolkit	Jetpack Compose
Gradle	9.x, Android Gradle Plugin 9.0 or later
JDK	21

Installation

Add the GitHub Packages repository

The Metabind Android libraries and their BindJS dependency are published only to GitHub Packages, which requires authentication even for public packages. Create a GitHub personal access token (classic) with the read:packages scope. Repository access alone doesn’t grant package access. Provide your GitHub username and the token to Gradle, either as environment variables:

export GITHUB_ACTOR=<your-github-username>
export GITHUB_TOKEN=<your-github-token>

Or in ~/.gradle/gradle.properties:

gpr.user=<your-github-username>
gpr.key=<your-github-token>

Then add the repository to your settings.gradle.kts:

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()
        maven {
            url = uri("https://maven.pkg.github.com/metabindai/bindjs-android-binary")
            credentials {
                username = providers.gradleProperty("gpr.user").orElse(providers.environmentVariable("GITHUB_ACTOR")).get()
                password = providers.gradleProperty("gpr.key").orElse(providers.environmentVariable("GITHUB_TOKEN")).get()
            }
        }
    }
}

Add the dependency

Add the Assistant SDK dependency, which pulls in the MCP client (ai.metabind:mcpappshost-android) and the BindJS renderer (ai.metabind:bindjs-android) transitively:

build.gradle.kts
build.gradle

dependencies {
    implementation("ai.metabind:metabindai-android:0.2.12")
}

dependencies {
    implementation 'ai.metabind:metabindai-android:0.2.12'
}

Set the project’s LLM provider

The Agent Proxy runs your agent on the model provider set on your project, with your own model key stored in Metabind. It refuses chat requests for a project that has no provider and key, so set them once per project before the app’s first conversation:

In Metabind Studio: open your project, click the gear icon at the top right (Project Settings), and choose Agent. Click Setup Agent, choose a Provider and Model, enter the provider’s API Key, and click Setup Agent.
With the Metabind CLI: run metabind agent set in the bound project, and pipe the key in so it stays out of your shell history:
echo "$ANTHROPIC_API_KEY" | metabind agent set --api-key-stdin --provider anthropic --model claude-sonnet-5-5
--provider takes anthropic, openai, or google (Gemini). metabind agent models lists the models for each.

Metabind encrypts the key server-side and never returns it in API responses. See LLM provider configuration. On the same Agent page, write the agent’s System Prompt: its voice, rules, and goals. The proxy sends it to the model on every turn, after your server instructions. See System prompt.

What you configure

A Metabind API key, sent as a Bearer token to both the Agent Proxy and the MCP server.
Your project’s orgId and projectId: the internal IDs, not the slugs, because the Agent Proxy accepts only IDs. The SDK derives your project’s MCP server URL from these. To look them up, see Find your organization and project IDs.
Optionally, the agentHost and mcpHost constructor parameters, which default to https://agent.metabind.ai and https://mcp.metabind.ai.

Drop in the chat surface

The SDK ships MetabindAssistantView, a complete chat UI:

import ai.metabind.ai.MetabindAssistant
import ai.metabind.ai.MetabindAssistantView

@Composable
fun AssistantScreen() {
    val assistant = remember {
        MetabindAssistant(
            apiKey = apiKey,
            orgId = orgId,
            projectId = projectId
        )
    }

    MetabindAssistantView(assistant = assistant)
}

MetabindAssistantView handles message bubbles, streaming indicators, tool rendering, input, and auto-scrolling. It follows your app’s Material3 theme.

Retain the MetabindAssistant instance at an appropriate scope — inside a ViewModel, for example — and call close() when you discard it.

MetabindAssistant

MetabindAssistant manages the conversation. For custom UIs, observe its state directly:

Property	Type	Description
`messages`	`StateFlow<List<ChatMessage>>`	Conversation history
`isLoading`	`StateFlow<Boolean>`	True while streaming
`error`	`StateFlow<String?>`	Error message, if any
`toolUIContent`	`StateFlow<Map<String, ToolUIContent>>`	Tool UI payloads by call ID

Method	Description
`send(text)`	Send a user message
`cancel()`	Cancel current response
`reset()`	Clear conversation history and reset the agent’s server-side session
`close()`	Release resources

ChatMessage

data class ChatMessage(
    val id: String = UUID.randomUUID().toString(),
    val role: MessageRole,              // USER, ASSISTANT, TOOL, or ERROR
    val content: String,
    val toolName: String? = null,
    val toolStatus: ToolStatus? = null  // LOADING, COMPLETED, or ERROR
)

Stream a conversation turn

MetabindAgentProvider calls the Agent Proxy — which holds the LLM key and runs the tool loop server-side — and streams results back as a Flow<LLMStreamEvent>:

import ai.metabind.ai.MetabindAgentProvider
import ai.metabind.mcpappshost.LLMMessage
import ai.metabind.mcpappshost.LLMStreamEvent

val provider = MetabindAgentProvider()

provider.streamMessage(
    baseUrl = "https://agent.metabind.ai",
    apiKey = apiKey,
    orgId = orgId,
    projectId = projectId,
    messages = history   // List<LLMMessage>: User / Assistant / ToolResults
).collect { event ->
    when (event) {
        is LLMStreamEvent.TextDelta     -> { /* append streaming text */ }
        is LLMStreamEvent.ToolCallStart -> { /* a tool was invoked */ }
        is LLMStreamEvent.ToolResult    -> { /* tool finished */ }
        is LLMStreamEvent.Done          -> { /* turn complete */ }
        is LLMStreamEvent.Error         -> { /* handle the error */ }
        else -> {}
    }
}

The Android SDK is Agent-proxy only — there’s no bring-your-own-key Anthropic provider. See LLM provider configuration for how the proxy works.

Discover and fetch tool UIs

Use MCPAppsClient to list your project’s tools and fetch the UI resource for a tool that renders one:

import ai.metabind.mcpappshost.MCPAppsClient
import ai.metabind.ai.ToolUIContent

val client = MCPAppsClient(
    url = mcpServerUrl,
    headers = mapOf("authorization" to "Bearer $apiKey")
)

val tools = client.listTools()

// When a tool with a UI is called, fetch and parse its resource:
val resource = client.readResource(resourceUri)
val ui = ToolUIContent.fromResource(resource, toolArguments)  // BindJS or Html

MCPAppsClient also exposes callTool(name, arguments) for invoking tools.

Native rendering of tool output

If you use MetabindAssistantView, tool rendering is automatic. For custom UIs, render each tool call with MetabindToolView, the same renderer MetabindAssistantView uses. It takes a ToolUIContent, which has two variants:

ToolUIContent.BindJS — rendered as Compose through bindjs-android
ToolUIContent.Html — rendered in a WebView

import ai.metabind.ai.MetabindToolView

val toolUIContent by assistant.toolUIContent.collectAsState()

toolUIContent[message.id]?.let { content ->
    MetabindToolView(
        assistant = assistant,
        toolName = message.toolName ?: "",
        content = content,
    )
}

toolUIContent is keyed by tool call ID, the same ID as the TOOL message the call produced. See MetabindToolView.kt for the optional parameters.

Build a custom chat UI

If MetabindAssistantView doesn’t fit your design, build your own around MetabindAssistant. Observe assistant.messages, call assistant.send(text), and render each TOOL message’s UI by passing assistant.toolUIContent[message.id] to MetabindToolView. The finance demo is a complete custom UI built this way, and Custom host UI has a short example. The MetabindAssistantView source shows the drop-in surface built on the same APIs.

Next steps

Demo app

The reference Compose chat app, end to end.

LLM provider configuration

How the Agent Proxy holds keys and runs the tool loop.

BindJS reference

The component language the tool UIs are written in.

iOS SDK

The iOS equivalent.

Getting Started

Core Concepts

Building Your MCP App

Publishing

Connecting to MCP Hosts

Assistant SDK

Operations

Sample Apps

SDK on GitHub

Demo app

Requirements

Installation

Add the GitHub Packages repository

Add the dependency

Set the project’s LLM provider

What you configure

Drop in the chat surface

MetabindAssistant

ChatMessage

Stream a conversation turn

Discover and fetch tool UIs

Native rendering of tool output

Build a custom chat UI

Next steps

Demo app

LLM provider configuration

BindJS reference

iOS SDK

SDK on GitHub

Demo app

​Requirements

​Installation

​Add the GitHub Packages repository

​Add the dependency

​Set the project’s LLM provider

​What you configure

​Drop in the chat surface

​MetabindAssistant

​ChatMessage

​Stream a conversation turn

​Discover and fetch tool UIs

​Native rendering of tool output

​Build a custom chat UI

​Next steps

Demo app

LLM provider configuration

BindJS reference

iOS SDK

Requirements

Installation

Add the GitHub Packages repository

Add the dependency

Set the project’s LLM provider

What you configure

Drop in the chat surface

MetabindAssistant

ChatMessage

Stream a conversation turn

Discover and fetch tool UIs

Native rendering of tool output

Build a custom chat UI

Next steps