# Adding an AI/ML Source
Source: https://docs.squared.ai/activation/add-ai-source
How to connect and configure a hosted AI/ML model source in AI Squared.
You can connect your hosted AI/ML model endpoints to AI Squared in just a few steps. This allows your models to power real-time insights across business applications.
***
## Step 1: Select Your AI/ML Source
1. Navigate to **Sources** → **AI/ML Sources** in the sidebar.
2. Click **“Add Source”**.
3. Select the AI/ML source connector from the list.
> 📸 *Add screenshot of “Add AI/ML Source” UI*
***
## Step 2: Define and Connect the Endpoint
Fill in the required connection details:
* **Endpoint Name** – A descriptive name for easy identification.
* **Endpoint URL** – The hosted URL of your AI/ML model.
* **Authentication Method** – Choose between `OAuth`, `API Key`, etc.
* **Authorization Header** – Format of the header (if applicable).
* **Secret Key** – For secure access.
* **Request Format** – Define the input structure (e.g., JSON).
* **Response Format** – Define how the model returns predictions.
> 📸 *Add screenshot of endpoint configuration UI*
***
## Step 3: Test the Source
Before saving, click **“Test Connection”** to verify that the endpoint is reachable and properly configured.
> ⚠️ If the test fails, check for errors in the endpoint URL, headers, or authentication values.
> 📸 *Add screenshot of test results with success/failure examples*
***
## Step 4: Save the Source
Once the test passes:
* Provide a name and optional description.
* Click **“Save”** to finalize setup.
* Your model source will now appear under **AI/ML Sources**.
> 📸 *Add screenshot showing saved model in the source list*
***
## Step 5: Define Input Schema
The **Input Schema** tells AI Squared how to format data before sending it to the model.
Each input field requires:
* **Name** – Matches the key in your model’s input payload.
* **Type** – `String`, `Integer`, `Float`, or `Boolean`.
* **Value Type** – `Dynamic` (from data/apps) or `Static` (fixed value).
> 📸 *Add screenshot of input schema editor*
***
## Step 6: Define Output Schema
The **Output Schema** tells AI Squared how to interpret the model's response.
Each output field requires:
* **Field Name** – The key returned by the model.
* **Type** – Define the type: `String`, `Integer`, `Float`, `Boolean`.
This ensures downstream systems or visualizations can consume the output consistently.
> 📸 *Add screenshot of output schema editor*
***
## ✅ You’re Done!
You’ve successfully added and configured your hosted AI/ML model as a source in AI Squared. Your model can now be used in **Data Apps**, **Chatbots**, and other workflow automations.
# Anthropic Model
Source: https://docs.squared.ai/activation/ai-ml-sources/anthropic-model
## Connect AI Squared to Anthropic Model
This guide will help you configure the Anthropic Model Connector in AI Squared to access your Anthropic Model Endpoint.
### Prerequisites
Before proceeding, ensure you have the necessary API key from Anthropic.
## Step-by-Step Guide to Connect to an Anthropic Model Endpoint
## Step 1: Navigate to Anthropic Console
Start by logging into your Anthropic Console.
1. Sign in to your Anthropic account at [Anthropic](https://console.anthropic.com/dashboard).
## Step 2: Locate API keys
Once you're in the Anthropic, you'll find the necessary configuration details:
1. **API Key:**
* Click on "API keys" to view your API keys.
* If you haven't created an API Key before, click on "Create API key" to generate a new one. Make sure to copy the API Key as they are shown only once.
## Step 3: Configure Anthropic Model Connector in Your Application
Now that you have gathered all the necessary details enter the following information:
* **API Key:** Your Anthropic API key.
## Sample Request and Response
**Request:**
```json theme={null}
{
"model": "claude-3-7-sonnet-20250219",
"max_tokens": 256,
"messages": [{"role": "user", "content": "Hi."}],
"stream": false
}
```
**Response:**
```json theme={null}
{
"id": "msg_0123ABC",
"type": "message",
"role": "assistant",
"model": "claude-3-7-sonnet-20250219",
"content": [
{
"type": "text",
"text": "Hello there! How can I assist you today? Whether you have a question, need some information, or just want to chat, I'm here to help. What's on your mind?"
}
],
"stop_reason": "end_turn",
"stop_sequence": null,
"usage": {
"input_tokens": 10,
"cache_creation_input_tokens": 0,
"cache_read_input_tokens": 0,
"output_tokens": 41
}
}
```
**Request:**
```json theme={null}
{
"model": "claude-3-7-sonnet-20250219",
"max_tokens": 1024,
"messages": [{"role": "user", "content": "Hi"}],
"stream": true
}
```
**Response:**
```json theme={null}
{
"type": "content_block_delta",
"index": 0,
"delta": {
"type": "text_delta",
"text": "Hello!"
}
}
```
# AWS Bedrock Model
Source: https://docs.squared.ai/activation/ai-ml-sources/aws_bedrock-model
## Connect AI Squared to AWS Bedrock Model
This guide will help you configure the AWS Bedrock Model Connector in AI Squared to access your AWS Bedrock Model Endpoint.
### Prerequisites
Before proceeding, ensure you have the necessary access key, secret access key, and region from AWS.
## Step-by-Step Guide to Connect to an AWS Bedrock Model Endpoint
## Step 1: Navigate to AWS Console
Start by logging into your AWS Management Console.
1. Sign in to your AWS account at [AWS Management Console](https://aws.amazon.com/console/).
## Step 2: Locate AWS Configuration Details
Once you're in the AWS console, you'll find the necessary configuration details:
1. **Access Key and Secret Access Key:**
* Click on your username at the top right corner of the AWS Management Console.
* Choose "Security Credentials" from the dropdown menu.
* In the "Access keys" section, you can create or view your access keys.
* If you haven't created an access key pair before, click on "Create access key" to generate a new one. Make sure to copy the Access Key ID and Secret Access Key as they are shown only once.
2. **Region:**
* The AWS region can be selected from the top right corner of the AWS Management Console. Choose the region where your AWS Bedrock resources is located and note down the region.
3. **Inference Profile ARN:**
* The Inference Profile ARN is in the Cross-region inference page and can be found in your selected model.
4. **Model ID:**
* The AWS Model Id can be found in your selected models catalog.
## Step 3: Configure AWS Bedrock Model Connector in Your Application
Now that you have gathered all the necessary details enter the following information:
* **Access Key ID:** Your AWS IAM user's Access Key ID.
* **Secret Access Key:** The corresponding Secret Access Key.
* **Region:** The AWS region where your Bedrock model are located.
* **Inference Profile ARN:** Inference Profile ARN for Model in AWS Bedrock.
* **Model ID:** The Model ID.
## Sample Request and Response
**Request:**
```json theme={null}
{
"messages": [
{
"role": "user",
"content": "hello"
}
],
"max_tokens": 100
}
```
**Response:**
```json theme={null}
{
"id": "chatcmpl",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": " Hello!",
"tool_calls": null
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 12,
"completion_tokens": 10,
"total_tokens": 22
},
"meta": {
"requestDurationMillis": 113
},
"model": "jamba-1.5-large"
}
```
**Request:**
```json theme={null}
{
"messages": [
{
"role": "user",
"content": "hello"
}
],
"max_tokens": 100
}
```
**Response:**
```json theme={null}
{
"id": "chatcmpl",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": " Hello!",
"tool_calls": null
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 12,
"completion_tokens": 10,
"total_tokens": 22
},
"meta": {
"requestDurationMillis": 113
},
"model": "jamba-1.5-mini"
}
```
**Request:**
```json theme={null}
{
"inferenceConfig": {
"max_new_tokens": 100
},
"messages": [
{
"role": "user",
"content": [
{
"text": "hello"
}
]
}
]
}
```
**Response:**
```json theme={null}
{
"output": {
"message": {
"content": [
{
"text": "Hello!"
}
],
"role": "assistant"
}
},
"stopReason": "end_turn",
"usage": {
"inputTokens": 1,
"outputTokens": 51,
"totalTokens": 52,
"cacheReadInputTokenCount": 0,
"cacheWriteInputTokenCount": 0
}
}
```
**Request:**
```json theme={null}
{
"inferenceConfig": {
"max_new_tokens": 100
},
"messages": [
{
"role": "user",
"content": [
{
"text": "hello"
}
]
}
]
}
```
**Response:**
```json theme={null}
{
"output": {
"message": {
"content": [
{
"text": "Hello!"
}
],
"role": "assistant"
}
},
"stopReason": "end_turn",
"usage": {
"inputTokens": 1,
"outputTokens": 51,
"totalTokens": 52,
"cacheReadInputTokenCount": 0,
"cacheWriteInputTokenCount": 0
}
}
```
**Request:**
```json theme={null}
{
"inferenceConfig": {
"max_new_tokens": 100
},
"messages": [
{
"role": "user",
"content": [
{
"text": "hello"
}
]
}
]
}
```
**Response:**
```json theme={null}
{
"output": {
"message": {
"content": [
{
"text": "Hello!"
}
],
"role": "assistant"
}
},
"stopReason": "end_turn",
"usage": {
"inputTokens": 1,
"outputTokens": 51,
"totalTokens": 52,
"cacheReadInputTokenCount": 0,
"cacheWriteInputTokenCount": 0
}
}
```
**Request:**
```json theme={null}
{
"inputText": "hello",
"textGenerationConfig": {
"maxTokenCount": 100,
"stopSequences": []
}
}
```
**Response:**
```json theme={null}
{
"inputTextTokenCount": 3,
"results": [
{
"tokenCount": 13,
"outputText": "\nBot: Hi there! How can I help you?",
"completionReason": "FINISH"
}
]
}
```
**Request:**
```json theme={null}
{
"inputText": "hello",
"textGenerationConfig": {
"maxTokenCount": 100,
"stopSequences": []
}
}
```
**Response:**
```json theme={null}
{
"inputTextTokenCount": 3,
"results": [
{
"tokenCount": 13,
"outputText": "\nBot: Hi there! How can I help you?",
"completionReason": "FINISH"
}
]
}
```
**Request:**
```json theme={null}
{
"inputText": "hello",
"textGenerationConfig": {
"maxTokenCount": 100,
"stopSequences": []
}
}
```
**Response:**
```json theme={null}
{
"inputTextTokenCount": 3,
"results": [
{
"tokenCount": 13,
"outputText": "\nBot: Hi there! How can I help you?",
"completionReason": "FINISH"
}
]
}
```
**Request:**
```json theme={null}
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 100,
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "hello"
}
]
}
]
}
```
**Response:**
```json theme={null}
{
"id": "msg_01XFDUDYJgAACzvnptvVoYEL",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "Hello!"
}
],
"model": "claude-3-7-sonnet-20250219",
"stop_reason": "end_turn",
"stop_sequence": null,
"usage": {
"input_tokens": 12,
"output_tokens": 6
}
}
```
**Request:**
```json theme={null}
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 100,
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "hello"
}
]
}
]
}
```
**Response:**
```json theme={null}
{
"id": "msg_02ABC1234",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "Hi there!"
}
],
"model": "claude-3-5-haiku-20240305",
"stop_reason": "end_turn",
"usage": {
"input_tokens": 9,
"output_tokens": 5
}
}
```
**Request:**
```json theme={null}
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 100,
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "hello"
}
]
}
]
}
```
**Response:**
```json theme={null}
{
"id": "msg_03XYZ5678",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "Hello, friend!"
}
],
"model": "claude-3-5-sonnet-20240315-v2",
"stop_reason": "end_turn",
"usage": {
"input_tokens": 9,
"output_tokens": 6
}
}
```
**Request:**
```json theme={null}
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 100,
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "hello"
}
]
}
]
}
```
**Response:**
```json theme={null}
{
"id": "msg_bdrk",
"type": "message",
"role": "assistant",
"model": "claude-3-5-sonnet-20240307",
"content": [
{
"type": "text",
"text": "Hello!"
}
],
"stop_reason": "end_turn",
"stop_sequence": null,
"usage": {
"input_tokens": 8,
"output_tokens": 12
}
}
```
**Request:**
```json theme={null}
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 100,
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "hello"
}
]
}
]
}
```
**Response:**
```json theme={null}
{
"id": "msg_05OPQ2345",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "Hey there!"
}
],
"model": "claude-3-opus-20240229",
"stop_reason": "end_turn",
"usage": {
"input_tokens": 9,
"output_tokens": 6
}
}
```
**Request:**
```json theme={null}
{
"anthropic_version": "bedrock-2023-05-31",
"max_tokens": 100,
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "hello"
}
]
}
]
}
```
**Response:**
```json theme={null}
{
"id": "msg_06RST6789",
"type": "message",
"role": "assistant",
"content": [
{
"type": "text",
"text": "Hello, world!"
}
],
"model": "claude-3-haiku-20240305",
"stop_reason": "end_turn",
"usage": {
"input_tokens": 9,
"output_tokens": 6
}
}
```
**Request:**
```json theme={null}
{
"message": "Hi"
}
```
**Response:**
```json theme={null}
{
"response_id": "123D7",
"text": "Hi there!",
"generation_id": "e70d12",
"chat_history": [
{
"role": "USER",
"message": "Hi"
},
{
"role": "CHATBOT",
"message": "Hi there!"
}
],
"finish_reason": "COMPLETE"
}
```
**Request:**
```json theme={null}
{
"message": "Hi"
}
```
**Response:**
```json theme={null}
{
"response_id": "123D7",
"text": "Hi there!",
"generation_id": "e70d12",
"chat_history": [
{
"role": "USER",
"message": "Hi"
},
{
"role": "CHATBOT",
"message": "Hi there!"
}
],
"finish_reason": "COMPLETE"
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_tokens": 100
}
```
**Response:**
```json theme={null}
{
"id": "5e820f61f54d",
"generations": [
{
"id": "5e820f61f54d",
"text": " Hello!",
"finish_reason": "COMPLETE"
}
],
"prompt": "hello"
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_tokens": 100
}
```
**Response:**
```json theme={null}
{
"id": "5e820f61f54d",
"generations": [
{
"id": "5e820f61f54d",
"text": " Hello!",
"finish_reason": "COMPLETE"
}
],
"prompt": "hello"
}
```
**Request:**
```json theme={null}
{
"prompt": "Hello",
"max_tokens": 100
}
```
**Response:**
```json theme={null}
{
"choices": [
{
"text": "Hi!",
"stop_reason": "length"
}
]
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_gen_len": 100
}
```
**Response:**
```json theme={null}
{
"generation": "Hi!",
"prompt_token_count": 1,
"generation_token_count": 100,
"stop_reason": "length"
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_gen_len": 100
}
```
**Response:**
```json theme={null}
{
"generation": "Hi",
"prompt_token_count": 1,
"generation_token_count": 100,
"stop_reason": "length"
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_gen_len": 100
}
```
**Response:**
```json theme={null}
{
"generation": "Hi!",
"prompt_token_count": 1,
"generation_token_count": 480,
"stop_reason": "stop"
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_gen_len": 100
}
```
**Response:**
```json theme={null}
{
"generation": "Hi!",
"prompt_token_count": 1,
"generation_token_count": 480,
"stop_reason": "stop"
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_gen_len": 100
}
```
**Response:**
```json theme={null}
{
"generation": "Hi!",
"prompt_token_count": 1,
"generation_token_count": 100,
"stop_reason": "length"
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_gen_len": 100
}
```
**Response:**
```json theme={null}
{
"generation": "Hi!",
"prompt_token_count": 1,
"generation_token_count": 445,
"stop_reason": "length"
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_gen_len": 100
}
```
**Response:**
```json theme={null}
{
"generation": "Hi!",
"prompt_token_count": 1,
"generation_token_count": 445,
"stop_reason": "length"
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_gen_len": 100
}
```
**Response:**
```json theme={null}
{
"generation": "Hi!",
"prompt_token_count": 1,
"generation_token_count": 445,
"stop_reason": "stop"
}
```
**Request:**
```json theme={null}
{
"prompt": "hello",
"max_gen_len": 100
}
```
**Response:**
```json theme={null}
{
"generation": "Hi!",
"prompt_token_count": 1,
"generation_token_count": 445,
"stop_reason": "stop"
}
```
**Request:**
```json theme={null}
{
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "hello"
}
]
}
]
}
```
**Response:**
```json theme={null}
{
"id": "model_id",
"object": "chat.completion",
"created": 1745858024,
"model": "pixtral-large-2502",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "Hello!"
},
"finish_reason": "stop"
}
],
"usage": {
"prompt_tokens": 5,
"completion_tokens": 33,
"total_tokens": 38
}
}
```
**Request:**
```json theme={null}
{
"prompt": "[INST] hello [/INST]",
"max_tokens": 100
}
```
**Response:**
```json theme={null}
{
"outputs": [
{
"text": " Hello!",
"stop_reason": "stop"
}
]
}
```
**Request:**
```json theme={null}
{
"prompt": "[INST] hello [/INST]",
"max_tokens": 100
}
```
**Response:**
```json theme={null}
{
"outputs": [
{
"text": " Hello!",
"stop_reason": "stop"
}
]
}
```
**Request:**
```json theme={null}
{
"prompt": "[INST] hello [/INST]",
"max_tokens": 100
}
```
**Response:**
```json theme={null}
{
"outputs": [
{
"text": " Hello!",
"stop_reason": "stop"
}
]
}
```
**Request:**
```json theme={null}
{
"prompt": "[INST] hello [/INST]",
"max_tokens": 100
}
```
**Response:**
```json theme={null}
{
"outputs": [
{
"text": " Hello!",
"stop_reason": "stop"
}
]
}
```
# Generic Generic Open AI Spec Endpoint
Source: https://docs.squared.ai/activation/ai-ml-sources/generic_open_ai-endpoint
## Connect AI Squared to Generic Open AI Model
This guide will help you configure the Generic Open AI Model Connector in AI Squared to access your Generic Open AI Model Endpoint.
### Prerequisites
Before proceeding, ensure you have the necessary API key from Open AI.
## Step-by-Step Guide to Connect to an Generic Open AI Model Endpoint
## Step 1: Navigate to Open AI Console
Start by logging into your Open AI Console.
1. Sign in to your Open AI account at [Open AI](https://platform.openai.com/docs/overview).
## Step 2: Locate Developer Access
Once you're in the Open AI, you'll find the necessary configuration details:
1. **API Key:**
* Click the gear icon on the top right corner.
* Click on "API keys" to view your API keys.
* If you haven't created an API Key before, click on "Create new secret key" to generate a new one. Make sure to copy the API Key as they are shown only once.
## Step 3: Configure Generic Open AI Model Connector in Your Application
Now that you have gathered all the necessary details enter the following information:
* **API Key:** Your Open ai API key.
# Google Vertex Model
Source: https://docs.squared.ai/activation/ai-ml-sources/google_vertex-model
## Connect AI Squared to Google Vertex Model
This guide will help you configure the Google Vertex Model Connector in AI Squared to access your Google Vertex Model Endpoint.
### Prerequisites
Before proceeding, ensure you have the necessary project id, endpoint id, region, and credential json from Google Vertex.
## Step-by-Step Guide to Connect to an Google Vertex Model Endpoint
## Step 1: Navigate to Google Cloud Console
Start by logging into your Google Cloud Console.
1. Sign in to your google cloud account at [Google Cloud Console](https://console.cloud.google.com/).
## Step 2: Enable Vertex API
* If you don't have a project, create one.
* Enable the [Vertex API for your project](https://console.cloud.google.com/apis/library/aiplatform.googleapis.com).
## Step 3: Locate Google Vertex Configuration Details
1. **Project ID, Endpoint ID, and Region:**
* In the search bar search and select "Vertex AI".
* Choose "Online prediction" from the menu on the left hand side.
* Select the region where your endpoint is and select your endpoint. Note down the Region that is shown.
* Click on "SAMPLE REQUEST" and note down the Endpoint ID and Project ID
2. **JSON Key File:**
* In the search bar search and select "APIs & Services".
* Choose "Credentials" from the menu on the left hand side.
* In the "Credentials" section, you can create or select your service account.
* After selecting your service account goto the "KEYS" tab and click "ADD KEY". For Key type select JSON.
## Step 3: Configure Google Vertex Model Connector in Your Application
Now that you have gathered all the necessary details enter the following information:
* **Project ID:** Your Google Vertex Project ID.
* **Endpoint ID:** Your Google Vertex Region ID.
* **Region:** The Endpoint region where your Google Vertex resources are located.
* **JSON Key File:** The JSON key file containing the authentication credentials for your service account.
# HTTP Model Source Connector
Source: https://docs.squared.ai/activation/ai-ml-sources/http-model-endpoint
Guide on how to configure the HTTP Model Connector on the AI Squared platform
## Connect AI Squared to HTTP Model
This guide will help you configure the HTTP Model Connector in AI Squared to access your HTTP Model Endpoint.
### Prerequisites
Before starting, ensure you have the URL of your HTTP Model and any required headers for authentication or request configuration.
## Step-by-Step Guide to Connect to an HTTP Model Endpoint
## Step 1: Log in to AI Squared
Sign in to your AI Squared account and navigate to the **Source** section.
## Step 2: Add a New HTTP Model Source Connector
From AI/ML Sources in Sources click **Add Source** and select **HTTP Model** from the list of available source types.
## Step 3: Configure HTTP Connection Details
Enter the following information to set up your HTTP connection:
* **URL**: The URL where your model resides.
* **Headers**: Any required headers as key-value pairs, such as authentication tokens or content types.
* **Timeout**: The maximum time, in seconds, to wait for a response from the server before the request is canceled
## Step 4: Test the Connection
Use the **Test Connection** feature to ensure that AI Squared can connect to your HTTP Model endpoint. If the test is successful, you’ll receive a confirmation message. If not, review your connection details.
## Step 5: Save the Connector Settings
Once the connection test is successful, save the connector settings to establish the destination.
# Open AI Model
Source: https://docs.squared.ai/activation/ai-ml-sources/open_ai-model
## Connect AI Squared to Open AI Model
This guide will help you configure the Open AI Model Connector in AI Squared to access your Open AI Model Endpoint.
### Prerequisites
Before proceeding, ensure you have the necessary API key from Open AI.
## Step-by-Step Guide to Connect to an Open AI Model Endpoint
## Step 1: Navigate to Open AI Console
Start by logging into your Open AI Console.
1. Sign in to your Open AI account at [Open AI](https://platform.openai.com/docs/overview).
## Step 2: Locate Developer Access
Once you're in the Open AI, you'll find the necessary configuration details:
1. **API Key:**
* Click the gear icon on the top right corner.
* Click on "API keys" to view your API keys.
* If you haven't created an API Key before, click on "Create new secret key" to generate a new one. Make sure to copy the API Key as they are shown only once.
## Step 3: Configure Open AI Model Connector in Your Application
Now that you have gathered all the necessary details enter the following information:
* **API Key:** Your Open ai API key.
# WatsonX.AI Model
Source: https://docs.squared.ai/activation/ai-ml-sources/watsonx_ai-model
## Connect AI Squared to WatsonX.AI Model
This guide will help you configure the WatsonX.AI Model Connector in AI Squared to access your WatsonX.AI Model Endpoint.
### Prerequisites
Before proceeding, ensure you have the necessary API key, region, and deployment id from WatsonX.AI.
## Step-by-Step Guide to Connect to an WatsonX.AI Model Endpoint
## Step 1: Navigate to WatsonX.AI Console
Start by logging into your WatsonX.AI Console.
1. Sign in to your IBM WatsonX account at [WatsonX.AI](https://dataplatform.cloud.ibm.com/wx/home?context=wx).
## Step 2: Locate Developer Access
Once you're in the WatsonX.AI, you'll find the necessary configuration details:
1. **API Key:**
* Scroll down to Developer access.
* Click on "Manage IBM Cloud API keys" to view your API keys.
* If you haven't created an API Key before, click on "Create API key" to generate a new one. Make sure to copy the API Key as they are shown only once.
2. **Region**
* The IBM Cloud region can be selected from the top right corner of the WatsonX.AI Console. Choose the region where your WatsonX.AI resources is located and note down the region.
3. **Deployment Id**
* Scroll down to Deployment spaces and click on your deployment space.
* In your selected deployment space select your online deployed model
* On the right-hand side, under "About this deployment", the Deployment ID will appear under "Deployment Details".
## Step 3: Configure WatsonX.AI Model Connector in Your Application
Now that you have gathered all the necessary details enter the following information:
* **API Key:** Your IBM Cloud API key.
* **Region:** The IBM Cloud region where your WatsonX.AI resources are located.
* **Deployment ID:** The WatsonX.AI online deployment id
# Connect Source
Source: https://docs.squared.ai/activation/ai-modelling/connect-source
Learn how to connect and configure an AI/ML model as a source for use within the AI Squared platform.
Connecting an AI/ML source is the first step in activating AI within your business workflows. AI Squared allows you to seamlessly integrate your deployed model endpoints—from providers like SageMaker, Vertex AI, Databricks, or custom HTTP APIs.
This guide walks you through connecting a new model source.
***
## Step 1: Select an AI/ML Source
1. Navigate to **AI Activation → AI Modeling → Connect Source**
2. Click on **Add Source**
3. Choose your desired connector from the list:
* AWS SageMaker
* Google Vertex AI
* Databricks Model
* OpenAI Model Endpoint
* HTTP Model Source (Generic)
📸 *Placeholder for: Screenshot of “Add Source” screen*
***
## Step 2: Enter Endpoint Details
Each connector requires some basic configuration for successful integration.
### Required Fields
* **Endpoint Name** – A meaningful name for this model source
* **Endpoint URL** – The endpoint where the model is hosted
* **Authentication Method** – e.g., OAuth, API Key, Bearer Token
* **Auth Header / Secret Key** – If applicable
* **Request Format** – Structure expected by the model (e.g., JSON payload)
* **Response Format** – Format returned by the model (e.g., structured JSON with keys)
📸 *Placeholder for: Screenshot of endpoint input form*
***
## Step 3: Test Connection
Click **Test Connection** to validate that the model endpoint is reachable and returns a valid response.
* Ensure all fields are correct
* The system will validate the endpoint and return a success or error message
📸 *Placeholder for: Screenshot of test success/failure*
***
## Step 4: Define Input Schema
The input schema specifies the fields your model expects during inference.
| Field | Description |
| --------- | ------------------------------------------ |
| **Name** | Key name expected by the model |
| **Type** | Data type: String, Integer, Float, Boolean |
| **Value** | Static or dynamic input value |
📸 *Placeholder for: Input schema editor screenshot*
***
## Step 5: Define Output Schema
The output schema ensures consistent mapping of the model’s response.
| Field | Description |
| -------------- | ------------------------------------------ |
| **Field Name** | Key name from the model response |
| **Type** | Data type: String, Integer, Float, Boolean |
📸 *Placeholder for: Output schema editor screenshot*
***
## Step 6: Save the Source
Click **Save** once configuration is complete. Your model source will now appear in the **AI Modeling** tab and can be used in downstream workflows such as Data Apps or visualizations.
📸 *Placeholder for: Final save and confirmation screen*
***
Need help? Head over to our [Support & FAQs](/support) section for troubleshooting tips or reach out via the in-app help widget.
# Input Schema
Source: https://docs.squared.ai/activation/ai-modelling/input-schema
Define and configure the input schema to structure the data your model receives.
The **Input Schema** defines the structure of the data passed to your AI/ML model during inference. This ensures that inputs sent from your business applications or workflows match the format expected by your model endpoint.
AI Squared provides a no-code interface to configure input fields, set value types, and ensure compatibility with model requirements.
***
## Why Input Schema Matters
* Ensures data integrity before reaching the model
* Maps business inputs to model parameters
* Prevents inference failures due to malformed payloads
* Enables dynamic or static parameter configuration
***
## Defining Input Fields
Each input field includes the following:
| Field | Description |
| -------------- | --------------------------------------------------------------------- |
| **Name** | The key name expected in your model’s request payload |
| **Type** | The data type: `String`, `Integer`, `Float`, or `Boolean` |
| **Value Type** | `Dynamic` (changes with each query/request) or `Static` (fixed value) |
📸 *Placeholder for: Screenshot of input schema editor*
***
## Static vs. Dynamic Values
* **Static**: Hardcoded values used for all model requests. Example: `country: "US"`
* **Dynamic**: Values sourced from the business application or runtime context. Example: `user_id` passed from Salesforce record
📘 *Tip: Use harvesting (covered later) to auto-fetch dynamic values from frontend apps like CRMs.*
***
## Example Input Schema
```json theme={null}
{
"customer_id": "12345",
"email": "user@example.com",
"plan_type": "premium",
"language": "en"
}
```
In this example:
customer\_id and email may be dynamic
plan\_type could be static
Each key must align with your model's expected input structure
## Next Steps
Once your input schema is defined, you can:
Add optional Preprocessing logic to transform or clean inputs
Move forward with configuring your Output Schema
# Introduction
Source: https://docs.squared.ai/activation/ai-modelling/introduction
AI Activation in AI Squared refers to the process of operationalizing your AI models—bringing model outputs directly into business tools where decisions are made.
This capability allows teams to go beyond experimentation and deploy context-aware AI insights across real business workflows, such as CRMs, service platforms, or internal tools.
***
## What AI Activation Enables
With AI Activation, you can:
* **Connect any AI model** from cloud providers (e.g., SageMaker, Vertex, OpenAI) or your own endpoints
* **Define input & output schemas** to standardize how models consume and return data
* **Visualize model results** using low-code Data Apps
* **Embed insights directly** inside enterprise applications like Salesforce, ServiceNow, or custom web apps
* **Capture user feedback** to evaluate relevance and improve model performance over time
***
## Core Concepts
| Concept | Description |
| --------------- | -------------------------------------------------------------------------------------------------------- |
| **AI Modeling** | Configure how input is passed to the model and how output is interpreted. |
| **Data Apps** | Visual components used to surface model predictions directly within business tools. |
| **Feedback** | Capture user responses (e.g., thumbs up/down, star ratings) to monitor model quality and iterate faster. |
***
## What's Next
Start by configuring your [AI Model](./ai-modeling), then move on to building and embedding [Data Apps](./data-apps) into your business environment.
# Overview
Source: https://docs.squared.ai/activation/ai-modelling/modelling-overview
Understand what AI Modeling means inside AI Squared and how to configure your models for activation.
# AI Modeling
AI Modeling in AI Squared allows you to connect, configure, and prepare your hosted AI/ML models for use inside business applications. This process ensures that AI outputs are both reliable and context-aware—ready for consumption by business users within CRMs, ERPs, and custom interfaces.
## Why AI Modeling Matters
Simply connecting a model isn't enough—each model expects specific inputs and returns outputs in a particular format. AI Modeling provides a no-code interface to:
* Define input and output schemas
* Format and validate requests before they're sent
* Clean and transform responses before embedding
* Map model insights directly into business apps
## Key Benefits
* **Standardization**: Ensure data passed to and from models adheres to consistent formats.
* **Configurability**: Customize model payloads, headers, and transformations without writing code.
* **Reusability**: Use one model across multiple Data Apps with different UI contexts.
* **Feedback-Ready**: Configure outputs to support user feedback mechanisms like thumbs-up/down, scale ratings, and more.
## What You Can Do in This Section
* Connect to an AI/ML model source (like OpenAI, SageMaker, or Vertex AI)
* Define input and output fields
* Add optional pre-processing and post-processing logic
* Test your model’s behavior with sample payloads
* Finalize your model for embedding into business workflows
AI Modeling is the foundation for building **Data Apps**—which surface model results in enterprise applications and enable user feedback.
> Ready to configure your first model? Jump into [Connecting a Model Source](./connect-source) or learn how to [define your input schema](./input-schema).
# Output Schema
Source: https://docs.squared.ai/activation/ai-modelling/output-schema
Define how to handle and structure your AI/ML model's responses.
The **Output Schema** defines the structure of the response returned by your AI/ML model. This ensures that predictions or insights received from the model are properly formatted, mapped, and usable within downstream components like Data Apps, feedback mechanisms, or automation triggers.
AI Squared allows you to specify each expected field and its data type so the platform can interpret and surface the response correctly.
***
## Why Output Schema Matters
* Standardizes how model results are parsed and displayed
* Enables seamless integration into Data Apps or embedded tools
* Ensures feedback mechanisms are correctly tied to model responses
* Supports chaining outputs to downstream actions
***
## Defining Output Fields
Each field you expect from the model response must be described in the schema:
| Field | Description |
| -------------- | ----------------------------------------------------- |
| **Field Name** | The key name returned in the model’s response payload |
| **Type** | Data type: `String`, `Integer`, `Float`, `Boolean` |
📸 *Placeholder for: Screenshot of output schema configuration UI*
***
## Example Output Payload
```json theme={null}
{
"churn_risk_score": 0.92,
"prediction_label": "High Risk",
"confidence": 0.88
}
```
Your output schema should include:
churn\_risk\_score → Float
prediction\_label → String
confidence → Float
This structure ensures consistent formatting across visualizations and workflows.
## Tips for Defining Output Fields
Make sure field names exactly match the keys returned by the model.
Use descriptive names that make the output easy to understand in UI or downstream logic.
Choose the right type — AI Squared uses this for formatting (e.g., number rounding, boolean flags, etc.).
## What's Next
You’ve now connected your source, defined inputs, optionally transformed them, and configured the expected output. Next, you can:
* Test Your Model with sample payloads
* Embed the output into Data Apps
* Set up Feedback Capture
# Preprocessing
Source: https://docs.squared.ai/activation/ai-modelling/preprocessing
Configure transformations on input data before sending it to your AI/ML model.
**Preprocessing** allows you to transform or enrich the input data before it is sent to your AI/ML model endpoint. This is useful when your source data requires formatting, restructuring, or enhancement to match the model's expected input.
With AI Squared, preprocessing is fully configurable through a no-code interface or optional custom logic for more advanced cases.
***
## When to Use Preprocessing
* Format inputs to match the model schema (e.g., convert a date to ISO format)
* Add additional metadata required by the model
* Clean raw input (e.g., remove special characters from text)
* Combine or derive fields (e.g., full name = first + last)
***
## How Preprocessing Works
Each input field can be passed through one or more transformations before being sent to the model. These transformations are applied in the order defined in the UI.
> ⚠️ Preprocessing does not modify your original data — it only adjusts the payload sent to the model for that request.
***
## Common Use Cases
| Example Use Case | Transformation |
| ----------------------------- | ----------------------------- |
| Format `created_at` timestamp | Convert to ISO 8601 |
| Combine first and last name | Join with space |
| Normalize text input | Lowercase, remove punctuation |
| Apply static fallback | Use default if no value found |
📸 *Placeholder for: Screenshot of preprocessing config screen*
***
## Dynamic Input + Preprocessing
Preprocessing is often used alongside **Dynamic Input Values** to shape data pulled from apps like Salesforce, ServiceNow, or custom web tools.
📘 Example:\
If you're harvesting a value like `deal_amount` from a CRM, you might want to round it or convert it into another currency before sending it to the model.
***
## Optional Scripting (Advanced)
In upcoming versions, advanced users may have the option to inject lightweight transformation scripts for more customized logic. Contact support to learn more about enabling this feature.
***
## What’s Next
Now that your inputs are prepared, it’s time to define how your model’s **responses** are structured.
👉 Proceed to [Output Schema](./output-schema) to configure your response handling.
# Headless Extension
Source: https://docs.squared.ai/activation/data-apps/browser-extension/headless-ext
The **Headless Extension** is a lightweight Chrome extension package that allows advanced users to run AI models directly on webpages without embedding anything in the page itself. This is ideal for internal use cases where you want automation, harvesting, or insight overlay without platform and closed environments.
This guide walks through the steps to enable, install, and run `.air` model files via the headless mode.
## Enable the Headless Extension
1. Go to **Settings > Organization > Headless** tab.
2. Toggle **Enable Headless Extension** to ON.
## Install the Headless Chrome Extension
> The Headless Extension must be installed in Developer Mode.
### Step 1: Download Extension
* Click the download link to get the `.zip` file.
### Step 2: Unzip and Prepare
* Extract the contents of the `.zip` file to a local folder.
### Step 3: Load as Unpacked Extension
1. Open Chrome and navigate to: `chrome://extensions`
2. Enable **Developer Mode** (top right)
3. Click **Load Unpacked** and select the extracted folder (must include `manifest.json`)
***
## Upload an AIR File
To run a model, you need to upload a valid `.air` file to the extension.
1. Open the extension (puzzle icon → AI Squared)
2. Click the **settings gear** ⚙️
3. Use the **Upload Model Card** view to drag/drop or browse for your `.air` file
***
## Run the Model
Once uploaded:
1. You’ll see your model listed as a **Model Card** (e.g. *Building Damage Detector*)
2. Click **Run** to activate it on the current page
3. The extension will display the results inline or in a results panel
***
Watch the complete demo video for headless extension setup
## ✅ You're Done!
Once set up, the extension will:
* Load the `.air` model automatically (if Auto Run is enabled)
* Harvest insights from the active tab based on the model logic
* Show results directly in the browser
You can manage, re-upload, or delete model cards anytime from the extension settings.
***
## File Format
* Supported: `.air` model files
* Make sure `manifest.json` is at the root of the extension folder when loading
***
# Platform Extension
Source: https://docs.squared.ai/activation/data-apps/browser-extension/platform
The **Platform Extension** is a no-code method to bring AI-powered **Data Apps** into your everyday business tools (like Salesforce, HubSpot, or internal apps) using the AI Squared Chrome Extension.
It allows business users to “pin” a Data App to specific screens without modifying the host application, perfect for surfacing insights exactly where decisions are made.
## Choose Integration Method
When creating or configuring a Data App, select your rendering method:
* **Embeddable Code**: Iframe-based embedding
* ✅ **No-Code Integration**: Uses the AI Squared Chrome Extension (Platform Extension)
## Install the Chrome Extension
Install the **AI Squared – Data Apps** extension from the Chrome Web Store:
## Run a Data App in Any Web App
Once installed:
1. Open the business app where you want to run a Data App (e.g. Salesforce)
2. Click the AI Squared extension icon in your Chrome toolbar
3. Log in and select your organization
4. You'll see a list of **Data Apps** available to run
## Pin a Data App to a Page
You can pin a Data App to automatically render when a certain app or page loads.
* Click **Run** next to a Data App
* The extension remembers this page and keeps the app live until unpinned
* AI output is displayed in a floating panel on the right
## Best Practices
* Use clear Data App names (e.g. “Lead Scoring” or “Support Next Action”)
* Pin insights where reps, agents, or analysts spend time
* Combine with **Feedback Capture** to evaluate performance
# Chatbot
Source: https://docs.squared.ai/activation/data-apps/chatbot/overview
Coming soon..
# Overview
Source: https://docs.squared.ai/activation/data-apps/overview
Understand what Data Apps are and how they help bring AI into business workflows.
# What Are Data Apps?
**Data Apps** in AI Squared are lightweight, embeddable interfaces that bring AI/ML outputs directly to the point of business decision-making. These apps allow business users to interact with AI model outputs in context—within CRMs, support tools, or web apps—without needing to switch platforms or understand the underlying AI infrastructure.
Data Apps bridge the last mile between ML models and real business outcomes.
***
## Key Benefits
* ⚡ **Instant Access to AI**: Serve AI insights where work happens (e.g., Salesforce, ServiceNow, internal portals)
* 🧠 **Contextualized Results**: Results are customized for the business context and the specific user
* 🛠 **No-Code Setup**: Configure and publish Data Apps with zero front-end or back-end development
* 📊 **Feedback Loop**: Collect structured user feedback to improve AI performance and relevance over time
***
## Where Can You Use Data Apps?
* Sales & CRM platforms (e.g., Salesforce, Hubspot)
* Support & ITSM platforms (e.g., Zendesk, ServiceNow)
* Marketing tools (e.g., Klaviyo, Iterable)
* Internal dashboards or custom web apps
***
## What’s Next?
* 👉 [Create a Data App](../create-a-data-app): Build your first app from a connected model
* 👉 [Embed in Business Apps](../embed-in-business-apps): Learn how to deploy your Data App across tools
* 👉 [Configure Feedback](../feedback-and-ratings): Capture real-time user input
* 👉 [Analyze Reports](../reports-and-analytics): Review app usage and AI effectiveness
***
# Create a Data App
Source: https://docs.squared.ai/activation/data-apps/visualizations/create-data-app
Step-by-step guide to building and configuring a Data App in AI Squared.
A **Data App** allows you to visualize and embed AI model predictions into business applications. This guide walks through the setup steps to publish your first Data App using a connected AI/ML model.
***
## Step 1: Select a Model
1. Navigate to **Data Apps** from the sidebar.
2. Click **Create New Data App**.
3. Select the AI model you want to connect from the dropdown list.
* Only models with input and output schemas defined will appear here.
***
## Step 2: Choose Display Type
Choose how the AI output will be displayed:
* **Table**: For listing multiple rows of output
* **Bar Chart** / **Pie Chart**: For aggregate or category-based insights
* **Text Card**: For single prediction or summary output
Each display type supports basic customization (e.g., column order, labels, units).
***
## Step 3: Customize Appearance
You can optionally style the Data App to match your brand:
* Modify font styles, background colors, and borders
* Add custom labels or tooltips
* Choose dark/light mode compatibility
> 📌 Custom CSS is not supported; visual changes are made through the built-in configuration options.
***
## Step 4: Configure Feedback (Optional)
Enable in-app feedback collection for business users interacting with the app:
* **Thumbs Up / Down**
* **Rating Scale (1–5, configurable)**
* **Text Comments**
* **Predefined Options (Multi-select)**
Feedback will be collected and visible under **Reports > Data Apps Reports**.
***
## Step 5: Save & Preview
1. Click **Save** to create the Data App.
2. Use the **Preview** mode to validate how the results and layout look.
3. If needed, go back to edit layout or display type.
***
## Next Steps
* 👉 [Embed in Business Apps](../embed-in-business-apps): Learn how to add the Data App to CRMs or other tools.
* 👉 [Feedback & Ratings](../feedback-and-ratings): Set up capture options and monitor usage.
# Embed in Business Apps
Source: https://docs.squared.ai/activation/data-apps/visualizations/embed
Learn how to embed Data Apps into tools like CRMs, support platforms, or internal web apps.
Once your Data App is configured and saved, you can embed it within internal or third-party business tools where your users work—such as CRMs, support platforms, or internal dashboards.
AI Squared supports multiple embedding options for flexibility across environments.
***
## Option 1: Embed via IFrame
1. Go to **Data Apps**.
2. Select the Data App you want to embed.
3. Click on **Embed Options** > **IFrame**.
4. Copy the generated `