# How AionUi Integrates with AWS Bedrock and Cloud Providers via Custom API Endpoints

> Learn how AionUi integrates AWS Bedrock and custom API endpoints. Discover seamless LLM provider abstraction for your cloud applications.

- Repository: [OfficeAI/AionUi](https://github.com/iofficeai/aionui)
- Tags: how-to-guide
- Published: 2026-02-16

---

**AionUi abstracts every LLM provider behind a platform-type system that routes AWS Bedrock calls through the AWS SDK with temporary credential injection while treating custom endpoints as OpenAI-compatible APIs using dynamic base URL configuration.**

AionUi provides a unified interface for connecting to various large language model providers. The application integrates with AWS Bedrock and other cloud providers via custom API endpoints through a flexible architecture that normalizes provider-specific logic into a consistent model selection interface.

## Platform Abstraction Architecture in AionUi

AionUi categorizes every LLM provider using a **platform-type** identifier such as `bedrock`, `custom`, or `new-api`. The **model bridge** located at [`src/process/bridge/modelBridge.ts`](https://github.com/iOfficeAI/AionUi/blob/main/src/process/bridge/modelBridge.ts) serves as the central routing layer that resolves these platform types into concrete implementation logic. This architecture allows the UI to present a uniform model selection dropdown regardless of whether the backend communicates with AWS Bedrock or a self-hosted OpenAI-compatible server.

## AWS Bedrock Integration Implementation

### Credential Management and SDK Initialization

When users select the AWS Bedrock platform, the model bridge initializes the `@aws-sdk/client-bedrock` client. The system temporarily injects user-supplied AWS credentials into the process environment to authenticate requests without persisting sensitive data to disk. This implementation appears in [`src/process/bridge/modelBridge.ts`](https://github.com/iOfficeAI/AionUi/blob/main/src/process/bridge/modelBridge.ts) between lines 161-173 and 186-212.

### Inference Profile Retrieval and Model Mapping

The bridge executes `ListInferenceProfilesCommand` to retrieve available inference profiles from AWS Bedrock. It filters the results for Claude models and maps technical identifiers to friendly display names using the `BEDROCK_MODEL_NAMES` constant. The normalized output returns to the UI as an array of `{ id, name }` objects, populating the model selection interface with human-readable options.

### Connection Testing with BedrockContentGenerator

Before establishing full sessions, AionUi verifies Bedrock credentials through a lightweight validation call. The `BedrockContentGenerator` class, defined in [`src/process/bridge/bedrockBridge.ts`](https://github.com/iOfficeAI/AionUi/blob/main/src/process/bridge/bedrockBridge.ts) (lines 12-62), performs a "count-tokens" operation that confirms authentication without consuming inference quota. This method provides immediate feedback in the settings interface when users test their AWS configuration.

## Custom API Endpoint Integration

### OpenAI-Compatible API Support

For providers not explicitly predefined, AionUi supports **custom** platform types that accept user-defined API endpoints. When the platform value equals `custom`, the system treats the endpoint as OpenAI-compatible. The model bridge constructs an `OpenAI` SDK instance using the user-provided `base_url` and `api_key`, then calls `openai.models.list()` to retrieve available models. This logic appears in [`src/process/bridge/modelBridge.ts`](https://github.com/iOfficeAI/AionUi/blob/main/src/process/bridge/modelBridge.ts) at lines 87-99 and 131-149.

### New-API Gateway Compatibility

AionUi extends custom endpoint support to **new-api** gateways that expose standard `/v1/models` paths. The utility function `isNewApiPlatform` in [`src/common/utils/platformConstants.ts`](https://github.com/iOfficeAI/AionUi/blob/main/src/common/utils/platformConstants.ts) identifies these gateway types, allowing the model bridge to apply the same OpenAI-compatible retrieval logic while handling subtle differences in response formatting. This ensures compatibility with popular open-source API gateways like LiteLLM and OneAPI.

### Dynamic Base URL Configuration

Unlike predefined platforms with static endpoints, custom integrations require runtime URL configuration. The UI prompts users to input their endpoint address when selecting the custom platform type. The model bridge validates this input and incorporates it as the `baseUrl` parameter for SDK initialization, enabling connections to private cloud deployments, VPC endpoints, or regional API mirrors without code modifications.

## Platform Configuration Registry

All supported platforms, including AWS Bedrock and custom endpoints, are declared in [`src/renderer/config/modelPlatforms.ts`](https://github.com/iOfficeAI/AionUi/blob/main/src/renderer/config/modelPlatforms.ts). This configuration file defines the Bedrock entry at lines 86-89, specifying required fields such as region and authentication method. The custom option appears at lines 75-78, marked with a flag indicating that it requires user-entered base URL configuration. This centralized registry allows the renderer process to dynamically generate settings forms based on platform metadata.

## Code Examples

The following examples demonstrate how AionUi's IPC bridge exposes these integrations to the renderer process.

Fetch model list for a custom OpenAI-compatible provider:

```typescript
await ipcBridge.mode.fetchModelList.provider({
  base_url: 'https://api.custom-provider.com/v1',
  api_key: 'sk-custom-key',
  platform: 'custom',
});

```

Test AWS Bedrock credentials before saving settings:

```typescript
await ipcBridge.bedrock.testConnection.provider({
  bedrockConfig: {
    region: 'us-east-1',
    authMethod: 'profile',
    profile: 'my-aws-profile',
  },
});

```

## Summary

- AionUi uses a **platform-type abstraction** in [`src/process/bridge/modelBridge.ts`](https://github.com/iOfficeAI/AionUi/blob/main/src/process/bridge/modelBridge.ts) to normalize interactions with AWS Bedrock and custom API endpoints.
- **AWS Bedrock integration** leverages the AWS SDK with temporary credential injection, inference profile retrieval, and the `BedrockContentGenerator` for connection testing.
- **Custom endpoints** are treated as OpenAI-compatible APIs, supporting dynamic base URL configuration and new-api gateways through the `isNewApiPlatform` utility.
- Platform definitions in [`src/renderer/config/modelPlatforms.ts`](https://github.com/iOfficeAI/AionUi/blob/main/src/renderer/config/modelPlatforms.ts) centralize configuration for both built-in and custom providers.

## Frequently Asked Questions

### How does AionUi handle AWS credential security when connecting to Bedrock?

AionUi temporarily injects AWS credentials into the process environment only during the active SDK call, then clears them immediately after the operation completes. This approach prevents persistent storage of sensitive keys in memory or on disk while still allowing the `@aws-sdk/client-bedrock` client to authenticate with AWS services.

### Can AionUi connect to private LLM deployments or VPC endpoints?

Yes, the **custom** platform type supports arbitrary base URLs, allowing connections to private cloud deployments, VPC endpoints, or regional API mirrors. Users simply enter their endpoint address in the UI, and the model bridge initializes the OpenAI SDK with the provided `base_url` parameter.

### What is the difference between the "custom" and "new-api" platform types in AionUi?

The **custom** platform type is a generic category for user-defined OpenAI-compatible endpoints, while **new-api** specifically identifies gateways that follow the standard `/v1/models` path structure used by popular open-source proxies like LiteLLM. The `isNewApiPlatform` utility in [`src/common/utils/platformConstants.ts`](https://github.com/iOfficeAI/AionUi/blob/main/src/common/utils/platformConstants.ts) distinguishes these cases to handle subtle response formatting differences.

### How can I verify my AWS Bedrock configuration before using it in AionUi?

Use the connection test feature available in the settings interface, which calls `ipcBridge.bedrock.testConnection.provider()` with your configuration. This executes a lightweight token-counting operation through the `BedrockContentGenerator` class in [`src/process/bridge/bedrockBridge.ts`](https://github.com/iOfficeAI/AionUi/blob/main/src/process/bridge/bedrockBridge.ts) to verify credentials without consuming inference quota.