Add a governed agent to your iOS app

The Assistant SDK for iOS ships as the MetabindAI product of the metabind-apple Swift Package: an MCP client, conversation state, an LLM provider abstraction, and the native SwiftUI renderer for BindJS. Drop it into your app and you have a governed agent inside your own app — calling your tools, rendering results as native SwiftUI views, and rendering only the components you approved.

Rendered Interactive Tool components — product detail cards, a purchasable item card with Buy Now, a 3D model viewer chip, and a product-comparison view — all returned by AI tool calls and rendered as native UI.

Start free

No credit card. Free Assistant SDK. Free tier on the platform.

iOS SDK reference

Full install, configuration, and custom-UI documentation.

Building for Android? Same SDK shape, Jetpack Compose renderer. Jump to the Android SDK guide.

Install via Swift Package Manager

In Xcode: File → Add Package Dependencies → paste:

https://github.com/metabindai/metabind-apple

Or in Package.swift:

dependencies: [
  .package(url: "https://github.com/metabindai/metabind-apple.git", from: "1.3.0")
]

Then add the MetabindAI product to your target’s dependencies. Requirements: iOS 17+, macOS 14+, or visionOS 1+; Swift 5.11+.

Configure with the Agent proxy (recommended)

The Agent proxy holds the LLM key server-side, runs the tool loop, and streams responses back as SSE — your iOS binary never ships a third-party API key.

import MetabindAI

let assistant = MetabindAssistant(
  serverURL: URL(string: "https://mcp.metabind.ai/my-org/my-project")!,
  serverHeaders: ["Authorization": "Bearer \(projectToken)"],
  provider: MetabindAgentProvider(
    apiKey: projectToken,
    orgId: "my-org",
    projectId: "my-project"
  )
)

The proxy supports Anthropic, OpenAI, and Google — selected per-project in MCP App Studio. Switch providers without shipping a new app version.

Drop in the chat surface

import SwiftUI
import MetabindAI

struct AssistantScreen: View {
  let assistant: MetabindAssistant

  var body: some View {
    MetabindAssistantView(assistant: assistant)
      .navigationTitle("Assistant")
  }
}

That’s a working in-app assistant. MetabindAssistantView handles user input, message rendering, streaming SSE deltas, and inline native rendering of Interactive Tool output. It respects your app’s color scheme, dynamic type, and accessibility settings — because it’s SwiftUI, not a WebView. For a fully custom UI, use the lower-level API on MetabindAssistant — assistant.send(...), assistant.conversation, assistant.cancel(), assistant.isProcessing. See Custom host UI.

What you don’t write

You write	The SDK does
Project URL + token from your backend	MCP connection, auth, retries
LLM provider config (Agent proxy or BYOK)	Tool calls, schema validation, conversation state
`MetabindAssistantView` placement (or custom UI)	Streaming, message rendering, tool-result rendering

No tool-calling loop. In Agent proxy mode the proxy runs it; in BYOK mode the SDK does. Either way, not you.
No streaming code. SSE deltas flow into conversation state and re-render the UI automatically.
No native renderer. Interactive Tool output renders through BindJS without you wiring it up.
No schema validation. Inputs and outputs are validated against the project’s tool schemas before they reach the renderer.

Native rendering, not a WebView

A Metabind ProductCard renders inline in a chat conversation as a real native SwiftUI view — image, title, price, and shop button — not as a WebView.

When the assistant calls one of your Interactive Tools, the result renders as SwiftUI inline in the conversation. A ProductCard is a SwiftUI view — it animates with your app’s transitions, respects dynamic type, supports VoiceOver, and adopts your color scheme. The renderer is BindJS’s native Swift engine — no embedded browser, and no App Store release when you change a layout. The same Interactive Tool definition that renders here renders as Jetpack Compose on Android and React on the web — one BindJS definition, three renderers, the same governance everywhere.

Your tools. Your brand. Your app.

Most “drop-in AI” SDKs route users to someone else’s chat surface, someone else’s brand, and someone else’s tool ecosystem. The Assistant SDK is the opposite — the governed agent runs inside your product, calling tools you built in Metabind, rendered with your components, on your typography and color. Your users never leave your app. You don’t expose them to a third-party host.

Token and key handling

Where it lives	What
Your backend (recommended)	Mint per-user or per-session Metabind project tokens. The SDK uses them to authenticate to the MCP server and the Agent proxy.
Agent proxy, server-side	The LLM provider key (Anthropic, OpenAI, or Google). Your client never sees it.
BYOK direct mode (dev only)	Anthropic API key delivered to the SDK by your auth flow. For production, prefer the Agent proxy.

Don’t hard-code an Anthropic API key in a production iOS app — anyone can extract it from the binary. Use the Agent proxy for production.

Use the Assistant SDK when

You’re building an iOS, Android, or web product and want a governed agent inside it.
You want users to use AI inside your app, not be redirected to Claude or ChatGPT.
You want tool results rendered as real components — SwiftUI on iOS, Jetpack Compose on Android (not web views), and React on the web.
You want Metabind to manage LLM key custody and the tool loop server-side.

A project’s tools work in both the Assistant SDK and connected MCP hosts at the same time. Ship the SDK in your app, and let power users also connect Claude Desktop to the same project if they want to.

Three platforms, one model

Platform	Package	Renderer
iOS	`MetabindAI` product of the `metabind-apple` Swift Package	SwiftUI via `bindjs-apple`
Android	`ai.metabind:metabindai-android` (Maven, from `metabind-android`)	Jetpack Compose via `bindjs-android`
Web	`@metabindai/agent-ui` (npm, from `metabind-web`)	React; Interactive Tools render in sandboxed iframes

The mobile SDKs expose the same shape — a MetabindAssistant configured with a server and an LLMProvider, plus a drop-in MetabindAssistantView chat surface — adapted to each platform’s idioms. On the web, @metabindai/agent-ui provides the drop-in <AgentChat /> React component.

Ship today

Start free

No credit card. Free Assistant SDK. Free tier on the platform.

iOS SDK reference

Full install, configuration, mock mode for previews.

Android SDK

Jetpack Compose renderer, Kotlin install, parity with iOS.

LLM provider configuration

Agent proxy vs. BYOK. Anthropic, OpenAI, Google selection.

Getting Started

Core Concepts

Building Your MCP App

Publishing

Connecting to MCP Hosts

Assistant SDK

Operations

Sample Apps

Add a governed agent to your iOS app

Start free

iOS SDK reference

Install via Swift Package Manager

Configure with the Agent proxy (recommended)

Drop in the chat surface

What you don’t write

Native rendering, not a WebView

Your tools. Your brand. Your app.

Token and key handling

Use the Assistant SDK when

Three platforms, one model

Ship today

Start free

iOS SDK reference

Android SDK

LLM provider configuration

Start free

iOS SDK reference

​Install via Swift Package Manager

​Configure with the Agent proxy (recommended)

​Drop in the chat surface

​What you don’t write

​Native rendering, not a WebView

​Your tools. Your brand. Your app.

​Token and key handling

​Use the Assistant SDK when

​Three platforms, one model

​Ship today

Start free

iOS SDK reference

Android SDK

LLM provider configuration

Install via Swift Package Manager

Configure with the Agent proxy (recommended)

Drop in the chat surface

What you don’t write

Native rendering, not a WebView

Your tools. Your brand. Your app.

Token and key handling

Use the Assistant SDK when

Three platforms, one model

Ship today