# 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).
   <Frame>
     <img />
   </Frame>

## 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.

   <Frame>
     <img />
   </Frame>

## 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

<AccordionGroup>
  <Accordion title="Stream disabled" icon="key">
    **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
      }
    }
    ```
  </Accordion>
</AccordionGroup>

<AccordionGroup>
  <Accordion title="Stream enabled" icon="key">
    **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!"
      }
    }
    ```
  </Accordion>
</AccordionGroup>


# 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.
     <Frame>
       <img />
     </Frame>

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.
     <Frame>
       <img />
     </Frame>

3. **Inference Profile ARN:**
   * The Inference Profile ARN is in the Cross-region inference page and can be found in your selected model.
     <Frame>
       <img />
     </Frame>

4. **Model ID:**
   * The AWS Model Id can be found in your selected models catalog.
   <Frame>
     <img />
   </Frame>

## 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

<AccordionGroup>
  <Accordion title="Jamba Models" icon="layers">
    <Accordion title="Jamba 1.5 Large" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Jamba 1.5 Mini" icon="key">
      **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"
      }
      ```
    </Accordion>
  </Accordion>
</AccordionGroup>

<AccordionGroup>
  <Accordion title="Amazon Models" icon="layers">
    <Accordion title="Nova Lite" icon="key">
      **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
        }
      }
      ```
    </Accordion>

    <Accordion title="Nova Micro" icon="key">
      **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
        }
      }
      ```
    </Accordion>

    <Accordion title="Nova Pro" icon="key">
      **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
        }
      }
      ```
    </Accordion>

    <Accordion title="Titan Text G1 - Premier" icon="key">
      **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"
          }
        ]
      }
      ```
    </Accordion>

    <Accordion title="Titan Text G1 - Express" icon="key">
      **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"
          }
        ]
      }
      ```
    </Accordion>

    <Accordion title="Titan Text G1 - Lite" icon="key">
      **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"
          }
        ]
      }
      ```
    </Accordion>
  </Accordion>
</AccordionGroup>

<AccordionGroup>
  <Accordion title="Anthropic Models" icon="layers">
    <Accordion title="Claude 3.7 Sonnet" icon="key">
      **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
        }
      }
      ```
    </Accordion>

    <Accordion title="Claude 3.5 Haiku" icon="key">
      **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
        }
      }
      ```
    </Accordion>

    <Accordion title="Claude 3.5 Sonnet v2" icon="key">
      **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
        }
      }
      ```
    </Accordion>

    <Accordion title="Claude 3.5 Sonnet" icon="key">
      **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
        }
      }
      ```
    </Accordion>

    <Accordion title="Claude 3 Opus" icon="key">
      **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
        }
      }
      ```
    </Accordion>

    <Accordion title="Claude 3 Haiku" icon="key">
      **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
        }
      }
      ```
    </Accordion>
  </Accordion>
</AccordionGroup>

<AccordionGroup>
  <Accordion title="Cohere Models" icon="layers">
    <Accordion title="Command R" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Command R+" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Command Light" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Command" icon="key">
      **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"
      }
      ```
    </Accordion>
  </Accordion>
</AccordionGroup>

<AccordionGroup>
  <Accordion title="DeepSeek Models" icon="layers">
    <Accordion title="DeepSeek-R1" icon="key">
      **Request:**

      ```json theme={null}
      {
        "prompt": "Hello",
        "max_tokens": 100
      }
      ```

      **Response:**

      ```json theme={null}
      {
        "choices": [
          {
            "text": "Hi!",
            "stop_reason": "length"
          }
        ]
      }
      ```
    </Accordion>
  </Accordion>
</AccordionGroup>

<AccordionGroup>
  <Accordion title="Meta Models" icon="layers">
    <Accordion title="Llama 3.3 70B Instruct" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Llama 3.2 11B Instruct" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Llama 3.2 1B Instruct" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Llama 3.2 3B Instruct" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Llama 3.2 90B Instruct" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Llama 3.1 70B Instruct" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Llama 3.1 8B Instruct" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Llama 3 70B Instruct" icon="key">
      **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"
      }
      ```
    </Accordion>

    <Accordion title="Llama 3 8B Instruct" icon="key">
      **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"
      }
      ```
    </Accordion>
  </Accordion>
</AccordionGroup>

<AccordionGroup>
  <Accordion title="Mistral AI Models" icon="layers">
    <Accordion title="Pixtral Large (25.02)" icon="key">
      **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
        }
      }
      ```
    </Accordion>

    <Accordion title="Mistral Large (24.02)" icon="key">
      **Request:**

      ```json theme={null}
      {
        "prompt": "

 hello 
",
        "max_tokens": 100
      }
      ```

      **Response:**

      ```json theme={null}
      {
        "outputs": [
          {
            "text": " Hello!",
            "stop_reason": "stop"
          }
        ]
      }
      ```
    </Accordion>

    <Accordion title="Mistral 7B Instruct" icon="key">
      **Request:**

      ```json theme={null}
      {
        "prompt": "

 hello 
",
        "max_tokens": 100
      }
      ```

      **Response:**

      ```json theme={null}
      {
        "outputs": [
          {
            "text": " Hello!",
            "stop_reason": "stop"
          }
        ]
      }
      ```
    </Accordion>

    <Accordion title="Mixtral 8x7B Instruct" icon="key">
      **Request:**

      ```json theme={null}
      {
        "prompt": "

 hello 
",
        "max_tokens": 100
      }
      ```

      **Response:**

      ```json theme={null}
      {
        "outputs": [
          {
            "text": " Hello!",
            "stop_reason": "stop"
          }
        ]
      }
      ```
    </Accordion>

    <Accordion title="Mistral Small (24.02)" icon="key">
      **Request:**

      ```json theme={null}
      {
        "prompt": "

 hello 
",
        "max_tokens": 100
      }
      ```

      **Response:**

      ```json theme={null}
      {
        "outputs": [
          {
            "text": " Hello!",
            "stop_reason": "stop"
          }
        ]
      }
      ```
    </Accordion>
  </Accordion>
</AccordionGroup>


# OpenAI Compatible Endpoint
Source: https://docs.squared.ai/activation/ai-ml-sources/generic_open_ai-endpoint

Connect AI Squared to any OpenAI-compatible API endpoint.

## Connect AI Squared to an OpenAI Compatible Endpoint

This guide will help you configure the OpenAI Compatible Endpoint Connector in AI Squared to access any OpenAI-compatible API endpoint, such as OpenAI itself, self-hosted models, or third-party providers that implement the OpenAI API spec.

### Prerequisites

Before proceeding, ensure you have:

* The **endpoint URL** of the OpenAI-compatible API you want to connect to.
* A valid **API key** for that endpoint.

## Step-by-Step Guide to Connect to an OpenAI Compatible Endpoint

## Step 1: Obtain Your Endpoint URL

Identify the URL of the OpenAI-compatible API you want to use. The connector sends requests to this exact URL, so it must be the full chat completions endpoint path.

* For OpenAI, use `https://api.openai.com/v1/chat/completions`.
* For self-hosted or third-party providers, use the URL documented by that provider (for example, `https://your-host.example.com/v1/chat/completions`).

<Note>
  The connector uses the URL configured on the source. Make sure the URL points to a chat completions endpoint that follows the OpenAI API spec.
</Note>

## Step 2: Obtain Your API Key

If you are connecting to OpenAI, follow these steps to retrieve your API key:

1. Sign in to your Open AI account at [Open AI](https://platform.openai.com/docs/overview).
2. Click the gear icon on the top right corner.
   <Frame>
     <img />
   </Frame>
3. Click on "API keys" to view your API keys.
4. 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.
   <Frame>
     <img />
   </Frame>

For non-OpenAI providers, refer to the provider's documentation to obtain an API key.

## Step 3: Configure the OpenAI Compatible Endpoint Connector in Your Application

Now that you have gathered all the necessary details, enter the following information:

| Field                | Description                                                                                                                               |
| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
| **Endpoint URL**     | The full URL of the chat completions endpoint that follows the OpenAI API spec. Defaults to `https://api.openai.com/v1/chat/completions`. |
| **API Key**          | Your OpenAI API key or the API key for your OpenAI-compatible endpoint.                                                                   |
| **Enable streaming** | Enables data streaming when supported by the model. When `true`, responses are processed in chunks for faster delivery.                   |
| **HTTP Timeout**     | Maximum time, in seconds, to wait for a response from the server before the request is canceled. Defaults to `30`.                        |
| **Request Format**   | A sample request body that matches the OpenAI chat completions spec.                                                                      |
| **Response Format**  | A sample response body that matches the OpenAI chat completions spec.                                                                     |


# 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
     <Frame>
       <img />
     </Frame>

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.
     <Frame>
       <img />
     </Frame>

## 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.

<Frame>
  <img alt="Configure HTTP Destination" />
</Frame>

## Step 3: Configure HTTP Connection Details

Enter the following information to set up your HTTP connection:

<Frame>
  <img alt="Configure HTTP Destination" />
</Frame>

* **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.

<Frame>
  <img alt="Configure HTTP Destination" />
</Frame>

## 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.
     <Frame>
       <img />
     </Frame>
   * 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.
     <Frame>
       <img />
     </Frame>

## 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.
  <Frame>
    <img />
  </Frame>
* 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.
  <Frame>
    <img />
  </Frame>

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.
  <Frame>
    <img />
  </Frame>

3. **Deployment Id**

* Scroll down to Deployment spaces and click on your deployment space.
  <Frame>
    <img />
  </Frame>
* In your selected deployment space select your online deployed model
  <Frame>
    <img />
  </Frame>
* On the right-hand side, under "About this deployment", the Deployment ID will appear under "Deployment Details".
  <Frame>
    <img />
  </Frame>

## 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.

<img alt="Hero Light" />

## 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.

<img alt="title" />

2. Toggle **Enable Headless Extension** to ON.

<img alt="title" />

## 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

<video />

## ✅ 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)

<img alt="title" />

## Install the Chrome Extension

Install the **AI Squared – Data Apps** extension from the Chrome Web Store:

<img alt="title" />

## 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

<img alt="title" />

## 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

<img alt="title" />

## 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 `<iframe>` snippet.
5. Paste this into your target application (e.g., internal dashboard, web app).

> Note: Ensure the host application supports iframe embedding and cross-origin requests.

### Allow the host origin

For security, AI Squared only serves embedded Data Apps and Agentic Apps to origins you have explicitly allowlisted. Before your embed will load, an admin must add the host page's origin to the workspace or organization allowlist.

An **origin** is the scheme, host, and (non-default) port of the page hosting the iframe—for example, `https://app.example.com` or `http://localhost:3000`. Paths and query strings are not part of an origin.

**Scopes**

| Scope        | Applies to                                     |
| ------------ | ---------------------------------------------- |
| Organization | Every workspace in the organization.           |
| Workspace    | Only the workspace where the origin was added. |

<Note>
  Managing embed origins requires the **Embed Settings** permission, which is granted to organization admins by default. Non-admin roles can be granted read access to view the list.
</Note>

**Manage allowed origins**

<Steps>
  <Step title="Add an origin">
    As an admin, add the full origin of the page that will host the embed (for example, `https://crm.example.com`). Choose whether to scope it to the current workspace or to the whole organization.
  </Step>

  <Step title="Update or remove">
    Edit an origin to fix a typo or migrate to a new host, or remove it when the embed is no longer needed.
  </Step>

  <Step title="Wait for propagation">
    Origin changes are cached and refresh automatically on all servers within about 60 seconds. The API response includes a `refresh_interval_seconds` value so you know when the change is live.
  </Step>
</Steps>

<Warning>
  If a host page's origin is not in the allowlist, the browser will block the embed—either with a CORS error or a `frame-ancestors` Content Security Policy violation (clickjacking protection). Add the origin (including the correct scheme and port) before loading the embed.
</Warning>

The allowlist protects both Data App embeds and published Agentic App pages. Published apps send a `Content-Security-Policy: frame-ancestors` header that only permits framing from allowlisted origins, so adding an origin here also authorizes it to host your published apps.

***

## Option 2: Embed using Browser Extension

1. Install the AI Squared browser extension (Chrome/Edge).
2. Navigate to the target business app (e.g., Salesforce).
3. Use the extension to “pin” a Data App to a specific screen.
   * Example: Pin a churn score Data App on a Salesforce account details page.
4. Configure visibility rules if needed (e.g., user role, page section).

This option does not require modifying the application code.

***

## Best Practices

* Embed Data Apps near where decisions happen—sales records, support tickets, lead workflows.
* Keep layout minimal for seamless user experience.
* Use feedback capture where helpful for continual model improvement.

***

## Next Steps

* 👉 [Feedback & Ratings](../feedback-and-ratings): Set up qualitative or quantitative feedback mechanisms.
* 👉 [Monitor Usage](../data-apps-reports): Track adoption and model performance.


# Feedback
Source: https://docs.squared.ai/activation/data-apps/visualizations/feedback

Learn how to collect user feedback on AI insights delivered via Data Apps.

AI Squared allows you to capture direct feedback from business users who interact with AI model outputs embedded through Data Apps. This feedback is essential for evaluating model relevance, accuracy, and user confidence—fueling continuous improvement.

***

## Types of Feedback Supported

### 1. Thumbs Up / Thumbs Down

A binary feedback option to help users indicate whether the insight was useful.

* ✅ Thumbs Up — Insight was helpful
* ❌ Thumbs Down — Insight was not helpful

***

### 2. Rating (1–5 Scale)

Provides a more granular option for rating insight usefulness.

* Configure number of stars (3 to 5)
* Users select one rating per insight interaction

***

### 3. Text-Based Feedback

Capture open-ended qualitative feedback from users.

* Use for additional context when feedback is negative
* Example: “Prediction didn’t match actual customer churn status.”

***

### 4. Multiple Choice

Provide users with a predefined set of reasons for their rating.

* Example for thumbs down:
  * ❌ Not relevant
  * ❌ Incomplete data
  * ❌ Low confidence prediction

***

## How to Enable Feedback

1. Go to your **Data App** > **Edit**.
2. Scroll to the **Feedback Settings** section.
3. Toggle ON any of the following:
   * Thumbs
   * Star Ratings
   * Text Input
   * Multi-Select Options
4. Save the Data App.

Feedback will now appear alongside model outputs when embedded in business apps.

***

## Viewing Collected Feedback

Navigate to:

**Reports > Data Apps Reports** → Select a Data App

There, you’ll find:

* Feedback submission counts
* % positive feedback
* Breakdown by feedback type
* Most common comments or reasons selected

***

## Best Practices

* Keep feedback simple and non-intrusive
* Use feedback data to validate models
* Combine with usage metrics to gauge adoption quality

***

## Next Steps

* 👉 [Monitor Usage](../data-apps-reports): Analyze how your AI models are performing based on user activity and feedback.


# Data Apps Reports
Source: https://docs.squared.ai/activation/data-apps/visualizations/reports

Understand how to monitor and analyze user engagement and model effectiveness with Data Apps.

After embedding a Data App into your business application, AI Squared provides a reporting dashboard to help you track model usage, feedback, and performance over time.

These reports help teams understand how users interact with AI insights and identify opportunities to refine use cases.

***

## Accessing Reports

1. Navigate to **Reports** from the main sidebar.
2. Select the **Data Apps Reports** tab.
3. Choose the Data App you want to analyze.

***

## Key Metrics Tracked

### 1. **Sessions Rendered**

Tracks the number of sessions where model outputs were displayed to users.

### 2. **User Feedback Rate**

% of sessions where users submitted feedback (thumbs, ratings, etc.).

### 3. **Positive Feedback Rate**

% of total feedback that was marked as positive.

### 4. **Top Feedback Tags**

Most common reasons provided by users (e.g., “Not relevant,” “Incomplete”).

### 5. **Most Active Users**

List of users who frequently interact with the Data App.

***

## Using Reports to Improve AI Performance

* **Low positive feedback?** → Revisit model logic, prompt formatting, or context.
* **Low engagement?** → Ensure placement within the business app is visible and accessible.
* **Inconsistent feedback?** → Collect additional context using text or multi-select feedback options.

***

## Exporting Reports

* Use the **Export** button in the top-right of the Data App Reports view.
* Reports are exported in `.csv` format for deeper analysis or integration into your BI stack.

***

## Best Practices

* Regularly review feedback to guide model improvements.
* Correlate usage with business KPIs for value attribution.
* Enable feedback on new Data Apps by default to gather early signals.

***


# Pinecone
Source: https://docs.squared.ai/activation/vector-search/pinecone_db



## Connect AI Squared to Pinecone

This guide will help you configure the PineconeDB Connector in AI Squared to access and transfer data from your Pinecone database.

### Prerequisites

Before proceeding, ensure you have the required API key, region, index name, and namespace from your Pinecone database.

## Step-by-Step Guide to Connect to your Pinecone Database

## Step 1: Navigate to Pinecone Database

Start by logging into your Pinecone Console.

1. Sign in to your Pinecone account at [Pinecone Console](https://app.pinecone.io/).

## Step 2: Locate Pinecone Configuration Details

Once you're in the Pinecone console, you'll find the necessary configuration details:

1. **API Key:**
   * Click the API Keys tab on the left side the Pinecone Console.
   * 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.
     <Frame>
       <img />
     </Frame>

2. **Region, Index Name, and Namespace:**
   * Click on the Database tab then Indexes to see your list of Indexes.
   * Click on your selected Index.
   * The following details, region, index name, namespace will be shown on this page.
     <Frame>
       <img />
     </Frame>

## Step 3: Configure PineconeDB Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **API Key:** The authentication key used to access your Pinecone project securely.
* **Region:** The region where your Pinecone index is hosted.
* **Index Name:** The name of the Pinecone index where your namespaces are stored.
* **Namespace:** The name of the Pinecone namespace where your vectors will be stored or queried.

## Step 4: Test the PineconeDB Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Pinecone database from your application to ensure everything is set up correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your PineconeDB connector is now configured and ready to query data from your Pinecone database.

This guide will help you seamlessly connect your AI Squared application to Pinecone Database, enabling you to leverage your database's full potential.


# Qdrant
Source: https://docs.squared.ai/activation/vector-search/qdrant



## Connect AI Squared to Qdrant

This guide will help you configure the Qdrant Connector in AI Squared to access and transfer data to your Qdrant collection.

### Prerequisites

Before proceeding, ensure you have your host, API key, and collection name.

## Step-by-Step Guide to Connect to your Qdrant collection

## Step 1: Navigate to Qdrant

Start by logging into your Qdrant account.

1. Sign in to your Qdrant account at [Qdrant Account](https://login.cloud.qdrant.io/u/login/identifier?state=hKFo2SB6bDNQQTlydWFFZnpySEc0TXk1QlVWVHJ0Tk9MTDNyeqFur3VuaXZlcnNhbC1sb2dpbqN0aWTZIDVCYm9qV010WXVRSXZvZVFMMkFiLW8wXzl5SkhvZnM4o2NpZNkgckkxd2NPUEhPTWRlSHVUeDR4MWtGMEtGZFE3d25lemc)

2. Select Clusters from the side bar.

<Frame>
  <img />
</Frame>

## Step 2: Locate Qdrant Configuration Details

Once in your selected Qdrant cluster, you'll find the necessary configuration details:

**API Key:**

* Click on the API Keys tab.
* If you haven't created an API key before, click on "Create" to generate a new one. Make sure to copy the API Key as they are shown only once.

<Frame>
  <img />
</Frame>

**Host and Collection name:**

* Click on Cluster UI in you selected Qdrant Cluster.
* Enter your API key to access your collection.
* Note down your host, the url address before `/dashboard#/collections`, and the name of the collection.

<Frame>
  <img />
</Frame>

## Step 3: Configure qdrant Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **Host:** Qdrant cluster host url.
* **API Url:** The endpoint where your Qdrant cluster is hosted.
* **Collection Name:** The selected collections name in your Qdrant cluster.

## Step 4: Test the Qdrant Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Qdrant from your application to ensure everything is set up correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your Qdrant connector is now configured and ready to query data from your Qdrant cluster.

This guide will help you seamlessly connect your AI Squared application to Qdrant cluster, enabling you to leverage your clusters full potential.


# Create Catalog
Source: https://docs.squared.ai/api-reference/catalogs/create_catalog

POST /api/v1/catalogs



# Update Catalog
Source: https://docs.squared.ai/api-reference/catalogs/update_catalog

PUT /api/v1/catalogs/{id}



# Check Connection
Source: https://docs.squared.ai/api-reference/connector_definitions/check_connection

POST /api/v1/connector_definitions/check_connection



# Connector Definition
Source: https://docs.squared.ai/api-reference/connector_definitions/connector_definition

GET /api/v1/connector_definitions/{connector_name}



# Connector Definitions
Source: https://docs.squared.ai/api-reference/connector_definitions/connector_definitions

GET /api/v1/connector_definitions



# Create Connector
Source: https://docs.squared.ai/api-reference/connectors/create_connector

POST /api/v1/connectors



# Delete Connector
Source: https://docs.squared.ai/api-reference/connectors/delete_connector

DELETE /api/v1/connectors/{id}



# Connector Catalog
Source: https://docs.squared.ai/api-reference/connectors/discover

GET /api/v1/connectors/{id}/discover



# Get Connector
Source: https://docs.squared.ai/api-reference/connectors/get_connector

GET /api/v1/connectors/{id}



# List Connectors
Source: https://docs.squared.ai/api-reference/connectors/list_connectors

GET /api/v1/connectors



# Query Source
Source: https://docs.squared.ai/api-reference/connectors/query_source

POST /api/v1/connectors/{id}/query_source



# Update Connector
Source: https://docs.squared.ai/api-reference/connectors/update_connector

PUT /api/v1/connectors/{id}



# Introduction
Source: https://docs.squared.ai/api-reference/introduction



Welcome to the AI Squared API documentation! You can use our API to access all the features of the AI Squared platform.

## Authentication

The AI Squared API uses a JWT-based authentication mechanism. To access the API, you need a valid JWT token which should be included in the header of your requests. This ensures that your interactions with the API are secure and authenticated.

```text theme={null}
--header 'Authorization: Bearer <YOUR_JWT_TOKEN>'
```

<Warning>
  It is advised to keep your JWT token safe and not share it with anyone. If you
  think your token has been compromised, you can generate a new token from the
  AI Squared dashboard.
</Warning>

## API Endpoints

The AI Squared API is organized around REST. Our API has predictable resource-oriented URLs, accepts JSON-encoded request bodies, returns JSON-encoded responses, and uses standard HTTP response codes, authentication, and verbs.

### Base URL

The base URL for all API requests is `https://api.squared.ai/api/v1/`

### API Reference

The API reference contains a list of all the endpoints available in the AI Squared API. You can also use the navigation bar on the left to browse through the different endpoints.

<CardGroup>
  <Card title="Models" icon="square-1">
    Models are the core of the AI Squared API. They represent the different
    entities in the AI Squared platform.
  </Card>

  <Card title="Connectors" icon="square-2">
    Connectors help connect various data warehouse sources or destinations to
    the AI Squared platform.
  </Card>

  <Card title="Syncs" icon="square-3">
    Syncs help you sync data between different data warehouse sources and
    destinations.
  </Card>

  <Card title="AI Workflows" icon="square-4">
    AI Workflows allow you to build powerful workflows for Agents to trigger.
  </Card>
</CardGroup>

## Pagination

Requests that return multiple items will be paginated to 100 items by default. You can specify further pages with the `page` parameter. You can also set a custom page size up to 100 with the `page_size` parameter.

```text theme={null}
https://api.squared.ai/api/v1/models?page=2&page_size=50
```

## Rate Limiting

The AI Squared API is rate limited to 100 requests per minute. If you exceed this limit, you will receive a `429 Too Many Requests` response.

## Errors

The AI Squared API uses conventional HTTP response codes to indicate the success or failure of an API request. In general, codes in the `2xx` range indicate success, codes in the `4xx` range indicate an error that failed given the information provided, and codes in the `5xx` range indicate an error with AI Squared's servers.


# Create Model
Source: https://docs.squared.ai/api-reference/models/create-model

POST /api/v1/models



# Delete Model
Source: https://docs.squared.ai/api-reference/models/delete-model

DELETE /api/v1/models/{id}



# Get Models
Source: https://docs.squared.ai/api-reference/models/get-all-models

GET /api/v1/models



# Get Model
Source: https://docs.squared.ai/api-reference/models/get-model

GET /api/v1/models/{id}



# Update Model
Source: https://docs.squared.ai/api-reference/models/update-model

PUT /api/v1/models/{id}



# List Sync Records
Source: https://docs.squared.ai/api-reference/sync_records/get_sync_records

GET /api/v1/syncs/{sync_id}/sync_runs/{sync_run_id}/sync_records
Retrieves a list of sync records for a specific sync run, optionally filtered by status.



# Sync Run
Source: https://docs.squared.ai/api-reference/sync_runs/get_sync_run

GET /api/v1/syncs/{sync_id}/sync_runs/{sync_run_id}
Retrieves a sync run using sync_run_id for a specific sync.



# List Sync Runs
Source: https://docs.squared.ai/api-reference/sync_runs/get_sync_runs

GET /api/v1/syncs/{sync_id}/sync_runs
Retrieves a list of sync runs for a specific sync, optionally filtered by status.



# Create Sync
Source: https://docs.squared.ai/api-reference/syncs/create_sync

POST /api/v1/syncs



# Delete Sync
Source: https://docs.squared.ai/api-reference/syncs/delete_sync

DELETE /api/v1/syncs/{id}



# List Syncs
Source: https://docs.squared.ai/api-reference/syncs/get_syncs

GET /api/v1/syncs



# Manual Sync Cancel
Source: https://docs.squared.ai/api-reference/syncs/manual_sync_cancel

DELETE /api/v1/schedule_syncs/{sync_id}
Cancel a Manual Sync using the sync ID.



# Manual Sync Trigger
Source: https://docs.squared.ai/api-reference/syncs/manual_sync_trigger

POST /api/v1/schedule_syncs
Trigger a manual Sync by providing the sync ID.



# Get Sync
Source: https://docs.squared.ai/api-reference/syncs/show_sync

GET /api/v1/syncs/{id}



# Get Sync Configurations
Source: https://docs.squared.ai/api-reference/syncs/sync_configuration

Get /api/v1/syncs/configurations



# Test Sync
Source: https://docs.squared.ai/api-reference/syncs/test_sync

POST /enterprise/api/v1/syncs/{sync_id}/test
Triggers a test for the specified sync using the sync ID.



# Update Sync
Source: https://docs.squared.ai/api-reference/syncs/update_sync

PUT /api/v1/syncs/{id}



# Overview
Source: https://docs.squared.ai/deployment-and-security/auth/overview





# Cloud (Managed by AI Squared)
Source: https://docs.squared.ai/deployment-and-security/cloud

Learn how to access and use AI Squared's fully managed cloud deployment.

The cloud-hosted version of AI Squared offers a fully managed environment, ideal for teams that want fast onboarding, minimal infrastructure overhead, and secure access to all platform capabilities.

***

## Accessing the Platform

To access the managed cloud environment:

1. Visit [app.squared.ai](https://app.squared.ai) to log in to your workspace.
2. If you don’t have an account yet, go to [squared.ai](https://squared.ai) and submit the **Contact Us** form. Our team will provision your workspace and guide you through onboarding.

***

## What’s Included

When deployed in the cloud, AI Squared provides:

* A dedicated workspace per team or business unit
* Preconfigured connectors for supported data sources and AI/ML model endpoints
* Secure role-based access control
* Managed infrastructure, updates, and scaling

***

## Use Cases

* Scaling across departments without IT dependencies
* Centralized AI insights delivery into enterprise tools

***

## Next Steps

Once your workspace is provisioned and you're logged in:

* Set up your **data sources** and **AI/ML model endpoints**
* Build **data models** and configure **syncs**
* Create and deploy **data apps** into business applications

Refer to the [Getting Started](/getting-started/introduction) section for first-time user guidance.


# Overview
Source: https://docs.squared.ai/deployment-and-security/data-security-infra/overview





# Overview
Source: https://docs.squared.ai/deployment-and-security/overview



AI Squared is built to be enterprise-ready, with flexible deployment options and strong security foundations to meet your organization’s IT, compliance, and operational requirements.

This section provides an overview of how you can deploy AI Squared, how we handle access control, and what security measures are in place.

***

## Deployment Options

AI Squared offers three main deployment models to support different enterprise needs:

* **Cloud (Managed by AI Squared)**\
  Fully managed SaaS experience hosted by AI Squared. Ideal for teams looking for fast setup and scalability without infrastructure overhead.

* **Deploy Locally**\
  Install and run AI Squared locally on your enterprise infrastructure. This allows tighter control while leveraging the full platform capabilities.

* **Self-Hosted (On-Premise)**\
  For highly regulated environments, AI Squared can be deployed entirely within your own data center or private cloud with no external dependencies.

→ Explore deployment modes in detail under the **Deployment** section.

***

## Authentication & Access Control

The platform supports **Role-Based Access Control (RBAC)** and integrates with enterprise identity providers (e.g., Okta, Azure AD) via SSO.

→ Learn more in the **Authentication & Access Control** section.

***

## Data Security & Infrastructure

We follow industry best practices for data security, including:

* Data encryption in transit and at rest
* Secure key management and audit logging
* Isolated tenant environments in the managed cloud

→ Review our **Security & Infrastructure** details.

***

## Compliance & Certifications

AI Squared maintains security controls aligned with industry standards. We are SOC 2 Type II compliant, with ongoing security reviews and controls in place.

→ View our **Compliance & Certifications** for more details.

***

Need help deciding which deployment option fits your needs best? Reach out to our support team.


# SOC 2 Type II
Source: https://docs.squared.ai/deployment-and-security/security-and-compliance/overview



<Frame>
  <img />
</Frame>

At AI Squared, we are dedicated to safeguarding your data and privacy. We adhere to industry best practices to ensure the security and protection of your information.

We are SOC 2 Type II certified, demonstrating that we meet stringent standards for information security. This certification confirms that we have implemented robust policies and procedures to ensure the security, availability, processing integrity, and confidentiality of user data. You can trust that your data is safeguarded by the highest levels of security.

## Data Security

We encrypt data at rest and in transit for all our customers. Using Azure's Key Vault, we securely manage encryption keys in accordance with industry best practices. Additionally, customer data is securely isolated from that of other customers, ensuring that your information remains protected and segregated at all times.

## Infrastructure Security

We use Azure AKS to host our application, ensuring robust security through tools like Azure Key Vault, Azure Defender, and Azure Policy. We implement Role-Based Access Control (RBAC) to restrict access to customer data, ensuring that only authorized personnel have access. Your information is safeguarded by stringent security protocols, including limited access to our staff, and is protected by industry-leading infrastructure security measures.

## Reporting a Vulnerability

If you discover a security issue in this project, please report it by sending an email to [security@squared.ai](mailto:security@squared.ai).

We will respond to your report as soon as possible and will work with you to address the issue. We take security issues seriously and appreciate your help in making Multiwoven safe for everyone.


# Azure AKS (Kubernetes)
Source: https://docs.squared.ai/deployment-and-security/setup/aks



## Deploying Multiwoven on Azure Kubernetes Service (AKS)

This guide will walk you through setting up Multiwoven on AKS. We'll cover configuring and deploying an AKS cluster after which, you can refer to the Helm Charts section of our guide to install Multiwoven into it.

**Prerequisites**

* An active Azure subscription
* Basic knowledge of Kuberenetes and Helm

**Note:** AKS clusters are not free. Please refer to [https://azure.microsoft.com/en-us/pricing/details/kubernetes-service/#pricing](https://azure.microsoft.com/en-us/pricing/details/kubernetes-service/#pricing) for current pricing information.

**1. AKS Cluster Deployment:**

1. **Select a Resource Group for your deployment:**
   * Navigate to your Azure subscription and select a Resource Group or, if necessary, start by creating a new Resource Group.
   <Frame>
     <img />
   </Frame>
   <Frame>
     <img />
   </Frame>
   <Frame>
     <img />
   </Frame>
2. **Initiate AKS Deployment**
   * Select the **Create +** button at the top of the overview section of your Resource Group which will take you to the Azure Marketplace.
   * In the Azure Marketplace, type **aks** into the search field at the top. Select **Azure Kuberenetes Service (AKS)** and create.
   <Frame>
     <img />
   </Frame>
3. **Configure your AKS Cluster**
   * **Basics**
     * For **Cluster Preset Configuration**, we recommend **Dev/Test** for Development deployments.
     * For **Resource Group**, select your Resource Group.
     * For **AKS Pricing Tier**, we recommend **Standard**.
     * For **Kubernetes version**, we recommend sticking with the current **default**.
     * For **Authentication and Authorization**, we recommend **Local accounts with Kubernetes RBAC** for simplicity.
     <Frame>
       <img />
     </Frame>
     <Frame>
       <img />
     </Frame>
     <Frame>
       <img />
     </Frame>
   * **Node Pools**
     * Leave defaults
     <Frame>
       <img />
     </Frame>
     <Frame>
       <img />
     </Frame>
   * **Networking**
     * For **Network Configuration**, we recommend the **Azure CNI** network configuration for simplicity.
     * For **Network Policy**, we recommend **Azure**.
     <Frame>
       <img />
     </Frame>
     <Frame>
       <img />
     </Frame>
   * **Integrations**
     * Leave defaults
     <Frame>
       <img />
     </Frame>
   * **Monitoring**
     * Leave defaults, however, to reduce costs, you can uncheck **Managed Prometheus** which will automatically uncheck **Managed Grafana**.
     <Frame>
       <img />
     </Frame>
     <Frame>
       <img />
     </Frame>
   * **Advanced**
     * Leave defaults
     <Frame>
       <img />
     </Frame>
   * **Tags**
     * Add tags if necessary, otherwise, leave defaults.
     <Frame>
       <img />
     </Frame>
   * **Review + Create**
     * If there are validation errors that arise during the review, like a missed mandatory field, address the errors and create. If there are no validation errors, proceed to create.
     * Wait for your deployment to complete before proceeding.
4. **Connecting to your AKS Cluster**
   * In the **Overview** section of your AKS cluster, there is a **Connect** button at the top. Choose whichever method suits you best and follow the on-screen instructions. Make sure to run at least one of the test commands to verify that your kubectl commands are being run against your new AKS cluster.
   <Frame>
     <img />
   </Frame>
   <Frame>
     <img />
   </Frame>
5. **Deploying Multiwoven**
   * Please refer to the **Helm Charts** section of our guide to proceed with your installation of Multiwoven!\
     [Helm Chart Deployment Guide](https://docs.squared.ai/open-source/guides/setup/helm)


# Azure VMs
Source: https://docs.squared.ai/deployment-and-security/setup/avm



## Deploying Multiwoven on Azure VMs

This guide will walk you through setting up Multiwoven on an Azure VM. We'll cover launching the VM, installing Docker, running Multiwoven with its dependencies, and finally, accessing the Multiwoven UI.

**Prerequisites:**

* An Azure account with an active VM (Ubuntu recommended).
* Basic knowledge of Docker, Azure, and command-line tools.
* Docker Compose installed on your local machine.

**Note:** This guide uses environment variables for sensitive information. Replace the placeholders with your own values before proceeding.

**1. Azure VM Setup:**

1. **Launch an Azure VM:** Choose an Ubuntu VM with suitable specifications for your workload.

   **Network Security Group Configuration:**

   * Open port 22 (SSH) for inbound traffic from your IP address.
   * Open port 8000 (Multiwoven UI) for inbound traffic from your IP address (optional).

   **SSH Key Pair:** Create a new key pair or use an existing one to connect to your VM.

2. **Connect to your VM:** Use SSH to connect to your Azure VM.

   **Example:**

   ```
   ssh -i /path/to/your-key-pair.pem azureuser@<your_vm_public_ip>
   ```

   Replace `/path/to/your-key-pair.pem` with the path to your key pair file and `<your_vm_public_ip>` with your VM's public IP address.

3. **Update and upgrade:** Run `sudo apt update && sudo apt upgrade -y` to ensure your system is up-to-date.

**2. Docker and Docker Compose Installation:**

1. **Install Docker:** Follow the official Docker installation instructions for Ubuntu: [https://docs.docker.com/engine/install/](https://docs.docker.com/engine/install/)

2. **Install Docker Compose:** Download the latest version from the Docker Compose releases page and place it in a suitable directory (e.g., `/usr/local/bin/docker-compose`). Make the file executable: `sudo chmod +x /usr/local/bin/docker-compose`.

3. **Start and enable Docker:** Run `sudo systemctl start docker` and `sudo systemctl enable docker` to start Docker and configure it to start automatically on boot.

**3. Download Multiwoven `docker-compose.yml` file and Configure Environment:**

1. **Download the file:**

```
curl -LO https://multiwoven-deployments.s3.amazonaws.com/docker/docker-compose/docker-compose.yaml
```

2. **Download the `.env` file:**

```
curl -LO https://multiwoven-deployments.s3.amazonaws.com/docker/docker-compose/.env.production
```

3. Rename the file .env.production to .env and update the environment variables if required.

```bash theme={null}
mv .env.production .env
```

4. \*\*Configure `.env`, This file holds environment variables for various services. Replace the placeholders with your own values, including:
   * `DB_PASSWORD` and `DB_USERNAME` for your PostgreSQL database
   * `REDIS_PASSWORD` for your Redis server
   * (Optional) Additional environment variables specific to your Multiwoven configuration

**Example `.env` file:**

```
DB_PASSWORD=your_db_password
DB_USERNAME=your_db_username
REDIS_PASSWORD=your_redis_password
# Modify your Multiwoven-specific environment variables here
```

**4. Run Multiwoven with Docker Compose:**

1. **Start Multiwoven:** Navigate to the `multiwoven` directory and run `docker-compose up -d`. This will start all Multiwoven services in the background, including the Multiwoven UI.

**5. Accessing Multiwoven UI:**

Open your web browser and navigate to `http://<your_vm_public_ip>:8000` (replace `<your_vm_public_ip>` with your VM's public IP address). You should now see the Multiwoven UI.

**6. Stopping Multiwoven:**

To stop Multiwoven, navigate to the `multiwoven` directory and run.

```bash theme={null}
docker-compose down
```

**7. Upgrading Multiwoven:**
When a new version of Multiwoven is released, you can upgrade the Multiwoven using the following command.

```bash theme={null}
docker-compose pull && docker-compose up -d
```

<Tip> Make sure to run the above command from the same directory where the `docker-compose.yml` file is present.</Tip>

**Additional Notes:**

<Tip>**Note**: the frontend and backend services run on port 8000 and 3000, respectively. Make sure you update the **VITE\_API\_HOST** environment variable in the **.env** file to the desired backend service URL running on port 3000. </Tip>

* Depending on your network security group configuration, you might need to open port 8000 (Multiwoven UI) for inbound traffic.
* For production deployments, consider using a reverse proxy (e.g., Nginx) and a domain name with SSL/TLS certificates for secure access to the Multiwoven UI.


# Docker
Source: https://docs.squared.ai/deployment-and-security/setup/docker-compose

Deploying Multiwoven using Docker

Below steps will guide you through deploying Multiwoven on a server using Docker Compose. We require PostgreSQL database to store meta data for Multiwoven. We will use Docker Compose to deploy Multiwoven and PostgreSQL.

**Important Note:** TLS is mandatory for deployment. To successfully deploy the Platform via docker-compose, you must have access to a DNS record and obtain a valid TLS certificate from a Certificate Authority. You can acquire a free TLS certificate using tools like CertBot, Let's Encrypt, or other ACME-based solutions. If using a reverse proxy (e.g., Nginx or Traefik), consider integrating an automated certificate management tool such as letsencrypt-nginx-proxy-companion or Traefik's built-in Let's Encrypt support.

<Tip>Note: If you are setting up Multiwoven on your local machine, you can skip this section and refer to [Local Setup](/guides/setup/docker-compose-dev) section.</Tip>

## Prerequisites

* [Docker](https://docs.docker.com/get-docker/)
* [Docker Compose](https://docs.docker.com/compose/install/)

<Info> All our Docker images are available in x86\_64 architecture, make sure your server supports x86\_64 architecture.</Info>

## Deployment options

Multiwoven can be deployed using two different options for PostgreSQL database.

<Tabs>
  <Tab title="In-built PostgreSQL">
    1. Create a new directory for Multiwoven and navigate to it.

    ```bash theme={null}
    mkdir multiwoven
    cd multiwoven
    ```

    2. Download the production `docker-compose.yml` file from the following link.

    ```bash theme={null}
    curl -LO https://multiwoven-deployments.s3.amazonaws.com/docker/docker-compose/docker-compose.yaml
    ```

    3. Download the `.env.production` file from the following link.

    ```bash theme={null}
    curl -LO https://multiwoven-deployments.s3.amazonaws.com/docker/docker-compose/.env.production
    ```

    4. Rename the file .env.production to .env and update the environment variables if required.

    ```bash theme={null}
    mv .env.production .env
    ```

    5. Start the Multiwoven using the following command.

    ```bash theme={null}
    docker-compose up -d
    ```

    6. Stopping Multiwoven

    To stop the Multiwoven, use the following command.

    ```bash theme={null}
    docker-compose down
    ```

    7. Upgrading Multiwoven

    When a new version of Multiwoven is released, you can upgrade the Multiwoven using the following command.

    ```bash theme={null}
    docker-compose pull && docker-compose up -d
    ```

    <Tip> Make sure to run the above command from the same directory where the `docker-compose.yml` file is present.</Tip>
  </Tab>

  <Tab title="Cloud PostgreSQL">
    1. Create a new directory for Multiwoven and navigate to it.

       ```bash theme={null}
       mkdir multiwoven
       cd multiwoven
       ```

       2. Download the production `docker-compose.yml` file from the following link.

       ```bash theme={null}
       curl -LO https://multiwoven-deployments.s3.amazonaws.com/docker/docker-compose/docker-compose-cloud-postgres.yaml
       ```

       3. Rename the file .env.production to .env and update the **PostgreSQL** environment variables.

       `DB_HOST` - Database Host

       `DB_USERNAME` - Database Username

       `DB_PASSWORD` - Database Password

       The default port for PostgreSQL is 5432. If you are using a different port, update the `DB_PORT` environment variable.

       ```bash theme={null}
       mv .env.production .env
       ```

       4. Start the Multiwoven using the following command.

       ```bash theme={null}
       docker-compose up -d
       ```
  </Tab>
</Tabs>

## Accessing Multiwoven

Once the Multiwoven is up and running, you can access it using the following URL and port.

Multiwoven Server URL:

```http theme={null}
http://<server-ip>:3000
```

Multiwoven UI Service:

```http theme={null}
http://<server-ip>:8000
```

<Info>If you are using a custom domain you can update the `API_HOST` and `UI_HOST` environment variable in the `.env` file.</Info>

### Important considerations

* Make sure to update the environment variables in the `.env` file before starting the Multiwoven.

* Make sure to take regular **backups** of the PostgreSQL database.

To restore the backup, you can use the following command.

```bash theme={null}
cat dump.sql | docker exec -i --user postgres <postgres-container-name> psql -U postgres
```

* If you are using a custom domain, make sure to update the `API_HOST` and `UI_HOST` environment variables in the `.env` file.


# Docker
Source: https://docs.squared.ai/deployment-and-security/setup/docker-compose-dev



<Warning>**WARNING** The following guide is intended for developers to set-up Multiwoven locally. If you are a user, please refer to the [Self-Hosted](/guides/setup/docker-compose) guide.</Warning>

## Prerequisites

* [Docker](https://docs.docker.com/get-docker/)
* [Docker Compose](https://docs.docker.com/compose/install/)

<Tip>**Note**: if you are using Mac or Windows, you will need to install [Docker Desktop](https://www.docker.com/products/docker-desktop) instead of just docker. Docker Desktop includes both docker and docker-compose.</Tip>

Verify that you have the correct versions installed:

```bash theme={null}
docker --version
docker-compose --version
```

## Installation

1. Clone the repository

```bash theme={null}
git clone git@github.com:Multiwoven/multiwoven.git
```

2. Navigate to the `multiwoven` directory

```bash theme={null}
cd multiwoven
```

3. Initialize .env file

```bash theme={null}
cp .env.example .env
```

<Tip>**Note**: Refer to the [Environment Variables](/guides/setup/environment-variables) section for details on the ENV variables used in the Docker environment.</Tip>

4. Build docker images

```bash theme={null}
docker-compose build
```

<Tip>Note: The default build architecture is for **x86\_64**. If you are using **arm64** architecture, you will need to run the below command to build the images for arm64.</Tip>

```bash theme={null}
TARGETARCH=arm64 docker-compose
```

5. Start the containers

```bash theme={null}
docker-compose up
```

6. Stop the containers

```bash theme={null}
docker-compose down
```

## Usage

Once the containers are running, you can access the `Multiwoven UI` at [http://localhost:8000](http://localhost:8000).

The `multiwoven API` is available at [http://localhost:3000/api/v1](http://localhost:3000/api/v1).

## Running Tests

1. Running the complete test suite on the multiwoven server

```bash theme={null}
docker-compose exec multiwoven-server bundle exec rspec
```

## Troubleshooting

To cleanup all images and containers, run the following commands:

```bash theme={null}
docker rmi -f $(docker images -q)
docker rm -f $(docker ps -a -q)
```

prune all unused images, containers, networks and volumes

<Warning>**Danger:** This will remove all unused images, containers, networks and volumes.</Warning>

```bash theme={null}
docker system prune -a
```

Please open a new issue at [https://github.com/Multiwoven/multiwoven/issues](https://github.com/Multiwoven/multiwoven/issues) if you run into any issues or join our [Slack]() to chat with us.


# Digital Ocean Droplets
Source: https://docs.squared.ai/deployment-and-security/setup/dod

Coming soon...



# Digital Ocean Kubernetes
Source: https://docs.squared.ai/deployment-and-security/setup/dok

Coming soon...



# AWS EC2
Source: https://docs.squared.ai/deployment-and-security/setup/ec2



## Deploying Multiwoven on AWS EC2 Using Docker Compose

This guide walks you through setting up Multiwoven, on an AWS EC2 instance using Docker Compose. We'll cover launching the instance, installing Docker, running Multiwoven with its dependencies, and finally, accessing the Multiwoven UI.

**Important Note:** At present, TLS is required. This means that to successfully deploy the Platform via docker-compose, you will need access to a DNS record set as well as the ability to obtain a valid TLS certificate from a Certificate Authority. You can obtain a free TLS certificates via tools like CertBot, Amazon Certificate Manager (if using an AWS Application Load Balancer to front an EC2 instance), letsencrypt-nginx-proxy-companion (if you add an nginx proxy to the docker-compose file to front the other services), etc.

**Prerequisites:**

* An active AWS account
* Basic knowledge of AWS and Docker
* A private repository access key (please contact your AIS point of contact if you have not received one)

**Notes:**

* This guide uses environment variables for sensitive information. Replace the placeholders with your own values before proceeding.
* This guide uses an Application Load Balancer (ALB) to front the EC2 instance for ease of enabling secure TLS communication with the backend using an Amazon Certificate Manager (ACM) TLS certificate. These certificates are free of charge and ACM automatically rotates them every 90 days. While the ACM certificate is free, the ALB is not. You can refer to the following document for current ALB pricing: [ALB Pricing Page](https://aws.amazon.com/elasticloadbalancing/pricing/?nc=sn\&loc=3).

**1. Obtain TLS Certificate (Requires access to DNS Record Set)**

**1.1** In the AWS Management Console, navigate to Amazon Certificate Manager and request a new certificate.

<Frame>
  <img />
</Frame>

1.2 Unless your organization has created a Private CA (Certificate Authority), we recommend requesting a public certificate.

1.3 Request a single ACM certificate that can verify all three of your chosen subdomains for this deployment. DNS validation is recommended for automatic rotation of your certificate but this method requires access to your domain's DNS record set.

<Frame>
  <img />
</Frame>

1.4 Once you have added your selected sub-domains, scroll down and click **Request**.

5. Once your request has been made, you will be taken to a page that will describe your certificate request and its current status. Scroll down a bit and you will see a section labeled **Domains** with 3 subdomains and 1 CNAME validation record for each. These records need to be added to your DNS record set. Please refer to your organization's internal documentation or the documentation of your DNS service for further instruction on how to add DNS records to your domain's record set. <br />

   <Frame>
     <img />
   </Frame>

   **Note:** For automatic certificate rotation, you need to leave these records
   in your record set. If they are removed, automatic rotation will fail.

6. Once your ACM certificate has been issued, note the ARN of your certificate and proceed.

**2. Create and Configure Application Load Balancer and Target Groups**

1. In the AWS Management Console, navigate to the EC2 Dashboard and select **Load Balancers**.

   <Frame>
     <img />
   </Frame>

2. On the next screen select **Create** under **Application Load Balancer**.

   <Frame>
     <img />
   </Frame>

3. Under **Basic configuration** name your load balancer. If you are deploying this application within a private network, select **Internal**. Otherwise, select **Internet-facing**. Consult with your internal Networking team if you are unsure as this setting can not be changed post-deployment and you will need to create an entirely new load balancer to correct this.

   <Frame>
     <img />
   </Frame>

4. Under **Network mapping**, select a VPC and write it down somewhere for later use. Also, select 2 subnets (2 are **required** for an Application Load Balancer) and write them down too for later use.<br />

   **Note:** If you are using the **internal** configuration, select only **private** subnets. If you are using the **internet-facing** configuration, you must select **public** subnets and they must have routes to an **Internet Gateway**.

   <Frame>
     <img />
   </Frame>

5. Under **Security groups**, select the link to **create a new security group** and a new tab will open.

   <Frame>
     <img />
   </Frame>

6. Under **Basic details**, name your security group and provide a description. Be sure to pick the same VPC that you selected for your load balancer configuration.

   <Frame>
     <img />
   </Frame>

7. Under **Inbound rules**, create rules for HTTP and HTTPS and set the source for both rules to **Anywhere**. This will expose inbound ports 80 and 443 on the load balancer. Leave the default **Outbound rules** allowing for all outbound traffic for simplicity. Scroll down and select **Create security group**.

   <Frame>
     <img />
   </Frame>

8. Once the security group has been created, close the security group tab and return to the load balancer tab. On the load balancer tab, in the **Security groups** section, hit the refresh icon and select your newly created security group. If the VPC's **default security group** gets appended automatically, be sure to remove it before proceeding.

   <Frame>
     <img />
   </Frame>

9. Under **Listeners and routing** in the card for **Listener HTTP:80**, select **Create target group**. A new tab will open.

   <Frame>
     <img />
   </Frame>

10. Under **Basic configuration**, select **Instances**.

    <Frame>
      <img />
    </Frame>

11. Scroll down and name your target group. This first one will be for the Platform's web app so you should name it accordingly. Leave the protocol set to HTTP **but** change the port value to 8000. Also, make sure that the pre-selected VPC matches the VPC that you selected for the load balancer. Scroll down and click **Next**.

    <Frame>
      <img />
    </Frame>

12. Leave all defaults on the next screen, scroll down and select **Create target group**. Repeat this process 2 more times, once for the **Platform API** on **port 3000** and again for **Temporal UI** on **port 8080**. You should now have 3 target groups.

    <Frame>
      <img />
    </Frame>

13. Navigate back to the load balancer configuration screen and hit the refresh button in the card for **Listener HTTP:80**. Now, in the target group dropdown, you should see your 3 new target groups. For now, select any one of them. There will be some further configuration needed after the creation of the load balancer.

    <Frame>
      <img />
    </Frame>

14. Now, click **Add listener**.

    <Frame>
      <img />
    </Frame>

15. Change the protocol to HTTPS and in the target group dropdown, again, select any one of the target groups that you previously created.

    <Frame>
      <img />
    </Frame>

16. Scroll down to the **Secure listener settings**. Under **Default SSL/TLS server certificate**, select **From ACM** and in the **Select a certificate** dropdown, select the certificate that you created in Step 1. In the dropdown, your certificate will only show the first subdomain that you listed when you created the certificate request. This is expected behavior.

    **Note:** If you do not see your certificate in the dropdown list, the most likely issues are:<br />
    (1) your certificate has not yet been successfully issued. Navigate back to ACM and verify that your certificate has a status of **Issued**.
    (2) you created your certificate in a different region and will need to either recreate your load balancer in the same region as your certificate OR recreate your certificate in the region in which you are creating your load balancer.

    <Frame>
      <img />
    </Frame>

17. Scroll down to the bottom of the page and click **Create load balancer**. Load balancers take a while to create, approximately 10 minutes or more. However, while the load balancer is creating, copy the DNS name of the load balancer and create CNAME records in your DNS record set, pointing all 3 of your chosen subdomains to the DNS name of the load balancer. Until you complete this step, the deployment will not work as expected. You can proceed with the final steps of the deployment but you need to create those CNAME records.

    <Frame>
      <img />
    </Frame>

18. At the bottom of the details page for your load balancer, you will see the section **Listeners and rules**. Click on the listener labeled **HTTP:80**.

    <Frame>
      <img />
    </Frame>

19. Check the box next to the **Default** rule and click the **Actions** dropdown.

    <Frame>
      <img />
    </Frame>

20. Scroll down to **Routing actions** and select **Redirect to URL**. Leave **URI parts** selected. In the **Protocol** dropdown, select **HTTPS** and set the port value to **443**. This configuration step will automatically redirect all insecure requests to the load balancer on port 80 (HTTP) to port 443 (HTTPS). Scroll to the bottom and click **Save**.

    <Frame>
      <img />
    </Frame>

21. Return to the load balancer's configuration page (screenshot in step 18) and scroll back down to the *Listeners and rules* section. This time, click the listener labled **HTTPS:443**.

    <Frame>
      <img />
    </Frame>

22. Click **Add rule**.

    <Frame>
      <img />
    </Frame>

23. On the next page, you can optionally add a name to this new rule. Click **Next**.

24. On the next page, click **Add condition**. In the **Add condition** pop-up, select **Host header** from the dropdown. For the host header, put the subdomain that you selected for the Platform web app and click **Confirm** and then click **Next**.

    <Frame>
      <img />
    </Frame>

    <Frame>
      <img />
    </Frame>

25. One the next page, under **Actions**. Leave the **Routing actions** set to **Forward to target groups**. From the **Target group** dropdown, select the target group that you created for the web app. Click **Next**.

    <Frame>
      <img />
    </Frame>

26. On the next page, you can set the **Priority** to 1 and click **Next**.

    <Frame>
      <img />
    </Frame>

27. On the next page, click **Create**.

28. Repeat steps 24 - 27 for the **api** (priority 2) and **temporal ui** (priority 3).

29. Optionally, you can also edit the default rule so that it **Returns a fixed response**. The default **Response code** of 503 is fine.

    <Frame>
      <img />
    </Frame>

**3. Launch EC2 Instance**

1. Navigate to the EC2 Dashboard and click **Launch Instance**.

   <Frame>
     <img />
   </Frame>

2. Name your instance and select **Ubuntu 22.04 or later** with **64-bit** architecture.

   <Frame>
     <img />
   </Frame>

3. For instance type, we recommend **t3.large**. You can find EC2 on-demand pricing here: [EC2 Instance On-Demand Pricing](https://aws.amazon.com/ec2/pricing/on-demand). Also, create a **key pair** or select a pre-existing one as you will need it to SSH into the instance later.

   <Frame>
     <img />
   </Frame>

4. Under **Network settings**, click **Edit**.

   <Frame>
     <img />
   </Frame>

5. First, verify that the listed **VPC** is the same one that you selected for the load balancer. Also, verify that the pre-selected subnet is one of the two that you selected earlier for the load balancer as well. If either is incorrect, make the necessary changes. If you are using **private subnets** because your load balancer is **internal**, you do not need to auto-assign a public IP. However, if you chose **internet-facing**, you may need to associate a public IP address with your instance so you can SSH into it from your local machine.

   <Frame>
     <img />
   </Frame>

6. Under **Firewall (security groups)**, we recommend that you name the security group but this is optional. After naming the security security group, click the button \*Add security group rule\*\* 3 times to create 3 additional rules.

   <Frame>
     <img />
   </Frame>

7. In the first new rule (rule 2), set the port to **3000**. Click the **Source** input box and scroll down until you see the security group that you previously created for the load balancer. Doing this will firewall inbound traffic to port 3000 on the EC2 instance, only allowing inbound traffic from the load balancer that you created earlier. Do the same for rules 3 and 4, using ports 8000 and 8080 respectively.

   <Frame>
     <img />
   </Frame>

   <Frame>
     <img />
   </Frame>

8. Scroll to the bottom of the screen and click on **Advanced Details**.

   <Frame>
     <img />
   </Frame>

9. In the **User data** box, paste the following to automate the installation of **Docker** and **docker-compose**.

```
Content-Type: multipart/mixed; boundary="//"
MIME-Version: 1.0

--//
Content-Type: text/cloud-config; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment; filename="cloud-config.txt"

#cloud-config
cloud_final_modules:
- [scripts-user, always]

--//
Content-Type: text/x-shellscript; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment; filename="userdata.txt"
#!/bin/bash
sudo mkdir ais
cd ais
# install docker
sudo apt-get update
yes Y | sudo apt-get install apt-transport-https ca-certificates curl software-properties-common
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
echo | sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
sudo apt-get update
yes Y | sudo apt-get install docker-ce
sudo systemctl status docker --no-pager && echo "Docker status checked"
# install docker-compose
sudo apt-get install -y jq
VERSION=$(curl -s https://api.github.com/repos/docker/compose/releases/latest | jq -r .tag_name)
sudo curl -L "https://github.com/docker/compose/releases/download/${VERSION}/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
docker-compose --version
sudo systemctl enable docker
```

<Frame>
  <img />
</Frame>

10. In the right-hand panel, click **Launch instance**.

    <Frame>
      <img />
    </Frame>

**4. Register EC2 Instance in Target Groups**

1. Navigate back to the EC2 Dashboard and in the left panel, scroll down to **Target groups**.

   <Frame>
     <img />
   </Frame>

2. Click on the name of the first listed target group.

   <Frame>
     <img />
   </Frame>

3. Under **Registered targets**, click **Register targets**.

   <Frame>
     <img />
   </Frame>

4. Under **Available instances**, you should see the instance that you just created. Check the tick-box next to the instance and click **Include as pending below**. Once the instance shows in **Review targets**, click **Register pending targets**.

   <Frame>
     <img />
   </Frame>

   <Frame>
     <img />
   </Frame>

5. **Repeat steps 2 - 4 for the remaining 2 target groups.**

**5. Deploy AIS Platform**

1. SSH into the EC2 instance that you created earlier. For assistance, you can navigate to your EC2 instance in the EC2 dashboard and click the **Connect** button. In the **Connect to instance** screen, click on **SSH client** and follow the instructions on the screen.

   <Frame>
     <img />
   </Frame>

2. Verify that **Docker** and **docker-compose** were successfully installed by running the following commands

```
sudo docker --version
sudo docker-compose --version
```

You should see something similar to

<Frame>
  <img />
</Frame>

3. Change directory to the **ais** directory and download the AIS Platform docker-compose file and the corresponding .env file.

```
cd \ais
sudo curl -LO https://multiwoven-deployments.s3.amazonaws.com/docker/docker-compose/docker-compose.yaml
sudo curl -LO https://multiwoven-deployments.s3.amazonaws.com/docker/docker-compose/.env.production && sudo mv /ais/.env.production /ais/.env
```

Verify the downloads

```
ls -a
```

You should see the following

<Frame>
  <img />
</Frame>

4. You will need to edit both files a little before deploying. First open the .env file.

```
sudo nano .env
```

**There are 3 required changes.**<br /><br />
**(1)** Set the variable **VITE\_API\_HOST** so the UI knows to send requests to your **API subdomain**.<br /><br />
**(2)** If not present already, add a variable **Track** and set its value to **no**.<br /><br />
**(3)** If not present already, add a variable **ALLOWED\_HOST**. The value for this is dependent on how you selected your subdomains earlier. This variable only allows for a single step down in subdomain so if, for instance, you selected ***app.mydomain.com***, ***api.mydomain.com*** and ***temporal.mydomain.com*** you would set the value to **.mydomain.com**.

If you selected ***app.c1.mydomain.com***, ***api.c1.mydomain.com*** and ***temporal.c1.mydomain.com*** you would set the value to **.c1.mydomain.com**.<br /><br />
For simplicity, the remaining defaults are fine.

<Frame>
  <img />
</Frame>

<Frame>
  <img />
</Frame>

Commands to save and exit **nano**.<br />
**Mac users:**

```
  - to save your changes: Control + S
  - to exit: Control + X
```

**Windows users:**

```
  - to save your changes: Ctrl + O
  - to exit: Ctrl + X
```

5. Next, open the **docker-compose** file.

```
sudo nano docker-compose.yaml
```

The only changes that you should make here are to the AIS Platform image repositories. After opening the docker-compose file, scroll down to the Multiwoven Services and append **-ee** to the end of each repostiory and change the tag for each to **edge**.
Before changes

<Frame>
  <img />
</Frame>

After changes

<Frame>
  <img />
</Frame>

6. Deploy the AIS Platform. This step requires a private repository access key that you should have received from your AIS point of contact. If you do not have one, please reach out to AIS.

```
DOCKERHUB_USERNAME="multiwoven"
DOCKERHUB_PASSWORD="YOUR_PRIVATE_ACCESS_TOKEN"
sudo docker login --username $DOCKERHUB_USERNAME --password $DOCKERHUB_PASSWORD
sudo docker-compose up -d
```

You can use the following command to ensure that none of the containers have exited

```
sudo docker ps -a
```

7. Return to your browser and navigate back to the EC2 dashboard. In the left panel, scroll back down to **Target groups**. Click through each target group and verify that each has the registered instance showing as **healthy**. This may take a minute or two after starting the containers.

8. Once all target groups are showing your instance as healthy, you can navigate to your browser and enter the subdomain that you selected for the AIS Platform web app to get started!


# AWS ECS
Source: https://docs.squared.ai/deployment-and-security/setup/ecs

Coming soon...



# AWS EKS (Kubernetes)
Source: https://docs.squared.ai/deployment-and-security/setup/eks

Coming soon...



# Environment Variables
Source: https://docs.squared.ai/deployment-and-security/setup/environment-variables



Multiwoven uses the following environment variables for both the client and server:

<Note>
  If you have any questions about these variables, please contact us at
  <a href="mailto:hello@multiwoven.com">Hello Multiwoven</a> or join our
  <a href="https://multiwoven.slack.com">Slack Community</a>.
</Note>

## Required Variables

`RAILS_ENV` - Rails Environment (development, test, production)

`UI_HOST` - Hostname for UI service. Default is **localhost:8000**

`API_HOST` - Hostname for API service. Default to **localhost:3000**

`DB_HOST` - Database Host

`DB_USERNAME` - Database Username

`DB_PASSWORD` - Database Password

`ALLOWED_HOST` - Frontend host that can connect to API. Prevents against DNS rebinding and other Host header attacks. Default values is localhost.

`JWT_SECRET` - secret key used to sign generated token

`USER_EMAIL_VERIFICATION` - Skip user email verification after signup.When set to true, ensure SMTP credentials are configured correctly so that verification emails can be sent to users.

## SMTP Configuration

`SMTP_HOST` - This variable represents the host name of the SMTP server that the application will connect to for sending emails. The default configuration for SMTP\_HOST is set to `multiwoven.com`, indicating the server host.

`SMTP_ADDRESS` - This environment variable specifies the server address where the SMTP service is hosted, critical for establishing a connection with the email server. Depending on the service provider, this address will vary. Here are examples of SMTP server addresses for some popular email providers:

* Gmail: smtp.gmail.com - This is the server address for Google's Gmail service, allowing applications to send emails through Gmail's SMTP server.
* Outlook: smtp-mail.outlook.com - This address is used for Microsoft's Outlook email service, enabling applications to send emails through Outlook's SMTP server.
* Yahoo Mail: smtp.mail.yahoo.com - This address is used for Yahoo's SMTP server when configuring applications to send emails via Yahoo Mail.
* AWS SES: *.*.amazonaws.com - This address format is used for AWS SES (Simple Email Service) SMTP servers when configuring applications to send emails via AWS SES. The specific region address should be used as shown in [here](https://docs.aws.amazon.com/general/latest/gr/ses.html)
* Custom SMTP Server: mail.yourdomain.com - For custom SMTP servers, typically hosted by organizations or specialized email service providers, the SMTP address is specific to the domain or provider hosting the service.

  `SMTP_PORT` - This indicates the port number on which the SMTP server listens. The default configuration for SMTP\_PORT is set to 587, which is commonly used for SMTP with TLS/SSL.

`SMTP_USERNAME` - This environment variable specifies the username required to authenticate with the SMTP server. This username could be an email address or a specific account identifier, depending on the requirements of the SMTP service provider being used (such as Gmail, Outlook, etc.). The username is essential for logging into the SMTP server to send emails. It is kept as an environment variable to maintain security and flexibility, allowing changes without code modification.

`SMTP_PASSWORD` - Similar to the username, this environment variable holds the password associated with the SMTP\_USERNAME for authentication purposes. The password is critical for verifying the user's identity to the SMTP server, enabling the secure sending of emails. It is defined as an environment variable to ensure that sensitive credentials are not hard-coded into the application's source code, thereby protecting against unauthorized access and making it easy to update credentials securely.

`SMTP_SENDER_EMAIL` - This variable specifies the email address that appears as the sender in the emails sent by the application.

`BRAND_NAME` - This variable is used to customize the 'From' name in the emails sent from the application, allowing a personalized touch. It is set to **BRAND NAME**, which appears alongside the sender email address in outgoing emails.

## Sync Configuration

`SYNC_EXTRACTOR_BATCH_SIZE` - Sync Extractor Batch Size

`SYNC_LOADER_BATCH_SIZE` - Sync Loader Batch Size

`SYNC_EXTRACTOR_THREAD_POOL_SIZE` - Sync Extractor Thread Pool Size

`SYNC_LOADER_THREAD_POOL_SIZE` - Sync Loader Thread Pool Size

## Temporal Configuration

`TEMPORAL_VERSION` - Temporal Version

`TEMPORAL_UI_VERSION` - Temporal UI Version

`TEMPORAL_HOST` - Temporal Host

`TEMPORAL_PORT` - Temporal Port

`TEMPORAL_ROOT_CERT` - Temporal Root Certificate

`TEMPORAL_CLIENT_KEY` - Temporal Client Key

`TEMPORAL_CLIENT_CHAIN` - Temporal Client Chain

`TEMPORAL_POSTGRESQL_VERSION` - Temporal Postgres Version

`TEMPORAL_POSTGRES_PASSWORD` - Temporal Postgres Password

`TEMPORAL_POSTGRES_USER` - Temporal Postgres User

`TEMPORAL_POSTGRES_DEFAULT_PORT` - Temporal Postgres Default Port

`TEMPORAL_NAMESPACE` - Temporal Namespace

`TEMPORAL_TASK_QUEUE` - Temporal Task Queue

`TEMPORAL_ACTIVITY_THREAD_POOL_SIZE` - Temporal Activity Thread Pool Size

`TEMPORAL_WORKFLOW_THREAD_POOL_SIZE` - Temporal Workflow Thread Pool Size

## Community Edition Configuration

`VITE_API_HOST` - Hostname of API server

`VITE_APPSIGNAL_PUSH_API_KEY` - AppSignal API key

`VITE_BRAND_NAME` - Community Brand Name

`VITE_LOGO_URL` - URL of Brand Logo

`VITE_BRAND_COLOR` - Community Theme Color

`VITE_BRAND_HOVER_COLOR` - Community Theme Color On Hover

`VITE_FAV_ICON_URL` - URL of Brand Favicon

## Deployment Variables

`APP_ENV` - Deployment environment. Default: community.

`APP_REVISION` - Latest github commit sha. Used to identify revision of deployments.

## AWS Variables

`AWS_ACCESS_KEY_ID` - AWS Access Key Id. Used to assume role in S3 connector.

`AWS_SECRET_ACCESS_KEY` - AWS Secret Access Key. Used to assume role in S3 connector.

## Optional Variables

`APPSIGNAL_PUSH_API_KEY` - API Key for AppSignal integration.

`TRACK` - Track usage events.

`NEW_RELIC_KEY` - New Relic Key

`RAILS_LOG_LEVEL` - Rails log level. Default: info.


# Google Cloud Compute Engine
Source: https://docs.squared.ai/deployment-and-security/setup/gce



## Deploying Multiwoven on Google Cloud Platform using Docker Compose

This guide walks you through setting up Multiwoven, on a Google Cloud Platform (GCP) Compute Engine instance using Docker Compose. We'll cover launching the instance, installing Docker, running Multiwoven with its dependencies, and accessing the Multiwoven UI.

**Prerequisites:**

* A Google Cloud Platform account with an active project and billing enabled.
* Basic knowledge of GCP, Docker, and command-line tools.
* Docker Compose installed on your local machine.

**Note:** This guide uses environment variables for sensitive information. Replace the placeholders with your own values before proceeding.

**1. Create a GCP Compute Engine Instance:**

1. **Open the GCP Console:** [https://console.cloud.google.com](https://console.cloud.google.com)
2. **Navigate to Compute Engine:** Go to the "Compute Engine" section and click on "VM Instances."
3. **Create a new instance:** Choose an appropriate machine type based on your workload requirements. Ubuntu is a popular choice.
4. **Configure your instance:**
   * Select a suitable boot disk size and operating system image (Ubuntu recommended).
   * Enable SSH access with a strong password or SSH key.
   * Configure firewall rules to allow inbound traffic on port 22 (SSH) and potentially port 8000 (Multiwoven UI, optional).
5. **Create the instance:** Review your configuration and click "Create" to launch the instance.

**2. Connect to your Instance:**

1. **Get the external IP address:** Once the instance is running, find its external IP address in the GCP Console.
2. **Connect via SSH:** Use your preferred SSH client to connect to the instance:

```
ssh -i your_key_pair.pem user@<external_ip_address>
```

**3. Install Docker and Docker Compose:**

1. **Update and upgrade:** Run `sudo apt update && sudo apt upgrade -y` to ensure your system is up-to-date.
2. **Install Docker:** Follow the official Docker installation instructions for Ubuntu: [https://docs.docker.com/engine/install/](https://docs.docker.com/engine/install/)
3. **Install Docker Compose:** Download the latest version from the Docker Compose releases page and place it in a suitable directory (e.g., `/usr/local/bin/docker-compose`). Make the file executable: `sudo chmod +x /usr/local/bin/docker-compose`.
4. **Start and enable Docker:** Run `sudo systemctl start docker` and `sudo systemctl enable docker` to start Docker and configure it to start automatically on boot.

**4. Download Multiwoven `docker-compose.yml` file and Configure Environment:**

1. **Download the file:** 

```
curl -LO https://multiwoven-deployments.s3.amazonaws.com/docker/docker-compose/docker-compose.yaml
```

2. **Download the `.env` file:**  

```
curl -LO https://multiwoven-deployments.s3.amazonaws.com/docker/docker-compose/.env
```

3. **Create and Configure `.env` File:** Rename `multiwoven/.env.example` to `.env`. This file holds environment variables for various services. Replace the placeholders with your own values, including:
     \* `DB_PASSWORD` and `DB_USERNAME` for your PostgreSQL database
     \* `REDIS_PASSWORD` for your Redis server
     \* (Optional) Additional environment variables specific to your Multiwoven configuration

**Example `.env` file:**

```
DB_PASSWORD=your_db_password
DB_USERNAME=your_db_username
REDIS_PASSWORD=your_redis_password
# Modify your Multiwoven-specific environment variables here
```

**5. Run Multiwoven with Docker Compose:**

**Start Multiwoven:** Navigate to the `multiwoven` directory and run.

```bash theme={null}
docker-compose up -d
```

**6. Accessing Multiwoven UI:**

Open your web browser and navigate to `http://<external_ip_address>:8000` (replace `<external_ip_address>` with your instance's IP address). You should now see the Multiwoven UI.

**7. Stopping Multiwoven:**

To stop Multiwoven, navigate to the `multiwoven` directory and run.

```bash theme={null}
docker-compose down
```

**8. Upgrading Multiwoven:**
When a new version of Multiwoven is released, you can upgrade the Multiwoven using the following command.

```bash theme={null}
docker-compose pull && docker-compose up -d
```

<Tip> Make sure to run the above command from the same directory where the `docker-compose.yml` file is present.</Tip>

**Additional Notes:**

<Tip>**Note**: the frontend and backend services run on port 8000 and 3000, respectively. Make sure you update the **VITE\_API\_HOST** environment variable in the **.env** file to the desired backend service URL running on port 3000. </Tip>

* Depending on your firewall configuration, you might need to open port 8000 for inbound traffic.
* For production deployments, consider using a managed load balancer and a Cloud SQL database instance for better performance and scalability.


# Google Cloud GKE (Kubernetes)
Source: https://docs.squared.ai/deployment-and-security/setup/gke

Coming soon...



# Helm Charts	
Source: https://docs.squared.ai/deployment-and-security/setup/helm



## Description:

This helm chart is designed to deploy AI Squared's Platform 2.0 into a Kubernetes cluster.

Platform 2.0 is cloud-agnostic and can be deployed successfully into any Kubernetes cluster, including clusters deployed via Azure Kubernetes Service, Elastic Kubernetes Service, Microk8s, etc.

Along with the platform containers, there are also a couple of additional support resources added to simplify and further automate the installation process. These include: the **nginx-ingress resources** to expose the platform to end-users and **cert-manager** to automate the
creation and renewal of TLS certificates.

### Coming Soon!

We have a couple of useful features that are still in development that will further promote high availability, scalability and visibility into the platform pods!

These features include **horizontal-pod autoscaling** based on pod CPU and memory utilization as well as in-cluster instances of both **Prometheus** and **Grafana**.

## Prerequisites:

* Access to a DNS record set
* Kubernetes cluster
* [Install Kubernetes 1.16+](https://kubernetes.io/docs/tasks/tools/)
* [Install Helm 3.1.0+](https://kubernetes.io/docs/tasks/tools/)
* Temporal Namespace (optional)

## Overview of the Deployment Process

1. Install kubectl and helm on your local machine
2. Select required subdomains
3. Deploy the Cert-Manager Helm chart
4. Deploy the Multiwoven Helm Chart
5. Deploy additional (required) Nginx Ingress resources
6. Obtain the public IP address associated with your Nginx Ingress Controller
7. Create A records in your DNS record set that resolve to the public IP address of your Nginx Ingress Controller.
8. Wait for cert-manager to issue an invalid staging certificate to your K8s cluster
9. Switch letsencrypt-staging to letsencrypt-prod and upgrade Multiwoven again, this time obtaining a valid TLS certificate

## Installing Multiwoven via Helm

Below is a shell script that can be used to deploy Multiwoven and its dependencies.

### Chart Dependencies

#### Cert-Manager

Cert-Manager is used to automatically request, implement and rotate TLS certificates for your deployment. Enabling TLS is required.

#### Nginx-Ingress

Nginx-Ingress resources are added to provide the Multiwoven Ingress Controller with a external IP address.

### Install Multiwoven

#### Environment Variables:

##### Generic

1. <b>tls-admin-email-address</b> -> the email address that will receive email notifications about pending automatic TLS certificate rotations

2. <b>api-host</b> -> api.your\_domain (ex. api.multiwoven.com)

3. <b>ui-host</b> -> app.your\_domain (ex. app.multiwoven.com)

##### Temporal - Please read the [Notes](#notes) section below

4. <b>temporal-ui-host</b> -> temporal.your\_domain (ex. temporal.multiwoven.com)

5. <b>temporalHost</b> -> your Temporal Cloud host name (ex. my.personal.tmprl.cloud)

6. <b>temporalNamespace</b> -> your Temporal Namespace, verify within your Temporal Cloud account (ex. my.personal)

#### Notes:

* Deploying with the default In-cluster Temporal (<b>recommended for Development workloads</b>):
  1. Only temporal-ui-host is required. You should leave multiwovenConfig.temporalHost, temporal.enabled and multiwovenConfig.temporalNamespace commented out. You should also leave the temporal-cloud secret commented out as well.
* Deploying with Temporal Cloud (<b>HIGHLY recommended for Production workloads</b>):
  1. comment out or remove the flag setting multiwovenConfig.temporalUiHost
  2. Uncomment the flags setting multiwovenConfig.temporalHost, temporal.enabled and multiwovenConfig.temporalNamespace. Also uncomment the temporal-cloud secret.
  3. Before running this script, you need to make sure that your Temporal Namespace authentication certificate key and pem files are in the same directory as the script. We recommend renaming these files to temporal.key and temporal.pem for simplicity.
* Notice that for tlsCertIssuer, the value letsencrypt-staging is present. When the intial installation is done and cert-manager has successfully issued an invalid certificate for your 3 subdomains, you will switch this value to letsencrypt-prod to obtain a valid certificate. It is very important that you follow the steps written out here as LetsEncrypt's production server only allows 5 attempts per week to obtain a valid certificate. This switch should be done LAST after you have verified that everything is already working as expected.

```
#### Pull and deploy the cert-manager Helm chart
cd charts/multiwoven
echo "installing cert-manager"
helm repo add jetstack https://charts.jetstack.io --force-update
helm repo update
helm install cert-manager jetstack/cert-manager --namespace cert-manager --create-namespace --version v1.14.5 --set installCRDs=true

#### Pull and deploy the Multiwoven Helm chart
echo "installing Multiwoven"
helm repo add multiwoven https://multiwoven.github.io/helm-charts
helm upgrade -i multiwoven multiwoven/multiwoven \
  --set multiwovenConfig.tlsAdminEmail=<tls-admin-email-address> \
  --set multiwovenConfig.tlsCertIssuer=letsencrypt-staging \
  --set multiwovenConfig.apiHost=<api-host> \
  --set multiwovenConfig.uiHost=<ui-host> \
  --set multiwovenWorker.multiwovenWorker.args={./app/temporal/cli/worker} \
  --set multiwovenConfig.temporalUiHost=<temporal-ui-host>
  # --set temporal.enabled=false \
  # --set multiwovenConfig.temporalHost=<temporal-host> \
  # --set multiwovenConfig.temporalNamespace=<temporal-namespace>

# kubectl create secret generic temporal-cloud -n multiwoven \
#     --from-file=temporal-root-cert=./temporal.pem \
#     --from-file=temporal-client-key=./temporal.key

# Install additional required Nginx ingress resources
echo "installing ingress-nginx resources"
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/cloud/deploy.yaml
```

#### Post Installation Steps

1. Run the following command to find the external IP address of your Ingress Controller. Note that it may take a minute or two for this value to become available post installation.

```
kubectl get svc -n ingress-nginx
```

<Frame>
  <img />
</Frame>

2. Once you have this IP address, go to your DNS record set and use that IP address to create three A records, one for each subdomain. Below are a list of Cloud Service Provider DNS tools but please refer to the documentation of your specific provider if not listed below.

* [Adding a new record in Azure DNS Zones](https://learn.microsoft.com/en-us/azure/dns/dns-operations-recordsets-portal)
* [Adding a new record in AWS Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/resource-record-sets-creating.html)
* [Adding a new record in GCP Cloud DNS](https://cloud.google.com/dns/docs/records)

3. Run the following command, repeatedly, until an invalid LetsEncrypt staging certificate has been issued for your Ingress Controller.

```
kubectl describe certificate -n multiwoven mw-tls-cert
```

When the certificate has been issued, you will see the following output from the command above.

<Frame>
  <img />
</Frame>

We also encourage you to further verify by navigating to your subdomain, app.your\_domain, and check the certificate received by the browser. You should see something similar to the image below:

<Frame>
  <img />
</Frame>

Once the invalid certificate has been successfully issued, you are ready for the final steps.

4. Edit the shell script above by changing the tlsCertIssuer value from <b>letsencrypt-staging</b> to <b>letsencrypt-prod</b> and run the script again. Do not worry when you see Installation Failed for cert-manager, you are seeing this because it was installed on the intial run.

5. Repeat Post Installation Step 3 until a valid certificate has been issued. Once issued, your deployment is complete and you can navigate to app.your\_domain to get started using Mutliwoven!

Happy Helming!

## Helm Chart Environment Values

### Multiwoven Helm Configuration

#### General Configuration

* **kubernetesClusterDomain**: The domain used within the Kubernetes cluster.
  * Default: `cluster.local`
* **kubernetesNamespace**: The Kubernetes namespace for deployment.
  * Default: `multiwoven`

#### Multiwoven Configuration

| Parameter                                         | Description                                                 | Default                                       |
| ------------------------------------------------- | ----------------------------------------------------------- | --------------------------------------------- |
| `multiwovenConfig.apiHost`                        | Hostname for the API service.                               | `api.multiwoven.com`                          |
| `multiwovenConfig.appEnv`                         | Deployment environment.                                     | `community`                                   |
| `multiwovenConfig.appRevision`                    | Latest github commit sha, identifies revision of deployment | \`\`                                          |
| `multiwovenConfig.appsignalPushApiKey`            | AppSignal API key.                                          | `yourkey`                                     |
| `multiwovenConfig.awsAccessKeyId`                 | AWS Access Key Id. Used to assume role in S3 connector.     | \`\`                                          |
| `multiwovenConfig.awsSecretAccessKey`             | AWS Secret Access Key. Used to assume role in S3 connector. | \`\`                                          |
| `multiwovenConfig.dbHost`                         | Hostname for the PostgreSQL database service.               | `multiwoven-postgresql`                       |
| `multiwovenConfig.dbPassword`                     | Password for the database user.                             | `password`                                    |
| `multiwovenConfig.dbPort`                         | Port on which the database service is running.              | `5432`                                        |
| `multiwovenConfig.dbUsername`                     | Username for the database.                                  | `multiwoven`                                  |
| `multiwovenConfig.grpcEnableForkSupport`          | GRPC\_ENABLE\_FORK\_SUPPORT env variable.                   | `1`                                           |
| `multiwovenConfig.newRelicKey`                    | New Relic License Key.                                      | `yourkey`                                     |
| `multiwovenConfig.railsEnv`                       | Rails environment setting.                                  | `development`                                 |
| `multiwovenConfig.railsLogLevel`                  | Rails log level.                                            | `info`                                        |
| `multiwovenConfig.smtpAddress`                    | SMTP server address.                                        | `smtp.yourdomain.com`                         |
| `multiwovenConfig.smtpBrandName`                  | SMTP brand name used in From email.                         | `Multiwoven`                                  |
| `multiwovenConfig.smtpHost`                       | SMTP server host.                                           | `yourdomain.com`                              |
| `multiwovenConfig.smtpPassword`                   | SMTP server password.                                       | `yourpassword`                                |
| `multiwovenConfig.smtpPort`                       | SMTP server port.                                           | `587`                                         |
| `multiwovenConfig.smtpUsername`                   | SMTP server username.                                       | `yourusername`                                |
| `multiwovenConfig.smtpSenderEmail`                | SMTP sender email.                                          | `admin@yourdomain.com`                        |
| `multiwovenConfig.snowflakeDriverPath`            | Path to the Snowflake ODBC driver.                          | `/usr/lib/snowflake/odbc/lib/libSnowflake.so` |
| `multiwovenConfig.syncExtractorBatchSize`         | Batch size for the sync extractor.                          | `1000`                                        |
| `multiwovenConfig.syncExtractorThreadPoolSize`    | Thread pool size for the sync extractor.                    | `10`                                          |
| `multiwovenConfig.syncLoaderBatchSize`            | Batch size for the sync loader.                             | `1000`                                        |
| `multiwovenConfig.syncLoaderThreadPoolSize`       | Thread pool size for the sync loader.                       | `10`                                          |
| `multiwovenConfig.temporalActivityThreadPoolSize` | Thread pool size for Temporal activities.                   | `20`                                          |
| `multiwovenConfig.temporalClientChain`            | Path to Temporal client chain certificate.                  | `/certs/temporal.chain.pem`                   |
| `multiwovenConfig.temporalClientKey`              | Path to Temporal client key.                                | `/certs/temporal.key`                         |
| `multiwovenConfig.temporalHost`                   | Hostname for Temporal service.                              | `multiwoven-temporal`                         |
| `multiwovenConfig.temporalNamespace`              | Namespace for Temporal service.                             | `multiwoven-dev`                              |
| `multiwovenConfig.temporalPort`                   | Port for Temporal service.                                  | `7233`                                        |
| `multiwovenConfig.temporalPostgresDefaultPort`    | Default port for Temporal's PostgreSQL database.            | `5432`                                        |
| `multiwovenConfig.temporalPostgresPassword`       | Password for Temporal's PostgreSQL database.                | `password`                                    |
| `multiwovenConfig.temporalPostgresUser`           | Username for Temporal's PostgreSQL database.                | `multiwoven`                                  |
| `multiwovenConfig.temporalPostgresqlVersion`      | PostgreSQL version for Temporal.                            | `13`                                          |
| `multiwovenConfig.temporalRootCert`               | Path to Temporal root certificate.                          | `/certs/temporal.pem`                         |
| `multiwovenConfig.temporalTaskQueue`              | Task queue for Temporal workflows.                          | `sync-dev`                                    |
| `multiwovenConfig.temporalUiVersion`              | Version of Temporal UI.                                     | `2.23.2`                                      |
| `multiwovenConfig.temporalVersion`                | Version of Temporal service.                                | `1.22.4`                                      |
| `multiwovenConfig.temporalWorkflowThreadPoolSize` | Thread pool size for Temporal workflows.                    | `10`                                          |
| `multiwovenConfig.uiHost`                         | UI host for the application interface.                      | `app.multiwoven.com`                          |
| `multiwovenConfig.viteApiHost`                    | API host for the web application.                           | `api.multiwoven.com`                          |
| `multiwovenConfig.viteAppsignalPushApiKey`        | AppSignal API key.                                          | `yourkey`                                     |
| `multiwovenConfig.viteBrandName`                  | Community Brand Name.                                       | `Multiwoven`                                  |
| `multiwovenConfig.viteLogoUrl`                    | URL of Brand Logo.                                          |                                               |
| `multiwovenConfig.viteBrandColor`                 | Community Theme Color.                                      |                                               |
| `multiwovenConfig.viteBrandHoverColor`            | Community Theme Color On Hover.                             |                                               |
| `multiwovenConfig.viteFavIconUrl`                 | URL of Brand Favicon.                                       |                                               |
| 'multiwovenConfig.workerHost\`                    | Worker host for the worker service.                         | 'worker.multiwoven.com'                       |

### Multiwoven PostgreSQL Configuration

| Parameter                                        | Description                                        | Default     |
| ------------------------------------------------ | -------------------------------------------------- | ----------- |
| `multiwovenPostgresql.enabled`                   | Whether or not to deploy PostgreSQL.               | `true`      |
| `multiwovenPostgresql.image.repository`          | Docker image repository for PostgreSQL.            | `postgres`  |
| `multiwovenPostgresql.image.tag`                 | Docker image tag for PostgreSQL.                   | `13`        |
| `multiwovenPostgresql.resources.limits.cpu`      | CPU resource limits for PostgreSQL pod.            | `1`         |
| `multiwovenPostgresql.resources.limits.memory`   | Memory resource limits for PostgreSQL pod.         | `2Gi`       |
| `multiwovenPostgresql.resources.requests.cpu`    | CPU resource requests for PostgreSQL pod.          | `500m`      |
| `multiwovenPostgresql.resources.requests.memory` | Memory resource requests for PostgreSQL pod.       | `1Gi`       |
| `multiwovenPostgresql.ports.name`                | Port name for PostgreSQL service.                  | `postgres`  |
| `multiwovenPostgresql.ports.port`                | Port number for PostgreSQL service.                | `5432`      |
| `multiwovenPostgresql.ports.targetPort`          | Target port for PostgreSQL service within the pod. | `5432`      |
| `multiwovenPostgresql.replicas`                  | Number of PostgreSQL pod replicas.                 | `1`         |
| `multiwovenPostgresql.type`                      | Service type for PostgreSQL.                       | `ClusterIP` |

### Multiwoven Server Configuration

| Parameter                                    | Description                                               | Default                        |
| -------------------------------------------- | --------------------------------------------------------- | ------------------------------ |
| `multiwovenServer.image.repository`          | Docker image repository for Multiwoven server.            | `multiwoven/multiwoven-server` |
| `multiwovenServer.image.tag`                 | Docker image tag for Multiwoven server.                   | `latest`                       |
| `multiwovenServer.resources.limits.cpu`      | CPU resource limits for Multiwoven server pod.            | `2`                            |
| `multiwovenServer.resources.limits.memory`   | Memory resource limits for Multiwoven server pod.         | `2Gi`                          |
| `multiwovenServer.resources.requests.cpu`    | CPU resource requests for Multiwoven server pod.          | `1`                            |
| `multiwovenServer.resources.requests.memory` | Memory resource requests for Multiwoven server pod.       | `1Gi`                          |
| `multiwovenServer.ports.name`                | Port name for Multiwoven server service.                  | `3000`                         |
| `multiwovenServer.ports.port`                | Port number for Multiwoven server service.                | `3000`                         |
| `multiwovenServer.ports.targetPort`          | Target port for Multiwoven server service within the pod. | `3000`                         |
| `multiwovenServer.replicas`                  | Number of Multiwoven server pod replicas.                 | `1`                            |
| `multiwovenServer.type`                      | Service type for Multiwoven server.                       | `ClusterIP`                    |

### Multiwoven Worker Configuration

| Parameter                                    | Description                                               | Default                        |
| -------------------------------------------- | --------------------------------------------------------- | ------------------------------ |
| `multiwovenWorker.args`                      | Command arguments for the Multiwoven worker.              | See value                      |
| `multiwovenWorker.healthPort`                | The port in which the health check endpoint is exposed.   | `4567`                         |
| `multiwovenWorker.image.repository`          | Docker image repository for Multiwoven worker.            | `multiwoven/multiwoven-server` |
| `multiwovenWorker.image.tag`                 | Docker image tag for Multiwoven worker.                   | `latest`                       |
| `multiwovenWorker.resources.limits.cpu`      | CPU resource limits for Multiwoven worker pod.            | `1`                            |
| `multiwovenWorker.resources.limits.memory`   | Memory resource limits for Multiwoven worker pod.         | `1Gi`                          |
| `multiwovenWorker.resources.requests.cpu`    | CPU resource requests for Multiwoven worker pod.          | `500m`                         |
| `multiwovenWorker.resources.requests.memory` | Memory resource requests for Multiwoven worker pod.       | `512Mi`                        |
| `multiwovenWorker.ports.name`                | Port name for Multiwoven worker service.                  | `4567`                         |
| `multiwovenWorker.ports.port`                | Port number for Multiwoven worker service.                | `4567`                         |
| `multiwovenWorker.ports.targetPort`          | Target port for Multiwoven worker service within the pod. | `4567`                         |
| `multiwovenWorker.replicas`                  | Number of Multiwoven worker pod replicas.                 | `1`                            |
| `multiwovenWorker.type`                      | Service type for Multiwoven worker.                       | `ClusterIP`                    |

### Persistent Volume Claim (PVC)

| Parameter            | Description                       | Default |
| -------------------- | --------------------------------- | ------- |
| `pvc.storageRequest` | Storage request size for the PVC. | `100Mi` |

### Temporal Configuration

| Parameter                                     | Description                                                | Default                 |
| --------------------------------------------- | ---------------------------------------------------------- | ----------------------- |
| `temporal.enabled`                            | Whether or not to deploy Temporal and Temporal UI service. | `true`                  |
| `temporal.ports.name`                         | Port name for Temporal service.                            | `7233`                  |
| `temporal.ports.port`                         | Port number for Temporal service.                          | `7233`                  |
| `temporal.ports.targetPort`                   | Target port for Temporal service within the pod.           | `7233`                  |
| `temporal.replicas`                           | Number of Temporal service pod replicas.                   | `1`                     |
| `temporal.temporal.env.db`                    | Database type for Temporal.                                | `postgresql`            |
| `temporal.temporal.image.repository`          | Docker image repository for Temporal.                      | `temporalio/auto-setup` |
| `temporal.temporal.image.tag`                 | Docker image tag for Temporal.                             | `1.22.4`                |
| `temporal.temporal.resources.limits.cpu`      | CPU resource limits for Temporal pod.                      | `1`                     |
| `temporal.temporal.resources.limits.memory`   | Memory resource limits for Temporal pod.                   | `2Gi`                   |
| `temporal.temporal.resources.requests.cpu`    | CPU resource requests for Temporal pod.                    | `500m`                  |
| `temporal.temporal.resources.requests.memory` | Memory resource requests for Temporal pod.                 | `1Gi`                   |
| `temporal.type`                               | Service type for Temporal.                                 | `ClusterIP`             |

### Temporal UI Configuration

| Parameter                                            | Description                                                     | Default                    |
| ---------------------------------------------------- | --------------------------------------------------------------- | -------------------------- |
| `temporalUi.ports.name`                              | Port name for Temporal UI service.                              | `8080`                     |
| `temporalUi.ports.port`                              | Port number for Temporal UI service.                            | `8080`                     |
| `temporalUi.ports.targetPort`                        | Target port for Temporal UI service within the pod.             | `8080`                     |
| `temporalUi.replicas`                                | Number of Temporal UI service pod replicas.                     | `1`                        |
| `temporalUi.temporalUi.env.temporalAddress`          | Temporal service address for UI.                                | `multiwoven-temporal:7233` |
| `temporalUi.temporalUi.env.temporalAuthCallbackUrl`  | Authentication/authorization callback URL.                      |                            |
| `temporalUi.temporalUi.env.temporalAuthClientId`     | Authentication/authorization client ID.                         |                            |
| `temporalUi.temporalUi.env.temporalAuthClientSecret` | Authentication/authorization client secret.                     |                            |
| `temporalUi.temporalUi.env.temporalAuthEnabled`      | Enable or disable authentication/authorization for Temporal UI. | `false`                    |
| `temporalUi.temporalUi.env.temporalAuthProviderUrl`  | Authentication/authorization OIDC provider URL.                 |                            |
| `temporalUi.temporalUi.env.temporalCorsOrigins`      | Allowed CORS origins for Temporal UI.                           | `http://localhost:3000`    |
| `temporalUi.temporalUi.env.temporalUiPort`           | Port for Temporal UI service.                                   | `8080`                     |
| `temporalUi.temporalUi.image.repository`             | Docker image repository for Temporal UI.                        | `temporalio/ui`            |
| `temporalUi.temporalUi.image.tag`                    | Docker image tag for Temporal UI.                               | `2.22.3`                   |
| `temporalUi.type`                                    | Service type for Temporal UI.                                   | `ClusterIP`                |


# Heroku
Source: https://docs.squared.ai/deployment-and-security/setup/heroku

Coming soon...



# OpenShift
Source: https://docs.squared.ai/deployment-and-security/setup/openshift

Coming soon...



# Billing & Account
Source: https://docs.squared.ai/faqs/billing-and-account





# Data & AI Integration
Source: https://docs.squared.ai/faqs/data-and-ai-integration



This section addresses frequently asked questions when connecting data sources, setting up AI/ML model endpoints, or troubleshooting integration issues within AI Squared.

***

## Data Source Integration

### Why is my data source connection failing?

* Verify that the connection credentials (e.g., host, port, username, password) are correct.
* Ensure that the network/firewall rules allow connections to AI Squared’s IPs (for on-prem data).
* Check if the database is online and reachable.

### What formats are supported for ingesting data?

* AI Squared supports connections to major databases like Snowflake, BigQuery, PostgreSQL, Oracle, and more.
* Files such as CSV, Excel, and JSON can be ingested via SFTP or cloud storage (e.g., S3).

***

## AI/ML Model Integration

### How do I connect my hosted model?

* Use the [Add AI/ML Source](/activation/ai-modelling/connect-source) guide to define your model endpoint.
* Provide input/output schema details so the platform can handle data mapping effectively.

### What types of model endpoints are supported?

* REST-based hosted models with JSON payloads
* Hosted services like AWS SageMaker, Vertex AI, and custom HTTP endpoints

***

## Sync & Schema Issues

### Why is my sync failing?

* Confirm that your data model and sync mapping are valid
* Check that input types in your model schema match your data source fields
* Review logs for any missing fields or payload mismatches

### How can I test if my connection is working?

* Use the “Test Connection” button when setting up a new source or sync.
* If testing fails, examine error messages and retry with updated configs.

***


# Data Apps
Source: https://docs.squared.ai/faqs/data-apps





# Deployment & Security
Source: https://docs.squared.ai/faqs/deployment-and-security





# Feedback
Source: https://docs.squared.ai/faqs/feedback





# Model Configuration
Source: https://docs.squared.ai/faqs/model-config



This section answers frequently asked questions about configuring AI models within AISquared, including how to define schemas, preprocess inputs, and ensure model compatibility.

***

## Input & Output Schema

### What is the input schema used for?

The input schema defines the structure of data sent to your model. Each key in the schema maps to a variable used by the model endpoint.

* Ensure all required fields are covered
* Match data types (string, integer, float, boolean) exactly
* Use dynamic/static value tagging depending on your use case

### What is the output schema used for?

The output schema maps the model’s prediction response to fields that can be used in visualizations and downstream applications.

* Identify key-value pairs in the model response
* Use flat structures (nested objects not supported currently)
* Label predictions clearly for user-facing display

***

## Preprocessing & Formatting

### How do I clean or transform inputs before sending them to the model?

Use AI Squared's built-in **Preprocessing Rules**, which allow no-code logic to:

* Format strings or numbers (e.g., round decimals)
* Apply conditional logic (e.g., replace nulls)
* Normalize or scale inputs

Preprocessors are configurable per input field.

***

## Updating a Model Source

### Can I update a connected model after initial setup?

Yes, you can:

* Edit endpoint details (URL, auth, headers)
* Modify input/output schemas
* Add or update preprocessing rules

Changes will reflect in associated Data Apps using the model.

***

## Debugging Model Issues

### How can I test if my model responds correctly?

1. Navigate to the AI Modeling section and click on **Test Model**
2. Provide sample input data based on your schema
3. Review the response payload

Common issues include:

* Auth failures (invalid API keys or tokens)
* Incorrect input field names or types
* Mismatched response format from expected schema

***


# Introduction to AI Squared
Source: https://docs.squared.ai/getting-started/introduction

Learn what AI Squared is, who it’s for, and how it helps businesses integrate AI seamlessly into their workflows. 

<img alt="title" />

## What is AI Squared?

AI Squared helps enterprises accelerate AI adoption at scale - by integrating Artificial Intelligence and Machine Learning (AI/ML) into systems they already use, modernizing legacy systems, and operationalizing agentic AI. From federal teams that need secure, mission-ready solutions to enterprises who need systems that scale across their complex organizations, to mid-market companies seeking plug-and-play capabilities, AI Squared's software delivers faster adoption, better decisions, and real, measurable impact.

## Who is AI Squared for?

AI Squared is for data science teams and AI/Analytics teams at large enterprises who are:

* Unable to scale AI beyond the pilot stage
* Unable to showcase immediate business impact

## How AI Squared Works

* **Connect**: Integrate disparate data sources and AI sources seamlessly with no-code.
* **Learn**: Feedback loops continuously improve LLMs making them more accurate and tightly aligned to your organizations processes.
* **Orchestrate**: Route models, manage policies, enforce governance, observe agentic workflows and ensure uptime.
* **Secure**: Deliver defense-grade encryption, RBAC, and auditability.
* **Embed**: AI insights are integrated in the enterprise applications employees already use.

## Main Challenges Related to AI Deployment

One of the key challenges in the industry is that AI products do not reach production - About 95% of all AI POCs never make it to production, as per an MIT Report.

### **Why AI Proof-of-Concepts fail to launch:** 

1. **Disparate tools**: \
   Fragmented tools (sometimes 10-15 in number) come with their own UI, API, operating model. This makes end-to-end workflows harder to manage and scale.
2. **Complex integrations**: \
   Connecting data sources, models and applications requires time and engineering effort - thereby slowing down time to production and increasing the cost of the project.
3. **Lack of trust and governance systems**: \
   When governance is not built-in, it is harder to manage. It becomes difficult to track and report how AI models collect, use and process data.
4. **Low end-user adoption**: \
   AI insights often require new tools to track and monitor. As a result, it disrupts existing workflows and affects adoption.

AI Squared provides a unified, low-code platform for deploying, governing and scaling AI across the enterprise.

## AI Squared Architecture

AI Squared's UNIFI platform implements the AI Controls Model through a unified architecture that addresses all seven layers in an integrated system. Unlike fragmented point solutions, UNIFI provides native capabilities for data connectivity, context preparation, workflow orchestration, governance, delivery, and observability without requiring external integration.

<Frame>
  <img alt="AI Squared Unified Platform Marchitecture(4)" />
</Frame>

## Architectural Overview

The UNIFI platform architecture consists of 5 primary subsystems:

### Sources: 

UNIFI connects to both enterprise data systems and AI model endpoints.

**Enterprise Data Sources**

These include:

* CRMs such as Salesforce and Dynamics
* ERPs such as SAP and Oracle
* Data warehouses such as Snowflake and BigQuery
* Databases such as PostgreSQL and Redshift

File storage systems such as S3, SharePoint, and Google Drive\
\
**AI / ML Model Sources**

The platform also connects to:

* OpenAI
* Anthropic
* AWS SageMaker
* Google Vertex
* Databricks model endpoints
* Custom REST APIs

All sources are accessed through standardized connector interfaces. This removes the need for custom integration work and ensures consistency across environments.

**Business value:**\
Organizations can unify fragmented enterprise systems into a single operational layer. This eliminates manual data stitching and reduces integration timelines from months to days.

### Data Plane (Connectors and Syncs)

Scalable data movement layer using lightweight connector plugins that implement the Multiwoven Protocol. Each connector handles authentication and interaction with specific systems (CRM, database, warehouse). During sync operations, worker processes execute data transfers between sources and destinations. State management, retries, and scheduling are coordinated through Temporal workflow orchestration.

**Business value:** Organizations can add hundreds of new data sources without increasing operational burden on platform teams. Connectors scale independently, handling parallel data transfers without resource contention.

### Control Plane

Microservices-based architecture built with Ruby on Rails and TypeScript/React, providing horizontal services for configuring and executing data and AI workflows. The control plane manages objects (data sources, destinations, AI models, workflow configurations) and coordinates all platform operations. It includes the web UI for no-code interaction and REST APIs for programmatic access.

**Business value:** This separation means platform teams can manage system configuration without writing code, while developers can automate deployment through APIs. New data sources or workflow types can be added without platform downtime.

### Application Plane

User-facing capabilities including the Sparx conversational interface for natural language queries, Insight Dashboard for interactive analytics, Automation Engine for event-driven workflows, and Data Apps for embedding AI insights directly into business applications. This layer orchestrates retrieval from the unified data layer, LLM inference, and result formatting.

**Business value:** Business users ask questions in natural language and receive answers with citations in seconds, without manual report generation or SQL queries. AI capabilities are delivered where work happens rather than requiring separate tools.

### Consumption Plane 

The Consumption Plane represents where AI insights are delivered and consumed. Instead of pulling users away from the systems they already use, UNIFI embeds intelligence directly into existing enterprise and mission systems. 

This includes:

* CRM platforms
* ERP systems
* Collaboration tools
* Financial systems
* Federal mission applications
* Custom internal portals

AI outputs can appear as:

* Embedded widgets
* Contextual dashboards
* Chat assistants
* Automated recommendations
* Triggered workflows
* Automated workflows

The Consumption Plane closes the gap between AI experimentation and operational impact. It ensures that insights are delivered at the point of decision.

**Business value:**\
AI becomes part of daily workflows rather than a separate experiment. Users do not switch tools or change behavior. They receive trusted, contextual insights inside the systems they already use. This increases adoption, shortens feedback cycles, and accelerates measurable business impact.

## Detailed Overview of UNIFI Platform

### **Data Movement**

AI Squared connects with a wide range of enterprise systems across data platforms, business applications, and operational tools without the need of migration. Data remains in its system of record (minimising risks due to privacy or governance related factors). The table below provides a representative view of supported data sources, AI/ML integrations, and destination systems.

| **Feature Category** | **Capability**              | **Details & Supported Connectors**                                                                               |
| :------------------- | :-------------------------- | :--------------------------------------------------------------------------------------------------------------- |
| **Data Sources**     | **Warehouses & Databases**  | Snowflake, Amazon Redshift, Google BigQuery, Databricks, PostgreSQL, MariaDB, Oracle, ClickHouse, Microsoft SQL. |
|                      | **File & Storage**          | Amazon S3, SFTP, Google Drive.                                                                                   |
|                      | **Apps & Services**         | Salesforce Consumer Cloud, AWS Athena, Intuit QuickBooks, Odoo, Firecrawl.                                       |
| **AI/ML Sources**    | **Model Integration**       | **Bring Your Own Model (BYOM)** via HTTP endpoints or direct integration.                                        |
|                      | **Supported Providers**     | AWS SageMaker, Google Vertex AI, Databricks Model, OpenAI (GPT), Anthropic (Claude), Llama.                      |
| **Destinations**     | **Business Apps (CRM/ERP)** | Salesforce CRM, HubSpot CRM, Microsoft Dynamics 365, Zoho, Zendesk, ServiceNow, NetSuite.                        |
|                      | **Communication**           | Slack, Microsoft Teams.                                                                                          |
|                      | **Marketing/Ads**           | Braze, Klaviyo, Iterable, Mailchimp, Facebook Custom Audiences, Google Ads.                                      |
|                      | **Databases & Storage**     | Postgres, MariaDB, Oracle DB, Amazon S3, SFTP, Databricks Warehouse.                                             |

### **Data Modeling & Transformation** 

AI Squared supports data preparation and model execution as a governed, and controlled layer.Organizations retain full control over how data is shaped, synchronized, and prepared before it reaches the applications. Orchestration ensures that data access, transformations, and model execution follow defined rules. This approach allows enterprises to operationalize AI workflows without complex integrations, while maintaining reliability across environments. The following table describes the orchestration capabilities, modeling methods and scheduling mechanisms: 

| **Feature**          | **Description**     | **Technical Specifics**                                                                                                                                |
| :------------------- | :------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Modeling Methods** | **SQL Editor**      | Define models using static or dynamic SQL queries natively compatible with the data warehouse.                                                         |
|                      | **Table Selector**  | Visual, no-code interface to select specific tables and columns.                                                                                       |
|                      | **dbt Integration** | Leverage existing dbt models for advanced data transformation.                                                                                         |
| **Sync Types**       | **Full Refresh**    | Replaces all data in the destination with fresh source data.                                                                                           |
|                      | **Incremental**     | Syncs only data changed since the last run (supports Cursor Fields).                                                                                   |
|                      | **Scheduling**      | Manual, Interval-based, or Cron-based intervals.                                                                                                       |
| **Harvesting**       | **Context Capture** | **DOM Harvesting:** Captures text/data from the web page Document Object Model.<br />**Query Param Harvesting:** Captures context from URL parameters. |

### **Workflow Orchestration & Agentic Execution**

AI Squared’s orchestration layer operates as managed infrastructure. Model execution, workflow logic, and governance are handled centrally, without requiring end users to interact with new interfaces or modify existing workflows. Data scientists, engineers, and business users collaborate through governed orchestration workflows, while AI-generated insights are delivered directly into the systems where decisions occur.

| **Feature**          | **Capability**                     | **Source**                                                                                                        |
| :------------------- | :--------------------------------- | :---------------------------------------------------------------------------------------------------------------- |
| **RAG**              | **Retrieval-Augmented Generation** | Enriches LLMs with proprietary data via Vector Search to reduce hallucinations and provide context-aware answers. |
| **Knowledge Base**   | **AI Squared Vector Store**        | Optimized storage for vector embeddings to support semantic search and AI workflows.                              |
| **MCP Tools**        | **MCP Servers**                    | Connect with 26+ MCP servers to integrate with external systems into the AI workflows                             |
| **Agents**           | **Agent Core**                     | Understands, reasons, and performs actions; connects via MCP (Model Context Protocol) tools.                      |
| **Workflow Builder** | **Drag & Drop**                    | Visual builder to chain Inputs → Prompts → LLM Processing → Vector Search → Guardrails → Outputs.                 |
| **Guardrails**       | **Compliance Rules**               | Configure rules for PII masking, content policy violations, and custom compliance checks.                         |

### **AI Integration**

AI Squared acts as a single intelligence layer that delivers insights directly inside existing workflows. This removes the problem of fragmented tools and complexity in your environment. AI Squared centralizes AI reasoning and makes insights available in the tools and interfaces employees use regularly. This approach reduces tool sprawl, minimizes context switching, and ensures AI-driven insights are consumed at the point of decision-making rather than in separate systems. The table below shows the delivery mechanisms and interfaces through which users consume AI insights:

| **Feature**       | **Component**           | **Options / Details**                                                                                                                    |
| :---------------- | :---------------------- | :--------------------------------------------------------------------------------------------------------------------------------------- |
| **Data Apps**     | **Integration Type**    | **Browser Extension (No-code):** Overlays insights on existing web apps.<br />**Embeddable Code:** Snippet to insert into app codebases. |
|                   | **Visualization Types** | Donut Chart, Bar Chart, Table, Text, Chat Interface, Custom Component (Script-based).                                                    |
|                   | **Preview Mode**        | Visualize how the Data App will render with sample input before deploying.                                                               |
| **Sparx Chatbot** | **Conversational UI**   | Natural language interface for querying business data (e.g., "Show me sales by region").                                                 |
|                   | **Launchpad**           | Pre-configured workspace with default vector store and starter templates.                                                                |

### **Feedback & Analytics**

AI Squared allows you to monitor, measure, and improve AI performance continuously. These digital duplicates allow AI Squared to monitor how AI-powered workflows behave over time, gather user feedback, and deliver feedback such as usage patterns, errors, and failures. By combining feedback mechanisms with detailed reporting and usage analytics, AI Squared helps teams detect issues early, maintain performance, and reduce the risk of AI systems failing after pilot deployment.

| **Feature**          | **Type**               | **Details**                                                                  |
| :------------------- | :--------------------- | :--------------------------------------------------------------------------- |
| **Feedback Capture** | **Primary Feedback**   | Thumbs Up/Down, Star Rating (1-10), Single/Multi-select options.             |
|                      | **Secondary Feedback** | Text-based remarks (can be mandatory or optional).                           |
| **Reporting**        | **Sync Reports**       | Metrics on sync runs, rows processed, sync errors, and row-level failures.   |
|                      | **Usage Dashboards**   | Metrics on session renders, feedback response rates, and sentiment analysis. |

### **Built-in Security & Governance**

AI Squared incorporates governance, security, and auditability directly into the platform’s operating model. AI Squared enforces trust through controlled deployment options, access controls, and activity monitoring. These mechanisms ensure that data access, model execution, and workflow operations follow defined security and compliance requirements across environments. By combining role-based access control, encryption, audit logging, and real-time alerts, AI Squared provides the visibility and safeguards required for operating AI workflows in regulated and sensitive environments.

| **Feature**        | **Capability**       | **Details**                                                                                                                              |
| :----------------- | :------------------- | :--------------------------------------------------------------------------------------------------------------------------------------- |
| **Deployment**     | **Flexible Options** | **SaaS:** Managed cloud.**VPC:** Customer's Virtual Private Cloud.<br />**Air-Gapped:** Fully on-premises with no external dependencies. |
| **Access Control** | **RBAC**             | Granular roles: **Admin** (full access), **Member** (operational access), **Viewer** (read-only).                                        |
|                    | **Workspaces**       | Logical isolation for different teams or projects (Multi-tenancy).                                                                       |
| **Security**       | **Encryption**       | **AES-256** for data at rest and in transit; TLS 1.2+ protocols.                                                                         |
| **Auditing**       | **Audit Logs**       | Complete tracking of actions (login, connector creation, data access). Logs are exportable.                                              |
| **Alerting**       | **Notifications**    | Alerts via Email or Slack for sync failures, row failures (based on thresholds), or system activity.                                     |


# Navigating AI Squared
Source: https://docs.squared.ai/getting-started/navigation

Explore the AI Squared dashboard, including reports, sources, destinations, models, syncs, and data apps.

Once you log in to the platform, you will land on the **Reports** section by default, providing a performance overview of AI and data models.

## Reports

### Sync Reports

View real-time sync status on **data movement** from your data sources to destinations, such as:

* Databases
* Data warehouses
* Business applications

### Data App Reports

Monitor the **real-time usage of AI models** deployed within business applications, tracking adoption and performance.

## Sources

### Data Source

These include:

* Data warehouses
* Databases
* Other structured/unstructured data sources

### AI/ML Source

Endpoints for AI/ML models, such as:

* Large Language Models (LLMs)
* Custom AI/ML models

## Destinations

Business applications where AI insights or transformed data are delivered, including:

* **CRMs**
* **Support systems**
* **Marketing automation tools**
* **Other databases**

## Models

Data models define and organize the data you want to query from a source.

## Syncs

Syncs define how query results from a model should be **mapped and transferred** to a destination.

## Data Apps

**Data Apps** enable you to:

* Integrate AI/ML insights directly into business applications.
* Connect to AI/ML sources.
* Build visualizations for business users to consume insights effortlessly.

## Knowledge Bases

Knowledge Bases help you make structured and unstructured data more usable inside AI workflows.

## MCP Tools

The MCP Tools Component defines which MCP tools an Agent can use in a workflow. The MCP tools themselves do not execute by themselves. The Tools Component:

* Points to an MCP server
* Lists the tools available by that server
* Lets users select which tools an Agent is allowed to use

This keeps closer access control over the tools.

## Model Hub

Model Hub is the single place where you can discover, select, manage, and govern all your LLMs without switching between multiple tools.

Model Hub is designed to be configured with a wide range of model categories:

* Foundation Models: Access top LLMs from leading providers and use them directly in your workflows
* In-House Models: Host and govern your fine-tuned or proprietary models built for specific business needs
* External & Partner Models: Bring in OpenAI-compatible third-party models from partner ecosystems, no vendor lock-in

## AI Workflows

The AI Workflow Builder provides a chat-driven interface for creating and modifying workflows using natural language:

* Gather input from users or systems
* Enrich that input with contextual data
* Execute one or more AI reasoning steps
* Process intermediate and final results
* Deliver structured output to downstream consumers

## Chat Assistants

Chat Assistants are the interfaces through which you can access published AI workflows. Once an AI workflow is built and published, it can be exposed as a chat Assistant. Chat Assistants provide an interactive layer that allows users to submit queries and receive responses


# Setting Up Your Account
Source: https://docs.squared.ai/getting-started/setup

Learn how to create an account, manage workspaces, and define user roles and permissions in AI Squared.

## Creating an Account & Logging In

You can sign up with your email ID at the following URL: [app.squared.ai](https://app.squared.ai).

<img alt="title" />

## User Roles & Permissions

### Accessing Your Workspace

Once you log in to the platform, navigate to **Workspace** under **Settings** to create your workspace, add team members, and define access rights.

### Adding Team Members and Defining Permissions

To add team members in the selected workspace:

1. Click on the **Profile** section.
2. Select the option to **Add Team Members**.
3. Assign appropriate roles and permissions.

## How to Create Multiple Workspaces

If you are collaborating with multiple teams across the organization and need to organize access to data, you can create multiple workspaces.

### Steps to Create a New Workspace:

1. Click on the **drop-down menu** in the left corner to switch between workspaces or create a new one.
2. Select **Manage Workspaces**.
3. Click **Create New Workspace** and fill in the required details.

Once created, you can manage access rights and team collaboration across different workspaces.


# Workspace Management
Source: https://docs.squared.ai/getting-started/workspace-management/overview

Learn how to create a new workspace, manage settings and workspace users.

## Introduction

Workspaces enable the governance of data & AI activation. Each workspace within an organization's account will have self-contained data sources, data & AI models, syncs and business application destinations.

### Key workspace concepts

* Organization: An AI Squared account that is a container for a set of workspaces.

* Workspace: Represents a set of users and resources. One or more workspaces are contained within an organization.

* User: An individual within a workspace, with a specific Role. A user can be a part of one or more workspaces.

* Role: Defined by a set of rules that govern a user’s access to resources within a workspace

* Resources: Product features within the workspace that enable the activation of data and AI. These include data sources, destinations, models, syncs, and more.

### Workspace settings

You can access Workspace settings from within Settings on the left navigation menu. The workspace’s name and description can be edited at any time for clarity.

<img />

### Inviting users to a workspace

You can view the list of active users on the Members tab, within Settings. Users can be invited or deleted from this screen.

<img />

To invite a user, enter their email ID and choose their role. The invited user will receive an email invite (with a link that will expire after 30 days).

<img />

The invite to a user can be cancelled or resent from this screen.

<img />

### Role-based access control (RBAC)

Governance within workspaces is enabled by user Role-based access control (RBAC).

* **Admins** have unrestricted access to all resources in the Organization’s account and all its workspaces. Admins can also create workspaces and manage the workspace itself, including inviting users and setting user roles.

* **Members** belong to a single workspace, with access to all its resources. Members are typically part of a team or purpose that a workspace has been specifically set up for.

* **Viewers** have read-only access to core resources within a workspace. Viewers can’t manage the workspace itself or add users.

### Creating a new workspace

To create a workspace, use the drop-down on the left navigation panel that shows your current active workspace, click Manage Workspaces.

<img />

Choose Create New Workspace.

<img />

<img />

### Moving between workspaces

Your active workspace is visible on the left tab. The drop-down will allow you to view workspaces that you have access to, move between workspaces or create a workspace.

<img />


# Adding a Data Source
Source: https://docs.squared.ai/guides/add-data-source

How to connect and configure a business data source in AI Squared.

AI Squared allows you to integrate data from databases, warehouses, and storage systems to power downstream AI insights and business workflows.

Follow the steps below to connect your first data source.

***

## Step 1: Navigate to Data Sources

1. Go to **Sources** → **Data Sources** in the left sidebar.
2. Click **“Add Source”**.
   <img alt="title" />
3. Select your connector from the available list (e.g., Snowflake, BigQuery, PostgreSQL, etc.).

<img alt="title" />

***

## Step 2: Provide Connection Details

Each data source requires standard connection credentials. These typically include:

* **Source Name** – A descriptive label for your reference.
* **Host / Server URL** – Address of the database or data warehouse.
* **Port Number** – Default or custom port for the connection.
* **Database Name** – The name of the DB you want to access.
* **Authentication Type** – Options like password-based, token, or OAuth.
* **Username & Password / Token** – Credentials for access.
* **Schema (if applicable)** – Filter down to the relevant DB schema.

<img alt="title" />

***

## Step 3: Test the Connection

Click **“Test Connection”** to validate that your source credentials are correct and the system can access the data.

> ⚠️ Common issues include invalid credentials, incorrect hostnames, or firewall rules blocking access.

<img alt="title" />

***

## Step 4: Save the Source

After successful testing:

* Click **Finish** to finalize the connection.
* The source will now appear under **Data Sources** in your account.

<img alt="title" />

***

## Step 5: Next Steps — Use the Source

Once added, your data source can be used to:

* Create **Data Models** (via SQL editor, dbt, or table selector)
* Build **Syncs** to move transformed data into downstream destinations
* Enable AI apps to reference live or transformed business data

> 📘 Refer to the [Data Modeling](../data-activation/data-modelling) section to begin querying your connected source.

***

## ✅ You're All Set!

Your data source is now ready for activation. Use it to power AI pipelines, syncs, and application-level insights.


# Introduction
Source: https://docs.squared.ai/guides/core-concepts



The core concepts of data movement in AI Squared are the foundation of your data journey. They include Sources, Destinations, Models, and Syncs. Understanding these concepts is crucial to building a robust data pipeline.

<img alt="Hero Light" />

## Sources: The Foundation of Data

### Overview

Sources are the starting points of your data journey. It's where all your data is stored and where AI Squared pulls data from.

<img alt="Hero Light" />

These can be:

* **Data Warehouses**: For example, `Snowflake` `Google BigQuery` and `Amazon Redshift`
* **Databases and Files**: Including traditional databases, `CSV files`, `SFTP`

### Adding a Source

To integrate a source with AI Squared, navigate to the Sources overview page and select 'Add source'.

## Destinations: Where Data Finds Value

### Overview

'Destinations' in AI Squared are business tools where you want to send your data stored in sources.

<img alt="Hero Light" />

These can be:

* **CRM Systems**: Like Salesforce, HubSpot, etc.
* **Advertising Platforms**: Such as Google Ads, Facebook Ads, etc.
* **Marketing Tools**: Braze and Klaviyo, for example

### Integrating a Destination

Add a destination by going to the Destinations page and clicking 'Add destination'.

## Models: Shaping Your Data

### Overview

'Models' in AI Squared determine the data you wish to sync from a source to a destination. They are the building blocks of your data pipeline.

<img alt="Hero Light" />

They can be defined through:

* **SQL Editor**: For customized queries
* **Visual Table Selector**: For intuitive interface
* **Existing dbt Models or Looker Looks**: Leveraging pre-built models

### Importance of a Unique Primary Key

Every model must have a unique primary key to ensure each data entry is distinct, crucial for data tracking and updating.

## Syncs: Customizing Data Flow

### Overview

'Syncs' in AI Squared helps you move data from sources to destinations. They help you in mapping the data from your models to the destination.

<img alt="Hero Light" />

There are two types of syncs:

* **Full Refresh Sync**: All data is synced from the source to the destination.
* **Incremental Sync**: Only the new or updated data is synced.


# Overview
Source: https://docs.squared.ai/guides/data-modelling/models/overview



## Introduction

**Models** are designed to define and organize data, simplifying the process of querying from various sources.

<img alt="Hero Light" />

This guide outlines the process of creating a model, from selecting a data source to defining the model using various methods such as SQL queries, table selectors, or dbt models.

## Understanding the Model Creation Process

Creating a model in AI Squared involves a series of steps designed to streamline the organization of your data for efficient querying. This overview will guide you through each step of the process.

### Step 1: Navigate to the Models Section

To start defining a model:

1. Access the AI Squared dashboard.
2. Look for the `Define` menu on the sidebar and click on the `Models` section.

### Step 2: Add a New Model

Once you log in to the AI Squared platform, you can access the Models section to create, manage, and monitor your models.

1. Click on the `Add Model` button to initiate the model creation process.

2. Select SQL Query, Table Selector, or dbt Model as the method to define your model.

### Step 3: Select a Data Source

1. Choose from the list of existing connected data warehouse sources. This source will be the foundation for your model.

<img alt="Hero Light" />

### Step 4: Select a Modeling Method

Based on your requirements, select one of the following modeling methods:

1. **SQL Query**: Define your model directly using an SQL query.
2. **Table Selector**: For a straightforward, visual approach to model building.
3. **dbt Model**: Ideal for advanced data transformation, leveraging the dbt framework.

<img alt="Hero Light" />

### Step 5: Define Your Model

If you selected the SQL Query method:

1. Write your SQL query in the provided field.
2. Use the `Run Query` option to preview the results and ensure accuracy.

<img alt="Hero Light" />

### Step 6: Finalize Your Model

Complete the model setup by:

1. Adding a name and a brief description for your model. This helps in identifying and managing your models within AI Squared.

<img alt="Hero Light" />

#### Unique Primary Key Requirement

* **Essential Configuration**:
  Every model in AI Squared must be configured with a unique primary key.
  This primary key is pivotal for uniquely identifying each record in your dataset.

* **Configuring the Primary Key**:

  * During the final step of model creation, select a column that holds unique values from your dataset.

  <Tip>Ensuring the uniqueness of this primary key is crucial for the integrity and accuracy of data synchronization.</Tip>

* **Importance of a Unique Key**:
  * A unique primary key is essential for effectively managing data synchronization.
  * It enables the system to track and sync only the new or updated data to the designated destinations, ensuring data consistency and reducing redundancy.

After completing these steps, your model will be set up and ready to use.


# SQL Editor
Source: https://docs.squared.ai/guides/data-modelling/models/sql

SQL Editor for Data Modeling in AI Squared

## Overview

AI Squared's SQL Editor allows you to define and manage your data models directly through SQL queries. This powerful tool supports native SQL commands compatible with your data warehouse, enabling you to seamlessly model your data.

## Creating a Model with the SQL Editor

### Starting with a Query

Begin by writing a SQL query to define your model. For instance, if using a typical eCommerce dataset, you might start with a query like:

```sql theme={null}
SELECT * FROM sales_data.customers
```

### Previewing Your Data

Click the `Preview` button to review the first 100 rows of your data. This step ensures the query fetches the expected data. After verifying, proceed by clicking `Continue`.

<Tip>**Important Note:**  The model cannot be saved if the query is incorrect or yields no results.</Tip>

### Configuring Model Details

Finalize your model by:

* Naming the model descriptively.
* Choosing a column as the Primary Key.

### Completing the Setup

Finish your model setup by clicking the `Finish` button.

## Unique Primary Key Requirement

Every model requires a unique primary key. If no unique column exists, consider:

* Removing duplicate rows.
* Creating a composite column for the primary key.

## Handling Duplicate Data

To filter duplicates, use a `GROUP BY` clause in your SQL query. For instance:

```sql theme={null}
SELECT *
FROM customer_data
GROUP BY unique_identifier_column
```

## Composite Primary Keys

In scenarios where a unique primary key is not available, construct a composite key. Example:

```sql theme={null}
SELECT customer_id, 
       email, 
       purchase_date,
       MD5(CONCAT(customer_id, '-', email)) AS composite_key
FROM sales_data
```

## Saving a Model Without Current Results

To save a model expected to have future data:

```sql theme={null}
UNION ALL
SELECT NULL, NULL, NULL
```

Add this to your query to include a dummy row, ensuring the model can be saved.

## Excluding Rows with Null Values

To exclude rows with null values:

```sql theme={null}
SELECT *
FROM your_dataset
WHERE important_column1 IS NOT NULL AND important_column2 IS NOT NULL
```

Replace `important_column1`, `important_column2`, etc., with your relevant column names.


# Table Selector
Source: https://docs.squared.ai/guides/data-modelling/models/table-visualization



<Note>Watch out for this space, **Visual Table Selector** coming soon!</Note>


# Incremental - Cursor Field
Source: https://docs.squared.ai/guides/data-modelling/sync-modes/cursor-incremental

Incremental Cursor Field sync transfers only new or updated data, minimizing data transfer using a cursor field.

### Overview

Default Incremental Sync fetches all records from the source system and transfers only the new or updated ones to the destination. However, to optimize data transfer and reduce the number of duplicate fetches from the source, we implemented Incremental Sync with Cursor Field for those sources that support cursor fields

#### Cursor Field

A Cursor Field must be clearly defined within the dataset schema. It is identified based on its suitability for comparison and tracking changes over time.

* It serves as a marker to identify modified or added records since the previous sync.
* It facilitates efficient data retrieval by enabling the source to resume from where it left off during the last sync.

Note: Currently, only date fields are supported as Cursor Fields.

####

#### Sync Run 1

During the first sync run with the cursor field 'UpdatedAt', suppose we have the following data:
cursor field UpdatedAt value is 2024-04-20 10:00:00

| Name             | Plan | Updated At          |
| ---------------- | ---- | ------------------- |
| Charles Beaumont | free | 2024-04-20 10:00:00 |
| Eleanor Villiers | free | 2024-04-20 11:00:00 |

During this sync run, both Charles Beaumont's and Eleanor Villiers' records would meet the criteria since they both have an 'UpdatedAt' timestamp equal to '2024-04-20 10:00:00' or later. So, during the first sync run, both records would indeed be considered and fetched.

##### Query

```sql theme={null}
SELECT * FROM source_table
WHERE updated_at >= '2024-04-20 10:00:00';
```

#### Sync Run 2

Now cursor field UpdatedAt value is 2024-04-20 11:00:00
Suppose after some time, there are further updates in the source data:

| Name             | Plan | Updated At          |
| ---------------- | ---- | ------------------- |
| Charles Beaumont | free | 2024-04-20 10:00:00 |
| Eleanor Villiers | paid | 2024-04-21 10:00:00 |

During the second sync run with the same cursor field, only the records for Eleanor Villiers with 'Updated At' timestamp after the last sync would be fetched, ensuring minimal data transfer.

##### Query

```sql theme={null}
SELECT * FROM source_table
WHERE updated_at >= '2024-04-20 11:00:00';
```

#### Sync Run 3

If there are additional updates in the source data:
Now cursor field UpdatedAt value is 2024-04-21 10:00:00

| Name             | Plan | Updated At          |
| ---------------- | ---- | ------------------- |
| Charles Beaumont | paid | 2024-04-22 08:00:00 |
| Eleanor Villiers | pro  | 2024-04-22 09:00:00 |

During the third sync run with the same cursor field, only the records for Charles Beaumont and Eleanor Villiers with 'Updated At' timestamp after the last sync would be fetched, continuing the process of minimal data transfer.

##### Query

```sql theme={null}
SELECT * FROM source_table
WHERE updated_at >= '2024-04-21 10:00:00 ';
```

### Handling Ambiguity and Inclusive Cursors

When syncing data incrementally, we ensure at least one delivery. Limited cursor field granularity may cause sources to resend previously sent data. For example, if a cursor only tracks dates, distinguishing new from old data on the same day becomes unclear.

#### Scenario

Imagine sales transactions with a cursor field `transaction_date`. If we sync on April 1st and later sync on the same day, distinguishing new transactions becomes ambiguous. To mitigate this, we guarantee at least one delivery, allowing sources to resend data as needed.

### Known Limitations

Modifications to underlying records without updating the cursor field may result in updated records not being picked up by the Incremental sync as expected.

Edit or remove of cursor field can mess up tracking data changes, causing issues and data loss. So Don't change or remove the cursor field to keep sync smooth and reliable.


# Full Refresh
Source: https://docs.squared.ai/guides/data-modelling/sync-modes/full-refresh

Full Refresh syncs replace existing data with new data.

### Overview

The Full Refresh mode in AI Squared is a straightforward method used to sync data to a destination. It retrieves all available information from the source, regardless of whether it has been synced before. This mode is ideal for scenarios where you want to completely replace existing data in the destination with fresh data from the source.

In the Full Refresh mode, new syncs will replace all existing data in the destination table with the new data from the source. This ensures that the destination contains the most up-to-date information available from the source.

### Example Behavior

Consider the following scenario where we have a database table named `Users` in the destination:

#### Before Sync

| **id** | **name** | **email**                                     |
| ------ | -------- | --------------------------------------------- |
| 1      | Alice    | [alice@example.com](mailto:alice@example.com) |
| 2      | Bob      | [bob@example.com](mailto:bob@example.com)     |

#### New Data in Source

| **id** | **name** | **email**                                     |
| ------ | -------- | --------------------------------------------- |
| 1      | Alice    | [alice@example.com](mailto:alice@example.com) |
| 3      | Carol    | [carol@example.com](mailto:carol@example.com) |
| 4      | Dave     | [dave@example.com](mailto:dave@example.com)   |

#### After Sync

| **id** | **name** | **email**                                     |
| ------ | -------- | --------------------------------------------- |
| 1      | Alice    | [alice@example.com](mailto:alice@example.com) |
| 3      | Carol    | [carol@example.com](mailto:carol@example.com) |
| 4      | Dave     | [dave@example.com](mailto:dave@example.com)   |

In this example, notice how the previous user "Bob" is no longer present in the destination after the sync, and new users "Carol" and "Dave" have been added.


# Incremental
Source: https://docs.squared.ai/guides/data-modelling/sync-modes/incremental

Incremental sync only transfer new or updated data, minimizing data transfer

### Overview

Incremental syncing involves transferring only new or updated data, thus avoiding duplication of previously replicated data. This is achieved through deduplication using a unique primary key specified in the model. For initial syncs, it functions like a full refresh since all data is considered new.

### Example

### Initial State

Suppose the following records already exist in our source:

| Name             | Plan     | Updated At |
| ---------------- | -------- | ---------- |
| Charles Beaumont | freemium | 6789       |
| Eleanor Villiers | freemium | 6790       |

### First sync

In this sync, the delta contains an updated record for Charles:

| Name             | Plan     | Updated At |
| ---------------- | -------- | ---------- |
| Charles Beaumont | freemium | 6791       |

After this incremental sync, the data in the warehouse would now be:

| Name             | Plan     | Updated At |
| ---------------- | -------- | ---------- |
| Charles Beaumont | freemium | 6791       |
| Eleanor Villiers | freemium | 6790       |

### Second sync

Let's assume in the next delta both customers have upgraded to a paid plan:

| Name             | Plan | Updated At |
| ---------------- | ---- | ---------- |
| Charles Beaumont | paid | 6795       |
| Eleanor Villiers | paid | 6795       |

The final data at the destination after this update will be:

| Name             | Plan | Updated At |
| ---------------- | ---- | ---------- |
| Charles Beaumont | paid | 6795       |
| Eleanor Villiers | paid | 6795       |


# Overview
Source: https://docs.squared.ai/guides/data-modelling/syncs/overview



### Introduction

Syncs help in determining how the data appears in your destination. They are used to map the data from the source to the destination.

<img alt="Hero Light" />

In order to create a sync, you need to have a source and a destination. The source is the data that you want to sync and the destination is where you want to sync the data to.

### Types of Syncs

There are two types of syncs:

1. **Full Refresh Syncs**: This sync type replaces all the data in the destination with the data from the source. This is useful when you want to replace all the data in the destination with the data from the source.

2. **Incremental Syncs**: This sync type only syncs the data that has changed since the last sync. This is useful when you want to sync only the data that has changed since the last sync.

### Important Concepts

1. **Streams**: Streams in AI Squared are referred to the destination APIs that you want to sync the data to. For example, If you want to Sync the data to Salesforce, then `Account`, `Contact`, `Opportunity` are the streams.


# Facebook Custom Audiences
Source: https://docs.squared.ai/guides/destinations/retl-destinations/adtech/facebook-ads



## Connect AI Squared to Facebook Custom Audiences

This guide will walk you through configuring the Facebook Custom Audiences Connector in AI Squared to manage your custom audiences effectively.

### Prerequisites

Before you begin, make sure you have the following:

1. **Get your [System User Token](https://developers.facebook.com/docs/marketing-api/system-users/overview) from Facebook Business Manager account:**

   * Log in to your Facebook Business Manager account.
   * Go to Business Settings > Users > System Users.
   * Click "Add" to create a new system user if needed.
   * After creating the system user, access its details.
   * Generate a system user token by clicking "Generate New Token."
   * Copy the token for later use in the authentication process.

2. **Access to a Facebook Business Manager account:**

   * If you don't have an account, create one at [business.facebook.com](https://business.facebook.com/) by following the sign-up instructions.

3. **Custom Audiences:**

   * Log in to your Facebook Business Manager account.
   * Navigate to the Audiences section under Business Tools.
   * Create new custom audiences or access existing ones.

### Steps

### Authentication

Authentication is supported via two methods: System user token and Log in with Facebook account.

1. **System User Token:**

   * **[access\_token](https://developers.facebook.com/docs/marketing-api/system-users/create-retrieve-update)**: Obtain a system user token from your Facebook Business Manager account in step 1 of the prerequisites.
   * **[ad\_account\_id](https://www.facebook.com/business/help/1492627900875762)**: Paste the system user token into the provided authentication field in AI Squared.
   * **[audience\_id](https://developers.facebook.com/docs/marketing-api/reference/custom-audience/)**: Obtain the audience ID from step 3 of the prerequisites.

2. **Log in with Facebook Account**

   *Coming soon*

### Supported Sync Modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |


# Google Ads
Source: https://docs.squared.ai/guides/destinations/retl-destinations/adtech/google-ads





# Amplitude
Source: https://docs.squared.ai/guides/destinations/retl-destinations/analytics/amplitude





# Databricks
Source: https://docs.squared.ai/guides/destinations/retl-destinations/analytics/databricks_lakehouse



## Connect AI Squared to Databricks

This guide will help you configure the Databricks Connector in AI Squared to access and use your Databricks data.

### Prerequisites

Before proceeding, ensure you have the necessary Host URL and API Token from Databricks.

## Step-by-Step Guide to Connect to Databricks

## Step 1: Navigate to Databricks

Start by logging into your Databricks account and navigating to the Databricks workspace.

1. Sign in to your Databricks account at [Databricks Login](https://accounts.cloud.databricks.com/login).
2. Once logged in, you will be directed to the Databricks workspace dashboard.

## Step 2: Locate Databricks Host URL and API Token

Once you're logged into Databricks, you'll find the necessary configuration details:

1. **Host URL:**
   * The Host URL is the first part of the URL when you log into your Databricks. It will look something like `https://<your-instance>.databricks.com`.

2. **API Token:**
   * Click on your user icon in the upper right corner and select "Settings" from the dropdown menu.
   * In the Settings page, navigate to the "Developer" tab.
   * Here, you can create a new Access Token by clicking on Manage then "Generate New Token." Give it a name and set the expiration duration.
   * Once the token is generated, copy it as it will be required for configuring the connector. **Note:** This token will only be shown once, so make sure to store it securely.

<Frame>
  <img />
</Frame>

## Step 3: Test the Databricks Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Databricks from the AI Squared platform to ensure a connection is made.

By following these steps, you’ve successfully set up a Databricks destination connector in AI Squared. You can now efficiently transfer data to your Databricks endpoint for storage or further distribution within AI Squared.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

Follow these steps to configure and test your Databricks connector successfully.


# Google Analytics
Source: https://docs.squared.ai/guides/destinations/retl-destinations/analytics/google-analytics





# Mixpanel
Source: https://docs.squared.ai/guides/destinations/retl-destinations/analytics/mixpanel





# HubSpot
Source: https://docs.squared.ai/guides/destinations/retl-destinations/crm/hubspot

HubSpot is a customer platform with all the software, integrations, and resources you need to connect your marketing, sales, content management, and customer service. HubSpot's connected platform enables you to grow your business faster by focusing on what matters most: your customers.

## Hubspot Connector Configuration and Credential Retrieval Guide

### Prerequisite Requirements

Before initiating the Hubspot connector setup, ensure you have an created an Hubspot developer account.
This setup requires us to create an private app in Hubspot with [superuser admin access](https://knowledge.hubspot.com/user-management/hubspot-user-permissions-guide#super-admin).

<Tip>
  [Hubspot Developer
  Signup](https://app.hubspot.com/signup-v2/developers/step/join-hubspot?hubs_signup-url=developers.hubspot.com/get-started\&hubs_signup-cta=developers-getstarted-app&_ga=2.53325096.1868562849.1588606909-500942594.1573763828).
</Tip>

### Destination Setup

As mentioned earlier, this setup requires us to create an [private app](https://developers.hubspot.com/docs/api/private-apps) in Hubspot with superuser admin access.

HubSpot private applications facilitate interaction with your HubSpot account's data through the platform's APIs. Granular control over individual app permissions allows you to specify the data each app can access or modify. This process generates a unique access token for each app, ensuring secure authentication.

<Accordion title="Create a Private App" icon="lock">
  For AI Squared Open Source, we hubspot Private App Access Token for api authentication.

  <Steps>
    <Step title="Locate the Private Apps Section">
      Within your HubSpot account, access the settings menu from the main navigation bar. Navigate through the left sidebar menu to Integrations > Private Apps.

      <Frame>
        <img />
      </Frame>
    </Step>

    <Step title="Initiate App Creation">
      Click the Create Private App button.

      <Frame>
        <img />
      </Frame>
    </Step>

    <Step title="Define App Information">
      On the Basic Info tab, configure your app's details:

      * Name: Assign a descriptive name for your app.
      * Logo: Upload a square image to visually represent your app (optional).
      * Description: Provide a brief explanation of your app's functionality.
    </Step>

    <Step title="Specify Access Permissions">
      Navigate to the Scopes tab and select the desired access level (Write) for each data element your app requires. Utilize the search bar to locate specific scopes.

      <Frame>
        <img />
      </Frame>
    </Step>

    <Step title="Finalize Creation">
      After configuration, click Create app in the top right corner.
    </Step>

    <Step title="Review Access Token">
      A dialog box will display your app's unique access token. Click Continue creating to proceed.

      <Frame>
        <img />
      </Frame>
    </Step>

    <Step title="Utilize the App">
      Once created, you can leverage the access token to setup hubspot in AI Squared destination section.
    </Step>
  </Steps>
</Accordion>


# Microsoft Dynamics
Source: https://docs.squared.ai/guides/destinations/retl-destinations/crm/microsoft_dynamics



## Connect AI Squared to Microsoft Dynamics

This guide will help you configure the Microsoft Dynamics Connector in AI Squared to access and transfer data to your Dynamics CRM.

### Prerequisites

Before proceeding, ensure you have the necessary instance URL, tenant ID, application ID, and client secret from Azure Portal.

## Step-by-Step Guide to Connect to Microsoft Dynamics

## Step 1: Navigate to Azure Portal to create App Registration

Start by logging into your Azure Portal.

<Frame>
  <img />
</Frame>

1. Navigate to the Azure Portal and go to [App Registration](https://portal.azure.com/#home).
2. Create a new registration
3. Name the app registration and select single or multi-tenant, depending on the needs
4. You can disregard the Redirect URI for now
5. From the Overview screen, make note of the Application ID and the Tenant ID
6. Under Manage on the left panel, select API Permissions
7. Scroll down and select Dynamics CRM
8. Check all available permissions and click Add Permissions
9. Under Manage on the left panel, select Certificates and secrets
10. Create a new client secret and make note of the Client Secret ID and the Client Secret Value

<Frame>
  <img />
</Frame>

## Step 2: Add App Registration as Application User for Dynamics 365

When App Registration is created:

1. Navigate to the Application Users screen in Power Platform
2. At the top of the screen, select New App User
3. When the New App User blade opens, click Add an app
4. Find the name of your new App Registration and select Add
5. Select the appropriate Business Unit
6. Select appropriate Security Roles for your app, depending on its access needs
7. Click Create

## Step 3: Configure Microsoft Dynamics Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **Instance URL:** The URL of your Microsoft Dynamics instance (e.g., https\://**instance\_url**.crm.dynamics.com).
* **Application ID:** The unique identifier for your registered Azure AD application.
* **tenant ID:** The unique identifier of your Azure AD directory (tenant) where the Dynamics instance is hosted.
* **Client Secret:** The corresponding Secret Access Key.

## Step 4: Test the Microsoft Dynamics Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Microsoft Dynamics from your application to ensure everything is set up correctly.

By following these steps, you’ve successfully set up an Microsoft Dynamics destination connector in AI Squared. You can now efficiently transfer data to your Microsoft Dynamics endpoint for storage or further distribution within AI Squared.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |


# Odoo
Source: https://docs.squared.ai/guides/destinations/retl-destinations/crm/odoo



## Connect AI Squared to Odoo

This guide will help you configure the Odoo Connector in AI Squared to access and transfer data to your Odoo instance.

### Prerequisites

Before initiating the Odoo connector setup, ensure you have the appropriate Odoo edition.
This connector uses Odoo's <a href="https://www.odoo.com/documentation/18.0/developer/reference/external_api.html">External API</a>,
which is only available on <i>Custom</i> Odoo pricing plans. Access to the external API is not available on
<i>One App Free</i> or <i>Standard</i> plans.

## Step-by-Step Guide to Connect to your Odoo server.

Before proceeding, ensure you have the URL to the Odoo instance, the database name, the account username and account password.

### Step 1: Configure Odoo Connector in Your Application

Enter the following information in your application:

* **URL**: The URL where the Odoo instance is hosted.

* **Database**: The Odoo database name where your data is stored.

* **Username**: The username of the account you use to log into Odoo.

* **Password**: The password of the account you use to log into Odoo.

### Step 2: Test the Odoo Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Odoo from your application to ensure everything is setup correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your Odoo connector is now configured.

## Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |


# Salesforce
Source: https://docs.squared.ai/guides/destinations/retl-destinations/crm/salesforce



## Salesforce Connector Configuration and Credential Retrieval Guide

### Prerequisite Requirements

Before initiating the Salesforce connector setup, ensure you have an appropriate Salesforce edition. This setup requires either the Enterprise edition of Salesforce, the Professional Edition with an API access add-on, or the Developer edition. For further information on API access within Salesforce, please consult the [Salesforce documentation](https://developer.salesforce.com/docs/).

<Tip>
  If you need a Developer edition of Salesforce, you can register at [Salesforce
  Developer Signup](https://developer.salesforce.com/signup).
</Tip>

### Destination Setup

<AccordionGroup>
  <Accordion title="Create a Connected App" icon="key">
    For AI Squared Open Source, certain OAuth credentials are necessary for authentication. These credentials include:

    * Access Token
    * Refresh Token
    * Instance URL
    * Client ID
    * Client Secret

    <Steps>
      <Step title="Login">
        Start by logging into your Salesforce account with admin rights. Look for a Setup option in the menu at the top-right corner of the screen and click on it.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="App Manager">
        On the left side of the screen, you'll see a menu. Click on Apps, then App Manager.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="New Connected App">
        Find a button that says New Connected App at the top right and click it.
      </Step>

      <Step title="Fill the details">
        You'll be taken to a page to set up your new app.
        Here, you need to fill in some basic info: the name you want for your app, its API name (a technical identifier), and your email address.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Enable OAuth Settings">
        Now, look for a section named API (Enable OAuth Settings) and check the box for Enable OAuth Settings.
        There’s a box for a Callback URL; type in [https://login.salesforce.com/](https://login.salesforce.com/) there.
        You also need to pick some permissions from a list called Selected OAuth Scopes. Choose these: Access and manage your data (api), Perform requests on your behalf at any time (refresh\_token, offline\_access), Provide access to your data via the Web (web), and then add them to your app settings.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Save">
        Click Save to keep your new app's settings.
      </Step>

      <Step title="Apps > App Manager">
        Go back to where all your apps are listed (under Apps > App Manager), find the app you just created, and click Manage next to it.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="OAuth policies">
        On the next screen, click Edit.
        There’s an option for OAuth policies; under Permitted Users, choose All users may self-authorize. Save your changes.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="View App">
        Head back to your app list, find your new app again, and this time click View.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Save Permissions">
        Once more, go to the API (Enable OAuth Settings) section. Click on Manage Consumer Details.
        You need to write down two things: the Consumer Key and Consumer Secret.
        These are important because you'll use them to connect Salesforce.

        <Frame>
          <img />
        </Frame>
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Obtain OAuth Credentials" icon="key">
    <Steps>
      <Step title="Getting the Code">
        First, open Salesforce in your preferred web browser.
        To get the code, open a new tab and type in a special web address (URL).
        You'll need to change **CONSUMER\_KEY** to the Consumer Key you noted earlier.
        Also, replace **INSTANCE\_URL** with your specific Salesforce instance name (for example, ours is multiwoven-dev in [https://multiwoven-dev.develop.lightning.force.com/](https://multiwoven-dev.develop.lightning.force.com/)).

        ```
          https://INSTANCE_URL.salesforce.com/services/oauth2/authorize?response_type=code&client_id=CONSUMER_KEY&redirect_uri=https://login.salesforce.com/
        ```

        If you see any alerts asking for permission, go ahead and allow them.
        After that, the browser will take you to a new webpage.
        Pay attention to this new web address because it contains the code you need.
        Save the code available in the new URL as shown in the below example.

        ```
          https://login.salesforce.com/services/oauth2/success?code=aPrx0jWjRo8KRXs42SX1Q7A5ckVpD9lSAvxdKnJUApCpikQQZf.YFm4bHNDUlgiG_PHwWQ%3D%3Dclient_id = "3MVG9pRzvMkjMb6kugcl2xWhaCVwiZPwg17wZSM42kf6HqY4jmw6ocKKoYYLz4ztHqM1vWxMbZB6sxQQU"
        ```
      </Step>

      <Step title="Getting the Access Token and Refresh Token">
        Now, you'll use a tool called curl to ask for more keys, known as tokens.
        You'll type a command into your computer that includes the special code you just got.
        Remember to replace **CODE** with your code, and also replace **CONSUMER\_KEY** and **CONSUMER\_SECRET** with the details you saved from when you set up the app in Salesforce.

        ```
        curl -X POST https://INSTANCE_URL.salesforce.com/services/oauth2/token?code=CODE&grant_type=authorization_code&client_id=CONSUMER_KEY&client_secret=CONSUMER_SECRET&redirect_uri=https://login.salesforce.com/
        ```

        After you send this command, you'll get back a response that includes your access\_token and refresh\_token.
        These tokens are what you'll use to securely access Salesforce data.

        ```
          {
            "access_token": "access_token",
            "refresh_token": "refresh_token",
            "signature": "signature",
            "scope": "scopes",
            "id_token": "id_token",
            "instance_url": "https://multiwoven-dev.develop.my.salesforce.com",
            "id": "id",
            "token_type": "Bearer",
            "issued_at": "1707415379555",
            "api_instance_url": "https://api.salesforce.com"
        }
        ```

        This way, you’re essentially getting the necessary permissions and access to work with Salesforce data in more detail.
      </Step>
    </Steps>
  </Accordion>
</AccordionGroup>

<Accordion title="Supported Sync" icon="arrows-rotate">
  | Mode             | Supported (Yes/No/Coming soon) |
  | ---------------- | ------------------------------ |
  | Incremental sync | Yes                            |
  | Full refresh     | Coming soon                    |
</Accordion>

<Accordion title="Supported Streams">
  | Stream                                                                                                                             | Supported (Yes/No/Coming soon) |
  | ---------------------------------------------------------------------------------------------------------------------------------- | ------------------------------ |
  | [Account](https://developer.salesforce.com/docs/atlas.en-us.object_reference.meta/object_reference/sforce_api_objects_account.htm) | Yes                            |
</Accordion>


# Zoho
Source: https://docs.squared.ai/guides/destinations/retl-destinations/crm/zoho





# Intercom
Source: https://docs.squared.ai/guides/destinations/retl-destinations/customer-support/intercom





# Zendesk
Source: https://docs.squared.ai/guides/destinations/retl-destinations/customer-support/zendesk

Zendesk is a customer service software and support ticketing system. Zendesk's connected platform enables you to improve customer relationships by providing seamless support and comprehensive customer insights.

## Zendesk Connector Configuration and Credential Retrieval Guide

### Prerequisite Requirements

Before initiating the Zendesk connector setup, ensure you have an active Zendesk account with admin privileges. This setup requires you to use your Zendesk username and password for authentication.

<Tip>
  [Zendesk Developer Signup](https://www.zendesk.com/signup)
</Tip>

### Destination Setup

As mentioned earlier, this setup requires your Zendesk username and password with admin access for authentication.

<Accordion title="Configure Zendesk Credentials" icon="key">
  For Multiwoven Open Source, we use Zendesk username and password for authentication.

  <Steps>
    <Step title="Access the Admin Console">
      Log into your Zendesk Developer account and navigate to the Admin Center by clicking on the gear icon in the sidebar.

      <Frame>
        <img alt="Zendesk Admin Console" />
      </Frame>
    </Step>

    <Step title="Enable Password Access">
      Within the Admin Center, go to Channels > API. Ensure that the Password access is enabled by toggling the switch.

      <Frame>
        <img alt="Zendesk Auth Enablement" />
      </Frame>
    </Step>

    <Step title="Utilize the Credentials">
      Ensure you have your Zendesk username and password. The username is typically your email address associated with the Zendesk account. Once you have your credentials, you can use the username and password to set up Zendesk in the Multiwoven destination section.
    </Step>
  </Steps>
</Accordion>


# MariaDB
Source: https://docs.squared.ai/guides/destinations/retl-destinations/database/maria_db



## Connect AI Squared to MariaDB

This guide will help you configure the MariaDB Connector in AI Squared to access and transfer data to your MariaDB database.

### Prerequisites

Before proceeding, ensure you have the necessary host, port, username, password, and database name from your MariaDB server.

## Step-by-Step Guide to Connect to MariaDB

## Step 1: Navigate to MariaDB Console

Start by logging into your MariaDB Management Console and navigating to the MariaDB service.

1. Sign in to your MariaDB account on your local server or through the MariaDB Enterprise interface.
2. In the MariaDB console, select the service you want to connect to.

## Step 2: Locate MariaDB Configuration Details

Once you're in the MariaDB console, you'll find the necessary configuration details:

1. **Host and Port:**
   * For local servers, the host is typically `localhost` and the default port is `3306`.
   * For remote servers, check your server settings or consult with your database administrator to get the correct host and port.
   * Note down the host and port as they will be used to connect to your MariaDB service.

2. **Username and Password:**
   * In the MariaDB console, you can find or create a user with the necessary permissions to access the database.
   * Note down the username and password as they are required for the connection.

3. **Database Name:**
   * List the available databases using the command `SHOW DATABASES;` in the MariaDB console.
   * Choose the database you want to connect to and note down its name.

## Step 3: Configure MariaDB Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **Host:** The host of your MariaDB service.
* **Port:** The port number of your MariaDB service.
* **Username:** Your MariaDB service username.
* **Password:** The corresponding password for the username.
* **Database:** The name of the database you want to connect to.

## Step 4: Test the MariaDB Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to MariaDB from your application to ensure everything is set up correctly.

By following these steps, you’ve successfully set up an MariaDB destination connector in AI Squared. You can now efficiently transfer data to your MariaDB endpoint for storage or further distribution within AI Squared.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

This guide will help you seamlessly connect your AI Squared application to MariaDB, enabling you to leverage your database's full potential.


# MicrosoftSQL
Source: https://docs.squared.ai/guides/destinations/retl-destinations/database/ms_sql

Microsoft SQL Server (Structured Query Language) is a proprietary relational database management system developed by Microsoft. As a database server, it is a software product with the primary function of storing and retrieving data as requested by other software applications—which may run either on the same computer or on another computer across a network.

## Setting MS SQL Connector in AI Squared

To integrate Microsoft SQL with AI Squared, you need to establish a destination connector.
This connector will enable AI Squared to load data from various sources efficiently.
Below are the steps to set up the MS SQL Destination connector in AI Squared:

### Step 1: Access AI Squared

* Log in to your AI Squared account.
* Navigate to the `destinations` section where you can manage your destinations.

### Step 2: Create a New destination Connector

* Click on the `Add destination` button.
* Select `Microsoft SQL` from the list of available destination types.

### Step 3: Configure Connection Settings

You'll need to provide the following details to establish a connection between AI Squared and your MicrosoftSQL Database:

`Host` The hostname or IP address of the server where your MicrosoftSQL database is hosted.

`Port` The port number on which your MicrosoftSQL server is listening (default is 1433).

`Database` The name of the database you want to connect to.

`Schema` The schema within your MicrosoftSQL database you wish to access. The default schema for Microsoft SQL Server is dbo.

`Username` The username used to access the database.

`Password` The password associated with the username.

Enter these details in the respective fields on the connector configuration page and press continue.

### Step 4: Test the Connection

* Once you've entered the necessary information. The next step is automated **Test Connection** feature to ensure that AI Squared can successfully connect to your MicrosoftSQL database.
* If the test is successful, you'll receive a confirmation message. If not, double-check your entered details for any errors.

### Step 5: Finalize the destination Connector Setup

* Save the connector settings to establish the destination connection.

## Notes

* The Azure SQL Database firewall is a security feature that protects customer data by blocking access to the SQL Database server by default. To allow access, users can configure firewall rules to specify which IP addresses are permitted to access the database. [https://learn.microsoft.com/en-us/azure/azure-sql/database/firewall-configure?view=azuresql](https://learn.microsoft.com/en-us/azure/azure-sql/database/firewall-configure?view=azuresql)

* Your credentials must be able to: Add/update/delete rows in your sync's table.

* Get the connection information you need to connect to the database in Azure SQL Database. You'll need the fully qualified server name or host name, database name, and login information for the connection setup.
  * Sign in to the Azure portal.
  * Navigate to the SQL Databases or SQL Managed Instances page.
  * On the Overview page, review the fully qualified server name next to Server name for the database in Azure SQL Database or the fully qualified server name (or IP address) next to Host for an Azure SQL Managed Instance or SQL Server on Azure VM. To copy the server name or host name, hover over it and select the Copy icon.
  * More info at [https://learn.microsoft.com/en-us/azure/azure-sql/database/connect-query-content-reference-guide?view=azuresql](https://learn.microsoft.com/en-us/azure/azure-sql/database/connect-query-content-reference-guide?view=azuresql)


# Oracle
Source: https://docs.squared.ai/guides/destinations/retl-destinations/database/oracle



## Connect AI Squared to Oracle

This guide will help you configure the Oracle Connector in AI Squared to access and transfer data to your Oracle database.

### Prerequisites

Before proceeding, ensure you have the necessary host, port, SID or service name, username, and password from your Oracle database.

## Step-by-Step Guide to Connect to Oracle database

### Step 1: Locate Oracle database Configuration Details

In your Oracle database, you'll need to find the necessary configuration details:

1. **Host and Port:**
   * For local servers, the host is typically `localhost` and the default port is `1521`.
   * For remote servers, check your server settings or consult with your database administrator to get the correct host and port.
   * Note down the host and port as they will be used to connect to your Oracle database.

2. **SID or Service Name:**
   * To find your SID or Service name:
     1. **Using SQL\*Plus or SQL Developer:**
        * Connect to your Oracle database using SQL\*Plus or SQL Developer.
        * Execute the following query:
          ```sql theme={null}
          select instance from v$thread
          ```
          or
          ```sql theme={null}
          SELECT sys_context('userenv', 'service_name') AS service_name FROM dual;
          ```
        * The result will display the SID or service name of your Oracle database.
     2. **Checking the TNSNAMES.ORA File:**
        * Locate and open the `tnsnames.ora` file on your system. This file is usually found in the `ORACLE_HOME/network/admin` directory.
        * Look for the entry corresponding to your database connection. The `SERVICE_NAME` or `SID` will be listed within this entry.
     * Note down the SID or service name as it will be used to connect to your Oracle database.

3. **Username and Password:**
   * In the Oracle, you can find or create a user with the necessary permissions to access the database.
   * Note down the username and password as it will be used to connect to your Oracle database.

### Step 2: Configure Oracle Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **Host:** The host of your Oracle database.
* **Port:** The port number of your Oracle database.
* **SID:** The SID or service name you want to connect to.
* **Username:** Your Oracle username.
* **Password:** The corresponding password for the username.

### Step 3: Test the Oracle Database Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Oracle database from your application to ensure everything is set up correctly.

By following these steps, you’ve successfully set up an Oracle database destination connector in AI Squared. You can now efficiently transfer data to your Oracle database for storage or further distribution within AI Squared.

## Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

This guide will help you seamlessly connect your AI Squared application to Oracle Database, enabling you to leverage your database's full potential.


# Pinecone DB
Source: https://docs.squared.ai/guides/destinations/retl-destinations/database/pinecone_db



## Connect AI Squared to Pinecone DB

This guide will help you configure the Pinecone DB Connector in AI Squared to access and transfer data to your Pinecone database.

### Prerequisites

Before proceeding, ensure you have the required API key, region, index name, model name, and namespace from your Pinecone database.

## Step-by-Step Guide to Connect to your Pinecone Database

## Step 1: Navigate to Pinecone Database

Start by logging into your Pinecone Console.

1. Sign in to your Pinecone account at [Pinecone Console](https://app.pinecone.io/).

## Step 2: Locate Pinecone Configuration Details

Once you're in the Pinecone console, you'll find the necessary configuration details:

1. **API Key:**
   * Click the API Keys tab on the left side the Pinecone Console.
   * 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.
     <Frame>
       <img />
     </Frame>

2. **Region and Index Name:**
   * Click on the Database tab then Indexes to see your list of Indexes.
   * Click on your selected Index.
   * The following details, region and index name will be shown on this page.
     <Frame>
       <img />
     </Frame>

## Step 3: Configure Pinecone DB Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **API Key:** The authentication key used to access your Pinecone project securely.
* **Region:** The region where your Pinecone index is hosted.
* **Index Name:** The name of the Pinecone index where your vectors will be stored or queried.

## Step 4: Test the Pinecone DB Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Pinecone from your application to ensure everything is set up correctly.

By following these steps, you’ve successfully set up an Pinecone destination connector in AI Squared. You can now efficiently transfer data to your Pinecone endpoint for storage or further distribution within AI Squared.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

This guide will help you seamlessly connect your AI Squared application to Pinecone, enabling you to leverage your database's full potential.


# PostgreSQL
Source: https://docs.squared.ai/guides/destinations/retl-destinations/database/postgresql

PostgreSQL popularly known as Postgres, is a powerful, open-source object-relational database system that uses and extends the SQL language combined with many features that safely store and scale data workloads.

## Setting Up a destination Connector in AI Squared

To integrate PostgreSQL with AI Squared, you need to establish a destination connector.
This connector will enable AI Squared to extract data from your PostgreSQL database efficiently.
Below are the steps to set up the destination connector in AI Squared:

### Step 1: Access AI Squared

* Log in to your AI Squared account.
* Navigate to the `destinations` section where you can manage your data destinations.

### Step 2: Create a New destination Connector

* Click on the `Add destination` button.
* Select `PostgreSQL` from the list of available destination types.

### Step 3: Configure Connection Settings

You'll need to provide the following details to establish a connection between AI Squared and your PostgreSQL database:

`Host` The hostname or IP address of the server where your PostgreSQL database is hosted.

`Port` The port number on which your PostgreSQL server is listening (default is 5432).

`Database` The name of the database you want to connect to.

`Schema` The schema within your PostgreSQL database you wish to access.

`Username` The username used to access the database.

`Password` The password associated with the username.

Enter these details in the respective fields on the connector configuration page and press continue.

### Step 4: Test the Connection

* Once you've entered the necessary information. The next step is automated **Test Connection** feature to ensure that AI Squared can successfully connect to your PostgreSQL database.
* If the test is successful, you'll receive a confirmation message. If not, double-check your entered details for any errors.

### Step 5: Finalize the destination Connector Setup

* Save the connector settings to establish the destination connection.

## Performance Features

### Batch Write Support

The PostgreSQL destination connector supports high-performance batch writes with the following capabilities:

* **Bulk Operations**: Writes up to 10,000 records per batch using efficient bulk INSERT and UPSERT operations
* **Automatic Fallback**: If a bulk operation fails, the connector automatically falls back to individual record writes to ensure data integrity
* **Connection Management**: Database connections are properly closed after each write operation to prevent resource leaks
* **Upsert Support**: For update operations, the connector uses PostgreSQL's `ON CONFLICT` clause to perform efficient upserts based on primary keys

This batch support significantly improves write performance when syncing large volumes of data to PostgreSQL destinations.

### Conclusion

By following these steps, you've successfully set up a PostgreSQL destination connector in AI Squared.


# Qdrant
Source: https://docs.squared.ai/guides/destinations/retl-destinations/database/qdrant



## Connect AI Squared to Qdrant

This guide will help you configure the Qdrant Connector in AI Squared to access and transfer data to your Qdrant collection.

### Prerequisites

Before proceeding, ensure you have your API url and API key.

## Step-by-Step Guide to Connect to your Qdrant collection

## Step 1: Navigate to Qdrant

Start by logging into your Qdrant account.

1. Sign in to your Qdrant account at [Qdrant Account](https://login.cloud.qdrant.io/u/login/identifier?state=hKFo2SB6bDNQQTlydWFFZnpySEc0TXk1QlVWVHJ0Tk9MTDNyeqFur3VuaXZlcnNhbC1sb2dpbqN0aWTZIDVCYm9qV010WXVRSXZvZVFMMkFiLW8wXzl5SkhvZnM4o2NpZNkgckkxd2NPUEhPTWRlSHVUeDR4MWtGMEtGZFE3d25lemc)

<Frame>
  <img />
</Frame>

2. Select Clusters from the side bar.

<Frame>
  <img />
</Frame>

3. Select your cluster to see more details.

<Frame>
  <img />
</Frame>

## Step 2: Locate Qdrant Configuration Details

Once in your Qdrant cluster, you'll find the necessary configuration details:

**API Url:**

* Click on the Overview tab, and scroll down to the Use the API section.
* Copy the Endpoint URL (API Url).

<Frame>
  <img />
</Frame>

**API Key:**

* Click on the API Keys tab.
* If you haven't created an API key before, click on "Create" to generate a new one. Make sure to copy the API Key as they are shown only once.

<Frame>
  <img />
</Frame>

## Step 3: Configure qdrant Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **API Key:** The authentication key used to access your Qdrant cluster.
* **API Url:** The endpoint where your Qdrant cluster is hosted.

## Step 4: Test the Qdrant Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Qdrant from your application to ensure everything is set up correctly.

By following these steps, you've successfully set up a Qdrant destination connector in AI Squared.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

This guide will help you seamlessly connect your AI Squared application to Qdrant, enabling you to leverage your cluster's full potential.


# Weaviate
Source: https://docs.squared.ai/guides/destinations/retl-destinations/database/weaviate

Connect AI Squared to Weaviate to sync vector data to your Weaviate collections.

## Connect AI Squared to Weaviate

This guide will help you configure the Weaviate Connector in AI Squared to access and transfer data to your Weaviate collection.

### Prerequisites

Before proceeding, ensure you have your API URL and API key.

## Step-by-Step Guide to Connect to your Weaviate collection

## Step 1: Navigate to Weaviate

Start by logging into your Weaviate account.

1. Sign in to your Weaviate account at [Weaviate Cloud Console](https://console.weaviate.cloud/)

<Frame>
  <img />
</Frame>

2. Select **Clusters** from the side bar.

<Frame>
  <img />
</Frame>

3. Select your cluster to see more details.

<Frame>
  <img />
</Frame>

## Step 2: Locate Weaviate Configuration Details

Once in your Weaviate cluster, you'll find the necessary configuration details:

**API URL:**

* Click on the **Details** tab of your cluster.
* Copy the **Cluster URL** (API URL).

<Frame>
  <img />
</Frame>

**API Key:**

* Click on the **API Keys** tab.
* If you haven't created an API key before, click on **Create** to generate a new one. Make sure to copy the API Key as it is shown only once.

<Frame>
  <img />
</Frame>

## Step 3: Configure Weaviate Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **API Key:** The authentication key used to access your Weaviate cluster.
* **API URL:** The endpoint where your Weaviate cluster is hosted.

## Step 4: Test the Weaviate Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Weaviate from your application to ensure everything is set up correctly.

By following these steps, you've successfully set up a Weaviate destination connector in AI Squared.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

## Performance features

### Batch write support

The Weaviate destination connector supports efficient batch writes with the following capabilities:

* **Batch operations**: Records are written in batches using Weaviate's batch create API for optimal performance
* **Upsert support**: When an `id` field is provided, the connector generates a deterministic UUID to enable upsert behavior, preventing duplicate records
* **Automatic type coercion**: Property values are automatically coerced to match the Weaviate collection schema (text, integer, number, boolean, and date types)
* **Vector support**: Each record can include a `vector` field containing embedding arrays for semantic search and AI-powered applications

### Schema discovery

The connector automatically discovers your Weaviate collections and their property schemas during sync configuration. Each collection stream includes:

| Field        | Description                                                     |
| ------------ | --------------------------------------------------------------- |
| `id`         | Optional string identifier for upsert behavior                  |
| `vector`     | Embedding vector array (array of floats)                        |
| `properties` | Object containing collection properties with auto-coerced types |


# Facebook product catalog
Source: https://docs.squared.ai/guides/destinations/retl-destinations/e-commerce/facebook-product-catalog





# Shopify
Source: https://docs.squared.ai/guides/destinations/retl-destinations/e-commerce/shopify





# Amazon S3
Source: https://docs.squared.ai/guides/destinations/retl-destinations/file-storage/amazon_s3



## Connect AI Squared to Amazon S3

This guide will help you configure the Amazon S3 Connector in AI Squared to access and transfer data to your S3 bucket.

### Prerequisites

Before proceeding, ensure you have the necessary personal access key, secret access key, region, bucket name, and file path from your S3 account.

## Step-by-Step Guide to Connect to Amazon S3

## 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.
     <Frame>
       <img />
     </Frame>

2. **Region:**
   * The AWS region can be selected from the top right corner of the AWS Management Console. Choose the region where your AWS Sagemaker resources is located and note down the region.
     <Frame>
       <img />
     </Frame>

3. **Bucket Name:**
   * The S3 Bucket name can be found by selecting "General purpose buckets" on the left hand corner of the S3 Console. From there select the bucket you want to use and note down its name.
     <Frame>
       <img />
     </Frame>

4. **File Path**
   * After select your S3 bucket you can create a folder where you want your file to be stored or use an exist one.
   <Frame>
     <img />
   </Frame>

## Step 3: Configure Amazon S3 Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **Personal Access Key:** Your AWS IAM user's Access Key ID.
* **Secret Access Key:** The corresponding Secret Access Key.
* **Region:** The AWS region where your Sagemaker resources are located.
* **Bucket Name:** The Amazon S3 Bucket you want to access.
* **File Path:** The Path to the directory where files will be written.
* **File Name:** The Name of the file to be written.

## Step 4: Test the Amazon S3 Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Amazon S3 from your application to ensure everything is set up correctly.

By following these steps, you’ve successfully set up an Amazon S3 destination connector in AI Squared. You can now efficiently transfer data to your Amazon S3 endpoint for storage or further distribution within AI Squared.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

This guide will help you seamlessly connect your AI Squared application to MariaDB, enabling you to leverage your database's full potential.


# SFTP
Source: https://docs.squared.ai/guides/destinations/retl-destinations/file-storage/sftp

Learn how to set up a SFTP destination connector in AI Squared to efficiently transfer data to your SFTP server.

## Introduction

The Secure File Transfer Protocol (SFTP) is a secure method for transferring files between systems. Integrating SFTP with AI Squared allows you to efficiently transfer data to your SFTP server for storage or further distribution. This guide outlines the steps to set up an SFTP destination connector in AI Squared.

### Step 1: Access AI Squared

1. Log in to your AI Squared account.
2. Navigate to the **Destinations** section to manage your data destinations.

### Step 2: Create a New Destination Connector

1. Click on the **Add Destination** button.
2. Select **SFTP** from the list of available destination types.

### Step 3: Configure Connection Settings

Provide the following details to establish a connection between AI Squared and your SFTP server:

* **Host**: The hostname or IP address of the SFTP server.
* **Port**: The port number used for SFTP connections (default is 22).
* **Username**: Your username for accessing the SFTP server.
* **Password**: The password associated with the username.
* **Destination Path**: The directory path on the SFTP server where you want to store the files.
* **Filename**: The name of the file to be uploaded to the SFTP server, appended with the current timestamp.

Enter these details in the respective fields on the connector configuration page and press **Finish**.

### Step 4: Test the Connection

1. After entering the necessary information, use the automated **Test Connection** feature to ensure AI Squared can successfully connect to your SFTP server.
2. If the test is successful, you'll receive a confirmation message. If not, double-check your entered details for any errors.

### Step 5: Finalize the Destination Connector Setup

1. After a successful connection test, save the connector settings to establish the destination connection.

## Conclusion

By following these steps, you've successfully set up an SFTP destination connector in AI Squared. You can now efficiently transfer data to your SFTP server for storage or further distribution within AI Squared.


# HTTP
Source: https://docs.squared.ai/guides/destinations/retl-destinations/http/http

Learn how to set up a HTTP destination connector in AI Squared to efficiently transfer data to your HTTP destination.

## Introduction

The Hyper Text Transfer Protocol (HTTP) connector is a method of transerring data over the internet to specific url endpoints. Integrating the HTTP Destination connector with AI Squared allows you to efficiently transfer your data to HTTP endpoints of your choosing. This guide outlines how to setup your HTTP destination connector in AI Squared.

### Destination Setup

<AccordionGroup>
  <Accordion title="Create an HTTP destination" icon="key">
    <Steps>
      <Step title="Access AI Squared">
        Log in to your AI Squared account and navigate to the **Destinations** section to manage your data destinations.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Create a New Destination Connector">
        Click on the **Add Destination** button. Select **HTTP** from the list of available destination types.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Configure Connection Settings">
        Provide the following details to establish a connection between AI Squared and your HTTP endpoint:

        * **Destination Url**: The HTTP address of where you are sending your data.
        * **Headers**: A list of key value pairs of your choosing. This can include any headers that are required to send along with your HTTP request.
        * **Authentication Type**: Choose how AI Squared authenticates with your HTTP endpoint. Select `none` to skip authentication, or `oauth_client_credentials` to have AI Squared fetch and refresh an OAuth 2.0 access token automatically using the client credentials grant.

        When **Authentication Type** is set to `oauth_client_credentials`, provide the following additional fields:

        * **OAuth Token URL**: The token endpoint used to request access tokens (for example, `https://login.microsoftonline.com/{tenant_id}/oauth2/v2.0/token`).
        * **OAuth Client ID**: The client ID issued by your identity provider.
        * **OAuth Client Secret**: The client secret issued by your identity provider.
        * **OAuth Scope**: Optional scope value sent with the token request (for example, `https://graph.microsoft.com/.default`).

        <Note>
          When OAuth client credentials are configured, AI Squared automatically attaches the retrieved access token as a `Bearer` token in the `Authorization` header on every request. Tokens are cached and refreshed before they expire, so you do not need to manage them manually.
        </Note>

        Enter these details in the respective fields on the connector configuration page and press **Finish**.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Test the Connection">
        After entering the necessary information, use the automated **Test Connection** feature to ensure AI Squared can successfully connect to your HTTP endpoint. If the test is successful, you'll receive a confirmation message. If not, double-check your entered details for any errors.
      </Step>

      <Step title="Finalize the Destination Connector Setup">
        After a successful connection test, save the connector settings to establish the destination connection.

        By following these steps, you've successfully set up an HTTP destination connector in AI Squared. You can now efficiently transfer data to your HTTP endpoint for storage or further distribution within AI Squared.
      </Step>
    </Steps>
  </Accordion>
</AccordionGroup>

<Accordion title="Supported Sync" icon="arrows-rotate">
  | Mode             | Supported (Yes/No/Coming soon) |
  | ---------------- | ------------------------------ |
  | Incremental sync | Yes                            |
  | Full refresh     | No                             |
</Accordion>


# Braze
Source: https://docs.squared.ai/guides/destinations/retl-destinations/marketing-automation/braze





# CleverTap
Source: https://docs.squared.ai/guides/destinations/retl-destinations/marketing-automation/clevertap





# Iterable
Source: https://docs.squared.ai/guides/destinations/retl-destinations/marketing-automation/iterable



## Connect AI Squared to Iterable

This guide will help you configure the Iterable Connector in AI Squared to access and use your Iterable data.

### Prerequisites

Before proceeding, ensure you have the necessary API Key from Iterable.

## Step-by-Step Guide to Connect to Iterable

## Step 1: Navigate to Iterable

Start by logging into your Iterable account and navigating to the Iterable service.

1. Sign in to your Iterable account at [Iterable Login](https://www.iterable.com/login/).
2. Once logged in, you will be directed to the Iterable dashboard.

## Step 2: Locate Iterable API Key

Once you're logged into Iterable, you'll find the necessary configuration details:

1. **API Key:**
   * Click on "Integrations" and select "API Keys" from the dropdown menu.

<Frame>
  <img />
</Frame>

* Here, you can create a new API key or use an existing one. Click on "+ New API key" if needed, and give it a name.
* Once the API key is created, copy it as it will be required for configuring the connector.

## Step 3: Test the Iterable Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Iterable from the AI Squared platform to ensure a connection is made.

By following these steps, you’ve successfully set up an Iterable destination connector in AI Squared. You can now efficiently transfer data to your Iterable endpoint for storage or further distribution within AI Squared.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

Follow these steps to configure and test your Iterable connector successfully.


# Klaviyo
Source: https://docs.squared.ai/guides/destinations/retl-destinations/marketing-automation/klaviyo



# Destination/Klaviyo

### Overview

Enhance Your ECommerce Email Marketing Campaigns Using Warehouse Data in Klaviyo

### Setup

1. Create a [Klaviyo account](https://www.klaviyo.com/)
2. Generate a[ Private API Key](https://help.klaviyo.com/hc/en-us/articles/115005062267-How-to-Manage-Your-Account-s-API-Keys#your-private-api-keys3) and Ensure All Relevant Scopes are Included for the Streams You Wish to Replicate.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | Yes                            |
| Full refresh     | Coming soon                    |

### Supported streams

| Stream                                                                             | Supported (Yes/No/Coming soon) |
| ---------------------------------------------------------------------------------- | ------------------------------ |
| [Profiles](https://developers.klaviyo.com/en/v2023-02-22/reference/get_profiles)   | Yes                            |
| [Campaigns](https://developers.klaviyo.com/en/v2023-06-15/reference/get_campaigns) | Coming soon                    |
| [Events](https://developers.klaviyo.com/en/reference/get_events)                   | Coming soon                    |
| [Lists](https://developers.klaviyo.com/en/reference/get_lists)                     | Coming soon                    |


# Mailchimp
Source: https://docs.squared.ai/guides/destinations/retl-destinations/marketing-automation/mailchimp



## Setting Up the Mailchimp Connector in AI Squared

To integrate Mailchimp with AI Squared, you need to establish a destination connector. This connector will allow AI Squared to sync data efficiently from various sources to Mailchimp.

***

## Step 1: Access AI Squared

1. Log in to your **AI Squared** account.
2. Navigate to the **Destinations** section to manage your destination connectors.

## Step 2: Create a New Destination Connector

<Frame>
  <img />
</Frame>

1. Click on the **Add Destination** button.
2. Select **Mailchimp** from the list of available destination types.

## Step 3: Configure Connection Settings

To establish a connection between AI Squared and Mailchimp, provide the following details:

<Frame>
  <img />
</Frame>

1. **API Key**
   * Used to authenticate your Mailchimp account.
   * Generate this key in your Mailchimp account under `Account > Extras > API Keys`.

2. **List ID**
   * The unique identifier for the specific audience (mailing list) you want to target in Mailchimp.
   * Find your Audience ID in Mailchimp by navigating to `Audience > Manage Audience > Settings > Audience name and defaults`.

3. **Email Template ID**
   * The unique ID of the email template you want to use for campaigns or automated emails in Mailchimp.
   * Locate or create templates in the **Templates** section of Mailchimp. The ID is retrievable via the Mailchimp API or from the template’s settings.

Enter these parameters in their respective fields on the connector configuration page and press **Continue** to proceed.

## Step 4: Test the Connection

<Frame>
  <img />
</Frame>

1. Use the **Test Connection** feature to ensure AI Squared can successfully connect to your Mailchimp account.
2. If the test is successful, you’ll receive confirmation.
3. If unsuccessful, recheck the entered information.

## Step 5: Finalize the Destination Connector Setup

1. Save the connector settings to establish the Mailchimp destination connection.

<Frame>
  <img />
</Frame>

***

## Setting Up a Model for Mailchimp

To sync data to Mailchimp, you first need to prepare your data by creating a model based on the source data. Here's how:

1. **Review Your Source Data**
   Identify the key fields you need from the source (e.g., email, first name, last name, and tags).

2. **Create the Model**
   Select the necessary fields from your source.
   Map these fields to match Mailchimp’s required parameters, such as `email`, `merge_fields.FNAME` (first name), and `tags.0`.

3. **Save and Validate**
   Ensure the model is structured properly and contains clean, valid data.

4. **Sync the Model**
   Use the model as the basis for setting up your sync to Mailchimp.
   Map fields from the model to the corresponding Mailchimp parameters during sync configuration.

This step ensures your data is well-structured and ready to integrate with Mailchimp seamlessly.

***

## Configuring the Mapping for Mailchimp

When creating a sync for the Mailchimp destination connector, the following parameters can be mapped to enhance data synchronization and segmentation capabilities:

### Core Parameters

1. `email`\
   **Description**: The email address of the subscriber.\
   **Purpose**: Required to uniquely identify and add/update contacts in a Mailchimp audience.

2. `status`\
   **Description**: The subscription status of the contact.\
   **Purpose**: Maintains accurate subscription data for compliance and segmentation.\
   **Options**:
   * `subscribed` – Actively subscribed to the mailing list.
   * `unsubscribed` – Opted out of the list.
   * `cleaned` – Undeliverable address.
   * `pending` – Awaiting confirmation (e.g., double opt-in).

### Personalization Parameters

1. `first_name`\
   **Description**: The first name of the contact.\
   **Purpose**: Used for personalization in email campaigns.

2. `last_name`
   **Description**: The last name of the contact.\
   **Purpose**: Complements personalization for formal messaging.

3. `merge_fields.FNAME`\
   **Description**: Merge field for the first name of the contact.\
   **Purpose**: Enables advanced personalization in email templates (e.g., "Hello, |FNAME|!").

4. `merge_fields.LNAME`\
   **Description**: Merge field for the last name of the contact.\
   **Purpose**: Adds dynamic content based on the last name.

### Segmentation Parameters

1. `tags.0`\
   **Description**: A tag assigned to the contact.\
   **Purpose**: Enables grouping and segmentation within the Mailchimp audience.

2. `vip`\
   **Description**: Marks the contact as a VIP (true or false).\
   **Purpose**: Identifies high-priority contacts for specialized campaigns.

3. `language`\
   **Description**: The preferred language of the contact using an ISO 639-1 code (e.g., `en` for English, `fr` for French).\
   **Purpose**: Supports localization and tailored communication for multilingual audiences.

### Compliance and Tracking Parameters

1. `ip_opt`\
   **Description**: The IP address from which the contact opted into the list.\
   **Purpose**: Ensures regulatory compliance and tracks opt-in origins.

2. `ip_signup`\
   **Description**: The IP address where the contact originally signed up.\
   **Purpose**: Tracks the geographical location of the signup for analytics and compliance.

3. `timestamp_opt`\
   **Description**: The timestamp when the contact opted into the list (ISO 8601 format).\
   **Purpose**: Provides a record for regulatory compliance and automation triggers.

4. `timestamp_signup`\
   **Description**: The timestamp when the contact signed up (ISO 8601 format).\
   **Purpose**: Tracks the signup date for lifecycle and engagement analysis.

***


# Stripe
Source: https://docs.squared.ai/guides/destinations/retl-destinations/payment/stripe



## Overview

Integrating customer data with subscription metrics from Stripe provides valuable insights into the actions that most frequently convert free accounts into paying ones.
It also helps identify accounts that may be at risk of churning due to low activity levels.
By recognizing these trends, you can proactively engage at-risk customers to prevent churn and enhance customer retention.

## Stripe Connector Configuration and Credential Retrieval Guide

### Prerequisite Requirements

To authenticate the Stripe connector using AI Squared, you'll need a Stripe API key.
While you can use an existing key, it's better to create a new restricted key specifically for AI Squared.
Make sure to grant it write privileges only. Additionally, it's advisable to enable write privileges for all possible permissions and tailor the specific data you wish to synchronize within AI Squared.

### Set up Stripe

<AccordionGroup>
  <Accordion title="Create API Key" icon="stripe">
    <Steps>
      <Step title="Sign In">
        Sign into your Stripe account.
      </Step>

      <Step title="Developers">
        Click 'Developers' on the top navigation bar.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="API keys">
        At the top-left, click 'API keys'.
      </Step>

      <Step title="Restricted key">
        Select '+ Create restricted key'.
      </Step>

      <Step title="Naming and permission">
        Name your key, and ensure 'Write' is selected for all permissions.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Create key">
        Click 'Create key'. You may need to verify by entering a code sent to your email.
      </Step>
    </Steps>
  </Accordion>
</AccordionGroup>

<Accordion title="Supported Sync" icon="arrows-rotate">
  | Mode             | Supported (Yes/No/Coming soon) |
  | ---------------- | ------------------------------ |
  | Incremental sync | Yes                            |
  | Full refresh     | Coming soon                    |
</Accordion>

<Accordion title="Supported Streams">
  | Stream   | Supported (Yes/No/Coming soon) |
  | -------- | ------------------------------ |
  | Customer | Yes                            |
  | Product  | Yes                            |
</Accordion>


# Airtable
Source: https://docs.squared.ai/guides/destinations/retl-destinations/productivity-tools/airtable



# Destination/Airtable

### Overview

Airtable combines the simplicity of a spreadsheet with the complexity of a database. This cloud-based platform enables users to organize work, manage projects, and automate workflows in a customizable and collaborative environment.

### Prerequisite Requirements

Ensure you have created an Airtable account before you begin. Sign up [here](https://airtable.com/signup) if you haven't already.

### Setup

1. **Generate a Personal Access Token**

   Start by generating a personal access token. Follow the guide [here](https://airtable.com/developers/web/guides/personal-access-tokens) for instructions.

<Frame>
  <img />
</Frame>

2. **Grant Required Scopes**

   Assign the following scopes to your token for the necessary permissions:

   * `data.records:read`
   * `data.records:write`
   * `schema.bases:read`
   * `schema.bases:write`

   <Frame>
     <img />
   </Frame>


# Google Sheets - Service Account
Source: https://docs.squared.ai/guides/destinations/retl-destinations/productivity-tools/google-sheets

Google Sheets serves as an effective reverse ETL destination, enabling real-time data synchronization from data warehouses to a collaborative, user-friendly spreadsheet environment. It democratizes data access, allowing stakeholders to analyze, share, and act on insights without specialized skills. The platform supports automation and customization, enhancing decision-making and operational efficiency. Google Sheets transforms complex data into actionable intelligence, fostering a data-driven culture across organizations.

<Warning>
  Google Sheets is equipped with specific data capacity constraints, which, when exceeded, can lead to synchronization issues. Here's a concise overview of these limitations:

  * **Cell Limit**: A Google Sheets document is capped at `10 million` cells, which can be spread across one or multiple sheets. Once this limit is reached, no additional data can be added, either in the form of new rows or columns.
  * **Character Limit per Cell**: Each cell in Google Sheets can contain up to `50,000` characters. It's crucial to consider this when syncing data that includes fields with lengthy text.
  * **Column Limit**: A single worksheet within Google Sheets is limited to `18,278` columns.
  * **Worksheet Limit**: There is a cap of `200` worksheets within a single Google Sheets spreadsheet.

  Given these restrictions, Google Sheets is recommended primarily for smaller, non-critical data engagements.
  It may not be the optimal choice for handling expansive data operations due to its potential for sync failures upon reaching these imposed limits.
</Warning>

## Connector Configuration and Credential Retrieval Guide

### Prerequisite Requirements

Before initiating the Google Sheet connector setup, ensure you have an created or access an [Google cloud account](https://console.cloud.google.com).

### Destination Setup

<Accordion title="Set up the Service Account Key" icon="key">
  <Steps>
    <Step title="Create a Service Account">
      * Navigate to the [Service Accounts](https://console.cloud.google.com/projectselector2/iam-admin/serviceaccounts) page in your Google Cloud console.
        <Frame>
          <img />
        </Frame>
      * Choose an existing project or create a new one.
        <Frame>
          <img />
        </Frame>
      * Click + Create service account, enter its name and description, then click Create and Continue.
      * Assign appropriate permissions, recommending the Editor role, then click Continue.
    </Step>

    <Step title="Generate a Key">
      * Access the [API Console > Credentials](https://console.cloud.google.com/apis/credentials) page, select your service account's email.
        <Frame>
          <img />
        </Frame>
      * In the Keys tab, click + Add key and select Create new key.
      * Choose JSON as the Key type to download your authentication JSON key file. Click Continue.
        <Frame>
          <img />
        </Frame>
    </Step>

    <Step title="Enable the Google Sheets API">
      * Navigate to the [API Console > Library](https://console.cloud.google.com/apis/library) page.
        <Frame>
          <img />
        </Frame>
      * Verify that the correct project is selected at the top.
      * Find and select the Google Sheets API.
      * Click ENABLE.
        <Frame>
          <img />
        </Frame>
    </Step>

    <Step title="Spreadsheet Access">
      * If your spreadsheet is link-accessible, no extra steps are needed.
      * If not, [grant your service account](https://support.google.com/a/answer/60781?hl=en\&sjid=11618327295115173982-AP) access to your spreadsheet.
    </Step>

    <Step title="Output Schema">
      * Each worksheet becomes a separate source-connector stream in AI Squared.
      * Data is coerced to string format; nested structures need further processing for analysis.
      * AI Squared replicates text via Grid Sheets only; charts and images aren't supported.
    </Step>
  </Steps>
</Accordion>


# Microsoft Excel
Source: https://docs.squared.ai/guides/destinations/retl-destinations/productivity-tools/microsoft-excel



## Connect AI Squared to Microsoft Excel

This guide will help you configure the Iterable Connector in AI Squared to access and use your Iterable data.

### Prerequisites

Before proceeding, ensure you have the necessary Access Token from Microsoft Graph.

## Step-by-Step Guide to Connect to Microsoft Excel

## Step 1: Navigate to Microsoft Graph Explorer

Start by logging into Microsoft Graph Explorer using your Microsoft account and consent to the required permissions.

1. Sign into Microsoft Graph Explorer at [developer.microsoft.com](https://developer.microsoft.com/en-us/graph/graph-explorer).
2. Once logged in, consent to the following under each category:
   * **Excel:**
     * worksheets in a workbook
     * used range in worksheet
   * **OneDrive:**
     * list items in my drive
   * **User:**
     * me
3. Once the following is consented to click Access token and copy the token

## Step 2: Navigate to Microsoft Excel

Once you're logged into Microsoft Excel do the following:

1. **Create a new workbook:**
   * Create a new workbook in excel to have the data stored.
   * Once you have create the workbook open it and navigate to the sheet of you choosing.
   * In the sheet of your choosing make a table with the required headers you want to transfer data to.

<Frame>
  <img />
</Frame>

## Step 3: Configure Microsoft Excel Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **Token:** The access token from Microsoft Graph Explorer.

## Step 4: Test the Microsoft Excel Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Microsoft Excel from the AI Squared platform to ensure a connection is made.

By following these steps, you’ve successfully set up an Microsoft Excel destination connector in AI Squared. You can now efficiently transfer data to your Microsoft Excel workbook for storage or further distribution within AI Squared.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

Follow these steps to configure and test your Iterable connector successfully.


# Salesforce Consumer Goods Cloud
Source: https://docs.squared.ai/guides/destinations/retl-destinations/retail/salesforce-consumer-goods-cloud



## Overview

Salesforce Consumer Goods Cloud is a specialized CRM platform designed to help companies in the consumer goods industry manage their operations more efficiently.
It provides tools to optimize route-to-market strategies, increase sales performance, and enhance field execution.
This cloud-based solution leverages Salesforce's robust capabilities to deliver data-driven insights, streamline inventory and order management, and foster closer relationships with retailers and customers.

### Key Features:

* **Retail Execution**: Manage store visits, ensure product availability, and optimize shelf placement.
* **Sales Planning and Operations**: Create and manage sales plans that align with company goals.
* **Trade Promotion Management**: Plan, execute, and analyze promotional activities to maximize ROI.
* **Field Team Management**: Enable field reps with tools and data to improve productivity and effectiveness.

## Connector Configuration and Credential Retrieval Guide

### Prerequisite Requirements

When setting up an integration between Salesforce Consumer Goods Cloud and Multiwoven, certain credentials are required to authenticate and establish a secure connection. Below is a brief description of each credential needed:

* **Username**: The Salesforce username used to log in.
* **Password**: The password associated with the Salesforce username.
* **Host**: The URL of your Salesforce instance (e.g., [https://login.salesforce.com](https://login.salesforce.com)).
* **Security Token**: An additional security key that is appended to your password for API access from untrusted networks.
* **Client ID** and **Client Secret**: These are part of the OAuth credentials required for authenticating an application with Salesforce.
  They are obtained when you set up a new "Connected App" in Salesforce for integrating with external applications. You may refer our [Salesforce CRM docs](https://docs.multiwoven.com/destinations/crm/salesforce#destination-setup) for further details.

### Setting Up Security Token in Salesforce

<AccordionGroup>
  <Accordion title="Steps to Retrieve or Reset a Salesforce Security Token" icon="salesforce">
    <Steps>
      <Step title="Sign In">
        Log in to your Salesforce account.
      </Step>

      <Step title="Settings">
        Navigate to Settings or My Settings by first clicking on My Profile and then clicking **Settings** under the Personal Information section.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Quick Find">
        Once inside the Settings page click on the Quick Find box and type "Reset My Security Token" to quickly navigate to the option.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Reset My Security Token">
        Click on Reset My Security Token under the Personal section. Salesforce will send the new security token to the email address associated with your account.
        If you do not see the option to reset the security token, it may be because your organization uses Single Sign-On (SSO) or has IP restrictions that negate the need for a token.

        <Frame>
          <img />
        </Frame>
      </Step>
    </Steps>
  </Accordion>
</AccordionGroup>

<Accordion title="Supported Sync" icon="arrows-rotate">
  | Mode             | Supported (Yes/No/Coming soon) |
  | ---------------- | ------------------------------ |
  | Incremental sync | Yes                            |
  | Full refresh     | Coming soon                    |
</Accordion>

<Accordion title="Supported Streams">
  | Stream      | Supported (Yes/No/Coming soon) |
  | ----------- | ------------------------------ |
  | Account     | Yes                            |
  | User        | Yes                            |
  | Visit       | Yes                            |
  | RetailStore | Yes                            |
  | RecordType  | Yes                            |
</Accordion>


# Microsoft teams
Source: https://docs.squared.ai/guides/destinations/retl-destinations/team-collaboration/microsoft-teams





# Slack
Source: https://docs.squared.ai/guides/destinations/retl-destinations/team-collaboration/slack



## Usecase

<CardGroup>
  <Card title="Sales and Support Alerts" icon="bell">
    Notify sales or customer support teams about significant customer events,
    like contract renewals or support tickets, directly in Slack.
  </Card>

  <Card title="Collaborative Data Analysis" icon="magnifying-glass-chart">
    Share real-time insights and reports in Slack channels to foster
    collaborative analysis and decision-making among teams. This is particularly
    useful for remote and distributed teams
  </Card>

  <Card title="Operational Efficiency" icon="triangle-exclamation">
    Integrate Slack with operational systems to streamline operations. For
    instance, sending real-time alerts about system downtimes, performance
    bottlenecks, or successful deployments to relevant engineering or operations
    Slack channels.
  </Card>

  <Card title="Event-Driven Marketing" icon="bullseye">
    Trigger marketing actions based on customer behavior. For example, if a
    customer action indicates high engagement, a notification can be sent to the
    marketing team to follow up with personalized content or offers.
  </Card>
</CardGroup>

## Slack Connector Configuration and Credential Retrieval Guide

### Prerequisite Requirements

To access Slack through AI Squared, you must authenticate using an API Token. This authentication can be obtained through a Slack App. However, if you already possess one, it remains valid for use with this integration.
Given that AI Squared operates as a reverse ETL platform, requiring write access to perform its functions, we recommend creating a restricted API key that permits write access specifically for AI Squared's use.
This strategy enables you to maintain control over the extent of actions AI Squared can execute within your Slack environment, ensuring security and compliance with your data governance policies.

<Tip>Link to view your [Slack Apps](https://api.slack.com/apps).</Tip>

### Destination Setup

<AccordionGroup>
  <Accordion title="Create Bot App" icon="robot">
    To facilitate the integration of your Slack destination connector with AI Squared, please follow the detailed steps below:

    <Steps>
      <Step title="Create New App">
        Initiate the process by selecting the "Create New App" option.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="From scratch">
        You will be required to create a Bot app from the ground up. To do this, select the "from scratch" option.
      </Step>

      <Step title="App Name & Workspace">
        Proceed by entering your desired App Name and selecting a workspace where the app will be deployed.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Add features and functionality">
        Navigate to the **Add features and functionality** menu and select **Bots** to add this capability to your app.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="OAuth & Permissions">
        Within the menu on the side labeled as **Features** column, locate and click on **OAuth & Permissions**.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Add scope">
        In the "OAuth & Permissions" section, add the scope **chat:write** to define the permissions for your app.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Install Bot">
        To finalize the Bot installation, click on "Install to workspace" found in the "OAuth Tokens for Your Workspace" section.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Save Permissions">
        Upon successful installation, a Bot User OAuth Token will be generated.
        It is crucial to copy this token as it is required for the configuration of the Slack destination connector within AI Squared.

        <Frame>
          <img />
        </Frame>
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Obtain Channel ID" icon="key">
    <Steps>
      <Step title="View Channel Details">
        Additionally, acquiring the Channel ID is essential for configuring the Slack destination.
        This ID can be retrieved by right-clicking on the channel intended for message dispatch through the newly created bot.
        From the context menu, select **View channel details**

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Copy Channel ID">
        Locate and copy the Channel ID, which is displayed at the lower left corner of the tab.

        <Frame>
          <img />
        </Frame>
      </Step>
    </Steps>
  </Accordion>
</AccordionGroup>


# S3
Source: https://docs.squared.ai/guides/sources/data-sources/amazon_s3



## Connect AI Squared to S3

This page describes how to add AWS S3 as a source.

AI Squared lets you pull data from CSV and Parquet files stored in an Amazon S3 bucket and push them to downstream destinations. To get started, you need an S3 bucket and AWS credentials.

## Connector Configuration and Credentials Guide

### Prerequisites

Before proceeding, ensure you have the necessary information based on how you plan to authenticate to AWS. The two types of authentication we support are:

* IAM User with access id and secret access key.
* IAM Role with ARN configured with an external ID so that AI Square can connect to your S3 bucket.

Additional info you will need regardless of authentication type will be:

* Region
* Bucket name
* The type of file we are working with (CSV or Parquet)
* Path to the CSV or Parquet files

### Setting Up AWS Requirements

<AccordionGroup>
  <Accordion title="Steps to Retrieve or Create an IAM Role User credentials">
    <Steps>
      <Step title="Sign In">
        Log in to your AWS account at [AWS Management Console](https://aws.amazon.com/console/).
      </Step>

      <Step title="Users">
        Navigate to the the **Users**. This can be found in the left navigation under "Access Management" -> "Users".

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Access/Secret Key">
        Once inside the Users page, Select the User you would like to authenticate with. If there are no users to select, create one and make sure to give it the required permissions to read from S3 buckets. 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 Secret Access Key as they are shown only once.
        After selecting the user, go to **Security Credentials** tab and in it you should be able to see the Access keys for that user.

        <Frame>
          <img />
        </Frame>
      </Step>
    </Steps>
  </Accordion>

  <Accordion title="Steps to Retrieve or Create an IAM Role ARN">
    <Steps>
      <Step title="Sign In">
        Log in to your AWS account at [AWS Management Console](https://aws.amazon.com/console/).
      </Step>

      <Step title="External ID">
        The ARN is going to need an external ID which will be required during the configuration of the S3 source connector. The external ID will allow us to reach out to you S3 buckets and read data from it.
        You can generate an external Id using this [GUID generator tool](https://guidgenerator.com/). [Learn more about AWS STS external ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user_externalid.html).
      </Step>

      <Step title="Roles">
        Navigate to the the **Roles**. This can be found in the left navigation under "Access Management" -> "Roles".

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Create or Select an existing role">
        Select an existing role to edit or create a new one by clicking on "Create Role".
      </Step>

      <Step title="ARN Premissions Policy">
        The "Permissions Policy" should look something like this:

        ```
        {
            "Version": "2012-10-17",
            "Statement": [
               {
                     "Sid": "VisualEditor0",
                     "Effect": "Allow",
                     "Action": [
                        "s3:GetObject",
                        "s3:GetObjectVersion",
                        "s3:ListBucket"
                     ],
                     "Resource": [
                        "arn:aws:s3:::{your-bucket-name}",
                        "arn:aws:s3:::{your-bucket-name}/*"
                     ]
               }
            ]
         }
        ```
      </Step>

      <Step title="ARN Trust Relationship">
        The "Trust Relationship" should look something like this:

        ```
        {
            "Version": "2012-10-17",
            "Statement": [
               {
                     "Sid": "Statement1",
                     "Effect": "Allow",
                     "Principal": {
                        "AWS": "{iam-user-principal-arn}"
                     },
                     "Action": "sts:AssumeRole",
                     "Condition": {
                        "StringEquals": {
                           "sts:ExternalId": "{generated-external-id}"
                        }
                     }
               }
            ]
         }
        ```
      </Step>
    </Steps>
  </Accordion>
</AccordionGroup>

### Step 2: Locate AWS S3 Configuration Details

Now you should be in the AWS and have found your credentials. Now we will navigate to the S3 service to find the necessary configuration details:

1. **IAM User Access Key and Secret Access Key or IAM Role ARN and External ID:**
   * This has been gathered from the previous step.

2. **Bucket:**
   * Once inside of the AWS S3 console you should be able to see the list of buckets available, if not go ahead and create a bucket by clicking on the "Create bucket" button.

3. **Region:**
   * In the same list showing the buckets, there's a region assotiated with it.

4. **Path:**
   * The path where the file you wish to read from. This field is optional and can be left blank.

5. **File type:**
   * The files within the path that was selected should help determine the file type.

### Step 3: Configure S3 Connector in Your Application

Now that you have gathered all the necessary details enter the following information:

* **Region:** The AWS region where your S3 bucket resources are located.
* **Access Key ID:** Your AWS IAM user's Access Key ID.
* **Secret Access Key:** The corresponding Secret Access Key.
* **Bucket:** The name of the bucket you want to use.
* **Path:** The path directory where the files are located at.
* **File type:** The type of file (csv, parquet).

### Step 4: Test the S3 Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to S3 from your application to ensure everything is set up correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your S3 connector is now configured and ready to query data from your S3 data catalog.

## Building a Model Query

The S3 source connector is powered by [DuckDB S3 api support](https://duckdb.org/docs/extensions/httpfs/s3api.html). This allows us to use
SQL queries to describe and/or fetch data from an S3 bucket, for example:

```
SELECT * FROM 's3://my-bucket/path/to/file/file.parquet';
```

From the example, we can notice some details that are required in order to perform the query:

* **FROM command: `'s3://my-bucket/path/to/file/file.parquet'`** You need to provide a value in the same format as the example.
* **Bucket: `my-bucket`** In that format you will need to provide the bucket name. The bucket name needs to be
  the same one provided when configuring the S3 source connector.
* **Path: `/path/to/file`** In that format you will need to provide the path to the file. The path needs to be
  the same one provided when configuring the S3 source connector.
* **File name and type: `file.parquet`** In that format you will need to provide the file name and type at the end of the path. The file type needs to be
  the same one provided when configuring the S3 source connector.

## Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | YES                            |


# AWS Athena
Source: https://docs.squared.ai/guides/sources/data-sources/aws_athena



## Connect AI Squared to AWS Athena

This guide will help you configure the AWS Athena Connector in AI Squared to access and use your AWS Athena data.

### Prerequisites

Before proceeding, ensure you have the necessary access key, secret access key, region, workgroup, catalog, and output location from AWS Athena.

## Step-by-Step Guide to Connect to AWS Athena

## Step 1: Navigate to AWS Athena Console

Start by logging into your AWS Management Console and navigating to the AWS Athena service.

1. Sign in to your AWS account at [AWS Management Console](https://aws.amazon.com/console/).
2. In the AWS services search bar, type "Athena" and select it from the dropdown.

## Step 2: Locate AWS Athena Configuration Details

Once you're in the AWS Athena 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 Athena resources are located or where you want to perform queries.

3. **Workgroup:**
   * In the AWS Athena console, navigate to the "Workgroups" section in the left sidebar.
   * Here, you can view the existing workgroups or create a new one if needed. Note down the name of the workgroup you want to use.

4. **Catalog and Database:**
   * Go to the "Data Source" section in the in the left sidebar.
   * Select the catalog that contains the databases and tables you want to query. Note down the name of the catalog and database.

5. **Output Location:**
   * In the AWS Athena console, click on "Settings".
   * Under "Query result location," you can see the default output location for query results. You can also set a custom output location if needed. Note down the output location URL.

## Step 3: Configure AWS Athena 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 Athena resources are located.
* **Workgroup:** The name of the workgroup you want to use.
* **Catalog:** The name of the catalog containing your data.
* **Schema:** The name of the database containing your data.
* **Output Location:** The URL of the output location for query results.

## Step 4: Test the AWS Athena Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to AWS Athena from your application to ensure everything is set up correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your AWS Athena connector is now configured and ready to query data from your AWS Athena data catalog.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |


# AWS Sagemaker Model
Source: https://docs.squared.ai/guides/sources/data-sources/aws_sagemaker-model



## Connect AI Squared to AWS Sagemaker Model

This guide will help you configure the AWS Sagemaker Model Connector in AI Squared to access your AWS Sagemaker 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 Sagemaker 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.
     <Frame>
       <img />
     </Frame>

2. **Region:**
   * The AWS region can be selected from the top right corner of the AWS Management Console. Choose the region where your AWS Sagemaker resources is located and note down the region.
     <Frame>
       <img />
     </Frame>

## Step 3: Configure AWS Sagemaker 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 Sagemaker resources are located.


# Google Big Query
Source: https://docs.squared.ai/guides/sources/data-sources/bquery



## Connect AI Squared to BigQuery

This guide will help you configure the BigQuery Connector in AI Squared to access and use your BigQuery data.

### Prerequisites

Before you begin, you'll need to:

1. **Enable BigQuery API and Locate Dataset(s):**

   * Log in to the [Google Developers Console](https://console.cloud.google.com/apis/dashboard).
   * If you don't have a project, create one.
   * Enable the [BigQuery API for your project](https://console.cloud.google.com/flows/enableapi?apiid=bigquery&_ga=2.71379221.724057513.1673650275-1611021579.1664923822&_gac=1.213641504.1673650813.EAIaIQobChMIt9GagtPF_AIVkgB9Ch331QRREAAYASAAEgJfrfD_BwE).
   * Copy your Project ID.
   * Find the Project ID and Dataset ID of your BigQuery datasets. You can find this by querying the `INFORMATION_SCHEMA.SCHEMATA` view or by visiting the Google Cloud web console.

2. **Create a Service Account:**

   * Follow the instructions in our [Google Cloud Provider (GCP) documentation](https://cloud.google.com/iam/docs/service-accounts-create) to create a service account.

3. **Grant Access:**

   * In the Google Cloud web console, navigate to the [IAM](https://console.cloud.google.com/iam-admin/iam?supportedpurview=project,folder,organizationId) & Admin section and select IAM.
   * Find your service account and click on edit.
   * Go to the "Assign Roles" tab and click "Add another role".
   * Search and select the "BigQuery User" and "BigQuery Data Viewer" roles.
   * Click "Save".

4. **Download JSON Key File:**

   * In the Google Cloud web console, navigate to the [IAM](https://console.cloud.google.com/iam-admin/iam?supportedpurview=project,folder,organizationId) & Admin section and select IAM.
   * Find your service account and click on it.
   * Go to the "Keys" tab and click "Add Key".
   * Select "Create new key" and choose JSON format.
   * Click "Download".

### Steps

### Authentication

Authentication is supported via the following:

* **Dataset ID and JSON Key File**

  * **[Dataset ID](https://cloud.google.com/bigquery/docs/datasets):** The ID of the dataset within Google BigQuery that you want to access. This can be found in Step 1.
  * **[JSON Key File](https://cloud.google.com/iam/docs/keys-create-delete):** The JSON key file containing the authentication credentials for your service account.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |


# ClickHouse
Source: https://docs.squared.ai/guides/sources/data-sources/clickhouse



## Connect AI Squared to ClickHouse

This guide will help you configure the ClickHouse Connector in AI Squared to access and use your ClickHouse data.

### Prerequisites

Before proceeding, ensure you have the necessary URL, username, and password from ClickHouse.

## Step-by-Step Guide to Connect to ClickHouse

## Step 1: Navigate to ClickHouse Console

Start by logging into your ClickHouse Management Console and navigating to the ClickHouse service.

1. Sign in to your ClickHouse account at [ClickHouse](https://clickhouse.com/).
2. In the ClickHouse console, select the service you want to connect to.

## Step 2: Locate ClickHouse Configuration Details

Once you're in the ClickHouse console, you'll find the necessary configuration details:

1. **HTTP Interface URL:**
   * Click on the "Connect" button in your ClickHouse service.
   * In "Connect with" select HTTPS.
   * Find the HTTP interface URL, which typically looks like `http://<your-clickhouse-url>:8443`. Note down this URL as it will be used to connect to your ClickHouse service.

2. **Username and Password:**
   * Click on the "Connect" button in your ClickHouse service.
   * Here, you will see the credentials needed to connect, including the username and password.
   * Note down the username and password as they are required for the HTTP connection.

## Step 3: Configure ClickHouse Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **HTTP Interface URL:** The URL of your ClickHouse service HTTP interface.
* **Username:** Your ClickHouse service username.
* **Password:** The corresponding password for the username.

## Step 4: Test the ClickHouse Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to ClickHouse from your application to ensure everything is set up correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your ClickHouse connector is now configured and ready to query data from your ClickHouse service.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |


# Databricks
Source: https://docs.squared.ai/guides/sources/data-sources/databricks



### Overview

AI Squared enables you to transfer data from Databricks to various destinations by using Open Database Connectivity (ODBC). This guide explains how to obtain your Databricks cluster's ODBC URL and connect to AI Squared using your credentials. Follow the instructions to efficiently link your Databricks data with downstream platforms.

### Setup

<Steps>
  <Step title="Open workspace">
    In your Databricks account, navigate to the "Workspaces" page, choose the desired workspace, and click Open workspace

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Go to warehouse">
    In your workspace, go the SQL warehouses and click on the relevant warehouse

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Get connection details">
    Go to the Connection details section.This tab shows your cluster's Server Hostname, Port, and HTTP Path, essential for connecting to AI Squared

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Create personal token">
    Then click on the create a personal token link to generate the personal access token

    <Frame>
      <img />
    </Frame>
  </Step>
</Steps>

### Configuration

| Field               | Description                                                                                                                                  |
| ------------------- | -------------------------------------------------------------------------------------------------------------------------------------------- |
| **Server Hostname** | Visit the Databricks web console, locate your cluster, click for Advanced options, and go to the JDBC/ODBC tab to find your server hostname. |
| **Port**            | The default port is 443, although it might vary.                                                                                             |
| **HTTP Path**       | For the HTTP Path, repeat the steps for Server Hostname and Port.                                                                            |
| **Catalog**         | Database  catalog                                                                                                                            |
| **Schema**          | The initial schema to use when connecting.                                                                                                   |


# Databricks Model
Source: https://docs.squared.ai/guides/sources/data-sources/databricks-model



### Overview

AI Squared enables you to transfer data from a Databricks Model to various destinations or data apps. This guide explains how to obtain your Databricks Model URL and connect to AI Squared using your credentials.

### Setup

<Steps>
  <Step title="Get connection details">
    Go to the Serving tab in Databricks, select the endpoint you want to
    configure, and locate the Databricks host and endpoint as shown below.

    <Frame>
      <img />
    </Frame>
  </Step>

  <Step title="Create personal token">
    Generate a personal access token by following the steps in the [Databricks
    documentation](https://docs.databricks.com/en/dev-tools/auth/pat.html).

    <Frame>
      <img />
    </Frame>
  </Step>
</Steps>

### Configuration

| Field                | Description                                    |
| -------------------- | ---------------------------------------------- |
| **databricks\_host** | The databricks-instance url                    |
| **token**            | Bearer token to connect with Databricks Model. |
| **endpoint**         | Name of the serving endpoint                   |


# Firecrawl
Source: https://docs.squared.ai/guides/sources/data-sources/firecrawl



## Connect AI Squared to Firecrawl

This guide will help you configure the Firecrawl Connector in AI Squared to access and transfer data from your selected Web page.

### Prerequisites

Before proceeding, ensure you have the required API key from your Firecrawl account.

## Step-by-Step Guide to Connect to Firecrawl.

## Step 1: Navigate to Firecrawl

Start by logging into your Firecrawl Account.

1. Sign in to your Firecrawl account at [Firecrawl](https://www.firecrawl.dev/signin/password_signin).

## Step 2: Locate Firecrawl Configuration Details

Once you're in your Firecrawl account, you'll find the necessary configuration details:

1. **API key:**
   * Click the **API Keys** tab on the left side of the Firecrawl dashboard
     <Frame>
       <img />
     </Frame>

## Step 3: Configure Firecrawl Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **API Key:** Your personal authentication token used to access the Firecrawl API.

* **Base URL:** The root URL of the website or domain you want Firecrawl to scrape (e.g., [https://docs.squared.ai](https://docs.squared.ai)).

## Step 4: Test the Firecrawl Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Firecrawl from your application to ensure everything is set up correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your Firecrawl connector is now configured and ready to scrape data from your selected Web page.

## Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |


# Google Drive
Source: https://docs.squared.ai/guides/sources/data-sources/google-drive



## Connect AI Squared to Google Drive

This guide will help you configure the Google Drive Connector in AI Squared to access your Google Drive files.

### Prerequisites

Before initiating the Google Drive connector setup, ensure you have created or have access to a [Google cloud account](https://console.cloud.google.com).

## Step-by-Step Guide to Connect to Google Drive.

### Step 1: Create Service Account

1. Navigate to the [Service Accounts](https://console.cloud.google.com/projectselector2/iam-admin/serviceaccounts) page in your Google Cloud console.
   <Frame>
     <img />
   </Frame>
2. Choose an existing project or create a new one.
   <Frame>
     <img />
   </Frame>
3. Click + Create service account, enter its name and description, then click Create and Continue.
4. Assign appropriate permissions, recommending the Editor role, then click Continue.

### Step 2: Generate a Key

1. Access the [API Console > Credentials](https://console.cloud.google.com/apis/credentials) page, select your service account's email.
   <Frame>
     <img />
   </Frame>
2. In the Keys tab, click + Add key and select Create new key.
3. Choose JSON as the Key type to download your authentication JSON key file. Click Continue.
   <Frame>
     <img />
   </Frame>

### Step 3: Enable the Google Drive API

1. Navigate to the [API Console > Library](https://console.cloud.google.com/apis/library) page.
   <Frame>
     <img />
   </Frame>
2. Verify that the correct project is selected at the top.
3. Find and select the Google Drive API.
4. Click ENABLE.
   <Frame>
     <img />
   </Frame>

### Step 4: Configure Google Drive connector

Before proceeding, ensure you have the JSON file downloaded during the previous steps.

Enter the following information during connector setup:

**Credentials**

* **type**: Type of account to use for authentication. Select service\_account.
* **project\_id**: Obtained from downloaded JSON.
* **private\_key\_id**: Obtained from downloaded JSON.
* **private\_key**: Obtained from downloaded JSON.
* **client\_email**: Obtained from downloaded JSON.
* **client\_id**: Obtained from downloaded JSON.
* **auth\_uri**: Obtained from downloaded JSON.
* **token\_uri**: Obtained from downloaded JSON.
* **auth\_provider\_x509\_cert\_url**: Obtained from downloaded JSON.
* **client\_x509\_cert\_url**: Obtained from downloaded JSON.
* **universe\_domain**: Obtained from downloaded JSON.

**Options**

* **Folder**: The folder to read files from. If not specified, reads from root folder.
* **Read from Subfolders**: When enabled, it reads files from subfolders in the specified folder.
* **File type**: Type of files to read.
* **document\_type**: The type of document to parse. Supported: invoices/receipts.
* **fields**: List of fields to extract from the documents.

### Step 5: Test the Google Drive connection

1. Save the configuration settings.
2. Test the connection to Google Drive to ensure everything is setup correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your Google Drive connector is now configured.

## Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |


# Intuit QuickBooks
Source: https://docs.squared.ai/guides/sources/data-sources/intuit_quickbooks



## Connect AI Squared to Intuit QuickBooks

This guide will help you configure the Intuit QuickBooks Connector in AI Squared to access and transfer data from your Intuit QuickBooks database.

### Prerequisites

Before proceeding, ensure you have the required client id, client secret, realm id, and refresh token from your Intuit QuickBooks database.

## Step-by-Step Guide to Connect to your Intuit QuickBooks Database

## Step 1: Navigate to Intuit QuickBooks Database

Start by logging into your Intuit QuickBooks Console.

1. Sign in to your Intuit QuickBooks account at [Intuit QuickBooks Console](https://developer.intuit.com/app/developer/homepage).

## Step 2: Locate Intuit QuickBooks Configuration Details

Once you're in the Intuit QuickBooks console, you'll find the necessary configuration details:

1. **Client ID, Client Secret, Realm ID, and Refresh Token:**
   * Click the **My Hub** dropdown menu on the top-right of the Intuit QuickBooks Console then click **Playground**.
     <Frame>
       <img />
     </Frame>
   * Once in Playground follow the steps to retrive your **Client ID, Client Secret, Realm ID, and Refresh Token** and note them down.

## Step 3: Configure Intuit QuickBooks Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **Client ID:** The unique identifier for your QuickBooks application. This is issued by Intuit when you register your app in the QuickBooks Developer Portal.

* **Client Secret:** A secure secret key associated with your Client ID. Used together with the Client ID to authenticate your app when requesting OAuth tokens.

* **Realm ID:** A unique identifier for a QuickBooks company (also known as the Company ID). Required to make API requests specific to that company account.

* **Refresh Token:** A long-lived token used to obtain a new access token when the current one expires. This is essential for maintaining a persistent connection without requiring the user to re-authenticate.

## Step 4: Test the Intuit QuickBooks Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Intuit QuickBooks database from your application to ensure everything is set up correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your Intuit QuickBooks connector is now configured and ready to query data from your Intuit QuickBooks database.

## Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

This guide will help you seamlessly connect your AI Squared application to Intuit QuickBooks Database, enabling you to leverage your database's full potential.


# MariaDB
Source: https://docs.squared.ai/guides/sources/data-sources/maria_db



## Connect AI Squared to MariaDB

This guide will help you configure the MariaDB Connector in AI Squared to access and use your MariaDB data.

### Prerequisites

Before proceeding, ensure you have the necessary host, port, username, password, and database name from your MariaDB server.

## Step-by-Step Guide to Connect to MariaDB

## Step 1: Navigate to MariaDB Console

Start by logging into your MariaDB Management Console and navigating to the MariaDB service.

1. Sign in to your MariaDB account on your local server or through the MariaDB Enterprise interface.
2. In the MariaDB console, select the service you want to connect to.

## Step 2: Locate MariaDB Configuration Details

Once you're in the MariaDB console, you'll find the necessary configuration details:

1. **Host and Port:**
   * For local servers, the host is typically `localhost` and the default port is `3306`.
   * For remote servers, check your server settings or consult with your database administrator to get the correct host and port.
   * Note down the host and port as they will be used to connect to your MariaDB service.

2. **Username and Password:**
   * In the MariaDB console, you can find or create a user with the necessary permissions to access the database.
   * Note down the username and password as they are required for the connection.

3. **Database Name:**
   * List the available databases using the command `SHOW DATABASES;` in the MariaDB console.
   * Choose the database you want to connect to and note down its name.

## Step 3: Configure MariaDB Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **Host:** The host of your MariaDB service.
* **Port:** The port number of your MariaDB service.
* **Username:** Your MariaDB service username.
* **Password:** The corresponding password for the username.
* **Database:** The name of the database you want to connect to.

## Step 4: Test the MariaDB Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to MariaDB from your application to ensure everything is set up correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your MariaDB connector is now configured and ready to query data from your MariaDB service.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

This guide will help you seamlessly connect your AI Squared application to MariaDB, enabling you to leverage your database's full potential.


# Odoo
Source: https://docs.squared.ai/guides/sources/data-sources/odoo



## Connect AI Squared to Odoo

This guide will help you configure the Odoo Connector in AI Squared to access and transfer data from your Odoo instance.

### Prerequisites

Before initiating the Odoo connector setup, ensure you have the appropriate Odoo edition.
This connector uses Odoo's <a href="https://www.odoo.com/documentation/18.0/developer/reference/external_api.html">External API</a>,
which is only available on <i>Custom</i> Odoo pricing plans. Access to the external API is not available on
<i>One App Free</i> or <i>Standard</i> plans.

## Step-by-Step Guide to Connect to your Odoo server.

Before proceeding, ensure you have the URL to the Odoo instance, the database name, the account username and account password.

### Step 1: Configure Odoo Connector in Your Application

Enter the following information in your application:

* **URL**: The URL where the Odoo instance is hosted.

* **Database**: The Odoo database name where your data is stored.

* **Username**: The username of the account you use to log into Odoo.

* **Password**: The password of the account you use to log into Odoo.

### Step 2: Test the Odoo Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Odoo from your application to ensure everything is setup correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your Odoo connector is now configured.

## Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |


# Oracle
Source: https://docs.squared.ai/guides/sources/data-sources/oracle



## Connect AI Squared to Oracle

This guide will help you configure the Oracle Connector in AI Squared to access and transfer data to your Oracle database.

### Prerequisites

Before proceeding, ensure you have the necessary host, port, SID or service name, username, and password from your Oracle database.

## Step-by-Step Guide to Connect to Oracle database

### Step 1: Locate Oracle database Configuration Details

In your Oracle database, you'll need to find the necessary configuration details:

1. **Host and Port:**
   * For local servers, the host is typically `localhost` and the default port is `1521`.
   * For remote servers, check your server settings or consult with your database administrator to get the correct host and port.
   * Note down the host and port as they will be used to connect to your Oracle database.

2. **SID or Service Name:**
   * To find your SID or Service name:
     1. **Using SQL\*Plus or SQL Developer:**
        * Connect to your Oracle database using SQL\*Plus or SQL Developer.
        * Execute the following query:
          ```sql theme={null}
          select instance from v$thread
          ```
          or
          ```sql theme={null}
          SELECT sys_context('userenv', 'service_name') AS service_name FROM dual;
          ```
        * The result will display the SID or service name of your Oracle database.
     2. **Checking the TNSNAMES.ORA File:**
        * Locate and open the `tnsnames.ora` file on your system. This file is usually found in the `ORACLE_HOME/network/admin` directory.
        * Look for the entry corresponding to your database connection. The `SERVICE_NAME` or `SID` will be listed within this entry.
     * Note down the SID or service name as it will be used to connect to your Oracle database.

3. **Username and Password:**
   * In the Oracle, you can find or create a user with the necessary permissions to access the database.
   * Note down the username and password as it will be used to connect to your Oracle database.

### Step 2: Configure Oracle Connector in Your Application

Now that you have gathered all the necessary details, enter the following information in your application:

* **Host:** The host of your Oracle database.
* **Port:** The port number of your Oracle database.
* **SID:** The SID or service name you want to connect to.
* **Username:** Your Oracle username.
* **Password:** The corresponding password for the username.

### Step 3: Test the Oracle Database Connection

After configuring the connector in your application:

1. Save the configuration settings.
2. Test the connection to Oracle database from your application to ensure everything is set up correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your Oracle connector is now configured and ready to query data from your Oracle database.

## Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |

This guide will help you seamlessly connect your AI Squared application to Oracle Database, enabling you to leverage your database's full potential.


# PostgreSQL
Source: https://docs.squared.ai/guides/sources/data-sources/postgresql

PostgreSQL popularly known as Postgres, is a powerful, open-source object-relational database system that uses and extends the SQL language combined with many features that safely store and scale data workloads.

## Setting Up a Source Connector in AI Squared

To integrate PostgreSQL with AI Squared, you need to establish a source connector.
This connector will enable AI Squared to extract data from your PostgreSQL database efficiently.
Below are the steps to set up the source connector in AI Squared:

### Step 1: Access AI Squared

* Log in to your AI Squared account.
* Navigate to the `Sources` section where you can manage your data sources.

### Step 2: Create a New Source Connector

* Click on the `Add Source` button.
* Select `PostgreSQL` from the list of available source types.

### Step 3: Configure Connection Settings

You'll need to provide the following details to establish a connection between AI Squared and your PostgreSQL database:

`Host` The hostname or IP address of the server where your PostgreSQL database is hosted.

`Port` The port number on which your PostgreSQL server is listening (default is 5432).

`Database` The name of the database you want to connect to.

`Schema` The schema within your PostgreSQL database you wish to access.

`Username` The username used to access the database.

`Password` The password associated with the username.

Enter these details in the respective fields on the connector configuration page and press continue.

### Step 4: Test the Connection

* Once you've entered the necessary information. The next step is automated **Test Connection** feature to ensure that AI Squared can successfully connect to your PostgreSQL database.
* If the test is successful, you'll receive a confirmation message. If not, double-check your entered details for any errors.

### Step 5: Finalize the Source Connector Setup

* Save the connector settings to establish the source connection.

### Conclusion

By following these steps, you've successfully set up a PostgreSQL source connector in AI Squared.


# Amazon Redshift
Source: https://docs.squared.ai/guides/sources/data-sources/redshift



## Overview

Amazon Redshift connector is built on top of JDBC and is based on the [Redshift JDBC driver](https://docs.aws.amazon.com/redshift/latest/mgmt/configure-jdbc-connection.html). It allows you to connect to your Redshift data warehouse and extract data for further processing and analysis.

## Prerequisites

Before proceeding, ensure you have the necessary Redshift credentials available, including the endpoint (host), port, database name, user, and password. You might also need appropriate permissions to create connections and execute queries within your Redshift cluster.

## Step-by-Step Guide to Connect Amazon Redshift

### Step 1: Navigate to the Sources Section

Begin by accessing your AI Squared dashboard. From there:

1. Click on the Setup menu found on the sidebar.
2. Select the `Sources` section to proceed.

### Step 2: Add Redshift as a New Source

Within the Sources section:

1. Find and click on the `Add Source` button.
2. From the list of data warehouse options, select **Amazon Redshift**.

### Step 3: Enter Redshift Credentials

You will be prompted to enter the credentials for your Redshift cluster. This includes:

**`Endpoint (Host)`** The URL of your Redshift cluster endpoint.

**`Port`** The port number used by your Redshift cluster (default is 5439).

**`Database Name`** The name of the database you wish to connect.

**`User`** Your Redshift username.

**`Password`** Your Redshift password.

<Warning>Make sure to enter these details accurately to ensure a successful connection.</Warning>

### Step 4: Test the Connection

Before finalizing the connection:

Click on the `Test Connection` button. This step verifies that AI Squared can successfully connect to your Redshift cluster with the provided credentials.

### Step 5: Finalize Your Redshift Source Connection

After a successful connection test:

1. Assign a name and a brief description to your Redshift source. This helps in identifying and managing your source within AI Squared.
2. Click `Save` to complete the setup process.

### Step 6: Configure Redshift User Permissions

<Note>It is recommended to create a dedicated user with read-only access to the tables you want to query. Ensure that the new user has the necessary permissions to access the required tables and views.</Note>

```sql theme={null}
CREATE USER aisquared PASSWORD 'password';
GRANT USAGE ON SCHEMA public TO aisquared;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO aisquared;
```

Your Amazon Redshift data warehouse is now connected to AI Squared. You can now start creating models and running queries on your Redshift data.


# Salesforce Consumer Goods Cloud
Source: https://docs.squared.ai/guides/sources/data-sources/salesforce-consumer-goods-cloud



## Overview

Salesforce Consumer Goods Cloud is a specialized CRM platform designed to help companies in the consumer goods industry manage their operations more efficiently.
It provides tools to optimize route-to-market strategies, increase sales performance, and enhance field execution.
This cloud-based solution leverages Salesforce's robust capabilities to deliver data-driven insights, streamline inventory and order management, and foster closer relationships with retailers and customers.

### Key Features:

* **Retail Execution**: Manage store visits, ensure product availability, and optimize shelf placement.
* **Sales Planning and Operations**: Create and manage sales plans that align with company goals.
* **Trade Promotion Management**: Plan, execute, and analyze promotional activities to maximize ROI.
* **Field Team Management**: Enable field reps with tools and data to improve productivity and effectiveness.

## Connector Configuration and Credential Retrieval Guide

### Prerequisite Requirements

When setting up an integration between Salesforce Consumer Goods Cloud and Multiwoven, certain credentials are required to authenticate and establish a secure connection. Below is a brief description of each credential needed:

* **Username**: The Salesforce username used to log in.
* **Password**: The password associated with the Salesforce username.
* **Host**: The URL of your Salesforce instance (e.g., [https://login.salesforce.com](https://login.salesforce.com)).
* **Security Token**: An additional security key that is appended to your password for API access from untrusted networks.
* **Client ID** and **Client Secret**: These are part of the OAuth credentials required for authenticating an application with Salesforce.
  They are obtained when you set up a new "Connected App" in Salesforce for integrating with external applications. You may refer our [Salesforce CRM docs](https://docs.multiwoven.com/destinations/crm/salesforce#destination-setup) for further details.

### Setting Up Security Token in Salesforce

<AccordionGroup>
  <Accordion title="Steps to Retrieve or Reset a Salesforce Security Token" icon="salesforce">
    <Steps>
      <Step title="Sign In">
        Log in to your Salesforce account.
      </Step>

      <Step title="Settings">
        Navigate to Settings or My Settings by first clicking on My Profile and then clicking **Settings** under the Personal Information section.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Quick Find">
        Once inside the Settings page click on the Quick Find box and type "Reset My Security Token" to quickly navigate to the option.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Reset My Security Token">
        Click on Reset My Security Token under the Personal section. Salesforce will send the new security token to the email address associated with your account.
        If you do not see the option to reset the security token, it may be because your organization uses Single Sign-On (SSO) or has IP restrictions that negate the need for a token.

        <Frame>
          <img />
        </Frame>
      </Step>
    </Steps>
  </Accordion>
</AccordionGroup>

<Accordion title="Supported Sync" icon="arrows-rotate">
  | Mode             | Supported (Yes/No/Coming soon) |
  | ---------------- | ------------------------------ |
  | Incremental sync | Yes                            |
  | Full refresh     | Coming soon                    |
</Accordion>

<Accordion title="Supported Streams">
  | Stream      | Supported (Yes/No/Coming soon) |
  | ----------- | ------------------------------ |
  | Account     | Yes                            |
  | User        | Yes                            |
  | Visit       | Yes                            |
  | RetailStore | Yes                            |
  | RecordType  | Yes                            |
</Accordion>


# SFTP
Source: https://docs.squared.ai/guides/sources/data-sources/sftp



## Connect AI Squared to SFTP

The Secure File Transfer Protocol (SFTP) is a secure method for transferring files between systems. This guide will help you configure the SFTP Connector with AI Squared allows you to access your data.

### Prerequisites

Before proceeding, ensure you have the hostname/ip address, port, username, password, file path, and file name from your SFTP Server.

## Step-by-Step Guide to Connect to a SFTP Server Endpoint

### Step 1: Navigate to your SFTP Server

1. Log in to your SFTP Server.
2. Select your SFTP instances.

### Step 2: Locate SFTP Configuration Details

Once you're in your select instance of your SFTP Server, you'll find the necessary configuration details:

#### 1. User section

* **Host**: The hostname or IP address of the SFTP server.
* **Port**: The port number used for SFTP connections (default is 22).
* **Username**: Your username for accessing the SFTP server.
* **Password**: The password associated with the username.

<Frame>
  <img />
</Frame>

#### 2. File Manager section

* **File Path**: The directory path on the SFTP server where your file is stored.
* **File Name**: The name of the file to be read.

<Frame>
  <img />
</Frame>

### Step 3: Configure and Test the SFTP Connection

Now that you have gathered all the necessary details, enter the necessary details for the connector in your application:

1. Save the configuration settings.
2. Test the connection to SFTP from your application to ensure everything is set up correctly.
3. Run a test query or check the connection status to verify successful connectivity.

Your SFTP connector is now configured and ready to query data from your SFTP service.

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |


# Snowflake
Source: https://docs.squared.ai/guides/sources/data-sources/snowflake



# Source/Snowflake

### Overview

This Snowflake source connector is built on top of the ODBC and is configured to rely on the Snowflake ODBC driver as described in Snowflake [documentation](https://docs.snowflake.com/en/developer-guide/odbc/odbc).

### Setup

#### Authentication

Authentication is supported via two methods: username/password and OAuth 2.0.

1. Login and Password

| Field                                                                                                 | Description                                                                                                                                                                                            |
| ----------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [Host](https://docs.snowflake.com/en/user-guide/admin-account-identifier.html)                        | The host domain of the Snowflake instance. Must include the account, region, cloud environment, and end with snowflakecomputing.com. Example: accountname.us-east-2.aws.snowflakecomputing.com         |
| [Warehouse](https://docs.snowflake.com/en/user-guide/warehouses-overview.html#overview-of-warehouses) | The Snowflake warehouse to be used for processing queries.                                                                                                                                             |
| [Database](https://docs.snowflake.com/en/sql-reference/ddl-database.html#database-schema-share-ddl)   | The specific database in Snowflake to connect to.                                                                                                                                                      |
| [Schema](https://docs.snowflake.com/en/sql-reference/ddl-database.html#database-schema-share-ddl)     | The schema within the database you want to access.                                                                                                                                                     |
| Username                                                                                              | The username associated with your account                                                                                                                                                              |
| Password                                                                                              | The password associated with the username.                                                                                                                                                             |
| [JDBC URL Params](https://docs.snowflake.com/en/user-guide/jdbc-parameters.html)                      | (Optional) Additional properties to pass to the JDBC URL string when connecting to the database formatted as key=value pairs separated by the symbol &. Example: key1=value1\&key2=value2\&key3=value3 |

2. Oauth 2.0

   Coming soon

### Supported sync modes

| Mode             | Supported (Yes/No/Coming soon) |
| ---------------- | ------------------------------ |
| Incremental sync | YES                            |
| Full refresh     | Coming soon                    |


# WatsonX.Data
Source: https://docs.squared.ai/guides/sources/data-sources/watsonx_data



## Connect AI Squared to WatsonX.Data

This guide will help you configure the WatsonX.Data Connector in AI Squared to access your WatsxonX.Data databases.

### Prerequisites

Before proceeding, ensure you have the following details:
API key, region, Instance Id (CRN), Engine Id, Database, and Schema.

## Step-by-Step Guide to Connect to a WatsonX.Data Database Engine.

## Step 1: Navigate to WatsonX.Data Console

Start by logging into your [WatsonX Console](https://dataplatform.cloud.ibm.com/wx/home?context=wx).

## Step 2: Locate Developer Access

Once you're in WatsonX, you'll need find the necessary configuration details
by following these steps in order:

### **API Key:**

1. Scroll down to Developer access.

<Frame>
  <img />
</Frame>

2. Click on `Manage IBM Cloud API keys` to view your API keys.
3. 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.

<Frame>
  <img />
</Frame>

### Region

4. The IBM Cloud region can be selected from the top right corner of the WatsonX Console.
   Choose the region where your WatsonX.Data resources are located and note down the region.

## Instance Id

5. Open the `Navigation Menu`, select `Administration`, `Services`, and finally `Service instances`.

<Frame>
  <img />
</Frame>

6. From the `Service instances` table, select your WatsonX.Data instance.

<Frame>
  <img />
</Frame>

7. Scroll down to Deployment details, and write down the CRN, that's your Instance Id.

<Frame>
  <img />
</Frame>

### Engine ID

8. Scroll back up and click `Open web console`.

<Frame>
  <img />
</Frame>

9. Open the Global Menu, select `Infrastructure manager`.

10. Select the Presto engine you are building the connector for to show the Engine details.

<Frame>
  <img />
</Frame>

11. Write down the Engine ID.

<Frame>
  <img />
</Frame>

### Database

11. On the same screen as the previous step, your database is one of the Associated catalogs in the Presto engine.

### Schema

12. Open the Global Menu, select `Data manager`, and expand your associated catalog to show the available schemas.

<Frame>
  <img />
</Frame>

## Step 3: Configure WatsonX.Data Source 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.Data resources are located.
* **Instance Id:** The instance ID, or CRN (Clourd Resource Name) for your WatsonX.Data deployment.
* **Engine Id:** The Engine Id of the Presto engine.
* **Database:** The catalog associated to your Presto engine.
* **Schema:** The schema you want to connect to.


# Welcome
Source: https://docs.squared.ai/home/welcome



<div>
  <div>
    <img />
  </div>

  <div>
    <div>
      Bring AI To Where Work Happens
    </div>

    <p>
      What can we help you build?
    </p>

    <button type="button">
      <svg />

      Start a chat with us...
    </button>
  </div>
</div>

<div>
  <div>
    <h1>
      Choose a topic below or simply
      <a href="https://app.squared.ai">get started</a>
    </h1>
  </div>

  <CardGroup>
    <Card title="Getting Started" icon="book-open" href="/getting-started">
      Onboarding, setup, and key concepts to get started with AI Squared.
    </Card>

    <Card title="AI Activation" icon="brain" href="/activation/ai-modelling/introduction">
      Connect to AI/ML models, databases, and business data sources.
    </Card>

    <Card title="AI Workflows" icon="party-horn" href="/workflows">
      Latest features, enhancements, and release notes.
    </Card>

    <Card title="Data Movement" icon="database" href="/guides/core-concepts">
      Add AI-powered insights, chatbots, and automation into business apps.
    </Card>

    <Card title="Deployment & Security" icon="link-simple" href="/deployment-and-security/overview">
      Deployment options, security best practices, and compliance.
    </Card>

    <Card title="Developers" icon="code" href="/api-reference/introduction">
      API documentation, integration guides, and developer resources.
    </Card>
  </CardGroup>
</div>


# Commit Message Guidelines
Source: https://docs.squared.ai/open-source/community-support/commit-message-guidelines



Multiwoven follows the following format for all commit messages.

Format: `<type>([<edition>]) : <subject>`

## Example

```
feat(CE): add source/snowflake connector
^--^  ^--^  ^------------^
|     |     |
|     |     +-> Summary in present tense.
|     |
|     +-------> Edition: CE for Community Edition or EE for Enterprise Edition.
|
+-------------> Type: chore, docs, feat, fix, refactor, style, or test.
```

Supported Types:

* `feat`: (new feature for the user, not a new feature for build script)
* `fix`: (bug fix for the user, not a fix to a build script)
* `docs`: (changes to the documentation)
* `style`: (formatting, missing semi colons, etc; no production code change)
* `refactor`: (refactoring production code, eg. renaming a variable)
* `test`: (adding missing tests, refactoring tests; no production code change)
* `chore`: (updating grunt tasks etc; no production code change)

Sample messages:

* feat(CE): add source/snowflake connector
* feat(EE): add google sso

References:

* [https://gist.github.com/joshbuchea/6f47e86d2510bce28f8e7f42ae84c716](https://gist.github.com/joshbuchea/6f47e86d2510bce28f8e7f42ae84c716)
* [https://www.conventionalcommits.org/](https://www.conventionalcommits.org/)
* [https://seesparkbox.com/foundry/semantic\_commit\_messages](https://seesparkbox.com/foundry/semantic_commit_messages)
* [http://karma-runner.github.io/1.0/dev/git-commit-msg.html](http://karma-runner.github.io/1.0/dev/git-commit-msg.html)


# Contributor Code of Conduct
Source: https://docs.squared.ai/open-source/community-support/contribution

Contributor Covenant Code of Conduct

## Our Pledge

In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to make participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.

## Our Standards

Examples of behavior that contributes to creating a positive environment include:

* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members

Examples of unacceptable behavior by participants include:

* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting

## Our Responsibilities

Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.

Maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.

## Scope

This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community.

## Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at \[your email]. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances.

## Attribution

This Code of Conduct is adapted from the [Contributor Covenant](https://www.contributor-covenant.org/) , version 1.4, available at [https://www.contributor-covenant.org/version/1/4/code-of-conduct.html]()

For answers to common questions about this code of conduct, see [https://www.contributor-covenant.org/faq]()


# Overview
Source: https://docs.squared.ai/open-source/community-support/overview



<img alt="Hero Light" />

The aim of our community to provide anyone with the assistance they need, connect them with fellow users, and encourage them to contribute to the growth of the Multiwoven ecosystem.

## Getting Help from the Community

How to get help from the community?

* Join our Slack channel and ask your question in the relevant channel.

* Share as much information as possible about your issue, including screenshots, error messages, and steps to reproduce the issue.

* If you’re reporting a bug, please include the steps to reproduce the issue, the expected behavior, and the actual behavior.

### Github Issues

If you find a bug or have a feature request, please open an issue on GitHub.

To open an issue for a specific repository, go to the repository and click on the `Issues` tab. Then click on the `New Issue` button.

**Multiwoven server** issues can be reported [here](https://github.com/Multiwoven/multiwoven-server/issues).

**Multiwoven frontend** issues can be reported [here](https://github.com/Multiwoven/multiwoven-ui/issues).

**Multiwoven integration** issues can be reported [here](https://github.com/Multiwoven/multiwoven-integrations/issues).

### Contributing to Multiwoven

We welcome contributions to the Multiwoven ecosystem. Please read our [contributing guidelines](https://github.com/Multiwoven/multiwoven/blob/main/CONTRIBUTING.md) to get started.

We're always looking for ways to improve our documentation. If you find any mistakes or have suggestions for improvement, please [open an issue](https://github.com/Multiwoven/multiwoven/issues/new) on GitHub.


# Release Process
Source: https://docs.squared.ai/open-source/community-support/release-process



The release process at Multiwoven is fully automated through GitHub Actions.

<AccordionGroup>
  <Accordion title="Automation Stages" icon="github">
    Here's an overview of our automation stages, each facilitated by specific GitHub Actions:

    <Steps>
      <Step title="Weekly Release Workflow">
        * **Action**: [Release Workflow](https://github.com/Multiwoven/multiwoven/actions/workflows/release.yaml)
        * **Description**: Every Tuesday, a new release is automatically generated with a minor version tag (e.g., v0.4.0) following semantic versioning rules. This process also creates a pull request (PR) for release notes that summarize the changes in the new version.
        * **Additional Triggers**: The same workflow can be manually triggered to create a patch version (e.g., v0.4.1 for quick fixes) or a major version (e.g., v1.0.0 for significant architectural changes). This is done using the workflow dispatch feature in GitHub Actions.

        <Frame>
          <img />
        </Frame>
      </Step>

      <Step title="Automated Release Notes on Merge">
        * **Action**: [Create Release Note on Merge](https://github.com/Multiwoven/multiwoven/actions/workflows/create-release-notes.yaml)
        * **Description**: When the release notes PR is merged, it triggers the creation of a new release with detailed [release notes](https://github.com/Multiwoven/multiwoven/releases/tag/v0.4.0) on GitHub.
      </Step>

      <Step title="Docker Image Releases">
        * **Description**: Docker images need to be manually released based on the newly created tags from the GitHub Actions.
        * **Actions**:
          * [Build and push Multiwoven server docker image to Docker Hub](https://github.com/Multiwoven/multiwoven/actions/workflows/server-docker-hub-push-tags.yaml): This action handles the server-side Docker image push to docker hub with tag as latest and the new release tag i.e **v0.4.0**

            <Frame>
              <img />
            </Frame>
          * [Build and push Multiwoven UI docker image to Docker Hub](https://github.com/Multiwoven/multiwoven/actions/workflows/ui-docker-hub-push-tags.yaml): This action handles the user interface Docker image  to docker hub with tag as latest and the new release tag i.e **v0.4.0**

            <Frame>
              <img />
            </Frame>
      </Step>
    </Steps>
  </Accordion>
</AccordionGroup>


# Slack Code of Conduct
Source: https://docs.squared.ai/open-source/community-support/slack-conduct



## Introduction

At Multiwoven, we firmly believe that diversity and inclusion are the bedrock of a vibrant and effective community. We are committed to creating an environment that embraces a wide array of backgrounds and perspectives, and we want to clearly communicate our position on this.

## Our Commitment

We aim to foster a community that is safe, supportive, and friendly for all members, regardless of their experience, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, nationality, or any other defining characteristics.

## Scope

These guidelines apply to all forms of behavior and communication within our community spaces, both online and offline, including one-on-one interactions. This extends to any behavior that could impact the safety and well-being of community members, regardless of where it occurs.

## Expected Behaviors

* **Be Welcoming:**  Create an environment that is inviting and open to all.
* **Be Kind:**  Treat others with respect, understanding, and compassion.
* **Support Each Other:**  Actively look out for the well-being of fellow community members.

## Multiwoven Slack Etiquette Guidelines

To maintain a respectful, organized, and efficient communication environment within the Multiwoven community, we ask all members to adhere to the following etiquette guidelines on Slack:

## Etiquette Rules

1. **Be Respectful to Everyone:**  Treat all community members with kindness and respect. A positive attitude fosters a collaborative and friendly environment.
2. **Mark Resolved Questions:**  If your query is resolved, please indicate it by adding a ✅ reaction or a reply. This helps in identifying resolved issues and assists others with similar questions.
3. **Avoid Reposting Questions:**  If your question remains unanswered after 24 hours, review it for clarity and revise if necessary. If you still require assistance, you may tag @navaneeth for further attention.
4. **Public Posts Over Direct Messages:**  Please ask questions in public channels rather than through direct messages, unless you have explicit permission. Sharing questions and answers publicly benefits the entire community.
5. **Minimize Use of Tags:**  Our community is active and responsive. Please refrain from over-tagging members. Reserve tagging for urgent matters to respect everyone's time and attention.
6. **Use Threads for Detailed Discussions:**  To keep the main channel tidy, please use threads for ongoing discussions. This helps in keeping conversations organized and the main channel uncluttered.

## Conclusion

Following these etiquette guidelines will help ensure that our Slack workspace remains a supportive, efficient, and welcoming space for all members of the Multiwoven community. Your cooperation is greatly appreciated!


# Architecture Overview
Source: https://docs.squared.ai/open-source/guides/architecture/introduction



Multiwoven is structured into two primary components: the server and the connectors.

The server delivers all the essential horizontal services needed for configuring and executing data movement tasks, such as the[ User Interface](https://github.com/Multiwoven/multiwoven-ui), [API](https://github.com/Multiwoven/multiwoven-server), Job Scheduling, etc., and is organised as a collection of microservices.

Connectors are developed within the [multiwoven-integrations](https://github.com/Multiwoven/multiwoven-integrations) Ruby gem, which pushes and pulls data to and from various sources and destinations. These connectors are constructed following the [Multiwoven Protocol](https://docs.multiwoven.com/guides/architecture/multiwoven-protocol), which outlines the interface for transferring data between a source and a destination.

<Frame>
  <img />
</Frame>

1. [Multiwoven-UI](https://github.com/Multiwoven/multiwoven-ui) - User interface to interact with [ multiwoven-server](https://github.com/Multiwoven/multiwoven-server).
2. [Multiwoven-Server](https://github.com/Multiwoven/multiwoven-server) - Multiwoven’s control plane. All operations in Multiwoven such as creating sources, destinations, connections, managing configurations, etc., are configured and invoked from the server.
3. Database: Stores all connector/sync information.
4. [Temporal ](https://temporal.io/)- Orchestrates the the sync workflows.
5. Multiwoven-Workers - The worker connects to a source connector, pulls the data, and writes it to a destination. The workers' code resides in the [ multiwoven-server](https://github.com/Multiwoven/multiwoven-server) repo.


# Multiwoven Protocol
Source: https://docs.squared.ai/open-source/guides/architecture/multiwoven-protocol



### Introduction

Multiwoven [protocol](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/protocol/protocol.rb#L4) defines a set of interfaces for building connectors. Connectors can be implemented independent of our server application, this protocol allows developers to create connectors without requiring in-depth knowledge of our core platform.

### Concepts

**[Source](https://github.com/Multiwoven/multiwoven-integrations/blob/6462867b1a2698b4c30ae5abcdf3219a207a28d9/lib/multiwoven/integrations/protocol/protocol.rb#L66)** - A source in business data storage typically refers to data warehouses like Snowflake, AWS Redshift and Google BigQuery, as well as databases.

**[Destination](https://github.com/Multiwoven/multiwoven-integrations/blob/6462867b1a2698b4c30ae5abcdf3219a207a28d9/lib/multiwoven/integrations/protocol/protocol.rb#L66)** - A destination is a tool or third party service where source data is sent and utilised, often by end-users. It includes CRM systems, ad platforms, marketing automation, and support tools.

**[Stream](https://github.com/Multiwoven/multiwoven-integrations/blob/6462867b1a2698b4c30ae5abcdf3219a207a28d9/lib/multiwoven/integrations/protocol/protocol.rb#L105)** - A Stream defines the structure and metadata of a resource, such as a database table, REST API resource, or data stream, outlining how users can interact with it using query or request.

***Fields***

| Field                                   | Description                                                                                                                       |
| --------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| `name`                                  | A string representing the name of the stream.                                                                                     |
| `action` (optional)                     | Defines the action associated with the stream, e.g., "create", "update", or "delete".                                             |
| `json_schema`                           | A hash representing the JSON schema of the stream.                                                                                |
| `supported_sync_modes` (optional)       | An array of supported synchronization modes for the stream.                                                                       |
| `source_defined_cursor` (optional)      | A boolean indicating whether the source has defined a cursor for the stream.                                                      |
| `default_cursor_field` (optional)       | An array of strings representing the default cursor field(s) for the stream.                                                      |
| `source_defined_primary_key` (optional) | An array of arrays of strings representing the source-defined primary key(s) for the stream.                                      |
| `namespace` (optional)                  | A string representing the namespace of the stream.                                                                                |
| `url` (optional)                        | A string representing the URL of the API stream.                                                                                  |
| `request_method` (optional)             | A string representing the request method (e.g., "GET", "POST") for the API stream.                                                |
| `batch_support`                         | A boolean indicating whether the stream supports batching.                                                                        |
| `batch_size`                            | An integer representing the batch size for the stream.                                                                            |
| `request_rate_limit`                    | An integer value, specifying the maximum number of requests that can be made to the user data API within a given time limit unit. |
| `request_rate_limit_unit`               | A string value indicating the unit of time for the rate limit.                                                                    |
| `request_rate_concurrency`              | An integer value which limits the number of concurrent requests.                                                                  |

**[Catalog](https://github.com/Multiwoven/multiwoven-integrations/blob/6462867b1a2698b4c30ae5abcdf3219a207a28d9/lib/multiwoven/integrations/protocol/protocol.rb#L123)** - A Catalog is a collection of Streams detailing the data within a data store represented by a Source/Destination eg: Catalog = Schema, Streams = List\[Tables]
***Fields***

| Field                      | Description                                                                                                                                                                                                                         |
| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `streams`                  | An array of Streams detailing the data within the data store. This encapsulates various data streams available for synchronization or processing, each potentially with its own schema, sync modes, and other configurations.       |
| `request_rate_limit`       | An integer value, specifying the maximum number of requests that can be made to the user data API within a given time limit unit. This serves to prevent overloading the system by limiting the rate at which requests can be made. |
| `request_rate_limit_unit`  | A string value indicating the unit of time for the rate limit, such as "minute" or "second". This defines the time window in which the `request_rate_limit` applies.                                                                |
| `request_rate_concurrency` | An integer value which limits the number of concurrent requests that can be made. This is used to control the load on the system by restricting how many requests can be processed at the same time.                                |
| `schema_mode `             | A string value that identifies the schema handling mode for the connector. Supported values include **static, dynamic, and schemaless**. This parameter is crucial for determining how the connector handles data schema.           |

<Note>
  Rate limit specified in catalog will applied to stream if there is no stream specific
  rate limit is defined.
</Note>

**[Model](https://github.com/Multiwoven/multiwoven-integrations/blob/6462867b1a2698b4c30ae5abcdf3219a207a28d9/lib/multiwoven/integrations/protocol/protocol.rb#L86)** - Models specify the data to be extracted from a source
***Fields***

* `name` (optional): A string representing the name of the model.
* `query`: A string representing the query used to extract data from the source.
* `query_type`: A type representing the type of query used by the model.
* `primary_key`: A string representing the primary key of the model.

**[Sync](https://github.com/Multiwoven/multiwoven-integrations/blob/6462867b1a2698b4c30ae5abcdf3219a207a28d9/lib/multiwoven/integrations/protocol/protocol.rb#L134)** - A Sync sets the rules for data transfer from a chosen source to a destination

***Fields***

* `source`: The source connector from which data is transferred.
* `destination`: The destination connector where data is transferred.
* `model`: The model specifying the data to be transferred.
* `stream`: The stream defining the structure and metadata of the data to be transferred.
* `sync_mode`: The synchronization mode determining how data is transferred.
* `cursor_field` (optional): The field used as a cursor for incremental data transfer.
* `destination_sync_mode`: The synchronization mode at the destination.

### Interfaces

The output of each method in the interface is encapsulated in an [MultiwovenMessage](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/protocol/protocol.rb#L170), serving as an envelope for the message's return value. These are omitted in interface explanations for sake of simplicity.

#### Common

1. `connector_spec() -> ConnectorSpecification`

Description - [connector\_spec](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/core/base_connector.rb#L10) returns information about how the connector can be configured

Input - `None`

Output - [ConnectorSpecification](https://github.com/Multiwoven/multiwoven-integrations/blob/6462867b1a2698b4c30ae5abcdf3219a207a28d9/lib/multiwoven/integrations/protocol/protocol.rb#L49)
-One of the main pieces of information the specification shares is what information is needed to configure an Actor.

* **`documentation_url`**:\
  URL providing information about the connector.

* **`stream_type`**:\
  The type of stream supported by the connector. Possible values include:

  * `static`: The connector catalog is static.
  * `dynamic`: The connector catalog is dynamic, which can be either schemaless or with a schema.
  * `user_defined`: The connector catalog is defined by the user.

* **`connector_query_type`**:\
  The type of query supported by the connector. Possible values include:

  * `raw_sql`: The connector is SQL-based.
  * `soql`: Specifically for Salesforce.
  * `ai_ml`: Specific for AI model source connectors.

* **`connection_specification`**:\
  The properties required to connect to the source or destination.

* **`sync_mode`**:\
  The synchronization modes supported by the connector.

2. `meta_data() -> Hash`

Description - [meta\_data](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/core/base_connector.rb#L17) returns information about how the connector can be shown in the multiwoven ui eg: icon, labels etc.

Input - `None`

Output - `Hash`. Sample hash can be found [here](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/source/bigquery/config/meta.json)

3. `check_connection(connection_config) -> ConnectionStatus`

Description: The [check\_connection](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/core/base_connector.rb#L21) method verifies if a given configuration allows successful connection and access to necessary resources for a source/destination, such as confirming Snowflake database connectivity with provided credentials. It returns a success response if successful or a failure response with an error message in case of issues like incorrect passwords

Input - `Hash`

Output - [ConnectionStatus](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/protocol/protocol.rb#L37)

4. `discover(connection_config) -> Catalog`

Description: The [discover](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/core/base_connector.rb#L26) method identifies and outlines the data structure in a source/destination. Eg: Given a valid configuration for a Snowflake source, the discover method returns a list of accessible tables, formatted as streams.

Input - `Hash`

Output - [Catalog](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/protocol/protocol.rb#L121)

#### Source

[Source](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/core/source_connector.rb) implements the following interface methods including the common methods.

```
connector_spec() -> ConnectorSpecification
meta_data() -> Hash
check_connection(connection_config) -> ConnectionStatus
discover(connection_config)  -> Catalog
read(SyncConfig) ->Array[RecordMessage]
```

1. `read(SyncConfig) ->Array[RecordMessage]`

Description -The [read](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/core/source_connector.rb#L6) method extracts data from a data store and outputs it as RecordMessages.

Input - [SyncConfig](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/protocol/protocol.rb#L132)

Output - List\[[RecordMessage](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/protocol/protocol.rb#L93)]

#### Destination

[Destination](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/core/destination_connector.rb) implements the following interface methods including the common methods.

```
connector_spec() -> ConnectorSpecification
meta_data() -> Hash
check_connection(connection_config) -> ConnectionStatus
discover(connection_config)  -> Catalog
write(SyncConfig,Array[records]) -> TrackingMessage
```

1. `write(SyncConfig,Array[records]) -> TrackingMessage`

Description -The [write](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/core/destination_connector.rb#L6C11-L6C40) method loads data to destinations.

Input - `Array[Record]`

Output - [TrackingMessage](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/protocol/protocol.rb#L157)

Note: Complete multiwoven protocol models can be found [here](https://github.com/Multiwoven/multiwoven-integrations/blob/main/lib/multiwoven/integrations/protocol/protocol.rb)

### Acknowledgements

We've been significantly influenced by the [Airbyte protocol](https://github.com/airbytehq/airbyte-protocol), and their design choices greatly accelerated our project's development.


# Sync States
Source: https://docs.squared.ai/open-source/guides/architecture/sync-states



# Overview

This document details the states and transitions of sync operations, organizing the sync process into specific statuses and run states. These categories are vital for managing data flow during sync operations, ensuring successful and efficient execution.

## Sync Status Definitions

Each sync run operation can be in one of the following states, which represent the sync run's current status:

| State        | Description                                                                                       |
| ------------ | ------------------------------------------------------------------------------------------------- |
| **Healthy**  | A state indicating the successful completion of a recent sync run operation without any issues.   |
| **Disabled** | Indicates that the sync operation has been manually turned off and will not run until re-enabled. |
| **Pending**  | Assigned immediately after a sync is set up, signaling that no sync runs have been initiated yet. |
| **Failed**   | Denotes a sync operation that encountered an error, preventing successful completion.             |

> **Note:** Ensure that sync configurations are regularly reviewed to prevent prolonged periods in the Disabled or Failed states.

### Sync State Transitions

The following describes the allowed transitions between the sync states:

* **Pending ➔ Healthy**: Occurs when a sync run completes successfully.
* **Pending ➔ Failed**: Triggered if a sync run fails or is aborted.
* **Failed ➔ Healthy**: A successful sync run after a previously failed attempt.
* **Any state ➔ Disabled**: Reflects the manual disabling or enabling of the sync operation.

## Sync Run Status Definitions

| Status             | Description                                                                                                                                                                                                                                                                                    |
| ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Started**        | Indicates that the sync operation has begun. This status serves as the initial state of a new sync run operation after being triggered.                                                                                                                                                        |
| **Querying**       | The sync is currently querying a source with its associated model to retrieve the latest data. This involves moving data to a temporary table called "SyncRecord".                                                                                                                             |
| **Queued**         | Indicates the sync is scheduled for execution, following the successful transfer of source data to the "SyncRecord" table. This marks the completion of the preparation phase, with the sync now ready to transmit data to the destination as per system scheduling and resource availability. |
| **In Progress**    | The sync is actively transferring data from the "SyncRecord" table to the destination. This phase marks the actual update or insertion of data into the destination database, reflecting the final step of the sync process.                                                                   |
| **Success**        | The sync run is completed successfully without any issues.                                                                                                                                                                                                                                     |
| **Paused**         | Indicates a temporary interruption occurred while transferring data from the "SyncRecord" table to the destination. The sync is paused but designed to automatically resume in a subsequent run, ensuring continuity of the sync process.                                                      |
| **Aborted/Failed** | The sync has encountered an error that prevents it from completing successfully.                                                                                                                                                                                                               |

### Sync Run State Transitions

The following describes the allowed transitions between the sync run states:

* **Started ➔ Querying**: Transition post-initiation as data retrieval begins.
* **Querying ➔ Queued**: After staging data in the "SyncRecord" table, indicating readiness for transmission.
* **Queued ➔ In Progress**: Commences as the sync operation begins writing data to the destination, based on availability of system resources.
* **In Progress ➔ Success**: Marks the successful completion of data transmission.
* **In Progress ➔ Paused**: Triggered by a temporary interruption in the sync process.
* **Paused ➔ In Progress**: Signifies the resumption of a sync operation post-interruption.
* **In Progress ➔ Aborted/Failed**: Initiated when an error prevents the successful completion of the sync operation.


# Technical Stack
Source: https://docs.squared.ai/open-source/guides/architecture/technical-stack



### Frameworks

* **Ruby on Rails**

* **Typescript**

* **ReactJS**

## Database & Workers

* **PostgreSQL**

* **Temporal**

* **Redis**

## Deployment

* **Docker**

* **Kubernetes**

* **Helm**

## Monitoring

* **Prometheus**

* **Grafana**

## CI/CD

* **Github Actions**

## Testing

* **RSpec**

* **Cypress**


# Overview
Source: https://docs.squared.ai/overview



Most AI models are built to be general. Enterprise work is specific.

AISquared builds proprietary models for the real tasks that happen inside business systems: routing requests, applying guardrails, retrieving the right context, reading documents, and supporting workflow automation.

These models are part of the **Bolt model family** and are built to work inside **UNIFI**, where data, context, models, actions, and feedback come together in one governed system.

Instead of sending every request to one large model, UNIFI can use Bolt models to route each task to the right model or workflow. This helps teams improve speed, reduce cost, keep data under control, and get more reliable outputs in production.

## **Why Proprietary Models matter**

Enterprises do not just need larger models. They need models that work well in their own environment.

AISquared models are designed to:

* Work with enterprise data and applications through UNIFI
* Produce structured outputs that business systems can use
* Support secure deployment, including on-prem, VPC, and restricted environments
* Improve RAG, document processing, and workflow automation
* Help control cost and latency through model routing
* Support guardrails, feedback, and ongoing quality checks

## **Introducing The Bolt Model Family**

Our proprietary models are part of the **Bolt family**, built to support key parts of enterprise AI systems.

Each model is focused on a specific job:

### **Bolt Instruct**

**For structured outputs, routing, and guardrails**

Bolt Instruct models help UNIFI decide what should happen next. They support tasks where consistency, control, and safe behavior matter.

Bolt Instruct can be used to:

* Route requests to the right model or workflow
* Produce structured responses that systems can act on
* Classify tasks by type, risk, or complexity
* Detect sensitive data and unsafe content
* Support guardrails on inputs and outputs
* Power LLM-as-judge checks for quality review
* Support general chat and instruction-following tasks

### **Bolt Embedding**

**For accurate retrieval and context**

Bolt Embedding models help UNIFI find the right information before a model generates an answer.

They are used to:

* Retrieve relevant enterprise data
* Improve search across documents and systems
* Support RAG workflows
* Ground responses in trusted sources
* Reduce the risk of answers based on weak or missing context

The Bolt-Embedding family supports a tiered retrieval setup:

* **Bolt-Small** for broad, fast candidate retrieval
* **Bolt-Large** for precision reranking

This helps because RAG quality depends on the context passed into the model. Better retrieval helps UNIFI give users more grounded, source-backed answers.

### **Bolt Vision**

**For document understanding and extraction**

Bolt Vision, also referred to as **Bolt-VL** in research, is built for business documents and visual content.

It can be used to:

* Extract fields from invoices, reports, and forms
* Read tables and layouts
* Convert unstructured documents into structured data
* Support approvals, data entry, and downstream workflows
* Answer questions about documents and images

## How Bolt works within UNIFI

The Bolt model family is purpose-built to integrate seamlessly with the AISquared UNIFI platform, ensuring that AI outputs are securely and efficiently embedded into existing business applications. By excelling at targeted enterprise tasks, Bolt models are critical for maximizing UNIFI’s core value propositions: **Model Flexibility**, **Enterprise Guardrails**, and **Closed-Loop Improvement**.

### Bolt Instruct: Orchestration, Governance, and General Intelligence

Bolt Instruct models are the foundation for complex AI orchestration and governance within UNIFI.

* **General Chat & Instruction Following:** Instruct models have been tuned to excel as conversational chatbots, able to respond to user requests quickly and effectively.
* **Guardrails and Safety:** Instruct models are used for providing guardrails on inputs and outputs, directly supporting UNIFI's **Enterprise Guardrails** and **Inline Governance** features. The **Guardrails and Safety Evaluation** demonstrated that Bolt Instruct models achieve strong performance in detecting PII, unsafe content, and jailbreak attempts, even compared to larger production models. This ensures secure and compliance-aware operations for both enterprise and federal environments.
* **Model Routing:** By acting as the engine for routing requests to the appropriate downstream model(s), Bolt Instruct ensures optimal resource usage and cost efficiency. The **Model Routing Evaluation** confirmed the models’ effectiveness, achieving strong Strict and Lenient Accuracy metrics required for reliably orchestrating multi-model systems.
* **LLM-as-a-Judge & General Capabilities:** The models serve as a general chatbot, for translation, and for built-in LLM-as-a-judge functionality, which is vital for closing the feedback loop and iteratively tuning models. The models’ strong performance retention on reasoning benchmarks (*ARC-Easy*, *BBH*) ensures reliable decision-making and instruction-following for these complex, general-purpose tasks.

### Bolt Embedding: High-Performance Retrieval for Enterprise RAG

Bolt Embedding models are essential for turning raw data into actionable knowledge within the UNIFI platform.

* **Search and Retrieval:** Embeddings models convert ingested documents (from lakes, warehouses, and apps) to vector embeddings for search and retrieval. The model’s design for efficient, large-scale vector search supports UNIFI’s **Plug-and-Play Data Integration**.
* **Reliable RAG:** The **Real-World RAG Evaluation** is the key indicator of value. By achieving a lower average retrieval rank and more consistent performance on challenging queries than larger models like EmbeddingGemma, Bolt Embedding ensures that the UNIFI RAG pipeline retrieves the most relevant context reliably, leading to higher-quality, data-backed insights for end-users.

### Bolt Vision: Unlocking Business-Critical Data from Documents

Bolt Vision models are designed to enable the ingestion and use of multimodal and unstructured data, a core requirement for enterprise intelligence.

* **Structured Data Extraction:** Bolt Vision models are available to extract information from charts and tables, and to extract structured data from business documents like invoices, which UNIFI then sends to a downstream database. The **Internal Invoice Benchmark** validates this capability: the models exceeded the performance of Claude 4.6 Opus and GPT-5.2 on Line Item and Invoice Metadata Accuracy. This performance is critical for ensuring the extracted data is perfectly transcribed, preventing errors when added to downstream systems.
* **Efficiency and Multimodality:** The preserved general visual performance allows the models to answer multimodal chat queries. Furthermore, the model’s small size and efficiency—leading to over 60% reduction in hosting costs compared to other comparable models—supports UNIFI’s commitment to resource-constrained and on-premise deployment.

## **Why This Matters for Enterprise Teams**

### **Better cost control**

A routed model setup can reduce the need to use large frontier models for every task. In the evaluated mixed workload, the routed Bolt setup reduced estimated operating cost by **49% per million requests**.

### **Lower latency**

By sending simpler work to smaller models, UNIFI can reduce response times for common tasks. In AISquared’s evaluation, the routed setup improved weighted average latency by **42%**.

### **Stronger data protection**

Bolt Instruct 32B achieved a perfect PII detection score on the evaluated set, making it a strong fit for use cases where sensitive data controls are required.

### **Better document automation**

Bolt Vision supports document extraction workflows where accuracy matters, such as invoices, forms, reports, and other structured business documents.

### **More reliable RAG**

Bolt Embedding helps UNIFI retrieve better context for enterprise questions, which improves the quality of downstream answers.

### **Flexible deployment**

Bolt models support UNIFI deployments across cloud, VPC, on-prem, and restricted environments. This helps commercial, federal, and regulated teams keep AI closer to their data and policies.


# 2024 releases
Source: https://docs.squared.ai/release-notes/2024



<CardGroup>
  <Card title="May 2024" icon="book-open" href="/release-notes/2024/May-2024">
    Version: v0.5.0 to v0.8.0
  </Card>

  <Card title="June 2024" icon="book-open" href="/release-notes/2024/June-2024">
    Version: v0.12.0 to v0.13.0
  </Card>

  <Card title="July 2024" icon="book-open" href="/release-notes/2024/July-2024">
    Version: v0.14.0 to v0.19.0
  </Card>

  <Card title="August 2024" icon="book-open" href="/release-notes/2024/August-2024">
    Version: v0.20.0 to v0.22.0
  </Card>

  <Card title="September 2024" icon="book-open" href="/release-notes/2024/September-2024">
    Version: v0.23.0 to v0.24.0
  </Card>

  <Card title="October 2024" icon="book-open" href="/release-notes/2024/October-2024">
    Version: v0.25.0 to v0.30.0
  </Card>

  <Card title="November 2024" icon="book-open" href="/release-notes/2024/November-2024">
    Version: v0.31.0 to v0.35.0
  </Card>

  <Card title="December 2024" icon="book-open" href="/release-notes/2024/December-2024">
    Version: v0.36.0 to v0.38.0
  </Card>
</CardGroup>


# August 2024 releases
Source: https://docs.squared.ai/release-notes/2024/August-2024

Release updates for the month of August

## 🚀 **New Features**

### 🔄 **Enable/Disable Sync**

We’ve introduced the ability to enable or disable a sync. When a sync is disabled, it won’t execute according to its schedule, allowing you to effectively pause it without the need to delete it. This feature provides greater control and flexibility in managing your sync operations.

### 🧠 **Source: Databricks AI Model Connector**

Multiwoven now integrates seamlessly with [Databricks AI models](https://docs.squared.ai/guides/data-integration/sources/databricks-model) in the source connectors. This connection allows users to activate AI models directly through Multiwoven, enhancing your data processing and analytical capabilities with cutting-edge AI tools.

### 📊 **Destination: Microsoft Excel**

You can now use [Microsoft Excel](https://docs.squared.ai/guides/data-integration/destinations/productivity-tools/microsoft-excel) as a destination connector. Deliver your modeled data directly to Excel sheets for in-depth analysis or reporting. This addition simplifies workflows for those who rely on Excel for their data presentation and analysis needs.

### ✅ **Triggering Test Sync**

Before running a full sync, users can now initiate a test sync to verify that everything is functioning as expected. This feature ensures that potential issues are caught early, saving time and resources.

### 🏷️ **Sync Run Type**

Sync types are now clearly labeled as either "General" or "Test" in the Syncs Tab. This enhancement provides clearer context for each sync operation, making it easier to distinguish between different sync runs.

### 🛢️ **Oracle DB as a Destination Connector**

[Oracle DB](https://docs.squared.ai/guides/data-integration/destinations/database/oracle) is now available as a destination connector. Users can navigate to **Add Destination**, select **Oracle**, and input the necessary database details to route data directly to Oracle databases.

### 🗄️ **Oracle DB as a Source Connector**

[Oracle DB](https://docs.squared.ai/guides/data-integration/sources/oracle) has also been added as a source connector. Users can pull data from Oracle databases by navigating to **Add Source**, selecting **Oracle**, and entering the database details.

***

## 🔧 **Improvements**

### **Memory Bloat Issue in Sync**

Resolved an issue where memory bloat was affecting sync performance over time, ensuring more stable and efficient sync operations.

### **Discover and Table URL Fix**

Fixed issues with discovering and accessing table URLs, enhancing the reliability and accuracy of data retrieval processes.

### **Disable to Fields**

Added the option to disable fields where necessary, giving users more customization options to fit their specific needs.

### **Query Source Response Update**

Updated the query source response mechanism, improving data handling and accuracy in data query operations.

### **OCI8 Version Fix**

Resolved issues related to the OCI8 version, ensuring better compatibility and smoother database interactions.

### **User Read Permission Update**

Updated user read permissions to enhance security and provide more granular control over data access.

### **Connector Name Update**

Updated connector names across the platform to ensure better clarity and consistency, making it easier to manage and understand your integrations.

### **Account Verification Route Removal**

Streamlined the user signup process by removing the account verification route, reducing friction for new users.

### **Connector Creation Process**

Refined the connector creation process, making it more intuitive and user-friendly, thus reducing the learning curve for new users.

### **README Update**

The README file has been updated to reflect the latest changes and enhancements, providing more accurate and helpful guidance.

### **Request/Response Logs Added**

We’ve added request/response logs for multiple connectors, including Klaviyo, HTTP, Airtable, Slack, MariaDB, Google Sheets, Iterable, Zendesk, HubSpot, Stripe, and Salesforce CRM, improving debugging and traceability.

### **Logger Issue in Sync**

Addressed a logging issue within sync operations, ensuring that logs are accurate and provide valuable insights.

### **Main Layout Protected**

Wrapped the main layout with a protector, enhancing security and stability across the platform.

### **User Email Verification**

Implemented email verification during signup using Devise, increasing account security and ensuring that only verified users have access.

### **Databricks Datawarehouse Connector Name Update**

Renamed the Databricks connection to "Databricks Datawarehouse" for improved clarity and better alignment with user expectations.

### **Version Upgrade to 0.9.1**

The platform has been upgraded to version `0.9.1`, incorporating all the above features and improvements, ensuring a more robust and feature-rich experience.

### **Error Message Refactoring**

Refactored error messages to align with agreed-upon standards, resulting in clearer and more consistent communication across the platform.


# December 2024 releases
Source: https://docs.squared.ai/release-notes/2024/December-2024

Release updates for the month of December

# 🚀 Features and Improvements

## **Features**

### **Audit Logs UI**

Streamline the monitoring of user activities with a new, intuitive interface for audit logs.

### **Custom Visual Components**

Create tailored visual elements for unique data representation and insights.

### **Dynamic Query Data Models**

Enhance query flexibility with support for dynamic data models.

### **Stream Support in HTTP Model**

Enable efficient data streaming directly in HTTP models.

### **Pagination for Connectors, Models, and Sync Pages**

Improve navigation and usability with added pagination support.

### **Multiple Choice Feedback**

Collect more detailed user feedback with multiple-choice options.

### **Rendering Type Filter for Data Apps**

Filter data apps effectively with the new rendering type filter.

### **Improved User Login**

Fixes for invited user logins and prevention of duplicate invitations for already verified users.

### **Context-Aware Titles**

Titles dynamically change based on the current route for better navigation.

## **Improvements**

### **Bug Fixes**

* Fixed audit log filter badge calculation.
* Corrected timestamp formatting in utilities.
* Limited file size for custom visual components to 2MB.
* Resolved BigQuery test sync failures.
* Improved UI for audit log views.
* Addressed sidebar design inconsistencies with Figma.
* Ensured correct settings tab highlights.
* Adjusted visual component height for tables and custom visual types.
* Fixed issues with HTTP request method retrieval.

### **Enhancements**

* Added support for exporting audit logs without filters.
* Updated query type handling during model fetching.
* Improved exception handling in resource builder.
* Introduced catalog and schedule sync resources.
* Refined action names across multiple controllers for consistency.
* Reordered deployment steps, removing unnecessary commands.

### **Resource Links and Controllers**

* Added resource links to:
  * Audit Logs
  * Catalogs
  * Connectors
  * Models
  * Syncs
  * Schedule Syncs
  * Enterprise components (Users, Profiles, Feedbacks, Data Apps)
* Updated audit logs for comprehensive coverage across controllers.

### **UI and Usability**

* Improved design consistency in audit logs and data apps.
* Updated export features for audit logs.

***


# July 2024 releases
Source: https://docs.squared.ai/release-notes/2024/July-2024

Release updates for the month of July

## ✨ **New Features**

### 🔍 **Search Filter in Table Selector**

The table selector method now includes a powerful search filter. This feature enhances your workflow by allowing you to swiftly locate and select the exact tables you need, even in large datasets. It’s all about saving time and boosting productivity.

### 🏠 **Databricks Lakehouse Destination**

We're excited to introduce Databricks Lakehouse as a new destination connector. Seamlessly integrate your data pipelines with Databricks Lakehouse, harnessing its advanced analytics capabilities for data processing and AI-driven insights. This feature empowers your data strategies with greater flexibility and power.

### 📅 **Manual Sync Schedule Controller**

Take control of your data syncs with the new Manual Sync Schedule controller. This feature gives you the freedom to define when and how often syncs occur, ensuring they align perfectly with your business needs while optimizing resource usage.

### 🛢️ **MariaDB Destination Connector**

MariaDB is now available as a destination connector! You can now channel your processed data directly into MariaDB databases, enabling robust data storage and processing workflows. This integration is perfect for users operating in MariaDB environments.

### 🎛️ **Table Selector and Layout Enhancements**

We’ve made significant improvements to the table selector and layout. The interface is now more intuitive, making it easier than ever to navigate and manage your tables, especially in complex data scenarios.

### 🔄 **Catalog Refresh**

Introducing on-demand catalog refresh! Keep your data sources up-to-date with a simple refresh, ensuring you always have the latest data structure available. Say goodbye to outdated data and hello to consistency and accuracy.

### 🛡️ **S3 Connector ARN Support for Authentication**

Enhance your security with ARN (Amazon Resource Name) support for Amazon S3 connectors. This update provides a more secure and scalable approach to managing access to your S3 resources, particularly beneficial for large-scale environments.

### 📊 **Integration Changes for Sync Record Log**

We’ve optimized the integration logic for sync record logs. These changes ensure more reliable logging, making it easier to track sync operations and diagnose issues effectively.

### 🗄️ **Server Changes for Log Storage in Sync Record Table**

Logs are now stored directly in the sync record table, centralizing your data and improving log accessibility. This update ensures that all relevant sync information is easily retrievable for analysis.

### ✅ **Select Row Support in Data Table**

Interact with your data tables like never before! We've added row selection support, allowing for targeted actions such as editing or deleting entries directly from the table interface.

### 🛢️ **MariaDB Source Connector**

The MariaDB source connector is here! Pull data directly from MariaDB databases into Multiwoven for seamless integration into your data workflows.

### 🛠️ **Sync Records Error Log**

A detailed error log feature has been added to sync records, providing granular visibility into issues that occur during sync operations. Troubleshooting just got a whole lot easier!

### 🛠️ **Model Query Type - Table Selector**

The table selector is now available as a model query type, offering enhanced flexibility in defining queries and working with your data models.

### 🔄 **Force Catalog Refresh**

Set the refresh flag to true, and the catalog will be forcefully refreshed. This ensures you're always working with the latest data, reducing the chances of outdated information impacting your operations.

## 🔧 **Improvements**

* **Manual Sync Delete API Call**: Enhanced the API call for deleting manual syncs for smoother operations.
* **Server Error Handling**: Improved error handling to better display server errors when data fetches return empty results.
* **Heartbeat Timeout in Extractor**: Introduced new actions to handle heartbeat timeouts in extractors for improved reliability.
* **Sync Run Type Column**: Added a `sync_run_type` column in sync logs for better tracking and operational clarity.
* **Refactor Discover Stream**: Refined the discover stream process, leading to better efficiency and reliability.
* **DuckDB HTTPFS Extension**: Introduced server installation steps for the DuckDB `httpfs` extension.
* **Temporal Initialization**: Temporal processes are now initialized in all registered namespaces, improving system stability.
* **Password Reset Email**: Updated the reset password email template and validation for a smoother user experience.
* **Organization Model Changes**: Applied structural changes to the organization model, enhancing functionality.
* **Log Response Validation**: Added validation to log response bodies, improving error detection.
* **Missing DuckDB Dependencies**: Resolved missing dependencies for DuckDB, ensuring smoother operations.
* **STS Client Initialization**: Removed unnecessary credential parameters from STS client initialization, boosting security.
* **Main Layout Error Handling**: Added error screens for the main layout to improve user experience when data is missing or errors occur.
* **Server Gem Updates**: Upgraded server gems to the latest versions, enhancing performance and security.
* **AppSignal Logging**: Enhanced AppSignal logging by including app request and response logs for better monitoring.
* **Sync Records Table**: Added a dedicated table for sync records to improve data management and retrieval.
* **AWS S3 Connector**: Improved handling of S3 credentials and added support for STS credentials in AWS S3 connectors.
* **Sync Interval Dropdown Fix**: Fixed an issue where the sync interval dropdown text was hidden on smaller screens.
* **Form Data Processing**: Added a pre-check process for form data before checking connections, improving validation and accuracy.
* **S3 Connector ARN Support**: Updated the gem to support ARN-based authentication for S3 connectors, enhancing security.
* **Role Descriptions**: Updated role descriptions for clearer understanding and easier management.
* **JWT Secret Configuration**: JWT secret is now configurable from environment variables, boosting security practices.
* **MariaDB README Update**: Updated the README file to include the latest information on MariaDB connectors.
* **Logout Authorization**: Streamlined the logout process by skipping unnecessary authorization checks.
* **Sync Record JSON Error**: Added a JSON error field in sync records to enhance error tracking and debugging.
* **MariaDB DockerFile Update**: Added `mariadb-dev` to the DockerFile to better support MariaDB integrations.
* **Signup Error Response**: Improved the clarity and detail of signup error responses.
* **Role Policies Update**: Refined role policies for enhanced access control and security.
* **Pundit Policy Enhancements**: Applied Pundit policies at the role permission level, ensuring robust authorization management.


# June 2024 releases
Source: https://docs.squared.ai/release-notes/2024/June-2024

Release updates for the month of June

# 🚀 New Features

* **Iterable Destination Connector**\
  Integrate with Iterable, allowing seamless data flow to this popular marketing automation platform.

* **Workspace Settings and useQueryWrapper**\
  New enhancements to workspace settings and the introduction of `useQueryWrapper` for improved data handling.

* **Amazon S3 Source Connector**\
  Added support for Amazon S3 as a source connector, enabling data ingestion directly from your S3 buckets.

# 🛠️ Improvements

* **GitHub URL Issues**\
  Addressed inconsistencies with GitHub URLs in the application.

* **Change GitHub PAT to SSH Private Key**\
  Updated authentication method from GitHub PAT to SSH Private Key for enhanced security.

* **UI Maintainability and Workspace ID on Page Refresh**\
  Improved UI maintainability and ensured that the workspace ID persists after page refresh.

* **CE Sync Commit for Multiple Commits**\
  Fixed the issue where CE sync commits were not functioning correctly for multiple commits.

* **Add Role in User Info API Response**\
  Enhanced the user info API to include role details in the response.

* **Sync Write Update Action for Destination**\
  Synchronized the write update action across various destinations for consistency.

* **Fix Sync Name Validation Error**\
  Resolved validation errors in sync names due to contract issues.

* **Update Commit Message Regex**\
  Updated the regular expression for commit messages to follow git conventions.

* **Update Insert and Update Actions**\
  Renamed `insert` and `update` actions to `destination_insert` and `destination_update` for clarity.

* **Comment Contract Valid Rule in Update Sync Action**\
  Adjusted the contract validation rule in the update sync action to prevent failures.

* **Fix for Primary Key in `destination_update`**\
  Resolved the issue where `destination_update` was not correctly picking up the primary key.

* **Add Limit and Offset Query Validator**\
  Introduced validation for limit and offset queries to improve API reliability.

* **Ignore RBAC for Get Workspaces API**\
  Modified the API to bypass Role-Based Access Control (RBAC) for fetching workspaces.

* **Heartbeat Timeout Update for Loader**\
  Updated the heartbeat timeout for the loader to ensure smoother operations.

* **Add Strong Migration Gem**\
  Integrated the Strong Migration gem to help with safe database migrations.

<Note>Stay tuned for more exciting updates in the upcoming releases!</Note>


# May 2024 releases
Source: https://docs.squared.ai/release-notes/2024/May-2024

Release updates for the month of May

# 🚀 New Features

* **Role and Resource Migration**\
  Introduced migration capabilities for roles and resources, enhancing data management and security.

* **Zendesk Destination Connector**\
  Added support for Zendesk as a destination connector, enabling seamless integration with Zendesk for data flow.

* **Athena Connector**\
  Integrated the Athena Connector, allowing users to connect to and query Athena directly from the platform.

* **Support for Temporal Cloud**\
  Enabled support for Temporal Cloud, facilitating advanced workflow orchestration in the cloud.

* **Workspace APIs for CE**\
  Added Workspace APIs for the Community Edition, expanding workspace management capabilities.

* **HTTP Destination Connector**\
  Introduced the HTTP Destination Connector, allowing data to be sent to any HTTP endpoint.

* **Separate Routes for Main Application**\
  Organized and separated routes for the main application, improving modularity and maintainability.

* **Compression Support for SFTP**\
  Added compression support for SFTP, enabling faster and more efficient data transfers.

* **Password Field Toggle**\
  Introduced a toggle to view or hide password field values, enhancing user experience and security.

* **Dynamic UI Schema Generation**\
  Added dynamic generation of UI schemas, streamlining the user interface customization process.

* **Health Check Endpoint for Worker**\
  Added a health check endpoint for worker services, ensuring better monitoring and reliability.

* **Skip Rows in Sync Runs Table**\
  Implemented functionality to skip rows in the sync runs table, providing more control over data synchronization.

* **Cron Expression as Schedule Type**\
  Added support for using cron expressions as a schedule type, offering more flexibility in task scheduling.

* **SQL Autocomplete**\
  Introduced SQL autocomplete functionality, improving query writing efficiency.

# 🛠️ Improvements

* **Text Update in Finalize Source Form**\
  Changed and improved the text in the Finalize Source Form for clarity.

* **Rate Limiter Spec Failure**\
  Fixed a failure issue in the rate limiter specifications, ensuring better performance and stability.

* **Check for Null Record Data**\
  Added a condition to check if record data is null, preventing errors during data processing.

* **Cursor Field Mandatory Check**\
  Ensured that the cursor field is mandatory, improving data integrity during synchronization.

* **Docker Build for ARM64 Release**\
  Fixed the Docker build process for ARM64 releases, ensuring compatibility across architectures.

* **UI Auto Deploy**\
  Improved the UI auto-deployment process for more efficient updates.

* **Cursor Query for SOQL**\
  Added support for cursor queries in SOQL, enhancing Salesforce data operations.

* **Skip Cursor Query for Empty Cursor Field**\
  Implemented a check to skip cursor queries when the cursor field is empty, avoiding unnecessary processing.

* **Updated Integration Gem Version**\
  Updated the integration gem to version 0.1.67, including support for Athena source, Zendesk, and HTTP destinations.

* **Removed Stale User Management APIs**\
  Deleted outdated user management APIs and made changes to role ID handling for better security.

* **Color and Logo Theme Update**\
  Changed colors and logos to align with the new theme, providing a refreshed UI appearance.

* **Refactored Modeling Method Screen**\
  Refactored the modeling method screen for better usability and code maintainability.

* **Removed Hardcoded UI Schema**\
  Removed hardcoded UI schema elements, making the UI more dynamic and adaptable.

* **Heartbeat Timeout for Loader**\
  Updated the heartbeat timeout for the loader, improving the reliability of the loading process.

* **Integration Gem to 1.63**\
  Bumped the integration gem version to 1.63, including various improvements and bug fixes.

* **Core Chakra Config Update**\
  Updated the core Chakra UI configuration to support new branding requirements.

* **Branding Support in Config**\
  Modified the configuration to support custom branding, allowing for more personalized user experiences.

* **Strong Migration Gem Addition**\
  Integrated the Strong Migration gem to ensure safer and more efficient database migrations.

<Note>Stay tuned for more exciting updates in future releases!</Note>


# November 2024 releases
Source: https://docs.squared.ai/release-notes/2024/November-2024

Release updates for the month of November

# 🚀 New Features

### **Add HTTP Model Source Connector**

Enables seamless integration with HTTP-based model sources, allowing users to fetch and manage data directly from APIs with greater flexibility.

### **Paginate and Delete Data App**

Introduces functionality to paginate data within apps and delete them as needed, improving data app lifecycle management.

### **Data App Report Export**

Enables exporting comprehensive reports from data apps, making it easier to share insights with stakeholders.

### **Fetch JSON Schema from Model**

Adds support to fetch the JSON schema for models, aiding in better structure and schema validation.

### **Custom Preview of Data Apps**

Offers a customizable preview experience for data apps, allowing users to tailor the visualization to their needs.

### **Bar Chart Visual Type**

Introduces bar charts as a new visual type, complete with a color picker for enhanced customization.

### **Support Multiple Data in a Single Chart**

Allows users to combine multiple datasets into a single chart, providing a consolidated view of insights.

### **Mailchimp Destination Connector**

Adds a connector for Mailchimp, enabling direct data integration with email marketing campaigns.

### **Session Management During Rendering**

Improves session handling for rendering data apps, ensuring smoother and more secure experiences.

### **Update iFrame URL for Multiple Components**

Supports multiple visual components within a single iFrame, streamlining complex data app designs.

***

# 🔧 Improvements

### **Error Handling Enhancements**

Improved logging for duplicated primary keys and other edge cases to ensure smoother operations.

### **Borderless iFrame Rendering**

Removed borders from iFrame elements for a cleaner, more modern design.

### **Audit Logging Across Controllers**

Audit logs are now available for sync, report, user, role, and feedback controllers to improve traceability and compliance.

### **Improved Session Management**

Fixed session management bugs to enhance user experience during data app rendering.

### **Responsive Data App Rendering**

Improved rendering for smaller elements to ensure better usability on various screen sizes.

### **Improved Token Expiry**

Increased token expiry duration for extended session stability.

***

# ⚙️ Miscellaneous Updates

* Added icons for HTTP Model for better visual representation.
* Refactored code to remove hardcoded elements and improve maintainability.
* Updated dependencies to resolve build and compatibility issues.
* Enhanced feedback submission with component-specific IDs for more precise data collection.

***


# October 2024 releases
Source: https://docs.squared.ai/release-notes/2024/October-2024

Release updates for the month of October

# 🚀 New Features

* **Data Apps Configurations and Rendering**\
  Provides robust configurations and rendering capabilities for data apps, enhancing customization.

* **Scale and Text Input Feedback Methods**\
  Introduces new feedback options with scale and text inputs to capture user insights effectively.

* **Support for Multiple Visual Components**\
  Expands visualization options by supporting multiple visual components, enriching data presentation.

* **Audit Log Filter**\
  Adds a filter feature in the Audit Log, simplifying the process of finding specific entries.

***

# 🛠 Improvements

* **Disable Mixpanel Tracking**\
  Disabled Mixpanel tracking for enhanced data privacy and user control.

* **Data App Runner Script URL Fix**\
  Resolved an issue with the UI host URL in the data app runner script for smoother operation.

* **Text Input Bugs**\
  Fixed bugs affecting text input functionality, improving stability and responsiveness.

* **Dynamic Variables in Naming and Filters**\
  Adjusted naming conventions and filters to rely exclusively on dynamic variables, increasing flexibility and reducing redundancy.

* **Sort Data Apps List in Descending Order**\
  The data apps list is now sorted in descending order by default for easier access to recent entries.

* **Data App Response Enhancements**\
  Updated responses for data app creation and update APIs, improving clarity and usability.

***

> For further details on any feature or update, check the detailed documentation or contact our support team. We’re here to help make your experience seamless!

***


# September 2024 releases
Source: https://docs.squared.ai/release-notes/2024/September-2024

Release updates for the month of September

# 🚀 New Features

* **AI/ML Sources**\
  Introduces support for a range of AI/ML sources, broadening model integration capabilities.

* **Added AI/ML Models Support**\
  Comprehensive support for integrating and managing AI and ML models across various workflows.

* **Data App Update API**\
  This API endpoint allows users to update existing data apps without needing to recreate them from scratch. By enabling seamless updates with the latest configurations and features, users can Save time, Improve accuracy and Ensure consistency

* **Donut Chart Component**
  The donut chart component enhances data visualization by providing a clear, concise way to represent proportions or percentages within a dataset.

* **Google Vertex Model Source Connector**\
  Enables connection to Google Vertex AI, expanding options for model sourcing and integration.

***

# 🛠️ Improvements

* **Verify User After Signup**\
  A new verification step ensures all users are authenticated right after signing up, enhancing security.

* **Enable and Disable Sync via UI**\
  Users can now control sync processes directly from the UI, giving flexibility to manage syncs as needed.

* **Disable Catalog Validation for Data Models**\
  Catalog validation is now disabled for non-AI data models, improving compatibility and accuracy.

* **Model Query Preview API Error Handling**\
  Added try-catch blocks to the model query preview API call, providing better error management and debugging.

* **Fixed Sync Mapping for Model Column Values**\
  Corrected an issue in sync mapping to ensure accurate model column value assignments.

* **Test Connection Text**\
  Fixed display issues with the "Test Connection" text, making it clearer and more user-friendly.

* **Enable Catalog Validation Only for AI Models**\
  Ensures that catalog validation is applied exclusively to AI models, maintaining model integrity.

* **Disable Catalog Validation for Data Models**\
  Disables catalog validation for non-AI data models to improve compatibility.

* **AIML Source Schema Components**\
  Refined AI/ML source schema components, enhancing performance and readability in configurations.

* **Setup Charting Library and Tailwind CSS**\
  Tailwind CSS integration and charting library setup provide better styling and data visualization tools.

* **Add Model Name in Data App Response**\
  Model names are now included in data app responses, offering better clarity for users.

* **Add Connector Icon in Data App Response**\
  Connector icons are displayed within data app responses, making it easier to identify connections visually.

* **Add Catalog Presence Validation for Models**\
  Ensures that a catalog is present and validated for all applicable models.

* **Validate Catalog for Query Source**\
  Introduces validation for query source catalogs, enhancing data accuracy.

* **Add Filtering Scope to Connectors**\
  Allows for targeted filtering within connectors, simplifying the search for relevant connections.

* **Common Elements for Sign Up & Sign In**\
  Moved shared components for sign-up and sign-in into separate views to improve code organization.

* **Updated Sync Records UX**\
  Enhanced the user experience for sync records, providing a more intuitive interface.

* **Setup Models Renamed to Define Setup**\
  Updated terminology from "setup models" to "define setup" for clearer, more precise language.

***

> For further details on any feature or update, check the detailed documentation or contact our support team. We’re here to help make your experience seamless!

***


# 2025 Releases
Source: https://docs.squared.ai/release-notes/2025

Release updates for the year 2025

<CardGroup>
  <Card title="January 2025" icon="book-open" href="/release-notes/2025/January-2025">
    Version: v0.39.0 to v0.41.0
  </Card>

  <Card title="February 2025" icon="book-open" href="/release-notes/2025/Feb-2025">
    Version: v0.41.0 to v0.41.0
  </Card>

  <Card title="March 2025" icon="book-open" href="/release-notes/2025/March-2025">
    Version: v0.42.0 to v0.46.0
  </Card>

  <Card title="April 2025" icon="book-open" href="/release-notes/2025/April-2025">
    Version: v0.47.0 to v0.50.0
  </Card>

  <Card title="May 2025" icon="book-open" href="/release-notes/2025/May-2025">
    Version: v0.51.0 to v0.54.0
  </Card>

  <Card title="June 2025" icon="book-open" href="/release-notes/2025/June-2025">
    Version: v0.55.0 to v0.59.0
  </Card>

  <Card title="July 2025" icon="book-open" href="/release-notes/2025/July-2025">
    Version: v0.60.0 to v0.63.0
  </Card>

  <Card title="August 2025" icon="book-open" href="/release-notes/2025/August-2025">
    Version: v0.64.0 to v0.67.0
  </Card>

  <Card title="September 2025" icon="book-open" href="/release-notes/2025/September-2025">
    Version: v0.68.0 to v0.72.0
  </Card>

  <Card title="October 2025" icon="book-open" href="/release-notes/2025/October-2025">
    Version: v0.73.0 to v0.77.0
  </Card>

  <Card title="November 2025" icon="book-open" href="/release-notes/2025/November-2025">
    Version: v0.78.0 to v0.81.0
  </Card>

  <Card title="December 2025" icon="book-open" href="/release-notes/2025/December-2025">
    Version: v0.82.0 to v0.85.0
  </Card>
</CardGroup>


# April 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/April-2025

Release updates for the month of April

## 🚀 Features

* **Assistant UI**\
  Introduced a new Assistant interface with UI improvements for enhanced user interaction and workflow automation.

* **EULA Management**\
  Added End User License Agreement (EULA) controller and management capabilities, including database storage, permissions, and acceptance tracking.

* **WatsonX.Data Source Connector**\
  Added IBM WatsonX.Data as a new source connector for data integration workflows.

* **Generic Connector Edit Component**\
  Introduced a reusable generic connector edit component for improved maintainability and consistent editing experience.

* **Unstructured File Support in S3 Connector**\
  Added support for unstructured files in the S3 connector, expanding data ingestion capabilities.

* **Chatbot Data App Reports Enhancements**\
  Improved reporting capabilities for chatbot data applications with new overview pages and dedicated routes.

* **Databricks Timeout Configuration**\
  Added timeout configuration options for the Databricks source connector to handle long-running queries.

* **QA Verification Workflow**\
  Enforced qa-verified label requirement for PRs with needs-qa label, improving quality assurance processes.

* **CI/CD Improvements**\
  Updated workflows with GHA Docker cache, latest versions, and improved trigger event types for faster builds.

* **Snyk Security Scanning**\
  Enhanced Snyk scanning to focus on manifests and lockfiles for more efficient vulnerability detection.

## 🐛 Bug Fixes

* **Top Bar Name Rendering**\
  Fixed proper rendering of names in the top bar and added truncation for long names with tooltips.

* **Confirm Email Template**\
  Corrected issues with the email confirmation template.

* **Test Connection Flow**\
  Removed separate test connection step and combined it with the save changes button for streamlined UX.

* **Connector Deletion**\
  Fixed connector deletion to use connectorID as the parameter.

* **Query Handling with Multiple FROMs**\
  Applied different gsub handling when queries contain multiple FROM clauses.

* **Catalog Refresh Indicator**\
  Added visual indicator for catalog refresh and fixed duplicate API calls.

* **EULA Enable Fix**\
  Resolved issues with EULA enable functionality and added skip option for invite sign-up flow.

* **Add Models Button**\
  Fixed redirect issues with the Add Models button from the syncs page.

* **SSO Documentation**\
  Updated notes to clarify support for Okta and Azure in SSO configuration.

* **Assistant UI Bugs**\
  Fixed various bugs in the Assistant UI including duplicate field entity components.

* **SFTP Connection Query**\
  Fixed inner query replacement for SFTP connections.

* **Data App Message Feedbacks**\
  Ensured selected data apps only display their own message feedbacks.

* **Breadcrumb Navigation**\
  Fixed navigation issues in breadcrumb components.

* **Chatbot Keys**\
  Corrected key usage for chatbot components.

* **AI/ML Source State Persistence**\
  Fixed state persistence when creating AI/ML sources and prevented resubmission when navigating back.

* **Company Name Display**\
  Fixed display to show company name instead of workspace name in invitations and org settings.

* **EULA Popup Flash**\
  Fixed EULA popup briefly appearing when updating documents.

## 🚜 Refactor

* **Destination Name in Syncs**\
  Changed destination name display in Syncs from Connector Name to Name for clarity.

* **Image to SVG Conversion**\
  Converted images to SVGs for better scalability and performance.

* **Custom Select Widget for RJSF**\
  Added custom widget for select components in React JSON Schema Forms.

* **Reports UI/UX Audit**\
  Completed Reports UI/UX audit fixes for improved user experience.

* **Data Apps Audit**\
  Addressed medium priority items from the Data Apps audit.

* **Error Logs Modal**\
  Refactored error logs modal for better usability.

* **Catalog Fetching Hook**\
  Created dedicated hook for fetching catalog data.

* **Reports Overview Page**\
  Added new Overview page with RBAC for Reports route and dedicated data apps reports route.

* **User Invite Company Name**\
  Updated user invites to send company name instead of workspace name.

* **Data App Reports Tags**\
  Changed tag and empty copy for data app reports.

* **Feature Flag Arrays**\
  Changed feature flags to use arrays for enabling across multiple workspaces.

## ⚙️ Miscellaneous Tasks

* **EULA Database Setup**\
  Added EULA to database, factory, and model with proper permissions and role groups.

* **Okta SSO Support**\
  Added Okta support to Single Sign-On configuration.

* **Assistant Resources**\
  Added assistant rendering type, resource permissions, and role group configuration.

* **Server Gem Updates**\
  Updated server gem through versions 0.22.0, 0.22.1, 0.22.3, 0.22.5, and integrations gem to 0.22.6.

* **Visual Component Model Update**\
  Updated the Visual Component model with improvements.

* **Chat Report Implementation**\
  Added Chat Report implementation to Data App functionality.

* **Template Mapping Tests**\
  Added comprehensive tests for template mapping options and static template options.

* **EULA Application Check**\
  Added EULA check to Application controller for compliance enforcement.

* **Dependency Updates**\
  Bumped dependency versions for security and compatibility improvements.

* **Legacy File Cleanup**\
  Removed old and unused files from the codebase.


# August 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/August-2025

Release updates for the month of August

## 🚀 Features

* **Google Drive Source Connector**\
  Added Google Drive as a new source connector for integrating cloud storage documents and files.

* **Headless Extension Support**\
  Introduced headless browser extension support for enhanced automation capabilities.

* **Agent Templates**\
  Added agent template modal and functionality for creating workflows from pre-built templates.

* **Assistant PDF Export**\
  Added ability to export assistant messages as PDF documents.

* **Chat History Persistence**\
  Implemented persistent chat history storage for maintaining conversation context across sessions.

* **Bar Chart Enhancements**\
  Added color coding and X/Y axes labels to bar charts for improved data visualization.

* **Data App Workflow Integration**\
  Integrated workflows with data apps, enabling workflow execution through chatbot and assistant interfaces.

* **Lead Capture for HubSpot and Slack**\
  Added lead capture functionality for HubSpot and Slack integrations.

* **Chatbot Expand Toggle**\
  Added toggle functionality to expand and collapse the chatbot interface.

* **Assistant List View**\
  Added list view for displaying available assistants with breadcrumb navigation.

* **GitHub Bot Release Workflows**\
  Updated release workflows with GitHub bot integration for automated releases.

## 🐛 Bug Fixes

* **Overview Card Heights**\
  Fixed inconsistent height rendering for overview cards.

* **Connection Edges**\
  Resolved issues with connection edges in workflow canvas.

* **File Name Assignment**\
  Fixed file name incorrectly being assigned file ID in Google Drive connector.

* **Workflow Name Assignment**\
  Corrected workflow name assignment during updates.

* **Chatbot Error Responses**\
  Fixed error response handling in chatbot interactions.

* **LLM Field Label**\
  Corrected label for LLM configuration field.

* **Google Drive Vendor Name**\
  Fixed missing vendor name in field list for Google Drive connector.

* **Exception Data Handling**\
  Fixed missing exception from returned data.

* **Workflow Failure**\
  Resolved workflow execution failure issues.

* **One2Many Type Parsing**\
  Fixed parsing of one2many type as JSON array.

* **Signup Form Copy**\
  Updated copy changes for signup form.

* **Assistant Component Properties**\
  Fixed component properties rendering in assistant.

* **Base URL Configuration**\
  Corrected base URL for published links and API calls.

* **Chatbot Dimensions**\
  Fixed chatbot dimensions when in expanded state.

* **Model Configuration Key**\
  Changed model to configurable key for flexibility.

* **Data Apps Pagination**\
  Fixed pagination for data apps and assistants lists.

* **Chatbot Cross Icon**\
  Fixed chatbot cross icon visibility in expanded state.

* **No Access Rendering**\
  Fixed rendering of No Access state on page reload.

## 🚜 Refactor

* **Feedback Metric Calculation**\
  Updated and reverted feedback metric calculation changes.

* **Workflow Create & Update Logic**\
  Changed logic for workflow creation and update operations.

* **Table Styling**\
  Updated styling and copy in table components.

* **Node Selection**\
  Prevented multiple node selection in workflow builder.

* **Attribution Removal**\
  Removed attribution from components.

* **JSON Form Font Size**\
  Changed font size in JSON Form for better readability.

* **Data App Deletion**\
  Added automatic data app deletion during workflow deletion.

* **Configurable Type Default**\
  Added configurable\_type as model as default value.

* **Filter Updates**\
  Changed filters for improved data filtering.

## ⚙️ Miscellaneous Tasks

* **Server Gem Updates**\
  Updated server gem through versions 0.32.3 and 0.33.0.

* **Integrations Gem Updates**\
  Upgraded integrations gem through versions 0.33.3 and 0.33.4.

* **Error Message Handling**\
  Updated error message handling in detail field for APIs.

* **AI Workflow Description**\
  Updated AI Workflow description text.

* **Workflow Log Database**\
  Added Workflow Log storage in database.

* **Direct Database Template**\
  Changed the Direct Database Template configuration.

* **Embedding Provider Service**\
  Added support for embedding provider service.

* **Chat Messages Title**\
  Added Title field to Chat Messages database table.

* **Sync Run Logger**\
  Added logger for sync run status updates.

* **Data App Session Title**\
  Moved title field to Data App Session database.

* **Workflow Logger**\
  Added workflow execution logger for debugging.

* **Data App Session API**\
  Added destroy API endpoint to data app session controller.

* **Template Null Fix**\
  Added template fix for handling null values.

* **Data App Token**\
  Send data app token on workflow run request.

* **Chat History Search**\
  Added search bar for chat history.


# December 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/December-2025

Release updates for the month of December

## 🚀 Features

* **Workflow RBAC**\
  Added Role-Based Access Control for workflows with governance UI for managing permissions.

* **AIS Hosted Vector Store**\
  Introduced AIS Hosted Vector Store setup for managed vector database storage.

* **Guardrails Workflow Component**\
  Added guardrails component support for implementing safety constraints in workflows.

* **Connector Form State Persistence**\
  Added form state persistence for connectors to maintain user input across sessions.

* **SQL Schema for Vector Store Tables**\
  Added SQL schema option during vector store table creation for customized data structures.

* **Workflow Auditability**\
  Implemented workflow auditability features for tracking changes and compliance.

* **Custom Compliance Support**\
  Added custom compliance support with custom list input capabilities.

* **Chatbot Chat Sessions**\
  Implemented chatbot chat sessions support for persistent conversations.

* **User Uploadable Chat Avatar**\
  Added ability for users to upload custom chat avatars.

* **Scatterplot Visualization**\
  Introduced scatterplot visualization type for data analysis.

* **Stepped Form Persistent State**\
  Implemented persistent state for stepped forms to preserve progress.

* **Coverage Report Prefix**\
  Added prefix to coverage report in UI-CI workflow for better organization.

## 🐛 Bug Fixes

* **Workflow Run ID in Error**\
  Fixed workflow run ID display in error messages.

* **Unit Test Coverage CI**\
  Reverted unit test coverage display in CI.

* **See More Endpoint Payload**\
  Corrected payload for see more endpoint.

* **File Download Error Handling**\
  Fixed error string handling in handle\_file\_download\_error.

* **Chat Assistant Date Display**\
  Fixed date display alongside time in chat assistant with proper formatting.

* **Cursor Assertion Error**\
  Fixed missing cursor assertion error.

* **Coverage File Collection**\
  Fixed coverage collection from all files.

* **Delete Data App Session Policy**\
  Updated delete data app session policy.

* **Workflow Name During Setup**\
  Fixed showing the name of the workflow during setup process.

* **Odoo Abstract Field**\
  Fixed abstract field not available in model in some Odoo versions.

## 🚜 Refactor

* **Model Provider Selection**\
  Changed to allow model selection only after provider is selected.

* **Fallback Value Formatting**\
  Changed fallback and formatted value handling.

## ⚙️ Miscellaneous Tasks

* **Workflow Error Handling**\
  Added raise error in await workflow result for better error propagation.

* **Server Gem Update**\
  Updated Server Gem to version 0.34.12.

* **Vector DB Connector Filters**\
  Added filter changes for vector DB connectors and storage components.

* **Parsing Flag Removal**\
  Removed need parsing flag from workflow processing.

* **Auth Failure Logging**\
  Added logs for authentication failures.

* **Workflows Page Title**\
  Added page title for Workflows section.

* **Chatbot Interface Tests**\
  Improved tests for chatbot interface and helpers.

* **Prompt Input Sample**\
  Added sample input to prompt input component.

* **Unit Test Coverage**\
  Added comprehensive unit tests for workflow builder.

* **Assistant Workspace IDs**\
  Removed ASSISTANT\_ENABLED\_WORKSPACE\_IDS constant.

* **CI Naming Updates**\
  Updated CI name and job titles for clarity.

* **Integrations Gem Update**\
  Upgraded integrations gem to version 0.34.13.

* **Knowledge Base Database**\
  Added Knowledge Base and Knowledge Base File to database.

* **Dynamic SQL Payload**\
  Updated DynamicSql in Payload Generator.

* **Tool Model**\
  Added Tool model for workflow tooling support.

* **Knowledge Base Create API**\
  Added Knowledge Base Create API endpoint.


# February 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/Feb-2025

Release updates for the month of February

## 🚀 Features

* **PG vector as source changes**\
  Made changes to the PostgreSQL connector to support PG Vector.

## 🐛 Bug Fixes

* **Vulnerable integration gem versions update**\
  Upgraded Server Gems to the new versions, fixing vulnerabilities found in previous versions of the Gems.

## ⚙️ Miscellaneous Tasks

* **Sync alert bug fixes**\
  Fixed certain issues in the Sync Alert mailers.


# January 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/January-2025

Release updates for the month of January

## 🚀 Features

* **Added Empty State for Feedback Overview Table**\
  Introduces a default view when no feedback data is available, ensuring clearer guidance and intuitive messaging for end users.

* **Custom Visual Component for Writing Data to Destination Connectors**\
  Simplifies the process of sending or mapping data to various destination connectors within the platform’s interface.

* **Azure Blob Storage Integration**\
  Adds support for storing and retrieving data from Azure Blob, expanding available cloud storage options.

* **Update Workflows to Deploy Solid Worker**\
  Automates deployment of a dedicated worker process, improving back-end task management and system scalability.

* **Chatbot Visual Type**\
  Adds a dedicated visualization type designed for chatbot creation and management, enabling more intuitive configuration of conversational experiences.

* **Trigger Sync Alerts / Sync Alerts**\
  Implements a notification system to inform teams about the success or failure of data synchronization events in real time.

* **Runner Script Enhancements for Chatbot**\
  Improves the runner script’s capability to handle chatbot logic, ensuring smoother automated operations.

* **Add S3 Destination Connector**\
  Enables direct export of transformed or collected data to Amazon S3, broadening deployment possibilities for cloud-based workflows.

* **Add SFTP Source Connector**\
  Permits data ingestion from SFTP servers, streamlining workflows where secure file transfers are a primary data source.

## 🐛 Bug Fixes

* **Handle Chatbot Response When Streaming Is Off**\
  Resolves an issue causing chatbot responses to fail when streaming mode was disabled, improving overall reliability.

* **Sync Alert Issues**\
  Fixes various edge cases where alerts either triggered incorrectly or failed to trigger for certain data sync events.

* **UI Enhancements and Fixes**\
  Addresses multiple interface inconsistencies, refining the user experience for navigation and data presentation.

* **Validation for “Continue” CTA During Chatbot Creation**\
  Ensures that all mandatory fields are properly completed before users can progress through chatbot setup.

* **Refetch Data Model After Update**\
  Corrects a scenario where updated data models were not automatically reloaded, preventing stale information in certain views.

* **OpenAI Connector Failure Handling**\
  Improves error handling and retry mechanisms for OpenAI-related requests, reducing the impact of transient network issues.

* **Stream Fetch Fix for Salesforce**\
  Patches a problem causing occasional timeouts or failed data streams when retrieving records from Salesforce.

* **Radio Button Inconsistencies**\
  Unifies radio button behavior across the platform’s interface, preventing unexpected selection or styling errors.

* **Keep Reports Link Highlight**\
  Ensures the “Reports” link remains visibly highlighted in the navigation menu, maintaining consistent visual cues.

## ⚙️ Miscellaneous Tasks

* **Add Default Request and Response in Connection Configuration for OpenAI**\
  Provides pre-populated request/response templates for OpenAI connectors, simplifying initial setup for users.

* **Add Alert Policy to Roles**\
  Integrates alert policies into user role management, allowing fine-grained control over who can create or modify data alerts.


# July 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/July-2025

Release updates for the month of July

## 🚀 Features

* **Workflow Builder**\
  Introduced a comprehensive visual workflow builder with React Flow canvas, drag-and-drop components, sidebar navigation, and node configuration. Includes auto-save functionality, workflow publishing, and interface testing capabilities.

* **Odoo Source Connector**\
  Added Odoo as a new source connector for ERP data integration.

* **Odoo Destination Connector**\
  Introduced Odoo as a destination connector for writing data to Odoo systems.

* **Workflow Run Feature API**\
  Added API endpoints for executing and managing workflow runs.

* **Retrieval Flow Components**\
  Implemented retrieval flow with configurable components for building AI-powered data retrieval workflows.

* **Agent Routes Setup**\
  Set up routing infrastructure for agent-based workflow interactions.

* **Workflow Interface**\
  Added chatbot/assistant interface for testing workflows with pagination support and list view.

* **Workflow Component Descriptions**\
  Added descriptions for workflow components to improve user understanding.

* **Code Quality Migration**\
  Migrated code climate and code coverage tools to qlty.sh with updated badges.

* **GitHub Workflow Timeout**\
  Added timeout configuration for server-ci GitHub Actions workflow.

## 🐛 Bug Fixes

* **Global Namespace Violation**\
  Fixed global namespace violation in runner script.

* **JSON Schema Validation**\
  Removed invalid field from JSON schema and fixed various schema issues.

* **Batched Query Processing**\
  Added batched\_query call and improved SQL parsing capabilities.

* **Workflow Builder UI Fixes**\
  Fixed numerous workflow builder issues including drop position calculation, component selection, node duplication, edge deletion, and fit view functionality.

* **LLM Model Temperature**\
  Fixed missing temperature field for LLM model configuration.

* **Component Rendering**\
  Fixed component icon rendering from URLs and dynamic component loading from API.

* **Interface State Persistence**\
  Resolved issues with interface state not persisting correctly.

* **Auto-Save Status**\
  Fixed auto-save to correctly update status to draft and trigger after 1 second delay.

* **Chatbot Messages**\
  Fixed assistant chat JSON messages, loading states, and message responder issues.

* **Prompt Input Modal**\
  Resolved issues with prompt input modal and variable values.

* **Chart Rendering**\
  Fixed chart rendering issues in workflow interfaces.

* **RBAC Policy**\
  Corrected RBAC policy implementation for workflows.

* **Sidebar Styling**\
  Fixed sidebar collapsed state, styling, and component sizes.

* **Async Dropdown**\
  Fixed async dropdown scrolling and sizing to window dimensions.

* **Workflow Template JSON**\
  Corrected workflow template JSON structure.

* **Workflow Execution Errors**\
  Added user feedback on workflow execution errors.

## 🚜 Refactor

* **AIS Data Store Discover**\
  Fixed AIS Data Store discover method implementation.

* **Workflow Templates**\
  Refactored workflow templates for better maintainability.

## ⚙️ Miscellaneous Tasks

* **Sub-Category Support**\
  Added sub\_category to connector model and fixed postgres sub-category handling.

* **Connector Instance Protocol**\
  Added connector\_instance to protocol for better connector management.

* **Server Gem Updates**\
  Updated server gem through versions 0.30.4, 0.31.3, 0.32.0, and 0.32.1.

* **Vector Search Enhancements**\
  Added execute\_search to connector for vector operations and vector search support for PostgreSQL.

* **Firecrawl Updates**\
  Added markdown\_hash to Firecrawl and updated web\_scraping extractors for VectorDB integration.

* **Workflow Components**\
  Updated workflow components with filters, JSON updates, and schema improvements.

* **Chatbot Default State**\
  Changed chatbot to render closed by default.

* **Workflow Run Model**\
  Added workflow run model changes and scope for updated\_at descending.

* **Security Enhancements**\
  Added rack attack for rate limiting, secured cross-domain access, and added clickjacking prevention.

* **Credential Masking**\
  Implemented connector credentials masking for improved security.

* **PG Vector Migration**\
  Migrated existing PostgreSQL vector connectors to vector sub\_category.

* **NASA Workspace**\
  Added NASA workspace to production environment.

* **Workflow Role Group**\
  Added Workflows role group for permission management.

* **Workflow Template Database**\
  Added and reverted template field for workflow in database.

* **Workflow Builder Validations**\
  Implemented agent workflow builder validations.

* **Async Dropdown Filtering**\
  Added async dropdown service support with filters and connector sub\_category filtering.

* **BigQuery Private Key**\
  Reformatted private\_key in BigQuery client for connection handling.

* **Pinecone Metadata**\
  Updated metadata handling in Pinecone DB destination connector.


# June 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/June-2025

Release updates for the month of June

## 🚀 Features

* **Intuit QuickBooks Source Connector**\
  Added Intuit QuickBooks as a new source connector for integrating accounting and financial data.

* **Pinecone DB Source Connector**\
  Added Pinecone DB as a source connector for reading from vector databases.

* **Qdrant Source Connector**\
  Introduced Qdrant as a source connector for vector search data retrieval.

* **Firecrawl Source Connector**\
  Added Firecrawl as a new source connector for web crawling and scraping capabilities.

* **White-Labelling Support**\
  Introduced comprehensive white-labelling capabilities including custom logo uploads for workspaces and organizations.

* **Workflow CRUD APIs**\
  Added complete Create, Read, Update, Delete APIs for workflow management.

* **Components Schema API**\
  Introduced components schema API for better component management and configuration.

* **File-Based Assistant**\
  Added file-based assistant functionality for Space Cadet workspace.

* **Email Verification Redirect**\
  Implemented redirect to login page when email verification is disabled for streamlined user experience.

* **Empty Graph Text**\
  Added descriptive text for empty graph states to improve user guidance.

* **Deploy to Staging and QA Workflows**\
  Created new deployment workflows for staging and QA environments with failure handling and environment visibility.

## 🐛 Bug Fixes

* **Continue Button State**\
  Fixed continue button being incorrectly disabled in forms.

* **Searchbar Double Border**\
  Resolved double border styling issue on search bars.

* **Long Title Truncation**\
  Added truncation for long titles to prevent layout issues.

* **Double Toast Notifications**\
  Fixed duplicate toast notifications appearing.

* **Workflow Component Schema**\
  Corrected workflow component schema configuration issues.

* **Qdrant and Pinecone Spec**\
  Quick fix for Qdrant and Pinecone connector specifications.

* **Read User Permission**\
  Removed read user permission from non-admin roles for better security.

## 🚜 Refactor

* **Chatbot Metrics Data App Reports**\
  Added support for chatbot metrics in data app reports.

* **Models Audit Changes**\
  Implemented audit-related improvements for models.

* **SignUp Email Verification**\
  Updated SignUp flow to handle email verification configuration.

* **Searchbar Width Prop**\
  Added width prop to searchbar component for flexible sizing.

* **Vector Search Protocol**\
  Updated protocol handling for Vector\_Search type.

* **Logo Management**\
  Refactored logo imports, API responses, and added sidebar logo component with max file size validation.

* **API Host Configuration**\
  Changed API host configuration for better environment management.

* **Error Toast Handling**\
  Added consistent error toast notifications across the application.

## ⚙️ Miscellaneous Tasks

* **Logo Upload Infrastructure**\
  Added database changes and serializer updates for logo upload functionality.

* **Data App Reports Enhancement**\
  Updated Data App reports to show messages and feedback responses.

* **Monthly API Response**\
  Updated API to return 'monthly' instead of 'month' for consistency.

* **Enterprise Controller Updates**\
  Updated Enterprise Workspace and Organization controllers for logo upload support.

* **Workflow Model Changes**\
  Added workflow model associations and unique index for workflow names.

* **Component URL Icons**\
  Updated component URL icons for better visual consistency.

* **Server Gem Updates**\
  Updated server gem through versions 0.27.0, 0.29.0, 0.30.0, and 0.30.3.

* **S3 Bucket Storage**\
  Enabled S3 bucket for storage capabilities.

* **Connector Sub-Categories**\
  Added sub\_category field to connector meta for better organization.

* **Firecrawl Optimizations**\
  Optimized Firecrawl client and added query support.

* **Demo Stage Workspace**\
  Added demo stage workspace ID to assistant enabled workspace IDs.

* **Component Model Updates**\
  Updated component model with improvements.

* **BCLL Cleanup**\
  Removed hardcoded BCLL logo and custom height configurations.


# March 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/March-2025

Release updates for the month of March

## 🚀 Features

* **Custom RBAC UI**\
  Introduced a comprehensive Role-Based Access Control interface, allowing administrators to create, edit, and manage custom roles with granular permissions across the platform.

* **SSO Integration**\
  Added complete Single Sign-On support including SSO Configuration Controller, SSO Login, ACS Callback, and organization settings for seamless enterprise authentication.

* **WatsonX.AI Connector**\
  Added IBM WatsonX.AI as a new AI/ML source connector, expanding the available AI model integrations.

* **Anthropic AI/ML Source Connector**\
  Introduced Anthropic as a new AI/ML source connector for leveraging Claude models in data workflows.

* **Chatbot Enhancements**\
  Added feedback display on chatbot preview and history context for user prompts, improving conversational AI experiences.

* **Sync Export API**\
  New API endpoints for exporting sync configurations and sync records, enabling better data portability and backup options.

* **Environment Variables for Connection Config**\
  Support for using environment variables in connection configurations, improving security and deployment flexibility.

* **Enhanced Search Functionality**\
  Added search bars to model selection, destination section, and data source views for easier navigation in large datasets.

* **Delete Confirmation Modals**\
  Added confirmation dialogs when deleting sources and workspace members to prevent accidental data loss.

* **Docker Hub Integration**\
  Updated workflow to automatically push images to Docker Hub when new releases are created.

* **Snyk Security Testing**\
  Integrated Snyk tests for server, UI, and integrations to enhance security vulnerability detection.

* **Primary Key Helper Text**\
  Added helper text and tooltips for Primary Key fields to improve user understanding during data modeling.

## 🐛 Bug Fixes

* **Pagination in Empty State**\
  Fixed pagination controls incorrectly showing when there are no results to display.

* **Content Layout**\
  Corrected content centering at maximum width for better visual consistency.

* **User Login with Email Confirmation**\
  Resolved issues with user login flow when email confirmation is required.

* **Role Permission Count**\
  Fixed incorrect permission count display for roles and updated to group permission count.

* **SSO Entity ID**\
  Corrected entity ID handling in SSO configuration.

* **Missing Logo Icons**\
  Fixed missing logo icons appearing in various authentication views.

* **Invite User Workflow**\
  Addressed issues in the user invitation workflow for better reliability.

* **Solid Worker Migrations**\
  Fixed migration issues affecting the Solid Worker background job processor.

* **Anthropic Connector**\
  Fixed spelling error and quick fixes for the Anthropic AI/ML connector.

* **Template Value Persistence**\
  Resolved issues where template values were not persisting correctly in AI/ML models.

* **Auth UI/UX Improvements**\
  Fixed password validation design, forgot password positioning, sign-in/sign-up UI audit issues, and checkbox styling on RJSF forms.

## 🚜 Refactor

* **Data Apps Audits**\
  Completed high-priority audit items for Data Apps, improving overall code quality and user experience.

* **Template Mapping Components**\
  Refactored template options into generic, reusable components for better maintainability.

* **Model Page Improvements**\
  Applied audit fixes to model pages including navigation, timestamp formatting, and empty state handling.

* **Settings Page Audit**\
  Completed comprehensive audit of settings pages for consistency and usability.

* **Authentication UI**\
  Improved copy for invalid credentials, placeholders, terms and privacy policy messages, and password instructions.

* **Stepped Form Exit**\
  Removed unnecessary exit warnings when leaving stepped forms for smoother user experience.

## ⚙️ Miscellaneous Tasks

* **ChatMessage Model**\
  Added ChatMessage model and ChatMessageTransformer for enhanced chat prompt message handling.

* **Ruby SAML Gem**\
  Added ruby-saml gem to support SAML-based SSO authentication.

* **Playwright E2E Tests**\
  Set up Playwright framework for end-to-end testing automation.

* **SSO Configuration Permissions**\
  Added permissions for SSO Configuration management at organization and workspace levels.

* **Signing Certificate Verification**\
  Implemented signing certificate verification for enhanced security.

* **Audit Log Enhancements**\
  Added audit logging to Roles Controller and updated audit usage across multiple controllers for better traceability.

* **Export Improvements**\
  Refactored date handling in Audit Log and Feedback exports, and added Additional Remarks field to message feedback exports.

* **Server Gem Updates**\
  Updated Server gem to versions 0.20.0, 0.21.1, and 0.21.2 with various improvements and fixes.

* **System Role Descriptions**\
  Updated descriptions for system roles to provide clearer guidance.

* **Security Updates**\
  Updated gems to address Snyk security vulnerabilities.


# May 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/May-2025

Release updates for the month of May

## 🚀 Features

* **Amazon Bedrock Source Connector**\
  Added Amazon Bedrock as a new AI/ML source connector for integrating AWS foundation models into data workflows.

* **Pinecone Vector DB Destination Connector**\
  Introduced Pinecone as a destination connector for vector database storage and retrieval.

* **Qdrant Destination Connector**\
  Added Qdrant as a new vector database destination connector for similarity search workloads.

* **Generic OpenAI Spec Connector**\
  Added a generic OpenAI specification connector for flexible integration with OpenAI-compatible endpoints.

* **Unstructured Data Support**\
  Comprehensive support for unstructured data including LangChain Ruby integration, chunking configuration, and embedding config screens.

* **Assistant UI Enhancements**\
  Added Bar and Pie Chart support, feedback collection, table data rendering, CSV download capability, and dynamic title changes based on conversation.

* **Vector Search Model Support**\
  Added unstructured and vector\_search types to ModelQueryType with embedding configuration for vector-based models.

* **Sync Alerts Workflow**\
  Added workflow middleware for sync alerts to improve notification handling.

* **Solid Worker in Docker Compose**\
  Added solid worker service to docker-compose.yml for improved background job processing.

* **Prometheus Client**\
  Added prometheus client gem for metrics collection and monitoring.

* **Update Feedback and Message Feedback**\
  Implemented update capabilities for feedback and message feedback records.

* **Demo Workspace for Assistant**\
  Added Demo Workspace to Assistant Enabled Workspaces for easier onboarding and testing.

* **Custom Workspace Branding**\
  Added support for logo and name customization for specific workspaces (e.g., BCLL Workspace).

## 🐛 Bug Fixes

* **Bedrock Inference Profile**\
  Removed inference profile from Bedrock connector configuration.

* **Sync Run Email Notifications**\
  Disabled sync run send\_status\_email and fixed sync run mailer issues.

* **CVE Corrections**\
  Corrected CVEs for BAH using Trivy security scanning.

* **Failed Sync Alerts Email Format**\
  Fixed email format for failed sync alerts and added end\_time to sync failure emails.

* **Pagination Issues**\
  Fixed broken pagination across various views.

* **Logo URL Updates**\
  Updated the logo URL for Slack and Email Alerts.

* **Email Taken Error Message**\
  Improved error message when email is already taken during signup.

* **Unstructured Model Handling**\
  Fixed model updates for vector type, catalog data usage, and API updates for unstructured models.

* **Duplicate API Calls**\
  Removed duplicate GET call during connector updates.

* **Pinecone Spec**\
  Removed model and namespace from Pinecone specification.

* **Connector Edit Navigation**\
  Fixed opening connector edit screen after creation.

* **Stepped Form Issues**\
  Fixed multiple issues with stepped form including browser back restriction, query params in URL, and infinite loop problems.

* **Configure Sync Screen**\
  Resolved issues with the configure sync screen for unstructured models.

* **Embedding Validation**\
  Disabled continue button if embedding configuration is not completed.

* **Chat History Display**\
  Show chat history only when messages exist.

* **Unstructured Model Steps**\
  Fixed dynamic step addition for unstructured models and preserved base steps for reset.

## 🚜 Refactor

* **Button Styling Updates**\
  Changed button styling across the application for consistency.

* **Datalist Icon Removal**\
  Removed icons from datalist components for cleaner UI.

* **Error Toast Improvements**\
  Removed titleCase from error toasts and added support to hide success toasts when not needed.

* **Schema Validation**\
  Removed input and output schema validation for improved flexibility.

* **Pagination Logic**\
  Changed logic to show pagination only when rows equal 10 or more.

* **Assistant Deployment Option**\
  Changed deploy to assistant option to only be visible in Assistant Enabled Workspaces.

* **Embedding Config Component**\
  Extracted embedding config fields into a standalone reusable component.

* **Chart Export Utilities**\
  Added chart download and copy functionality with export function moved to utilities.

* **Data Apps Empty State**\
  Improved copy for empty state in data apps.

* **Slack Sync Button**\
  Updated View Sync Run button styling for Slack notifications.

* **Stepped Form Store**\
  Refactored stepped form state management for better maintainability.

## ⚙️ Miscellaneous Tasks

* **EULA Role Updates**\
  Made read permission in EULA true for Custom Role.

* **Model Query Type Updates**\
  Added unstructured and vector\_search types to ModelQueryType.

* **Data App Querying**\
  Enabled Data App querying capabilities.

* **Redis Removal**\
  Removed Redis dependency from the application stack.

* **Data Format Type Names**\
  Updated title names for Data Format Types.

* **Server Gem Updates**\
  Updated server gem through versions 0.23.2, 0.24.0, 0.24.1, 0.24.2, 0.25.0, and 0.26.0.

* **Connector Documentation URLs**\
  Updated connector documentation URLs in spec and meta files.

* **Counter Culture for Messages**\
  Added count\_culture for chat\_messages and message\_feedbacks for efficient counting.


# November 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/November-2025

Release updates for the month of November

## 🚀 Features

* **Workflow Builder Control Panel**\
  Added control panel for workflow builder with enhanced management capabilities.

* **Export Workflows as Slack App**\
  Enabled exporting workflows as Slack applications for seamless team integration.

* **Embeddable Chat Assistants**\
  Introduced embeddable assistant support with script updates for embedding chatbots in external applications.

* **Hosted Data Store**\
  Added Hosted Database and Hosted Table support with complete CRUD APIs for managed data storage.

* **Semistructured Data Support**\
  Added semistructured model query type with configuration support for handling partially structured data formats.

* **Primary Key Disabled Callout**\
  Added callout notification when primary key is disabled to improve user awareness.

* **Google Drive Connector Refactor**\
  Refactored Google Drive source connector for improved performance and reliability.

* **Larger CI Runner**\
  Added support for new larger runner in CI pipeline for faster builds.

## 🐛 Bug Fixes

* **Spec Fix**\
  Resolved specification test issues.

* **AWS Bedrock Sub-Category**\
  Changed AWS Bedrock sub-category for proper classification.

* **Embeddable Assistant Variable**\
  Fixed variable handling in embeddable assistant configuration.

* **Message Content Fallback**\
  Assign message to content at fallback for proper error handling.

* **Chat Messages Overflow**\
  Added overflow handling to chat messages for long content.

* **Interface Toggle Condition**\
  Fixed condition handling for interface toggle state.

* **Google Drive File Download**\
  Fixed errors when downloading files from Drive with backslashes and next\_page\_token clearing issues.

* **Duplicate Submissions**\
  Handled duplicate form submissions to prevent data duplication.

* **Semistructure Column Mapping**\
  Fixed missing columns for mapping in semistructure models.

* **Lightning Request Timeout**\
  Increased lightning request timeout and removed explicit DPI settings.

* **Enterprise Config Fetch**\
  Updated MW fetch to use enterprise configuration.

* **Store ID in Connector List**\
  Fixed returning store ID in connector list API.

* **File Upload for Assistants**\
  Fixed file upload functionality for assistant interactions.

* **File Prompt and Response**\
  Fixed file prompt and response handling in chat.

* **Unit Test Coverage CI**\
  Fixed unit test coverage reporting in CI pipeline.

## 🚜 Refactor

* **Welcome Message Rename**\
  Changed introduction\_message to welcome\_message in channel\_join for consistency.

* **Chatbot Unified Component**\
  Refactored chatbot into unified component for better maintainability.

* **Hosted Data Store Creation**\
  Refactored hosted data store creation workflow.

* **Data Store Delete API**\
  Removed enable check for Data Store delete API.

* **Hosted Data Stores Validation**\
  Added raise for existing hosted data stores validation.

* **Connector Host Addition**\
  Added host field to connector configuration.

* **Axios Config Unification**\
  Updated axios config to be common for enterprise and CE APIs.

* **SQL Script Table Rename**\
  Allowed update SQL script to rename tables.

## ⚙️ Miscellaneous Tasks

* **LLM Component Enhancement**\
  Enhanced LLM Component to handle Generic OpenAI endpoints.

* **PostHog Feature Flags**\
  Implemented PostHog feature flag integration for controlled rollouts.

* **Slack Bot Chat History**\
  Added chat history support to Slack Bot.

* **Template ID for Hosted Data Store**\
  Added template ID to Hosted Data Store model.

* **Vector Store Template API**\
  Added Template API for Vector Store configuration.

* **Data App Auth for List API**\
  Added data\_app\_auth support for list API endpoints.

* **Server Gem Update**\
  Updated Server Gem to version 0.34.7.

* **Hosted DB APIs**\
  Added Create, Index, Update, Destroy, Enable, and Delete APIs for Hosted Data Store and Tables.

* **Component Failure Scenarios**\
  Added failure scenarios handling for workflow components.

* **PGUtils Addition**\
  Added PGUtils utility for PostgreSQL operations.

* **Embed Login Header**\
  Added login support with X-App-Context header for embed scenarios.

* **Workflow Model RBAC**\
  Added RBAC changes for workflow model permissions.

* **Data Store Template Refactor**\
  Refactored Data Store template configuration.

* **Integrations Gem Updates**\
  Upgraded multiwoven-integrations gem through versions 0.34.11.

* **Hosted DB Connectors**\
  Added connectors for hosted database integration.

* **Connector Model Configuration**\
  Added empty configuration support for Connector model.

* **Sync-Based Table Updates**\
  Updated data store table based on sync creation.

* **Hosted Data Store Connector Definition**\
  Added hosted data store to connector definition.

* **PostgreSQL Destination Refactor**\
  Refactored PostgreSQL Destination Connector for improved performance.


# October 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/October-2025

Release updates for the month of October

## 🚀 Features

* **Conditional Component**\
  Added conditional component functionality for enhanced workflow control.

* **Conditional Workflow Component**\
  Implemented conditional workflow component for enterprise workflows.

* **S3 Storage Encryption Options**\
  Added encryption options to S3 storage configuration for enhanced data security.

* **Pipeline Appsignal Revision Variable**\
  Updated pipelines to fix Appsignal revision variable handling.

* **Deploy Pipeline Cleanup**\
  Cleaned up deploy pipelines for improved maintainability.

* **Deploy Pipeline Updates**\
  Updated deploy pipeline configuration and processes.

* **License Links Update**\
  Updated license links in Readme files for UI and server components.

* **Workflow Job Timeout**\
  Added timeout configuration at job level for all workflows.

* **Full Screen Chart Modal**\
  Added modal functionality to view charts in full screen mode.

* **Custom Date Range for Reports**\
  Implemented custom date range filter for data app reports.

## 🐛 Bug Fixes

* **Preview Image Display**\
  Fixed preview image being pushed down in the interface.

* **CI/CD Spec Failure**\
  Resolved CI/CD specification test failures.

* **Chatbot White Background**\
  Fixed white background issue in chatbot data app.

* **Workflow Integration Folder**\
  Renamed integration folder for Workflow Integration consistency.

* **Agent Selection Reset**\
  Fixed issue where selectedAgent was not set to null when creating new Agent.

## 🚜 Refactor

* **Google Drive Textract Environment Variable**\
  Renamed environment variable for Textract in Google Drive connector.

## ⚙️ Miscellaneous Tasks

* **Slack App Database Integration**\
  Added Slack App to database schema.

* **Branding Update**\
  Updated multiwoven references to AI Squared across the codebase.

* **Integrations Gem Upgrade**\
  Upgraded integrations gem to version 0.34.5.

* **Reports Tab Date Range**\
  Added custom date range functionality for reports tab in data apps.

* **Security Gem Updates**\
  Upgraded git and rexml gems per security findings.


# September 2025 Releases
Source: https://docs.squared.ai/release-notes/2025/September-2025

Release updates for the month of September

## 🚀 Features

* **Workflow Playground Testing**\
  Added playground environment for testing workflows before deployment.

* **HTTP Source Connector**\
  Introduced HTTP as a new source connector for fetching data from REST APIs and web endpoints.

* **Chat Assistant Session History**\
  Implemented session history for chat assistants to maintain conversation context.

* **Animated Thinking Text**\
  Added animated thinking text in chat responses for better user feedback during processing.

* **Custom Code Component**\
  Added Custom Code Component in Workflow Builder with Python support for advanced customizations.

* **Workflow Export**\
  Implemented workflow export functionality for sharing and backup purposes.

* **Custom Component Platform**\
  Added platform changes to support custom component development and integration.

* **Dynamic Schema for PGVector**\
  Added dynamic schema change capability for PGVector Vector Store.

* **Multi-Page PDF Support**\
  Added support for processing multi-page PDF documents.

* **Full Screen Chart Modal**\
  Added modal to view charts in full screen mode for better data analysis.

* **Custom Date Range Filter**\
  Implemented custom date range filter for data app report filtering.

* **Remote Code Executions Model**\
  Added remote code executions model changes for extended processing capabilities.

* **Invoice Catalog Results**\
  Added full results to invoices catalog for comprehensive data access.

* **Deploy Workflow Updates**\
  Updated deploy to staging and QA workflows for improved CI/CD.

## 🐛 Bug Fixes

* **Chat Title Trim**\
  Fixed trimming of chat title during delete session modal.

* **Session Token in Workflow Run**\
  Corrected session token handling in workflow run execution.

* **Chat Response Parsing**\
  Fixed parsing of chat responses to handle data correctly.

* **Middleware Fix**\
  Resolved middleware issues affecting request processing.

* **Python Component Logo**\
  Fixed Python component logo display in workflow builder.

* **HTTP Client Increment Strategy**\
  Added increment\_strategy check to HTTP Client for proper pagination.

* **Visual Component ID**\
  Fixed passing visual component ID during workflow update.

* **Pinecone Namespace**\
  Fixed Pinecone default namespaces and write operations.

* **Selected Agent Reset**\
  Set selectedAgent to null when creating new Agent to prevent state issues.

## 🚜 Refactor

* **Sync Enhancements**\
  Added source, models, and destinations to Sync for comprehensive data mapping.

* **Textract Environment Variable**\
  Renamed environment variable for Textract in Google Drive connector.

## ⚙️ Miscellaneous Tasks

* **Session ID Serializer**\
  Added Session ID to Data App Serializer.

* **Server Gem Updates**\
  Updated server gem through versions 0.33.5 and 0.34.4.

* **Integrations Gem Update**\
  Updated multiwoven integrations gem to 0.34.3.

* **PGVector Support**\
  Modified vector component to support PGVector integration.

* **Workflow Chat History**\
  Added chat history support for workflows.

* **HTTP Client Update**\
  Updated HTTP Client with improvements and added HTTP extractor.

* **Vector Store JSON**\
  Updated vector store JSON configuration.

* **SOC2 Agreement Checkboxes**\
  Added agreement checkboxes for SOC2 compliance.

* **Chat Message Serializer**\
  Added chat message serializer for API responses.

* **User Prompt Query Fix**\
  Temporary fix for user prompt query modification.

* **Workflow Feedback**\
  Added workflow feedback support for collecting user input.

* **Custom Date Range Reports**\
  Added custom date range support for reports tab in data apps.

* **Security Gem Updates**\
  Upgraded git and rexml gems per security findings.


# 2026 Releases
Source: https://docs.squared.ai/release-notes/2026

Release updates for the year 2026

<CardGroup>
  <Card title="January 2026" icon="book-open" href="/release-notes/2026/January-2026">
    Version: v0.86.0 to v0.91.0
  </Card>

  <Card title="February 2026" icon="book-open" href="/release-notes/2026/February-2026">
    Version: v0.92.0 to v0.94.0
  </Card>

  <Card title="March 2026" icon="book-open" href="/release-notes/2026/March-2026">
    Version: v0.95.0+
  </Card>

  <Card title="April 2026" icon="book-open" href="/release-notes/2026/April-2026">
    Version: v0.98.0+
  </Card>

  <Card title="June 2026" icon="book-open" href="/release-notes/2026/June-2026">
    Version: v0.98.0+
  </Card>

  <Card title="July 2026" icon="book-open" href="/release-notes/2026/July-2026">
    Version: v0.98.0+
  </Card>

  <Card title="August 2026" icon="book-open" href="/release-notes/2026/August-2026">
    Version: v0.98.0+
  </Card>
</CardGroup>


# April 2026 Releases
Source: https://docs.squared.ai/release-notes/2026/April-2026

Release updates for the month of April 2026

## 🐛 Bug Fixes

* **Onboarding Wizard Viewport on Smaller Screens**
  Fixed the onboarding wizard layout to display correctly on smaller screen sizes, ensuring the wizard content is fully accessible without overflow or clipping issues.

* **File input for AI workflows**
  You can now attach files directly to AI workflows using the new File Input component. This allows workflows to process document content as context for AI reasoning.
  * Upload up to 2 static files per workflow for persistent context across all executions
  * Enable end-user file uploads during chat sessions with the `allow_uploads` toggle
  * Supports 12 file types: CSV, DOC, DOCX, ODS, ODT, PDF, RTF, SQL, TSV, TXT, XLS, and XLSX
  * Maximum file size of 50 MB per file
  * File content is automatically parsed, truncated to a token limit, and injected as text into downstream workflow components
  * Session-scoped files are automatically cleaned up when chat sessions expire
  * File uploads appear in chat history for easy reference


# August 2026 Releases
Source: https://docs.squared.ai/release-notes/2026/August-2026

Release updates for the month of August 2026

## 🛠️ Chores

* **Request logs now include Origin and Referer headers**
  The server-side request/response logger now captures the incoming `Origin` and `Referer` headers alongside the existing `Workspace-Id` header, giving AppSignal traces more context for debugging cross-origin and embedded requests.

## 🔒 Security

* **Clickjacking protection for embedded published apps**
  Published Data Apps and Agentic Apps are now protected against clickjacking by enforcing a Content Security Policy `frame-ancestors` directive derived from each workspace's approved embed origins.
  * Added a `frame-ancestors` directive to responses served through the published app proxy, limiting embedding to `'self'` and the origins registered for the app's workspace
  * Added an embed-origins lookup endpoint that returns approved origins and propagation details for a workspace, with request coalescing, caching, timeouts, and safe fallbacks
  * Origin matching now supports exact, wildcard, and pattern-based entries so admins can allow entire subdomain trees or template-style origins
  * Default CORS access is restricted to approved domains and localhost, and the embed CORS bypass is disabled by default so the allow-list is always enforced
  * Added rate limiting for unauthenticated embed-origin lookups to prevent abuse of the public lookup endpoint


# February 2026 Releases
Source: https://docs.squared.ai/release-notes/2026/February-2026

Release updates for the month of February 2026

## 🚀 Features

* **Workflow Versioning**
  Introduced full workflow versioning support with version history management, preview support, version diffing, edit and delete capabilities, and visibility of the latest published version as live.
  * Version panel UI in workflow header
  * Version description in workflow publish modal

* **Model Routing**
  Implemented model routing to enable dynamic model selection within workflows.

* **Model Hub**
  Added Model Hub screen to manage model providers and AI model integrations.

* **LLM Usage Tracking**
  Added comprehensive LLM usage logging to monitor API calls, including tokens consumed, models utilized, and associated costs across workflow executions.

* **Workflow Analytics**
  Implemented automatic token estimation for input and output data in LLM operations with workflow-level metrics to track total token consumption and estimated API costs.

* **Knowledge Base Enhancements**
  Expanded Knowledge Base capabilities with tool integration, improved component filtering, and better handling of deleted components.

* **S3 Connector Enhancements**
  Enhanced S3 connector with support for any S3 Compatible endpoint, such as MinIO & Cloudflare R2.
  * Added support for custom endpoints
  * Implemented batch support and configurable batch size
  * Added URL\_STYLE 'path' configuration option

* **Session-aware Component Execution**
  Improved execution tracking by passing session context to component activities, enabling better differentiation for data app calls.

## 🐛 Bug Fixes

* **Workflow & Versioning Stability**
  Fixed issues related to version deletion, draft workflow save restrictions, preview handling, autosave behavior, and ensuring the correct published version is marked live.
  * Fixed delete restriction for current version in workflow
  * Removed UI restriction from workflow with draft status to save interface

* **AI Squared Vector Store**
  Fixed table rendering issue for AI Squared Vector Store in Vector Store Component.

* **UI & Interaction Fixes**
  Resolved issues in prompt input behavior, data app auto-refresh toggling, timestamp formatting, confirmation modals, toast handling, and various layout inconsistencies.

* **Performance Improvements**
  Reduced CPU and memory usage caused by database read and write operations and improved retry mechanisms for sync processes.
  * Disabled DDL transaction migration on index\_sync\_records
  * Added index on sync\_records for improved query performance

## 🚜 Refactor

* **API & Tooling Improvements**
  Refactored API response types, improved tools API structure, optimized query invalidation logic, and streamlined internal workflow handling.

* **Connector Naming**
  Renamed "Generic OpenAI Spec Endpoint" to "OpenAI Compatible Endpoint" for improved clarity.

* **Workflow Autosave**
  Updated autosave to prevent save during preview mode.

## ⚙️ Miscellaneous Tasks

* **Testing & Quality Improvements**
  Increased automated test coverage, improved linting, strengthened validation flows, and enhanced overall code quality.
  * Added tests for views/Activate module
  * Added tests for Assistant Module
  * Added tests for Enterprise/Views modules

* **Dependency & Platform Updates**
  Updated server dependencies and made internal stability improvements.
  * Updated multiwoven-integrations gem to version 0.34.19

* **S3 Connector**
  Removed schemaless catalog from Amazon S3 Connector for better data structure management.

* **UI Updates**
  Updated tool logos for better visual consistency.


# January 2026 Releases
Source: https://docs.squared.ai/release-notes/2026/January-2026

Release updates for the month of January 2026

## 🚀 Features

* **Custom Roles Edit Support**
  Added *Edit Details* button for Custom Roles to allow User-defined Roles to be modified.

* **Knowledge Base**
  Introduced Knowledge Base for use with Workflows.

* **Hugging Face Embedding Models**
  Added support for Hugging Face embedding models.

* **Agent Tools**
  Introduced Agent Tools.

* **Knowledge Base Component**
  Added Knowledge Base component in Workflows.

## 🐛 Bug Fixes

* **Collapsed Chat Overflow**
  Fixed overflow issue in collapsed chat.

* **Template Temperatures**
  Fixed temperature handling in templates.

* **Text Feedback Submission**
  Allowed text feedback submission even when additional remarks are required.

* **Prompt Template Variable Handling**
  Fixed handling when no variables are found in prompt templates.

* **Workflow Edge Updates**
  Fixed edge updates when deleting nodes in workflows.

* **React Optimization**
  Removed unnecessary useCallback and useMemo usage.

* **Vector Store UI**
  Fixed UI issues while creating vector stores in Knowledge Base.

* **Token Handling**
  Ensured different tokens per data app.

## 🚜 Refactor

* **Custom Component Layout**
  Allowed fit-content for Custom Components for better-fitting layouts.

## ⚙️ Miscellaneous Tasks

* **Anthropic Ruby Gem**
  Added Ruby Anthropic gem support.

* **Testing & Linting**
  Improved tests, linting, and overall code quality.


# July 2026 Releases
Source: https://docs.squared.ai/release-notes/2026/July-2026

Release updates for the month of July 2026

## ✨ Enhancements

* **User invite flow for agentic coding apps**
  Agentic coding apps now support visibility controls and per-app user management, letting owners share apps via public link or invite specific users.
  * Added **public** and **invite-only** visibility modes, configurable from a new **App Settings** modal in the editor
  * Owners can invite users by email, resend invitations, and accept or remove pending users on a per-app basis
  * Invitation emails guide recipients through an invite-aware sign-up flow that redirects to the deploy URL after acceptance
  * Added agentic-app token authentication for select endpoints and workflows so invited users can access apps securely
  * App Settings modal also exposes status controls and a **Built with** badge toggle

* **OAuth 2.0 client credentials authentication for HTTP connectors**
  The HTTP source and destination connectors now support OAuth 2.0 client credentials, letting Multiwoven fetch and attach Bearer access tokens automatically.
  * Added an **Authentication Type** setting with `none` and `oauth_client_credentials` options in the HTTP source and destination specs
  * When `oauth_client_credentials` is selected, configure **OAuth Token URL**, **OAuth Client ID**, **OAuth Client Secret**, and an optional **OAuth Scope**
  * Access tokens are cached and refreshed automatically before they expire, so requests continue to use a valid token without manual intervention
  * The integrations gem has been bumped to **0.38.0** to include this change

* **Expanded HTTP source response parsing**
  The HTTP source connector now handles a wider range of API response shapes, including tabular payloads with nested and two-dimensional value arrays, making it easier to ingest data from APIs such as Microsoft Graph.
  * Added support for mapping response headers to streamed row values so header/row-style responses are parsed into records correctly
  * Repeated requests no longer produce duplicate records
  * Improved handling of requests that do not use pagination settings

* **Same-origin frontend proxy and agentic coding deployment polling**
  Frontend requests now route through a same-origin proxy path, improving cookie handling and simplifying API routing across development and production environments.
  * API calls from the browser use same-origin proxy paths instead of cross-origin requests, keeping authentication cookies consistent
  * Credentialed cross-origin requests are no longer permitted by default; CSRF protection is enabled by default when no bypass setting is provided
  * Agentic coding deployments now run asynchronously on the frontend with status polling, surfacing clearer progress and failure messages to users

* **Refinements to cookie-based authentication and CSRF handling**
  Follow-up improvements to the cookie-based auth and CSRF rollout make the flow safer to deploy across environments.
  * Auth and CSRF cookies are now always host-only (no domain scoping) for stricter browser isolation
  * Browser JWT tokens are included by default, with per-request opt-out via a `token` param or environment configuration
  * CORS is now configured independently for credentialed and public (no-credentials) requests, so embed assets and anonymous API consumers can be scoped separately from authenticated origins
  * The CSRF middleware bypass now defaults to enabled, keeping enforcement off until each environment completes the frontend `X-CSRF-Token` cutover

* **Async deployment creation for agentic coding**
  Deployment creation can now run asynchronously, returning a pending deployment immediately while provisioning continues in the background.
  * Added an endpoint to retrieve individual deployment details
  * Async polling reports deployment status, completion URLs, and error messages so clients can track progress without blocking

* **Cookie-based authentication with CSRF protection**
  Sign-in and sign-out flows now use secure, HttpOnly authentication cookies alongside a CSRF cookie for browser-based sessions.
  * Added an API auth token endpoint that returns the current JWT when available via cookie or header
  * Enterprise sign-up and SSO flows now complete via cookie-based authentication, with success redirects that no longer include the token in the URL
  * Mutating requests now enforce double-submit CSRF validation and return `403` on mismatch or missing tokens
  * Safe HTTP methods (`GET`, `HEAD`, `OPTIONS`) skip CSRF validation, and requests without an auth cookie or using bearer-token auth are bypassed since they aren't vulnerable to the browser-cookie attack model
  * Frontend sign-in, sign-up, and SSO views now rely on a login state cookie instead of storing tokens in local storage, and public sign-in pages stay accessible for logged-out users while redirecting signed-in users away
  * App previews and event streams use updated authenticated request handling compatible with the cookie-based flow

* **Configurable allowed origins for embedded Data Apps and Agentic Apps**
  Embedded Data Apps and Agentic Apps now honor an explicit allow-list of origins instead of relying on permissive CORS defaults, giving admins control over where AI Squared assets can be embedded.
  * Added organization-wide and workspace-scoped embed origins that can be viewed, added, updated, and removed via new enterprise embed origins API endpoints
  * Added role-based **embed settings** permissions so only authorized roles can manage the allow-list
  * Added origin validation and normalization to keep stored values consistent and secure
  * Embed asset CORS handling — including preflight requests — is now driven by the registered origins, with automatic refresh when settings change

* **Allowed Origins admin UI in Settings**
  A new **Allowed Origins** page in Settings lets admins manage the embed allow-list directly from the app, with contextual guidance surfaced across embed and code-sharing flows.
  * Added workspace and organization-scoped **Allowed Origins** listing with add, edit, and delete actions gated by embed settings permissions
  * New add/edit modal validates URL origins inline and keeps the modal open on API errors while surfacing toast details
  * Added guidance notices on Data App embed, Agentic App embeddable code, and Share App flows so users know when origins must be configured
  * Added a dismissible announcement banner introducing the Allowed Origins feature
  * Embed CORS bypass now defaults to off when unset, ensuring the allow-list is enforced by default

## 🔧 Maintenance

* **Simplified embed CORS handling**
  Reverted the embed origins lookup endpoint and related CORS/CSP wiring to streamline how origins are resolved for embedded Data Apps and Agentic Apps.
  * CORS configuration now uses a default wildcard origin setting, and the Content Security Policy `frame-ancestors` injection has been removed
  * The embed origins lookup endpoint has been removed; origin allowlisting now uses the workspace-specific registry directly
  * Added support for agentic app paths with automatic workspace ID resolution from headers and URLs
  * Updated and removed tests to reflect the middleware and configuration changes

* **Pinned Premailer version to silence deprecation logs**
  The CE server `Gemfile` now pins **Premailer** to a specific release, resolving noisy deprecation warnings in email styling and keeping compatibility consistent across environments.

* **Dependency updates to resolve security vulnerabilities**
  Refreshed integrations dependencies and bumped the integrations gem to **0.37.4** to address known vulnerabilities.
  * Updated the **Nokogiri** version requirement
  * Removed **async-websocket** from runtime dependencies
  * Strengthened release validation to ensure the published version matches the expected semantic version format and the exact released version

* **CE server dependency updates to address vulnerabilities**
  Refreshed the CE server's Ruby dependencies (`server/Gemfile.lock`) to resolve known security vulnerabilities.

* **CE server integrations gem bump to 0.38.0**
  Updated the `multiwoven-integrations` dependency in the CE server to `~> 0.38.0`, aligning the CE server with the latest integrations release for improved compatibility and capabilities.

* **Deployment revision tagging for agentic coding telemetry**
  OpenTelemetry exports from the agentic coding tracer now include the application revision as a resource attribute, making it easier to filter traces and metrics by deployment.
  * Revision is resolved from AppSignal config when available, then falls back to `APP_REVISION` and `APPSIGNAL_APP_REVISION` environment variables
  * The revision attribute is omitted when no value is configured, avoiding errors and empty tags

* **Centralized auth token extraction across request contexts**
  Consolidated authentication-token extraction into a shared utility, making auth behavior consistent across API, embedded, and agentic coding session flows.
  * The configured auth cookie takes precedence, with a fallback to a valid Bearer token in the `Authorization` header
  * Bearer scheme matching is now case-insensitive
  * Added test coverage for token precedence, header variations, invalid schemes, and missing credentials

* **Per-deployment visitor tracking for agentic coding analytics**
  Agentic coding analytics now attribute visitors to specific app deployments, giving a more accurate view of usage across versions.
  * Added a deployment reference on visitor records so returning visitors map to the deployment they viewed
  * Dashboard active-user counts now deduplicate visitor tokens across visit records to avoid overcounting
  * App responses expose an `analytics` flag that is enabled once an app has a successful, versioned deployment
  * Analytics and reports authorization now requires a successful published deployment with a recorded version instead of relying on the app's published status alone

## 🐛 Bug Fixes

* **Safer batch pagination when the initial offset is missing or empty**
  Reverse ETL batch queries now handle missing or empty starting offsets consistently, so pagination begins at the correct position and advances reliably across subsequent batches instead of erroring out.

* **Clearer SAML SSO failure when no enabled configuration exists**
  SAML SSO sign-in now fails gracefully when no enabled SSO configuration is available, returning a clear failure message instead of leaving the authentication flow in an incomplete state. Failures are also logged with relevant sign-in details to aid troubleshooting.

* **Filter sub-session user prompts from agentic coding SSE output**
  Internal sub-session user prompt events are no longer persisted or streamed to the primary coding session's SSE output, while sub-session assistant tool-call events continue to be forwarded so task execution signals remain visible. Primary-session user messages render as before. The default reasoning variant now falls back to **low** when no explicit setting is provided.

* **Null-safe secret handling for agentic coding apps**
  Improved secret creation for agentic coding apps to gracefully handle cases where app settings are missing or empty.
  * Added a null check for secrets so no secret is created when the app configuration is unavailable
  * Prevents unnecessary errors when there are no secrets to create

* **Reliable logout cookie cleanup**
  Logout now reliably clears all authentication-related cookies.

* **Consistent cookie setting across sign-in flows**
  Authentication and CSRF cookies are now set consistently across standard sign-in, invitation, and SSO flows, and SSO handoffs preserve their intended redirect behavior. Analytics access checks also now require a successfully deployed, versioned app.

* **Improved invite signup handling**
  Invite signup flows now handle server responses more reliably.
  * Signups without authentication tokens no longer break login state updates
  * Successful invite signups with valid attributes complete login and navigation correctly
  * Server-provided errors are now displayed as separate notifications
  * AppGen invite redirects continue to work for external deployment URLs

* **Analytics availability driven by backend flag in AI app editor**
  The AI app editor now uses the backend-provided analytics flag to decide whether analytics are available, instead of relying on publication status alone.
  * Editor header reflects whether analytics are available for the selected app
  * Analytics modal status accurately mirrors the app's analytics availability
  * Improved handling when analytics information is not provided in the response

* **Persist reasoning and patch data in agentic coding prompts**
  Prompt persistence and event streaming now correctly capture reasoning, patch, and tool data across prompt lifecycles.
  * Added patch-type prompt support and richer structured metadata, including message/part tracking and started/ended timestamps
  * Event streaming now persists assistant updates per part, improving partial vs. completed handling for tool and patch data
  * Agentic coding prompts API now returns results in chronological order (oldest first)


# June 2026 Releases
Source: https://docs.squared.ai/release-notes/2026/June-2026

Release updates for the month of June 2026

## ✨ Enhancements

* **Extended Member Role for Vector Database Management**
  Member role permissions have been updated to allow management of data stores and knowledge bases.
  * Members now have **read** and **update** access to data stores and knowledge bases
  * **Create** and **delete** actions remain restricted to higher-privileged roles
  * Resource access options have been reorganized to separate workspace-related permissions from data store and knowledge base permissions for more consistent display and enforcement

## ⚙️ Miscellaneous

* **Updated integrations gem version**
  Bumped the integrations gem version used by the server to pick up the latest connector updates and fixes.


# March 2026 Releases
Source: https://docs.squared.ai/release-notes/2026/March-2026

Release updates for the month of March 2026

## Previous releases

## 🚀 Features

* **Agentic Coding (App Generation)**
  Introduced Agentic Coding feature for creating and managing AI-powered applications with interactive development sessions.
  * Create apps with workspace and user ownership
  * Interactive coding sessions with three states: active, paused, and ended
  * Prompt-based development flow with user and assistant roles
  * Deployment tracking with status monitoring (pending, running, succeeded, failed)
  * Session management with sandbox environments and preview URLs
  * Configurable agent models and session settings
  * Role-based permissions for app creation and management (Admin/Member: full CRUD, Viewer: read-only)

* **Prompt to Workflow Enhancements**
  Enhanced the prompt-to-workflow feature with improved UI and functionality for creating workflows from natural language descriptions.
  * Removed timestamps and chat names from AI workflow builder for cleaner interface
  * Improved workflow generation from prompts with better context handling
  * Added context to prompt functionality for more accurate workflow generation
  * Enhanced database support for prompt-to-workflow sessions
  * Added AI Workflow Builder panel with chat-driven workflow creation
  * Context component selector for adding workflow components as context
  * Workflow response visualization showing added, modified, and deleted components
  * Session history drawer with categorized workflow sessions
  * Suggested questions in empty state for guided workflow creation

* **Hosted Data Store Catalog Refresh**
  Implemented automatic catalog refresh for Hosted Data Stores to keep connector schemas synchronized.
  * Automatic catalog refresh when creating or updating data store tables
  * Refreshes both source and destination connector catalogs
  * Resilient error handling - refresh failures are logged but don't block table operations
  * Ensures connector catalogs stay up-to-date with schema changes

* **Human Approval Component**
  Introduced Human Approval Component for human-in-the-loop workflows, enabling manual review and approval gates within automated processes.

* **Tools Component UI Update**
  Enhanced the Tools selection interface for workflows with improved categorization and filtering.
  * Added tabbed interface to filter tools by category (All Tools, AI Squared, Custom)
  * Streamlined tool configuration flow with metadata handling
  * Improved error handling and validation for tool selection

* **Workflow Analytics - Token and Cost Tracking**
  Added comprehensive token usage and cost tracking to workflow analytics.
  * Track tokens used per workflow execution
  * Monitor estimated costs based on LLM usage
  * View detailed analytics in workflow dashboard

* **Firecrawl MCP Integration**
  Added Firecrawl Model Context Protocol (MCP) server integration for enhanced web scraping capabilities within workflows.
  * Secure API key-based authentication
  * Streamable HTTP transport protocol
  * Bearer token authentication support

* **PostgreSQL Batch Support**
  Enhanced PostgreSQL destination connector with high-performance batch write capabilities.
  * Bulk operations supporting up to 10,000 records per batch
  * Automatic fallback to individual writes on batch failure
  * Efficient upsert operations using PostgreSQL's ON CONFLICT clause

* **Devin Integration Enhancement**
  Switched Devin integration from SSE to Streamable HTTP for improved performance and reliability.

* **Agent-to-Agent (A2A) Workflow Component**
  Added a new A2A Agent component type for AI workflows, enabling agent-to-agent communication with a full configuration UI.
  * Connect to external AI agents using JSON-RPC protocol via the Agent Workflow editor
  * Configure agent endpoint URL and API key with a "Connect & Load Skills" button
  * Auto-discover remote agent skills from the standard `/.well-known/agent.json` endpoint
  * View discovered skills as read-only tags in the workflow sidebar
  * Support for multiple auth types including Bearer token and Basic auth
  * Secure credential handling with configuration values masked in API outputs

* **Configuration Security Enhancement**
  Improved security for workflow components with sensitive authentication data.
  * Auth configuration values are automatically masked when returned via API
  * Applies to A2A Agent components and other components with sensitive credentials
  * Prevents accidental exposure of secrets in API responses

* **Weaviate Destination Connector**
  Added Weaviate as a new destination connector for syncing vector data to Weaviate collections.
  * API key-based authentication
  * Automatic schema discovery from Weaviate classes
  * Batch write support with upsert capability
  * Property type coercion for text, integer, number, boolean, and date fields

## 🐛 Bug Fixes

* **Source Connector Delete**
  Fixed issue with deleting source connectors to ensure proper cleanup and resource management.

* **Guardrails Component Text**
  Corrected text for "Vulgar Content or Profanity" in guardrails component for improved clarity.

* **Synk Security Vulnerability**
  Fixed critical security vulnerability identified in Synk code scanning.

* **Nokogiri Security Update**
  Updated nokogiri gem to address security vulnerabilities.

* **Workflow Edge IDs**
  Fixed edge ID handling in workflows, converting from string to integer for better data consistency.

* **HITL Pause Check TypeError**
  Fixed a TypeError that occurred when checking for human-in-the-loop pause status on non-HITL workflow components.

* **Text to SQL Cyclic Dependency**
  Resolved a cyclic dependency issue in the Text to SQL workflow component.

* **SSE Streaming Buffering**
  Fixed SSE streaming buffering and zombie connection issues to improve real-time event delivery reliability.

* **API Base URL Handling**
  Fixed an issue where HTTPS was not automatically prepended to API base URLs, causing connection failures.

* **A2A Edge Fetching**
  Fixed agent-to-agent component fetching from workflow edges for correct data flow resolution.

* **Prompt-to-Workflow Optimization**
  Improved prompt-to-workflow generation performance and accuracy.

* **User Message Text Color**
  Fixed user message text color display issue in the chat interface.

* **CI Optimizations**
  Improved CI pipeline performance with caching, sharding, and parallelization.

* **OpenRouter LLM Usage Logging**
  Added Rails loggers for OpenRouter in LLM usage logs for better observability.

## ⚡ Improvements

* **Python Executor Import Helper Text**
  The Python Executor component now includes inline helper text in the default code template listing all supported libraries and a reminder that imports must be placed inside the `run` function.

## ⚙️ Miscellaneous Tasks

* **Testing & Quality Improvements**
  Expanded test coverage across multiple modules.
  * Added tests for Enterprise/Settings-and-Views/Models
  * Added tests for Enterprise P2 modules
  * Added tests for views/Settings
  * Added comprehensive test coverage for Agentic Coding models (App, Session, Prompt, Deployment)
  * Added tests for AI Workflow Builder components and hooks
  * Added tests for workflow session management and message handling

* **Error Message Improvements**
  Extracted error messages for Agent Component to improve debugging and user feedback.

* **Dependency Updates**
  Added tiktoken\_ruby to Gemfile for improved token counting capabilities.

* **Documentation Workflow**
  Added update-docs workflow to multiwoven-ee repository for automated documentation updates.

* **Feature Flags**
  Added feature flag support for prompt-to-workflow functionality to enable controlled rollout.

* **TextInput Max Length**
  Added max length validation to TextInput components across the UI for improved data integrity.

* **Text to SQL Workflow Fix**
  Fixed the text to SQL workflow component for correct query generation.

* **Security Vulnerability Fixes**
  Addressed critical vulnerability identified in code scanning to improve platform security.


# How Sparx Works
Source: https://docs.squared.ai/sparx/architecture

System architecture and technical components

## System Architecture

### Data Connectors Layer

* Pre-built connectors for ERP, CRM, HRIS, databases, APIs, and file systems.
* Examples: Quickbooks, Google Workspace, Office 365, Salesforce, SAP, Microsoft Dynamics, Snowflake, SharePoint, AWS S3.

### Unified Data Layer (UDL)

* Harmonizes structured, semi-structured, and unstructured data.
* Built on AI Squared's **Secure Data Fabric** technology.

### Processing & AI Models

* Pre-trained LLMs (Claude, OpenAI, Bedrock) and custom model support.
* Real-time inferencing with vector database indexing.

### Application Layer

* **Sparx Chatbot** – Conversational interface for querying data and triggering workflows.
* **Insight Dashboard** – Visual analytics with drill-down capabilities.
* **Automation Engine** – Triggers workflows based on rules or AI-detected events.

### Security & Compliance Layer

* End-to-end AES-256 encryption.
* Role-Based Access Control with SSO (Okta, Azure AD).
* Audit logging and compliance templates (HIPAA, GDPR, CCPA, FISMA).


# Getting Started
Source: https://docs.squared.ai/sparx/getting-started

How to get started with Sparx

# How to Get Started with Sparx

## Steps to Deploy Sparx

1. **Define your first use case** (e.g., reporting, forecasting, operations).
2. **Sign up** at [www.squared.ai](http://www.squared.ai) or contact [sales@squared.ai](mailto:sales@squared.ai).
3. **Configure in minutes** — or let our engineers guide you.
4. **Connect your data** via secure connectors.
5. **Deploy your AI assistant** and start asking questions.

## What's Included

### Sparx: Launchpad Workspace

* Pre-configured **Launchpad Workspace** in the AI Squared platform.
* Default vector store and out-of-the-box model integrations.
* Starter templates for Q\&A, RAG workflows, and chatbots.
* Ready-to-run workflows — zero code required.


# Overview
Source: https://docs.squared.ai/sparx/overview

Your Business AI Powered in an Hour

## What is Sparx?

Sparx by AISquared is an agent that delivers enterprise-grade AI as a conversational assistant or takes the form of an agentic action that securely connects to your existing data sources and delivers answers instantly, no coding and no data scientists required.

Originally developed on the AI Squared Unified Platform (UNIFI), technology proven in the U.S. Department of War, Sparx is designed to take AI-generated insights and execute them to help mid-sized enterprises and nonprofits to cut decision time, reduce errors, and unlock new revenue opportunities.

Ask any question. Get trusted answers from your data.

## Why Sparx:

* **Fast Deployment**: Production-ready in less than an hour.
* **No-Code Setup**: No data scientist needed for installation.
* **Defense-Grade Security**: AES-256 encryption, zero-trust architecture.
* **Conversational Interface**: Ask questions in plain language, get real answers.

## Business Impact:

Sparx gives each member of your team the power of AI:

* **Eliminates data silos**: ERP, CRM, HRIS, databases and more in a single view.
* **Automates Repetitive Work**: Frees teams to focus on high-value activities.
* **Accelerates Decisions**: AI tools analyze data in real time to deliver actionable insights.

Sparx Helps Level the Playing Field: Enables mid-market organizations to compete with larger enterprises.

## Who uses Sparx ?

* **Business Owners & Executives**: Drive growth and efficiency.
* **Non-Profit Leaders**: Optimize operations and donor engagement.
* **School Administrators**: Streamline reporting and compliance.
* **Line-of-Business Managers**: Gain real-time visibility into operations.
* **Individual Contributors**: Reduce manual data work.


# System Layout
Source: https://docs.squared.ai/sparx/system-layout

Visual representation of Sparx platform components

Sparx - **Data scientist in a box** system architecture diagram

<Frame>
  <img alt="Sparx Architecture" />
</Frame>


# Use Cases
Source: https://docs.squared.ai/sparx/use-cases

Real-world examples and before/after comparisons

## Example Implementation for a franchise:

Franchise implementation diagram showing Sparx integration with multiple franchise locations and systems

<Frame>
  <img alt="use-case" />
</Frame>

## Before & After Sparx

| Task                                     | Before Sparx                                                                                                                  | After Sparx                                                                        |
| ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------- |
| Create a P\&L since January of last year | 2FA login into QuickBooks → Navigate to Reports → Select Company & Financial → Choose P\&L → Select date range → Download PDF | Prompt: "Create P\&L from January of last year"                                    |
| Check Remaining Software Licenses        | Hire analyst → Engineer pulls logs → Export → Format → Pivot table → Match contracts → Calculate remaining licenses           | Prompt: "How many software licenses remain on this customer's contract?"           |
| Find Company Holidays                    | 2FA into HRIS → Navigate to Time Off → Search holiday calendar                                                                | Type: "What holidays do we observe?"                                               |
| Board Director Data Access               | Directors repeatedly request manual reports from staff                                                                        | Directors type their own questions directly into Sparx and receive instant answers |
| Sales Pipeline Report                    | CRM login → Apply filters → Export data → Format in Excel → Share via email                                                   | Prompt: "Show me the current sales pipeline by stage and owner"                    |
| Customer Support Ticket Summary          | Log into Helpdesk → Apply filters → Export data → Summarize manually → Email stakeholders                                     | Prompt: "Summarize top 10 customer issues this month"                              |
| Inventory Status Check                   | ERP login → Search SKU → Check warehouse availability → Cross-check with purchasing data                                      | Prompt: "What is the current inventory level for SKU 12345?"                       |
| Employee Turnover Rate                   | Pull HRIS data → Export to spreadsheet → Calculate turnover formula → Prepare chart for HR                                    | Prompt: "What's the employee turnover rate for the past 12 months?"                |


# Terms of Use
Source: https://docs.squared.ai/terms-of-use



## AI SQUARED COMMUNITY LICENSE

By using, reproducing, modifying, distributing, performing or displaying any portion or element of the AI Squared Open-Weight Model or any Model Derivatives, (each as defined below) (collectively, the “<u>AI Squared Services</u>”) or otherwise accepting the terms of this Agreement, you agree to be bound by this Agreement. You represent and warrant that you have the legal capacity to enter into this Agreement (including being of sufficient age of consent). If you are accessing or using any of the AI Squared Services for or on behalf of a legal entity, (a) you are entering into this Agreement on behalf of yourself and that legal entity, (b) you represent and warrant that you have the authority to act on behalf of and bind that entity to this Agreement and (c) references to “you” or “your” in the remainder of this Agreement refers to both you (as an individual) and that entity.

1. LICENSE

Subject to your compliance with these Terms, AI Squared grants you a non-exclusive, worldwide, non-transferable, non-sublicensable, revocable, royalty-free limited license to: (a) use or modify the AI Squared Services solely for your own internal business purposes or for non-commercial or personal use; and (b) Distribute the AI Squared Services or provide them to others, solely free of charge and for non-commercial purposes.

2. RESTRICTIONS

You agree not to, and will not assist or permit any third party to:

1. <u>Commercial Deployment</u>. Use the AI Squared Services for any Commercial Purpose. "<u>Commercial Purpose</u>" includes, but is not limited to, using the AI Squared Services for revenue-generating activities, business operations, or intended commercial advantage. If you wish to use the AI Squared Services for any commercial purpose, including but not limited to any customer-facing application, you must obtain a separate commercial license. If you are accessing or using any of the AI Squared Services for or on behalf of a legal entity, such access or use shall be deemed to be for Commercial Purposes, if (i) the total number of Authorized Users within your Entity exceeds the User Limit at any time, or (ii) the total annual revenues of your Entity in the most recently completed fiscal year exceed an amount equal to \$25,000,000 (“<u>Revenue Limit</u>”). Please contact our Legal Department ([legal@aisquared.ai](mailto:legal@aisquared.ai)) to discuss licensing terms for commercial use.
2. <u>No Customer-Facing Use</u>. Make the AI Squared Services available to third parties or end-users. This explicitly prohibits exposing the AI Squared Services via (i) public or private APIs; (ii) Software-as-a-Service (SaaS) platforms; (iii) web interfaces or mobile applications; or (iv) any other method where the output of the AI Squared Services is accessible to persons other than your internal employees or authorized contractors;
3. <u>Distribution</u>: Distribute the AI Squared Services to any third party, except in case of a Permitted Distribution as defined in Section 3; 
4. <u>Prohibited Use Policy</u>. Use the AI Squared Services in any way that violates the Prohibited Use Policy set forth in Appendix B;

All Model Derivatives are subject to the restrictions set forth in this Section. If, at any time, your Entity exceeds the number of Authorized Users or the Revenue Limit or you otherwise engage in use for a Commercial Purpose without the prior purchase of a Commercial License, the rights granted under Section 1 shall immediately and automatically terminate. Continued use of the AI Squared Services by you or your Entity after such threshold is crossed shall constitute a material breach of this Agreement.

3. PERMITTED DISTRIBUTION

You may reproduce or Distribute copies of the AI Squared Open-Weight Model or Model Derivatives if you meet all of the following conditions (“Permitted Distributions”):

1. Distribution is made solely free of charge and for non-commercial purposes.
2. You must include the use restrictions referenced in this License as an enforceable provision in any agreement (e.g., license agreement, terms of use, etc.) governing the use and/or distribution of the AI Squared Open-Weight Model or Model Derivatives and you must provide notice to subsequent users you Distribute to that the AI Squared Open-Weight Model or Model Derivatives are subject to the use restrictions herein.
3. You must provide all third party recipients of the AI Squared Open-Weight Model or Model Derivatives a copy of this Agreement.
4. You must cause any modified files to carry prominent notices stating that you modified the files.
5. All Distributions (other than through a hosted service) must be accompanied by a “Notice” text file that contains the following notice: “the AI Squared Open-Weight Model and any Model Derivatives are provided under and subject to the AI Squared Community License found at \[…]”.
6. INDEMNITY
   1. You agree to indemnify, defend, and hold harmless AI Squared, its affiliates, and their respective officers, directors, and employees (collectively, the "<u>Indemnified Parties</u>") from and against any and all claims, damages, liabilities, costs, and expenses (including reasonable attorneys’ fees) arising out of or related to any third-party claim concerning:
      1. your use of the AI Squared Services in violation of the Prohibited Use Policy;
      2. your violation of any applicable law or regulation in connection with the AI Squared Services; or
      3. any content or output generated by your use of the AI Squared Services that infringes or misappropriates the intellectual property or privacy rights of a third party.
   2. AI Squared shall provide prompt notice of any such claim to you. You shall have sole control of the defense and settlement of the claim, provided that you may not settle any claim without AI Squared’s prior written consent unless the settlement unconditionally releases AI Squared of all liability. AI Squared may participate in the defense at its own expense.
7. ADDITIONAL PROVISIONS
   1. <u>Generated Output</u>. AI Squared claims no rights in Outputs you generate using the AI Squared Open-Weight Model. You and your users are solely responsible for Outputs and their subsequent uses.
   2. <u>Updates</u>. AI Squared may update the AI Squared Open-Weight Model from time to time.
   3. <u>Trademarks</u>. Nothing in this Agreement grants you any rights to use AI Squared's trademarks, trade names, logos or to otherwise suggest endorsement or misrepresent the relationship between you and AI Squared. AI Squared reserves any rights not expressly granted herein.
   4. <u>DISCLAIMER OF WARRANTY</u>. UNLESS REQUIRED BY APPLICABLE LAW, THE AI SQUARED SERVICES, AND OUTPUTS, ARE PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE. YOU ARE SOLELY RESPONSIBLE FOR DETERMINING THE APPROPRIATENESS OF USING, REPRODUCING, MODIFYING, PERFORMING, DISPLAYING OR DISTRIBUTING ANY OF THE AI SQUARED SERVICES OR OUTPUTS AND ASSUME ANY AND ALL RISKS ASSOCIATED WITH YOUR USE OR DISTRIBUTION OF ANY OF THE AI SQUARED SERVICES OR OUTPUTS AND YOUR EXERCISE OF RIGHTS AND PERMISSIONS UNDER THIS AGREEMENT.
   5. <u>LIMITATION OF LIABILITY</u>. TO THE FULLEST EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), PRODUCT LIABILITY, CONTRACT, OR OTHERWISE, UNLESS REQUIRED BY APPLICABLE LAW, SHALL AI SQUARED OR ITS AFFILIATES BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT, INDIRECT, SPECIAL, INCIDENTAL, EXEMPLARY, CONSEQUENTIAL, OR PUNITIVE DAMAGES, OR LOST PROFITS OF ANY KIND ARISING FROM THIS AGREEMENT OR RELATED TO, ANY OF THE AI SQUARED SERVICES OR OUTPUTS EVEN IF AI SQUARED OR ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
   6. <u>Term, Termination, and Survival</u>. The term of this Agreement will commence upon your acceptance of this Agreement (including acceptance by your use, modification, or Distribution, reproduction, performance or display of any portion or element of the AI Squared Services) and will continue in full force and effect until terminated in accordance with the terms of this Agreement. AI Squared may terminate this Agreement if you are in breach of any term of this Agreement. Upon termination of this Agreement, you must delete and cease use and Distribution of all copies of the AI Squared Open-Weight Model and Model Derivatives in your possession or control. Sections 2, 4.3 to 4.10 and 5 shall survive the termination of this Agreement.
   7. <u>Governing Law and Jurisdiction</u>. This Agreement will be governed by the laws of the State of California without regard to choice of law principles. The UN Convention on Contracts for the International Sale of Goods does not apply to this Agreement. The state and federal courts of Santa Clara County, California shall have exclusive jurisdiction of any dispute arising out of this Agreement.
   8. <u>Severability</u>. If any provision of this Agreement is held to be invalid, illegal or unenforceable, the remaining provisions shall be unaffected thereby and remain valid as if such provision had not been set forth herein.
   9. <u>Entire Agreement</u>. This Agreement states all the terms agreed between the parties and supersedes all other agreements between the parties as of the date of acceptance relating to its subject matter.
   10. <u>No Waiver</u>. AI Squared will not be treated as having waived any rights by not exercising (or delaying the exercise of) any rights under this Agreement.
8. DEFINITIONS
   1. “**Agreement**” or “**AI Squared Community License**” means these terms and conditions that govern the use, reproduction, Distribution or modification of the AI Squared Services and any terms and conditions incorporated by reference.
   2. “**AI Squared Open-Weight Model**” means the set of machine learning language models, trained model weights and parameters identified in Appendix A, regardless of the source you obtained it from.
   3. “**Authorized User**” means any of your individual employees, contractors, or agents who access, download, modify, fine-tune, or utilize the AI Squared Service.
   4. “**Distribution**” or “**Distribute**” means any transmission, publication, or other sharing of the AI Squared Open-Weight Model or Model Derivatives to a third party, including by providing or making the AI Squared Open-Weight Model or its functionality available as a hosted service via API, web access, or any other electronic or remote means and including making available the AI Squared Serivices as part of a framework, a proxy server, middleware, a gateway infrastructure product or any product substantially similar in function or purpose to the foregoing.
   5. “**Entity**” means your organization and any organization, subsidiary, or affiliate that controls, is controlled by, or is under common control with you. For the purposes of the User Limit, all Authorized Users across the entire Entity shall be aggregated.
   6. “**Model Derivatives**” means all (i) modifications to the AI Squared Open-Weight Model, (ii) works based on the AI Squared Open-Weight Model, or (iii) any other machine learning model which is created by transfer of patterns of the weights, parameters, operations, or Output of the AI Squared Open-Weight Model, to that model in order to cause that model to perform similarly to the AI Squared Open-Weight Model, including distillation methods that use intermediate data representations or methods based on the generation of synthetic data Outputs by the AI Squared Open-Weight Model for training that model. For clarity, Outputs are not deemed Model Derivatives.
   7. “**Output**” means the information content output of the AI Squared Open-Weight Model or a Model Derivative that results from operating or otherwise using the AI Squared Open-Weight Model or the Model Derivative, including via a Hosted Service.
   8. “**User Limit**” means a maximum of 50 unique Authorized Users within the Entity at any given time.
   9. As used in this Agreement, “including” means “including without limitation”.

## **APPENDIX A**

AI Squared Open-Weight Models

* Bolt Instruct Models
  * Bolt Instruct 1b
    * [<u>https://huggingface.co/aisquared/bolt-instruct-1b</u>](https://huggingface.co/aisquared/bolt-instruct-1b)
  * Bolt Instruct 1b GGUF variant
    * [<u>https://huggingface.co/aisquared/bolt-instruct-1b-gguf</u>](https://huggingface.co/aisquared/bolt-instruct-1b-gguf)
  * Bolt Instruct 7b
    * [<u>https://huggingface.co/aisquared/bolt-instruct-7b</u>](https://huggingface.co/aisquared/bolt-instruct-7b)
  * Bolt Instruct 7b GGUF variant
    * [<u>https://huggingface.co/aisquared/bolt-instruct-7b-gguf</u>](https://huggingface.co/aisquared/bolt-instruct-7b-gguf)
  * Bolt Instruct 32b 
    * [<u>https://huggingface.co/aisquared/bolt-instruct-32b</u>](https://huggingface.co/aisquared/bolt-instruct-32b)
  * Bolt Instruct 32b GGUF variant
    * [<u>https://huggingface.co/aisquared/bolt-instruct-32b-gguf</u>](https://huggingface.co/aisquared/bolt-instruct-32b-gguf)
* Bolt Vision Models
  * Bolt Vision 9b
    * [<u>https://huggingface.co/aisquared/bolt-vl-9b</u>](https://huggingface.co/aisquared/bolt-vl-9b) 
  * Bolt Vision 9b GGUF variant
    * [<u>https://huggingface.co/aisquared/bolt-vl-9b-gguf</u>](https://huggingface.co/aisquared/bolt-vl-9b-gguf) 
  * Bolt Vision 4b
    * [<u>https://huggingface.co/aisquared/bolt-vl-4b</u>](https://huggingface.co/aisquared/bolt-vl-4b) 
  * Bolt Vision 4b GGUF variant
    * [<u>https://huggingface.co/aisquared/bolt-vl-4b-gguf</u>](https://huggingface.co/aisquared/bolt-vl-4b-gguf) 
* Bolt Embedding Models
  * Bolt Embedding Small
    * [<u>https://huggingface.co/aisquared/bolt-embedding-small</u>](https://huggingface.co/aisquared/bolt-embedding-small) 
  * Bolt Embedding Small GGUF variant
    * [<u>https://huggingface.co/aisquared/bolt-embedding-small-gguf</u>](https://huggingface.co/aisquared/bolt-embedding-small-gguf) 
  * Bolt Embedding Large
    * [<u>https://huggingface.co/aisquared/bolt-embedding-large</u>](https://huggingface.co/aisquared/bolt-embedding-large) 
  * Bolt Embedding Large GGUF variant
    * [<u>https://huggingface.co/aisquared/bolt-embedding-large-gguf</u>](https://huggingface.co/aisquared/bolt-embedding-large-gguf) 

## **APPENDIX B**

PROHIBITED USE POLICY

This Policy applies to any use of the AI Squared Open-Weight Model, including any Model Derivatives created using the AI Squared Open-Weight Model. By accessing or using the AI Squared Services, you agree NOT to use the AI Squared Services for any of the following purposes:

1. VIOLATION OF LAWS AND RIGHTS
2. <u>Illegal Activity</u>: Engaging in, promoting, or facilitating any activity that violates applicable local, state, national, or international laws or regulations.
3. <u>Privacy Violations</u>: Generating, collecting, or publishing personally identifiable information (PII) or protected health information (PHI) of others without their express consent.
4. <u>Intellectual Property</u>: Violating the intellectual property rights, proprietary rights, or trade secrets of AI Squared or any third party.
5. HARM TO MINORS
   1. <u>Child Sexual Abuse Material (CSAM)</u>: Generating, promoting, or distributing content that depicts, promotes, or normalizes the sexual abuse or exploitation of children.
   2. <u>Predatory Behavior</u>: Using the AI Squared Service to groom, solicit, or interact inappropriately with minors.
6. VIOLENCE, HATE, AND HARASSMENT
   1. <u>Violence and Physical Harm</u>: Promoting, facilitating, or encouraging violence, terrorism, or physical harm against individuals or groups. This includes instructions on how to create weapons, explosives, or biological/chemical agents.
   2. <u>Hate Speech</u>: Generating content that promotes discrimination, hostility, or violence based on race, ethnicity, national origin, religion, sex, gender, sexual orientation, disability, or medical condition.
   3. <u>Harassment</u>: Generating content intended to harass, bully, shame, threaten, or defame specific individuals or groups.
7. SELF-HARM
   1. <u>Promotion of Self-Harm</u>: Encouraging, providing instructions for, or idealizing suicide, self-mutilation, eating disorders, or other acts of self-harm.
8. SEXUALLY EXPLICIT CONTENT
   1. <u>Non-Consensual Sexual Content</u>: Generating content that depicts sexual violence or non-consensual sexual behavior.
   2. <u>Deepfakes</u>: Creating non-consensual sexual imagery of real individuals (deepfakes).
9. DECEPTION AND DISINFORMATION
   1. <u>Impersonation</u>: Deceiving others by creating content that falsely represents a real person or entity without disclosure (e.g., creating fake social media profiles or posing as a government official).
   2. <u>Disinformation Campaigns</u>: Generating or spreading verifiable false information for the purpose of interfering with democratic processes, manipulating public opinion, or causing public harm.
10. HIGH-RISK AND CRITICAL INFRASTRUCTURE
    1. <u>Critical Systems</u>: Using the AI Squared Services in the operation of nuclear facilities, air traffic control, life support systems, or military weaponry, where the failure of the AI Squared Services could lead to death, personal injury, or environmental damage.
    2. <u>Medical Advice</u>: Providing tailored medical advice or diagnosis without appropriate oversight by a licensed professional.
11. CIRCUMVENTION
    1. <u>Jailbreaking</u>: Attempting to bypass the AI Squared Services’ safety filters, training guardrails, or this Prohibited Use Policy.

Violation of this Policy constitutes a material breach of the AI Squared Community License. Upon any violation, your rights to use the AI Squared Services will terminate automatically and immediately. We reserve the right to report illegal activities to law enforcement authorities.


# Chat Assistants
Source: https://docs.squared.ai/workflows/chat-assistants

Deploy AI workflows as interactive chat assistants with support for file uploads and embedded deployment.

AI Assistants are the interfaces through which you can access published AI workflows.

Once an AI workflow is built and published, it can be exposed as an AI Assistant.

Assistants provide an interactive layer that allows users to submit queries and receive responses.

AI Assistants support:

* Executing published AI workflows through a chat-based interface
* Submitting natural language queries and viewing structured responses
* Uploading files as part of a conversation when the workflow includes a File Input component
* Capturing user feedback on responses
* Maintaining interaction history for ongoing conversations

AI Assistants can be deployed in multiple ways, including:

* As a hosted web-based chatbot
* Embedded within existing applications via iframe
* Integrated via APIs or supported platforms (such as Slack)

AI Workflows define how reasoning, data retrieval, and processing occur. Meanwhile, AI Assistants define how users interact with those workflows in production.

<Frame>
  <img alt="Screenshot2026 03 23at2 30 08PM" />
</Frame>

## File uploads in chat assistants

When a workflow includes a [File Input component](/workflows/overview#file-input-component) with uploads enabled, users can attach files directly within the chat assistant interface. This works in both the hosted assistant and embedded deployments.

**How it works:**

1. The chat input displays an attachment button when the workflow supports file uploads.
2. You select one or more files to attach. Supported formats include PDF, DOC, DOCX, XLS, XLSX, CSV, TXT, and others.
3. Attached files appear as chips in the input area with a loading indicator during upload.
4. Once uploaded, you can preview or remove files before sending your message.
5. When you send the message, the workflow processes the file contents alongside your query.

Uploaded files are scoped to your session and automatically removed when the session expires.

<Tip>
  You can preview uploaded files directly in the chat interface. Supported previews include PDFs, spreadsheets, and text-based documents.
</Tip>

## Embedded assistants

AI Assistants can be embedded within external applications using an iframe. Embedded assistants use a secure token-based authentication mechanism that restricts access to only the endpoints required for the chat experience.

Embedded assistants support the same capabilities as the hosted version, including:

* Conversational interactions with published workflows
* File uploads through the chat interface
* File previews and downloads
* Session-scoped interaction history


# Knowledge Bases
Source: https://docs.squared.ai/workflows/knowledge-bases



## Overview

Knowledge Bases help you make unstructured information more usable inside AI workflows.

A Knowledge Base lets users upload information (in the form of documents). split them in smaller parts, convert them into embeddings, and store them in a vector database. 

Once processed, this content can be retrieved as and when required by AI workflows.

A Knowledge Base:

* Stores uploaded files
* Manages how these files are processed
* Manages storage of processed data
* Helps contextual retrieval

This approach gives you flexibility to use external storage if required, and removes the need to manage additional databases.

## What a Knowledge Base Includes

Each Knowledge Base combines configuration, storage, and content into a single unit:

* File ingestion - Upload documents directly into the platform
* Chunking logic - Break documents into smaller, overlapping segments to get better context
* Embedding configuration - Define how text is converted into vectors
* Vector storage - Store embeddings in a hosted or customer-managed database
* Retrieval interface - Make the content available to workflows via semantic search or queries

## Supported Knowledge Base Types

AI Squared supports two Knowledge Base types:

1. **Vector Store**\
   Designed for semantic search and retrieval. Uploaded documents are embedded and stored as vectors, enabling similarity-based queries.
2. **Semantic Data Model**\
   Designed for non-vector or structured retrieval scenarios, where queries are executed directly against a connected database.

The selected type determines how data is processed and how retrieval queries are executed during workflow runs.

## Creating a Knowledge Base

When creating a Knowledge Base, users define how their documents should be processed and stored.

Some of the key configuration options are:

* **Embedding provider** - Service used to generate embeddings (default: OpenAI)
* **Embedding model** - Specific model used for vector generation
* **Chunk size** - Maximum size of each document chunk
* **Chunk overlap** - Overlap between chunks to preserve context
* **Vector storage** - Choose between a hosted vector store or an external database
* **Storage schema** - Define which database columns store vectors, text, and metadata

Once saved, the Knowledge Base becomes ready to accept file uploads.

<Frame>
  <img alt="Creating Knowledge Base" title="(1)" />
</Frame>

### File Upload and Processing

Uploading a file to a Knowledge Base triggers an automated processing pipeline:

1. The file is uploaded and verified
2. Content is extracted and split into smaller chunks
3. Each chunk is converted into an embedding
4. Embeddings, text, and metadata are written to the selected storage
5. File status is updated once processing completes

<Frame>
  <img alt="Chunking & Processing" title="(2)" />
</Frame>

This entire process runs asynchronously, allowing large files to be handled without blocking the user experience.

<Frame>
  <img alt="File Upload" title="(3)" />
</Frame>

### Updating a Knowledge Base

Knowledge Bases cannot be changed once they are created. If you need to make changes in the configuration, you must create a new Knowledge Base and re-upload files with the updated settings.

### Deleting Knowledge Bases and Files

Knowledge Bases and their files can be safely deleted when they are no longer in use.

When individual files are deleted, the embeddings associated with that file are also removed.

## Retrieval and Usage in Workflows

Knowledge Bases are designed in a way that they can be used directly by AI workflows. Retrieval is designed to ensure that AI responses are grounded in authoritative, relevant, and permitted data, rather than relying on general model knowledge.

When a query is received:

* Content is retrieved based on meaning allowing workflows to work effectively with unstructured information
* Semantic retrieval can be combined with simple keyword matching and metadata filters to improve accuracy and recall
* Access controls and permissions are enforced, ensuring users only retrieve data they are allowed to see
* Retrieved results can include references back to the original documents or records, maintaining traceability

This ensures workflows always retrieve relevant information. 

## **Knowledge Bases with agents**

When used within agent-driven workflows, Knowledge Bases can be invoked dynamically as part of the agent’s reasoning process. This allows agents to decide *when* retrieval is needed, query the Knowledge Base with the right context, and use the returned information to guide multi-step reasoning.

Even in these cases, retrieval remains controlled and predictable - agents can only access Knowledge Bases explicitly connected to the workflow, and all retrieved content is returned in a structured, auditable form.

## **Why are Knowledge Bases Important**

Knowledge Bases help translate raw data into data that is usable for AI workflows. 

They help teams to:

* Bring unstructured knowledge into AI systems
* Maintain clean separation between data, configuration, and workflows
* Ensure consistent, compliant access to knowledge within the company

Knowledge Bases turn static documents into usable knowledge inside AI Squared.


# Agents & MCP Tools
Source: https://docs.squared.ai/workflows/mcp-tools



## Overview

Agents help make workflows autonomous. An Agent can decide what tools it needs to perform a task, combine those tools, and consolidate the results into a final outcome.

This is powered by MCP (Model Context Protocol) servers, which expose external systems - like SaaS apps, APIs, or internal services - as callable tools. Agents don’t talk to these systems directly. Instead, they interact through a clean, governed tools layer.

This setup gives you:

* Workflows that can adapt at runtime
* More controlled access to external systems

## Core Building Blocks

The Agents & MCP system is built around three main components:

* **MCP Servers** - Helps AI agents perform actions through pre-defined tools
* **MCP Tools Component** - A way to select and grant tool access to an Agent
* **Agent Component** -Selects tools and executes actions

### MCP Servers

An MCP Server lets an Agent take actions in external systems, like searching data or creating records.

AI Squared supports two ways to work with MCP servers:

* Preconfigured servers
* Custom servers 

Each MCP server has connection details and authentication settings. 

Before a server can be used, the connection is tested to ensure it is valid and reachable, and exposes valid tools.

<Frame>
  <img alt="(6)" />
</Frame>

### MCP Tools Component

The Tools Component defines which MCP tools an Agent can use in a workflow.

The MCP tools themselves do not execute by themselves. The Tools Component:

* Points to an MCP server
* Lists the tools available by that server
* Lets users select which tools an Agent is allowed to use

This keeps closer access control over the tools. 

What’s Available:

* 26 pre-integrated remote MCP server tools
* Custom MCP Server support to connect any MCP-compliant server
* Centralized tool configuration and management
* Tools configured today can be reused in upcoming workflow and agent capabilities

<Frame>
  <img alt="Screenshot2026 03 23at2 04 59PM" />
</Frame>

### Agent Component

The Agent Component is where execution actually happens.

An Agent:

* Uses an LLM to reason
* Decides which tool to use based on the task
* Calls tools through the MCP client
* Interprets tool responses
* Produces a final result

Agents run on the backend and support multi-step reasoning, making them ideal for workflows in the real-world workflows.

## How the Workflow Functions 

When a workflow runs:

1. The scheduler reaches the Agent
2. The Agent inspects which tools are connected
3. The Agent builds an internal list of allowed tools
4. The Agent decides which tools to call and when
5. Tools are invoked dynamically through the MCP client

The workflow engine does not execute tools directly - only the Agent does.

### Safety, Control, and Governance

Several guardrails are built into the system:

* Agents can only use tools connected to them
* Tool credentials are stored securely
* Logs are captured for debugging

These controls ensure autonomy without compromising on security.

## **Why Agents & MCP Tools are Important**

Agents and MCP Tools together help make workflows smarter, compliant and efficient.

They allow teams to:

* Automate complex, multi-step tasks
* Integrate AI reasoning with real systems
* Keep tool access explicit and auditable
* Scale your operations efficiently.


# Overview
Source: https://docs.squared.ai/workflows/overview



## Introduction

The AI Workflow Builder provides a chat-driven interface for creating and modifying workflows using natural language:

* Gather input from users or systems
* Enrich that input with contextual data
* Execute one or more AI reasoning steps
* Process intermediate and final results
* Deliver structured output to downstream consumers

## Key Features

* **Build with AI Button**: Access the AI builder directly from the workflow canvas
* **Context-Aware Generation**: Select existing workflow components to provide context for modifications
* **Session History**: View and resume previous workflow building sessions
* **Suggested Questions**: Get started with pre-defined workflow templates and examples
* **Component Visualization**: See which components were added, modified, or deleted in each generation
* **Missing Connector Detection**: Automatically detects and prompts for required connector setup
* **Inline Connector Creation**: Create missing data or AI/ML source connectors without leaving the builder

## How It Works

1. Click "Build with AI" in the workflow canvas
2. Describe your workflow or select suggested questions
3. Optionally add existing components as context for modifications
4. Review the generated workflow with visual change indicators
5. Continue refining through conversational prompts

## Key Concepts

| Concept                      | Description                                                    |
| ---------------------------- | -------------------------------------------------------------- |
| **Chat Input**               | Accepts user questions to initiate the workflow                |
| **File Input**               | Provides document content as context for the workflow          |
| **Prompt**                   | Templates used to structure input for the LLM                  |
| **LLM**                      | Connects to OpenAI, Anthropic, etc., to generate completions   |
| **Database / Vector Search** | Queries your structured or embedded data                       |
| **Chat Output**              | Displays the final result in the interface                     |
| **Workflow Canvas**          | Visual UI to arrange and connect components                    |
| **A2A Agent**                | Connects to external AI agents via the Agent-to-Agent protocol |
| **Human Approval**           | Pauses workflow execution for manual approval or rejection     |
| **Agent-to-Agent**           | Enables agent-to-agent communication via JSON-RPC protocol     |

## Core Components of an AI Workflow

### Prompt to Workflow

AI Squared now supports creating workflows directly from natural language descriptions. This feature enables you to:

* **Rapid Prototyping**: Describe your workflow in plain English and have it automatically generated
* **Workflow Sessions**: Each workflow execution creates a session that tracks conversation history and maintains context
* **Session Management**: Sessions automatically expire after a configurable duration (default: 10 minutes)
* **Usage Tracking**: Workflow sessions are tracked for billing and analytics purposes

Workflow sessions are associated with both the workflow and workspace, ensuring proper data isolation and billing attribution.

### Templates

Templates provide pre-built starting points for common workflow patterns.

* **Direct LLM Chat**: A chat agent that uses an LLM model to generate a response.
* **Prompt LLM Chat**: A chat agent that uses a prompt template combined with an LLM to generate structured responses.
* **Database Vector Retrieval**: A chat agent that uses a vector database to retrieve context and a prompt template to generate a response.
* **Direct Database**: A chat agent that queries a database directly to retrieve data.
* **Text to SQL**: A chat agent that converts natural language questions into SQL queries, executes them against a connected database, and returns results with agentic retry and self-correction.

### **Input Components** 

Input components serve as the entry point into a workflow.**Responsibilities:**

* Accept user or system input
* Normalize input into a consumable format for downstream components

**Common types of input:**

* Chat input (natural language queries)
* File input (document content as context)
* Programmatic input (API-triggered payloads)

<Frame>
  <img alt="AI Wflow Fig2 Inputcomponent" />
</Frame>

### File Input Component

The File Input component allows you to attach files to a workflow so their content is available as context for downstream components such as prompts and LLMs.

**Capabilities:**

* **Static files** — Upload up to 2 permanent files per workflow. These files provide context for every execution.
* **Session file uploads** — Enable the `allow_uploads` toggle to let end users upload files during a chat session. Session files are automatically cleaned up when the session expires.

**Supported file types:**

| Format       | Extensions                    |
| ------------ | ----------------------------- |
| Spreadsheets | CSV, TSV, XLS, XLSX, ODS      |
| Documents    | DOC, DOCX, ODT, PDF, RTF, TXT |
| Code         | SQL                           |

<Note>
  Each file can be up to 50 MB. File content is automatically parsed and truncated to fit within token limits before being passed to downstream components.
</Note>

**How it works:**

1. Add a File Input component to your workflow canvas. A workflow can have at most one File Input component.
2. Optionally upload static files that persist across all executions.
3. Enable `allow_uploads` if you want chat users to attach files at runtime.
4. The component parses all attached files into text and outputs the combined content to connected components.

### Prompt Components

Prompt components define instruction templates that guide AI behavior.\
**Responsibilities:**

* Translate raw input into structured instructions
* Define task boundaries and constraints
* Introduce dynamic variables for runtime substitution

<Frame>
  <img alt="Prompt Component" title="AI Wflows Fig3 Prompt Component" />
</Frame>

**Key characteristics:**

* Support dynamic placeholders (e.g., user\_input, query, results)
* Are reusable across workflows
* Do not execute AI models directly

Prompt components act as the control layer between intent and execution.

### AI Components

AI components execute prompts and logic using connected AI capabilities. 

* **Large Language Models (LLMs):** LLMs are used for reasoning, transformation, summarizing, and other logic based activities.

  <Frame>
    <img alt="Large Language Models(ll Ms)" title="AI Wflows Fig4 Large Language Models(ll Ms)" />
  </Frame>
* **Agents:** Agents are helpful in managing reasoning (involving multiple steps), co-ordinating across multiple tools, maintaining the context of execution across steps. Agents will always operate within the guardrails or boundaries set by the users. You can use multiple Agent components in a single workflow for complex multi-agent orchestration.
* **A2A Agents:** A2A (Agent-to-Agent) agents allow your workflows to communicate with external AI agents running on other platforms using Google's open A2A protocol. Configure a remote A2A-compliant agent by providing its URL, and the system automatically discovers the agent's capabilities via its agent card. At runtime, the workflow sends prompts to the remote agent via JSON-RPC and receives structured responses.
* **Tools:** Tools allow AI systems to interact with external systems or perform specific activities such as query execution, data transformation, or enrichment.

### Data Components

Data components enable the workflows to interact with structured and unstructured data sources. 

* **Database:** These components allow workflows to execute structured queries and retrieve results in a tabular format. 
* **Vector:** Vector search components help in semantic retrieval and contextual augmentation using embeddings.

## Other Components

### Workflow Canvas

Workflow canvas is the layer where all the components are assembled. It gives users a visualization of workflows and ensures that the workflows execute in a predictable manner.

Components on the canvas are visually highlighted when their configuration is missing or invalid, making it easy to spot which components still need attention before a workflow can run. The canvas also automatically resolves overlapping components so the layout stays readable as workflows grow.

### Guardrails

Guardrails defines the boundaries of operation for your AI instance. Guardrails can include prompt-level limitations, data access limitations or checks on output format to ensure security. 

Guardrails ensure workflows remain safe and auditable, and meet enterprise requirements.  

### Conditional Component

Conditional components allow workflows to make decisions during execution. Based on the output of a previous component, conditions are evaluated to determine which branch of the workflow to proceed with. These decisions are made dynamically at run-time. 

### Workflow Versioning

Workflow versioning lets you track, compare and manage different versions of your workflow over time. Instead of manually tracking changes, Workflow Versioning maintains a complete version history for teams to refer. 

### Python Executor

The Python Executor allows custom Python code to run directly within a workflow. The execution is secure and results are returned to the workflow in real-time.

Python Executor supports libraries that help extend workflow capabilities, giving you more dynamic and customized processing steps.

**Supported libraries:**

| Category         | Libraries                                                             |
| ---------------- | --------------------------------------------------------------------- |
| Standard library | `json`, `io`, `re`, `time`, `random`, `base64`, `datetime`, `asyncio` |
| HTTP             | `requests`, `aiohttp`                                                 |
| Data & ML        | `numpy`, `pandas`, `sklearn`                                          |
| Visualization    | `matplotlib`, `seaborn`, `plotly`                                     |
| Utilities        | `tiktoken`, `fuzzywuzzy`, `tabulate`                                  |
| Vector databases | `weaviate`                                                            |

<Warning>
  All imports must be placed inside the `run` function. Top-level imports are not supported and will cause a `NameError`.
</Warning>

```python theme={null}
# Correct — imports inside the run function
def run(arg1, arg2):
    import re
    import requests
    return arg1 + arg2
```

### Smart Router

Smart Router selects the most appropriate LLM for each request. It uses context-aware routing to match requests to models based on task requirements and configured optimization goals. 

Smart Routers works in the following way:

* Analyzes the incoming query
* Analyzes model metadata (including strengths, capabilities, limits etc)
* Determines the best fit (using LLMs)
* Routes the request automatically.

### Workflow Playground

The Workflow Playground is where you can validate AI workflows before they are published or deployed.

It allows workflows to be executed in an isolated testing environment where inputs, intermediate steps, and outputs can be inspected without exposing the workflow to end users.

Using the Playground, teams can:

* Submit test inputs to trigger workflow execution
* Inspect intermediate and final outputs produced by AI and data components
* Identify configuration issues, data access problems, or execution errors
* Validate workflow behavior before deployment
* The Workflow Playground supports controlled testing and debugging during workflow development. 

Once workflows are published, ongoing behavior and performance are monitored using Workflow Analytics.

### Human Approval Component

The Human Approval component enables human-in-the-loop workflows by pausing execution and requiring manual approval before proceeding. This is useful for:

* **Quality Control**: Review AI-generated content or classifications before taking action
* **Compliance**: Ensure sensitive operations are manually verified
* **Decision Gates**: Add human judgment to automated processes

**Features:**

* Customizable approval prompts and messages
* Three status states: approved, rejected, and expired
* Configurable session timeouts
* Visual feedback for approval status

When a workflow reaches a Human Approval component, it displays an approval request to the user. The workflow pauses and waits for a decision. If approved, the workflow continues along the approval branch. If rejected or if the approval expires, the workflow routes to the rejection branch. Pending approvals can also be viewed and resolved via the API.

### Agent-to-Agent Component

The A2A (Agent-to-Agent) component enables workflows to communicate with external AI agents using the JSON-RPC protocol. This allows you to orchestrate complex multi-agent systems where different specialized agents collaborate on tasks.

**Features:**

* **JSON-RPC Protocol**: Standard 2.0 compliant communication with external agents
* **Secure Authentication**: Configure Bearer token, Basic auth, or custom authentication
* **Credential Masking**: Auth configuration is automatically masked in API responses for security
* **Flexible Integration**: Connect to any JSON-RPC compatible AI agent endpoint

**Use Cases:**

* Delegate specialized tasks to domain-specific agents
* Build multi-agent collaboration workflows
* Integrate with external AI services and APIs
* Create agent orchestration patterns

## Workflow Analytics

AI Squared tracks comprehensive analytics for workflow executions, including:

### Token Usage and Cost Tracking

Workflows now track LLM token consumption and associated costs:

* **Token Metrics**: Monitor input tokens, output tokens, and total tokens used per workflow run
* **Cost Calculation**: Automatic cost calculation based on token usage and model pricing
* **Usage Logs**: Detailed logs of LLM usage including token counts and costs for each model invocation
* **Billing Integration**: Token usage and costs are tracked in your organization's subscription for billing purposes

This enables you to:

* Understand the cost of running specific workflows
* Optimize prompts and model selection to reduce costs
* Track usage trends over time
* Set budgets and alerts based on token consumption


# Workflow Analytics
Source: https://docs.squared.ai/workflows/workflow-analytics



## Overview

Workflow Analytics provides visibility into how AI workflows are performing in production - what users are asking, how workflows respond, where errors happen, and how workflows function over time. It is designed to help users monitor usage and any issues that may come up.

Workflow Analytics is an observability layer for AI workflows. Every time a workflow is created and run, AI Squared captures data including:

* When the workflow was initiated
* The status (success or failure)
* Performance characteristics such as run time

This data is gathered and analysed through the Workflow Analytics dashboard giving details on how often workflows are being used, their success or failure, user feedback on the responses and more. 

## Accessing Workflow Analytics

Workflow Analytics is accessible from the AI Workflows section of the AI Squared platform.

Each workflow allows you to view analytics details, and helps teams to get visibility from a high-level overview into individual execution logs.

Analytics can be filtered by time range (for example, last 30 days) to analyze recent behavior or trends over time.

## Analytics Overview Metrics

At the top of the Workflow Analytics view, AI Squared displays a set of metrics that give a quick snapshot of workflow health and usage.

### Workflow Runs

Workflow Runs represents the total number of times the workflow has been executed during the selected time period. \
\
High workflow run counts indicate higher user engagement, while low counts may suggest discoverability or relevance issues.

### Workflow Errors

Workflow Errors shows the number of executions that failed. A failure can occur due to various factors such as SQL query errors, MCP server failures, invalid input, and such others. 

This metric is useful for organizations to measure reliability of AI systems. 

### Success Percentage

Success Percentage is the proportion of successful workflow runs relative to total runs.

This metric provides a quick health check:

* High success percentage indicates stable and reliable workflows
* Lower success percentage highlights the need for optimization

Teams use this as a key deciding factor before they roll out a workflow for the public. 

### Average Run Time

Average Run Time measures how long workflows take to complete, from start to the end.

This includes:

* Input processing
* Data retrieval or tool calls
* Response creation and formatting

Monitoring run time is important to track user experience. Sudden increases in run time can point to slow data queries or other service issues.

### Feedback Percentage

Feedback Percentage indicates the percentage of workflow runs for which users provided explicit feedback.

This metric helps teams understand:

* How often users are engaging with feedback mechanisms
* Whether there is enough signal to evaluate response quality

Low feedback percentages may suggest that feedback prompts are unclear or too intrusive.

### Positive Feedback

Positive Feedback represents the proportion of feedback that was positive.

This metric is a qualitative signal layered on top of system performance metrics. Even when workflows are technically successful, low positive feedback can indicate:

* Irrelevant or incomplete answers
* Poor response (formatting etc)
* Mismatch between user intent and workflow behavior

## Workflow Execution Logs

Workflow Analytics provides a detailed view of individual workflow executions. Each log entry includes the following fields:

* **Flow ID**: A unique identifier for each workflow execution.
* **Flow Initiated**: The timestamp indicating when the workflow was triggered.
* **Input**: The Input column captures the user query or trigger that initiated the workflow.
* **Output**: The Output field stores the response generated by the workflow. This may include summaries, table data, SQL queries and others.
* \*\*Status: \*\*The Status column indicates whether the workflow execution completed successfully or failed.

## Using Workflow Analytics Effectively

Workflow Analytics are designed to be used without deep setup or configuration.

Key usage patterns include:

* **Track overall workflow health** by reviewing performance and success data over a 30‑day period
* **Diagnose failures quickly** by inspecting individual runs, reviewing inputs, outputs, and execution status together.
* **Evaluate response quality** by combining system success metrics with user feedback signals.
* **Share and review data externally** using export functionality, enabling collaboration across product, engineering, and data teams.

Workflow Analytics is designed to be lightweight, making it easy to adopt as part of regular workflow review and iteration.

## Feedback and Continuous Improvement

Workflow Analytics surfaces both quantitative performance metrics and qualitative user feedback.

* **Feedback Percentage** reflects how often users provide feedback on workflow responses.
* **Positive Feedback** highlights overall sentiment toward workflow outputs.

In addition to viewing feedback directly in the Analytics UI, AI Squared is actively developing capabilities to export feedback data for specific requirements.

## Exporting Analytics Data

Workflow Analytics allows you to export analytics and feedback data so it can be analyzed to improve future performance.

Exported data can be used to:

* Review workflow performance with stakeholders
* Perform deeper offline analysis
* Feed user feedback into model improvement or fine‑tuning pipelines

This makes Workflow Analytics a feedback mechanism for continuous improvement.