openai-kmp

0.0.2indexed

Shared transport and config for OpenAI APIs, offering typed and raw endpoints (chat, responses, embeddings, images, audio, files, realtime, fine-tuning) with multipart and websocket support.

AndroidJVMNativeWasm·AndroidPoet/openai-kmp

Stars

—

Used by

dependents

—

Health

/ 100

OpenAI KMP

Kotlin Multiplatform SDK for OpenAI APIs.

Kotlin Ktor Platforms Maven Central Git tag Build Publish License

Why This SDK

Shared transport and configuration across all domains.
Raw and typed API access patterns for stable and fast-evolving payloads.
Multiplatform-first targets with one consistent client surface.

Module Map

Targets

Android
JVM
iOS (x64/arm64/simulator arm64)
macOS (x64/arm64)
tvOS (x64/arm64/simulator arm64)
watchOS (x64/arm64/simulator arm64)
Linux x64
Windows mingw x64
WasmJs

Setup

Version Catalog

Module Dependencies

kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation(libs.openai.client)       // base transport/config
            implementation(libs.openai.responses)    // optional
            implementation(libs.openai.chat)         // optional
            implementation(libs.openai.embeddings)   // optional
            implementation(libs.openai.files)        
            implementation(libs.openai.batches)      
            implementation(libs.openai.models)       
            implementation(libs.openai.moderations)  
            implementation(libs.openai.images)       
            implementation(libs.openai.audio)        
            implementation(libs.openai.realtime)     
            implementation(libs.openai.finetuning)   
            implementation(libs.openai.vectorstores) 
            implementation(libs.openai.uploads)      
        }
    }
}

Client Creation

val client = OpenAI.create(
    apiKey = System.getenv("OPENAI_API_KEY"),
) {
    logging = true
    timeoutMillis = 60_000
    organization = null
    project = null
}

Quick Start (Responses)

val responses = client.responses()
val responseOutcome = responses.createTyped(
    request = ResponseCreateRequest(
        model = "gpt-4.1-mini",
        input = buildJsonArray {
            addJsonObject {
                put("role", "user")
                put("content", buildJsonArray {
                    addJsonObject {
                        put("type", "input_text")
                        put("text", "Say hello from openai-kmp")
                    }
                })
            }
        },
    ),
)

Core Usage by Domain

Chat Completions

val chat = client.chat()
val completionOutcome = chat.createTyped(
    ChatCompletionRequest(
        model = "gpt-4.1-mini",
        messages = messagesJson,
    ),
)

Embeddings

val embeddings = client.embeddings()
val embeddingOutcome = embeddings.createTyped(
    EmbeddingRequest(
        model = "text-embedding-3-small",
        input = embeddingInputJson,
    ),
)

Files

val files = client.files()
val fileUploadOutcome = files.create(
    purpose = "assistants",
    bytes = fileBytes,
    filename = "knowledge.pdf",
    contentType = "application/pdf",
)

Images

val images = client.images()
val imageOutcome = images.generateTyped(
    ImageGenerationRequest(
        model = "gpt-image-1",
        prompt = "A cinematic landscape at sunset",
        size = "1024x1024",
    ),
)

Audio Transcription

val audio = client.audio()
val transcriptOutcome = audio.transcriptionTyped(
    audioBytes = wavBytes,
    audioFilename = "meeting.wav",
    model = "gpt-4o-mini-transcribe",
)

Fine-Tuning

val fineTuning = client.fineTuning()
val jobOutcome = fineTuning.createJobTyped(
    FineTuningJobCreateRequest(
        model = "gpt-4.1-mini",
        trainingFile = "file_abc123",
    ),
)

Vector Stores

val vectorStores = client.vectorStores()
val storeOutcome = vectorStores.createTyped(
    VectorStoreCreateRequest(
        name = "docs-index",
    ),
)

Upload Sessions

val uploads = client.uploads()
val uploadOutcome = uploads.createTyped(
    UploadCreateRequest(
        purpose = "assistants",
        filename = "archive.zip",
        bytesCount = zipSize,
        mimeType = "application/zip",
    ),
)

Handling Outcomes

val modelOutcome = client.models().retrieveTyped("gpt-4.1-mini")

modelOutcome
    .onSuccess { model ->
        println("model=${model.id}")
    }
    .onFailure { error ->
        println("status=${error.statusCode} message=${error.message}")
    }

Additional helpers:

map, flatMap
recover, getOrElse
getOrNull, getOrThrow, errorOrNull

Configuration Surface

OpenAI.create supports:

logging: Boolean
logLevel: LogLevel
organization: String?
project: String?
timeoutMillis: Long
headers: MutableMap<String, String>

Example:

val client = OpenAI.create(apiKey = token) {
    logging = true
    logLevel = LogLevel.HEADERS
    timeoutMillis = 90_000
    headers["X-App-Name"] = "my-kmp-app"
}

Recommended Integration Pattern

Create one long-lived OpenAIClient instance.
Expose feature clients from your application composition layer.
Keep endpoint request building in domain/services layer.
Centralize retry/backoff policy in one place.
Close the client on app shutdown.

File and Vector Workflow (Typical)

Upload document using files.create(...).
Create vector store using vectorStores.createTyped(...).
Attach file to store using vectorStores.addFile(...).
Query store using vectorStores.searchTyped(...).

Batches Workflow (Typical)

Upload JSONL requests file.
Create batch with batches.createTyped(...).
Poll status with batches.retrieveTyped(...).
Fetch output/error files after completion.

Project Docs

Full docs live under docs/:

Status

Multiplatform compile: green
JVM tests: green

Contributing

Contributions are welcome! If you've found a bug, have an idea for an improvement, or want to contribute new features, please open an issue or submit a pull request.

Find this repository useful? :heart:

Support it by joining stargazers for this repository. :star:
Also, follow me on GitHub for my next creations! 🤩

License

Related libraries

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

surrealdb-kotlin-driver★ 29

mnbjhuSimple driver for SurrealDB. Supports all Websocket endpoints, integrates with kotlinx.serialization, and performs asynchronous database operations. Features live queries, type-safe record links, and seamless JSON handling.Shared: service-sdk, network, kotlin-serialization

KtorMonitor★ 220

CosminMihuMDCMonitors network requests and responses, enhancing debugging and analysis of client-server interactions. Features include header sanitization, log retention, and content length management with platform-specific integrations.Shared: wasm, ktor, http

ktorgen★ 32

kingg22Generates HTTP client code at compile-time using annotations, inspired by Retrofit and Ktorfit. Features include no runtime dependencies, type-safe headers, and advanced customization options.Shared: network, ktor, http-client

`openai-core`	shared error/list contracts and common helpers	shared
`openai-client`	HTTP transport, config, JSON/multipart plumbing	shared
`openai-responses`	Responses API	`/responses`
`openai-chat`	Chat Completions API	`/chat/completions`
`openai-embeddings`	Embeddings API	`/embeddings`
`openai-files`	File upload/list/delete/content	`/files`
`openai-batches`	Batch job lifecycle	`/batches`
`openai-models`	Model list/retrieve/delete	`/models`
`openai-moderations`	Moderation checks	`/moderations`
`openai-images`	Generate/edit/variation image workflows	`/images`
`openai-audio`	Speech/transcription/translation	`/audio`
`openai-realtime`	Realtime WebSocket event sessions	`/realtime`
`openai-finetuning`	Fine-tuning jobs/events/checkpoints	`/fine_tuning`
`openai-vectorstores`	Vector store and vector file operations	`/vector_stores`
`openai-uploads`	multipart upload session lifecycle	`/uploads`