` |
**Body**
| Name | Type | Description |
| --------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| app\_id | string | -> Each model is uniquely characterized by its own `app_id`. |
| image | string | -> The image parameter specifies the URL of an existing image that will be used as a reference for the generation process.
-> If the original image dimensions exceed 1536x1536 pixels, the image will be adjusted to fit within this size while preserving the original aspect ratio.
|
| prompt | string | -> The `prompt` parameter is the textual input that guides the image generation process. This prompt serves as an artistic compass, shaping the visual output. |
| batch | int | -> The batch parameter allows you to specify the number of images to generate at once.
-> The valid range for this parameter is between 1 and 8.
|
| height | int | -> The height parameter represents the vertical dimension of an image.
-> The valid range for the parameter is between 256 and 1536 pixels.
|
| width | int | -> The width parameter represents the horizontal dimension of an image.
-> The valid range for the parameter is between 256 and 1536 pixels.
|
| num\_inference\_steps | int | -> The num\_inference\_steps parameter represents the number of denoising iterations to perform during the image generation process. Generally, more iterations can result in higher-quality images, but they also increase the time required for generation.
-> The valid range for the num\_inference\_steps parameter is between 1 and 50.
|
| guidance\_scale | float | -> The guidance\_scale parameter determines how closely the generated image adheres to the provided prompt. Higher values result in the model following the prompt more closely, while lower values allow for more creative deviation.
-> The valid range for the guidance\_scale parameter is between 1 and 30.
|
| negative\_prompt | string | -> The `negative_prompt` parameter allows you to specify content that you want the image generation model to avoid or minimize in the output. This can be useful for excluding certain visual elements or styles that you do not want to be present in the generated image. |
| strength | float | -> The strength parameter specifies the degree of transformation applied to the reference image.
-> A higher strength value (up to 1) results in the generated image closely following the reference image.
|
| celery | bool | -> The `celery` parameter is used for queuing tasks that require extended processing time. When you enqueue a task, you receive a unique `task_id`. This `task_id` allows you to check the task's status later using the task status API, which is useful for managing and tracking long-running tasks. |
| inference\_type | string | -> The inference\_type parameter allows you to specify the GPU to be used for the image generation task. The supported values are:
The different GPU options provide varying levels of performance and capabilities, allowing you to choose the most suitable GPU based on your requirements and the demand for the task.
|
**Response**
{% tabs %}
{% tab title="200" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% endtabs %}
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# Face Avatar
The concept of a "Face Avatar" involves the creation of images where the face maintains a consistent appearance across multiple generated Images. To achieve this, you start with an initial facial image and provide it as a reference. Using this reference, a sophisticated model goes to work, crafting new images while keeping the facial features in line with the original picture. In essence, the model uses your input to generate images where the face remains faithful to the structure and characteristics you've specified in your prompt. This way, you can effortlessly create a series of images with a consistent and recognizable face.
Working insights :
In this model, the default prompt settings includes a prompt, “SFW Content, black plain background, joyous dating profile, VECTOR CARTOON ILLUSTRATION, half-body shot portrait enjoyable pleasing pleasurable nice {gender\_word}, looking at camera, Relaxed, Charming, Cordial, Gracious, 5 o clock shadow, 3d bitmoji avatar render, pixar, high def textures 8k, highly detailed, 3d render, award winning, no background elements".
If you provide a custom prompt, it will override these default settings. To include a specific gender in your custom prompt, you must explicitly mention it in custom prompt. If you prefer to use the default settings without specifying any custom prompt, simply pass `None` in the prompt parameter. Subsequently, you can define the gender by using the gender parameter, which will apply the specified gender to the default image configuration.
## Face Avatar API
`POST` `/getImageToImage`
**Headers**
| Name | Value |
|---|
| Content-Type | application/json |
| Authorization | Bearer <token> |
**Body**
| Name | Type | Description |
| --------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| app\_id | string | -> Each model is uniquely characterized by its own `app_id`. |
| image | string | -> The file\_url parameter specifies the URL of an existing image that will be used as a reference for the generation process.
-> If the original image dimensions exceed 1536x1536 pixels, the image will be adjusted to fit within this size while preserving the original aspect ratio.
|
| prompt | string | -> The `prompt` parameter is the textual input that guides the image generation process. This prompt serves as an artistic compass, shaping the visual output. |
| batch | int | -> The batch parameter allows you to specify the number of images to generate at once.
-> The valid range for this parameter is between 1 and 8.
|
| height | int | -> The height parameter represents the vertical dimension of an image.
-> The valid range for the parameter is between 256 and 1536 pixels.
|
| width | int | -> The width parameter represents the horizontal dimension of an image.
-> The valid range for the parameter is between 256 and 1536 pixels.
|
| celery | bool | -> The `celery` parameter is used for queuing tasks that require extended processing time. When you enqueue a task, you receive a unique `task_id`. This `task_id` allows you to check the task's status later using the task status API, which is useful for managing and tracking long-running tasks. |
| num\_inference\_steps | int | -> The num\_inference\_steps parameter represents the number of denoising iterations to perform during the image generation process. Generally, more iterations can result in higher-quality images, but they also increase the time required for generation.
-> The valid range for the num\_inference\_steps parameter is between 1 and 50.
|
| guidance\_scale | float | -> The guidance\_scale parameter determines how closely the generated image adheres to the provided prompt. Higher values result in the model following the prompt more closely, while lower values allow for more creative deviation.
-> The valid range for the guidance\_scale parameter is between 1 and 30.
|
| negative\_prompt | string | -> The `negative_prompt` parameter allows you to specify content that you want the image generation model to avoid or minimize in the output. This can be useful for excluding certain visual elements or styles that you do not want to be present in the generated image. |
| gender | string | -> The `gender` parameter is used to guide the image generation model towards producing outputs with a specific gender representation. This can help avoid gender-related confusion or bias in the AI model's outputs. |
| remove\_background | bool | -> When the `remove_background` parameter is enabled, the background of the generated image will be removed and replaced with a transparent background. |
| bg\_color | string | -> The `bg_color` parameter allows you to set the background color of the generated image. The color value should be provided in hexadecimal format (e.g., `#FFFFFF` for white). |
**Response**
{% tabs %}
{% tab title="200" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% endtabs %}
\
Run the API
To test this API, please use the following link:
{% embed url="" %}
# Image Variation
This model has the ability to create diverse visual image variations by drawing inspiration from an input image.
For more details on this model, please refer to the [Broken mention](broken://pages/jVXXwaFgF4TUXOeUU8MR) section.
## Image variation API
`POST` `/getImagetoImage`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Name | Type | Description |
| --------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| app\_id | string | -> Each model is uniquely characterized by its own `app_id`. |
| image | string | -> The image parameter specifies the URL of an existing image that will be used as a reference for the generation process.
-> If the original image dimensions exceed 1536x1536 pixels, the image will be adjusted to fit within this size while preserving the original aspect ratio.
|
| prompt | string | -> The `prompt` parameter is the textual input that guides the image generation process. This prompt serves as an artistic compass, shaping the visual output. |
| guidance\_scale | float | -> The guidance\_scale parameter determines how closely the generated image adheres to the provided prompt. Higher values result in the model following the prompt more closely, while lower values allow for more creative deviation.
-> The valid range for the guidance\_scale parameter is between 1 and 30.
|
| batch | int | -> The batch parameter allows you to specify the number of images to generate at once.
-> The valid range for this parameter is between 1 and 8.
|
| strength | float | -> The strength parameter specifies the degree of transformation applied to the reference image.
-> A higher strength value (up to 1) results in the generated image closely following the initial reference image.
|
| negative\_prompt | string | -> The `negative_prompt` parameter allows you to specify content that you want the image generation model to avoid or minimize in the output. This can be useful for excluding certain visual elements or styles that you do not want to be present in the generated image. |
| num\_inference\_steps | int | -> The num\_inference\_steps parameter represents the number of denoising iterations to perform during the image generation process. Generally, more iterations can result in higher-quality images, but they also increase the time required for generation.
-> The valid range for the num\_inference\_steps parameter is between 1 and 50.
|
| celery | bool | -> The `celery` parameter is used for queuing tasks that require extended processing time. When you enqueue a task, you receive a unique `task_id`. This `task_id` allows you to check the task's status later using the task status API, which is useful for managing and tracking long-running tasks. |
| inference\_type | string | -> The inference\_type parameter allows you to specify the GPU to be used for the image generation task. The supported values are:
The different GPU options provide varying levels of performance and capabilities, allowing you to choose the most suitable GPU based on your requirements and the demand for the task.
|
**Response**
{% tabs %}
{% tab title="200" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% endtabs %}
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# Illusion Diffusion
**Illusion Diffusion Model**
Illusion Diffusion is a model built on the foundation of SD 1.5, designed to create illusionary effects within a given image. To use this model, you need to provide an input image or pattern, along with a prompt. The model will then generate a new image where the original image or pattern is concealed within the resulting artwork.
For more details on the Illusion Diffusion model, please refer to the [Broken mention](broken://pages/GgEcUUDai9Tk8AgXKxFE) section.
## Illusion Diffusion API
`POST` `/getImagetoImage`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Name | Type | Description |
| --------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| app\_id | string | -> Each model is uniquely characterized by its own `app_id`. |
| image | string | -> The image parameter specifies the URL of an existing image that will be used as a reference for the generation process.
-> If the original image dimensions exceed 1536x1536 pixels, the image will be adjusted to fit within this size while preserving the original aspect ratio.
|
| prompt | string | -> The `prompt` parameter is the textual input that guides the image generation process. This prompt serves as an artistic compass, shaping the visual output. |
| guidance\_scale | float | -> The guidance\_scale parameter determines how closely the generated image adheres to the provided prompt. Higher values result in the model following the prompt more closely, while lower values allow for more creative deviation.
-> The valid range for the guidance\_scale parameter is between 1 and 30.
|
| batch | int | -> The batch parameter allows you to specify the number of images to generate at once.
-> The valid range for this parameter is between 1 and 8.
|
| strength | float | -> The strength parameter specifies the degree of transformation applied to the reference image.
-> A higher strength value (up to 1) results in the generated image closely following the initial reference image.
|
| negative\_prompt | string | -> The `negative_prompt` parameter allows you to specify content that you want the image generation model to avoid or minimize in the output. This can be useful for excluding certain visual elements or styles that you do not want to be present in the generated image. |
| num\_inference\_steps | int | -> The num\_inference\_steps parameter represents the number of denoising iterations to perform during the image generation process. Generally, more iterations can result in higher-quality images, but they also increase the time required for generation.
-> The valid range for the num\_inference\_steps parameter is between 1 and 50.
|
| celery | bool | -> The `celery` parameter is used for queuing tasks that require extended processing time. When you enqueue a task, you receive a unique `task_id`. This `task_id` allows you to check the task's status later using the task status API, which is useful for managing and tracking long-running tasks. |
| inference\_type | string | -> The inference\_type parameter allows you to specify the GPU to be used for the image generation task. The supported values are:
The different GPU options provide varying levels of performance and capabilities, allowing you to choose the most suitable GPU based on your requirements and the demand for the task.
|
**Response**
{% tabs %}
{% tab title="200" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% endtabs %}
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# Upscaling
The Super-Resolution model, inspired by Real-ESRGAN, allows you to magnify the dimensions of any given image. This tool is excellent for upscaling photographs, illustrations, and graphics, helping you unlock greater levels of detail and clarity in your images.
For more details on the Super-Resolution model, please refer to the [Broken mention](broken://pages/VPM0zZSJGRj0eYEgmTe7) section.
## Upscale API
`POST` `/getImagetoImage`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Name | Type | Description |
| ------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| app\_id | string | -> Each model is uniquely characterized by its own `app_id`. |
| image | string | -> The image parameter specifies the URL of an existing image that will be used as a reference for the generation process.
-> If the original image dimensions exceed 1536x1536 pixels, the image will be adjusted to fit within this size while preserving the original aspect ratio.
|
| scale | int | -> The `scale` parameter determines the degree of upscaling applied to the input image. The available values for this parameter are 2, 4, and 8. |
| celery | bool | -> The `celery` parameter is used for queuing tasks that require extended processing time. When you enqueue a task, you receive a unique `task_id`. This `task_id` allows you to check the task's status later using the task status API, which is useful for managing and tracking long-running tasks. |
**Response**
{% tabs %}
{% tab title="200" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% endtabs %}
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# Background Removal
The Background Removal model offers a versatile solution for removing the background from an image. By default, it replaces the background with a transparent backdrop.
You can also customize the background by specifying the RGB values and activating the `bg_color` parameter. Additionally, you can choose to blur the background or replace it with a different image.
This model provides a flexible tool for enhancing your images by transforming and personalizing the setting to suit your vision. For more details on this model, please refer to the [Broken mention](broken://pages/N9PrN6Bz3ihq0O05mZpK) section.
## Remove Background API
`POST` `/getImagetoImage`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Name | Type | Description |
| --------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| app\_id | string | -> Each model is uniquely characterized by its own `app_id`. |
| image | number | -> The image parameter specifies the URL of an existing image that will be used as a reference for the generation process.
-> If the original image dimensions exceed 1536x1536 pixels, the image will be adjusted to fit within this size while preserving the original aspect ratio.
|
| bg\_img | string | -> The `bg_image` parameter allows you to specify a URL for an image that will be used as the background for the generated image. |
| bg\_color | bool | -> To use a custom background color, set the `bg_color` parameter to `true`. This will allow you to specify the desired RGB color values for the background. |
| r\_color | int | -> The `r_color` parameter controls the strength of the red hue in the background color, with a range from 0 to 255. Higher values result in a more vibrant red, while lower values make the red more subdued. |
| g\_color | int | -> The `g_color` parameter controls the strength of the green hue in the background color, with a range from 0 to 255. Higher values result in a more vibrant green, while lower values make the green more subdued. |
| b\_color | int | -> The `b_color` parameter controls the strength of the blue hue in the background color, with a range from 0 to 255. Higher values result in a more vibrant blue, while lower values make the blue more subdued. |
| blur | bool | -> Enable the `blur` parameter to apply a blurring effect to the background of the generated image, creating a captivating and enchanting visual effect. |
| celery | bool | -> The `celery` parameter is used for queuing tasks that require extended processing time. When you enqueue a task, you receive a unique `task_id`. This `task_id` allows you to check the task's status later using the task status API, which is useful for managing and tracking long-running tasks. |
**Response**
{% tabs %}
{% tab title="200" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% endtabs %}
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# Text to Speech
This innovative model has the potential to harness the capabilities of state-of-the-art technology, enabling the creation of lifelike, enthralling speech across a diverse array of languages. The more detail about this feature could be found on this [Broken mention](broken://pages/iqUAE6SI8KMlzDAeHTPS).
## Generate Speech
`POST` `/getAudio`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Name | Type | Description |
|---|
| app_id | string | -> Each model is uniquely characterized by its own app_id. |
| prompt | string | -> The prompt parameter is the textual input that guides the audio generation process. This prompt serves as an artistic compass, shaping the audio output. -> The minimum length of the prompt is 10 characters, and the maximum length is 2500 characters. |
| generate_audio | bool | -> Enable the generate_audio parameter to generate audio output in the form of speech. |
| audio_parameters | dict/map | -> The audio_parameters parameter is a dictionary that allows you to specify various audio-related settings. Here's an example of the structure: "audio_parameters": {
"voice_id": "21m00Tcm4TlvDq8ikWAM",
"stability": 0.5,
"similarity_boost": 0.75,
"style": null,
"use_speaker_boost": true
}
You can customize the values within this dictionary to adjust the audio generation according to your preferences. |
| celery | bool | -> The celery parameter is used for queuing tasks that require extended processing time. When you enqueue a task, you receive a unique task_id. This task_id allows you to check the task's status later using the task status API, which is useful for managing and tracking long-running tasks. |
The `audio_parameters` dictionary contains the following parameters:
| Name | Type | Description |
|---|
| voice_id | string | -> The voice_id parameter specifies a unique identifier for the voice to be used in the audio generation process. Some supported voice_id and their Attributes are-
- VoiceID: EXAVITQu4vr4xnSDxMaL
Name: Sarah
Attributes: american, professional, young, female, en, entertainment_tv - VoiceID: N2lVS1w4EtoT3dr4eOWO
Name: Callum
Attributes: en, middle_aged, male, characters - VoiceID: JBFqnCBsd6RMkjVDRZzb
Name: George
Attributes: british, mature, middle_aged, male, en, narrative_story - VoiceID: pqHfZKP75CvOlQylNhV4
Name: Bill
Attributes: american, crisp, old, male, en, advertisement - VoiceID: NFG5qt843uXKj4pFvR7C
Name: Adam Stone - late night radio
Attributes: british, meditative, middle_aged, male, en, narrative_story - VoiceID: XrExE9yKIg1WjnnlVkGX
Name: Matilda
Attributes: american, upbeat, middle_aged, female, en, informative_educational
|
| stability | float | -> The stability parameter controls the stability of the generated audio. Higher values (up to 1) result in more stable output, while lower values can lead to more variable output. |
| similarity_boost | float | -> The similarity_boost parameter adjusts the similarity boost applied to the generated audio. Higher values (up to 1) result in output that is more similar to the target, while lower values can lead to more variation. |
| style | float | -> The style parameter allows you to control the style of the generated speech. Higher values (up to 1) can result in more exaggerated or closely following the given voice style, but may also lead to increased instability in the generated speech. -> Setting this parameter to 0.0 (the default) will greatly increase the generation speed. |
| use_speaker_boost | bool | -> When enabled, the use_speaker_boost parameter will boost the similarity of the synthesized speech to the selected voice, at the cost of some generation speed. This option makes the model try to generate speech that more closely aligns with the chosen voice. |
**Response**
{% tabs %}
{% tab title="200" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% tab title="400" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% endtabs %}
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# Text to Speech
Converts text into lifelike audio using Google's Gemini TTS model. Supports multilingual synthesis, a wide selection of distinct voices, and optional style prompting to control tone and delivery.
## Generate Speech
**POST** `/api/v1/studio/synthesizeSpeech`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Parameter | Type | Required | Description |
| --------------- | -------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `text` | `string` | **Yes** | The input text to be converted into speech. Must be a non-empty string. This is the raw content that will be spoken aloud in the generated audio. |
| `voice` | `string` | **Yes** | The name of the voice persona to use for synthesis. Each voice has a distinct character and tone. Must be one of the supported voices (see `GET /api/v1/studio/speech/voices`). Examples: `"Zephyr"`, `"Puck"`, `"Aoede"`, `"Kore"`. |
| `model` | `string` | No | The TTS model to use for generation. Defaults to `"gemini-2.5-flash-tts"` |
| `language_code` | `string` | No | BCP-47 language code to control the language of the synthesized speech (e.g., `"en-US"`, `"fr-FR"`, `"hi-IN"`). If omitted, the model infers the language from the input text. See `GET /api/v1/studio/speech/languages` for supported codes. |
| `style_prompt` | `string` | No | A natural-language instruction that shapes the speaking style, tone, or emotion of the output. Examples: `"Speak in a calm, soothing tone"`, `"Sound excited and energetic"`, `"Read like a news anchor"`. |
**Response**
{% tabs %}
{% tab title="200" %}
```json
{
"url": "",
"mime_type": "",
"referenceID": ""
}
```
{% endtab %}
{% tab title="403" %}
```json
{
"message": "Forbidden: Insufficient credit"
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"message": "Internal Server Error"
}
```
{% endtab %}
{% tab title="401" %}
```json
{
"message": "Missing authorization token"
}
```
{% endtab %}
{% tab title="400" %}
```json
{
"message": "text is required and cannot be empty."
}
```
{% endtab %}
{% endtabs %}
| Field | Type | Description |
| ------------- | -------- | ------------------------------------------------------------------------------------- |
| `url` | `string` | A publicly accessible URL to the generated audio file. |
| `mime_type` | `string` | The MIME type of the audio file (e.g., `"audio/mpeg"`, `"audio/wav"`). |
| `referenceID` | `string` | A unique identifier for this synthesis request, used for tracking and audit purposes. |
***
#### Error Responses
| Status | Condition |
| ------ | ---------------------------------------------- |
| `400` | `text` is missing or empty |
| `400` | `voice` is missing |
| `400` | `voice` is not in the list of supported voices |
| `500` | Internal server error |
***
#### Related Endpoints
* `GET /api/v1/studio/speech/voices` — Returns all supported voice names
* `GET /api/v1/studio/speech/languages` — Returns all supported language codes
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# Task Status
Use this API endpoint to check the progress of a scheduled task through Celery. All you need is the `task_id`, which you receive when you schedule the task. This allows you to monitor the status and progress of your long-running tasks.
## Task Status API
`POST` `/getImage`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Name | Type | Description |
| ----- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| id | string | -> The `id` parameter is used to provide the unique identifier of the scheduled task you want to check the status for. |
| refID | string | -> The `reference_id` parameter is an optional field that allows you to provide a reference ID to identify the request, if required. If you did not specify a `reference_id` when passing the input parameters, there is no need to provide this parameter. |
**Response**
{% tabs %}
{% tab title="200" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"time_required": "",
"error": "",
"error_data": "",
"input": "",
"output": "",
"app_id": "",
"task_id": "",
"status": ""
}
```
{% endtab %}
{% endtabs %}
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# StreamChat
Bot API allows you to try out different Large Language Models (LLMs) from providers like Mistral, OpenAI, and Claude.
For more details on the supported LLM models and their capabilities, please refer to the [Broken mention](broken://pages/zF6PdCmIL9GuDtdhKuvb).
## Stream chat with LLM
`POST` `/stream_chat`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Name | Type | Description |
|---|
| llm | string | -> The llm parameter specifies the type of Large Language Model (LLM) to be used. The supported values are: ClaudeAIOpenAIGeminiAIOpenRouterAI
|
| llm_model | string | -> The llm_model parameter specifies the name of the Large Language Model (LLM) to be used. The supported values for this parameter depend on the llm you have selected. For example, if the llm is OpenAI, the supported llm_model values include: "gpt-4.1-mini-2025-04-14""gpt-4.1-2025-04-14"
Similarly, if the llm is ClaudeAI, the supported llm_model values include: "claude-3-7-sonnet-latest"
Ensure that the llm_model value you provide is compatible with the selected model_type. -> Supported LLMs and their Models are : GeminiAI - gemini-2.5-pro
- gemini-2.5-flash
ClaudeAI - claude-sonnet-4-20250514
- claude-opus-4-1-20250805
OpenAI - gpt-4.1-mini-2025-04-14
- gpt-4.1-nano-2025-04-14
- gpt-4o-mini
- gpt-4.1-2025-04-14
- o1
(Note: Below models for OpenAI LLM must be configured with temperature=1 ,while runninng this model) - o3-mini
- o3
- o4-mini-2025-04-16
- gpt-5-2025-08-07
- gpt-5-mini-2025-08-07
- gpt-5-nano-2025-08-07
OpenRouterAI - x-ai/grok-4
- x-ai/grok-3-mini-beta
- x-ai/grok-3-beta
- perplexity/sonar-pro
- perplexity/sonar-reasoning-pro
- perplexity/sonar-reasoning
- perplexity/sonar-deep-research
- deepseek/deepseek-chat
- deepseek/deepseek-r1
|
| history | List of Dictionary (Python) or map (C++) | -> The history parameter allows you to provide the previous chat history and the last user message. The history should follow a specific pattern: - The history should start with a user message.
- After each user message, there should be a response from the assistant.
- The last message in the history should be a user message or query.
-> The history should be provided as a list of dictionaries, where each dictionary represents a message. The dictionary should have the following structure: {
"role": "user",
"content": {
"text": "please give 50 word story in English",
"image_data": [
{
"url": "string",
"details": "low"
}
]
}
}
The image\_data parameter is a list that can contain up to 5 image URLs. The details parameter is optional and can be used to specify the level of detail required for the image analysis (only for OpenAI models). Here's an example of the history parameter: "history": \[
{
"role": "user",
"content": {
"text": "hey",
"image\_data": \[]
}
},
{
"role": "assistant",
"content": {
"text": "Hello! How can I assist you today?",
"image\_data": \[]
}
},
{
"role": "user",
"content": {
"text": "Please analyze this image",
"image\_data": \[
{
"url": "",
"details": "low"
}
]
}
}
]
|
| temperature | float | -> The temperature parameter accepts a float value between 0 and 1. This parameter helps control the level of determinism in the output from the Large Language Model (LLM). -> Higher temperature values (closer to 1) will result in more diverse and creative output, while lower values (closer to 0) will lead to more deterministic and conservative responses. |
| image\_analyze | bool | -> If you are passing image URLs and want the model to analyze the images, set the image\_analyze parameter to true. |
| enable\_tool | bool | -> To use the tools supported by the Chat API, enable the enable\_tool parameter. The Chat API currently supports two tools: - Vector Search
- Internet Search
-> After enabling the enable\_tool parameter, you can provide the details of the tool you want to use in the tools parameter.
|
| system\_msg | string | -> The system\_msg parameter allows you to set a system message for the Large Language Model (LLM). This message can be used to provide context or instructions to the model, which can influence the tone and behavior of the generated responses. |
| tools | dictionary or map | The tools parameter allows you to configure the capabilities available to the assistant during a conversation. It defines which tools are enabled, how much past context to consider, and specifies settings for embeddings, PDFs, and image generation. This is useful for tailoring the assistant’s functionality to your use case. 🔹 Structure jsonCopyEdit"tools": {
"tool\_list": {
"image\_generation": false,
"image\_generation1": false,
"image\_editing": false,
"search\_doc": false,
"internet\_search": false,
"python\_code\_execution\_tool": false,
"csv\_analysis": false
},
"number\_of\_context": 3,
"pdf\_references": \[],
"embedding\_model": \[
"text-embedding-3-large"
],
"image\_generation\_parameters": {}
}
🔹 Field Descriptions |
| token | string | Authentication token needed for the request. |
| orgID | string | Identifies the organization associated with the request. |
| function\_call\_list | string | Lists the functions called during the process. |
| systemId | string | Specifies the system identifier linked to the request. |
| last\_user\_query | string | Provides the last user query made in the chat. |
Example of Input body parameters :
```
data '{
"llm": "GeminiAI",
"llm_model": "gemini-2.5-flash",
"history": [
{
"role": "user",
"content": {
"text": "please give 50 word story in English",
"image_data": [
{
"url": "string",
"details": "low"
}
]
}
}
],
"temperature": 0.7,
"image_analyze": false,
"enable_tool": false,
"system_msg": "You are a helpful assistant.",
"tools": {
"tool_list": {
"image_generation": false,
"image_generation1": false,
"image_editing": false,
"search_doc": false,
"internet_search": false,
"python_code_execution_tool": false,
"csv_analysis": false
},
"number_of_context": 3,
"pdf_references": [
"output vectorstore1",
"output vectorstore2"
],
"embedding_model": [
"text-embedding-3-large",
"text-embedding-3-large"
],
"image_generation_parameters": {}
},
"token": "123",
"orgID": "string",
"function_call_list": [],
"systemId": "string",
"last_user_query": "string"
}'
```
After passing the necessary parameters and executing the Chat API, you will receive a stream response. A successful response will look similar to the following:
**Response**
{% tabs %}
{% tab title="200" %}
{
"output": null,
"error": null,
"error_data": null
}
{% endtab %}
{% tab title="500" %}
```json
{
"output": null,
"error": string,
"error_data": string
}
```
{% endtab %}
{% endtabs %}
The Chat API response is a streaming response, which means you will receive the output in chunks as the model generates the response. The response will continue to stream until the generation is complete.
The response will contain the following elements:
* `output`: This object contains the generated text output from the model.
The text output from the LLM can be obtained from the `output` parameter. When the response is complete, the final chunk will contain a `null` value in the `output` parameter, indicating the end of the stream.
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# OpenAI-Compatible Chat
OpenAI-compatible chat completions endpoint. Supports both standard (JSON) and streaming (SSE) responses. Rate-limited per API key.
**Base URL:**
{% embed url="" %}
**Supported endpoints**
| `GET` | `/v1/chat/models` | List all available models |
| ------ | -------------------------- | ------------------------------------------------------ |
| `GET` | `/v1/chat/models/{model}` | Retrieve a specific model |
| `POST` | `/api/v1/chat/completions` | Create chat completions (streaming, tools, multimodal) |
## Chat Completions
**POST** `/api/v1/chat/completions`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Parameter | Type | Required | Description |
| ------------------- | -------------------- | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `model` | `string` | **Yes** | The model ID to use for completion. Use `GET /api/v1/chat/models` to list available models. |
| `messages` | `array` | **Yes** | Ordered list of messages forming the conversation. Each object must have a `role` (`"system"`, `"user"`, or `"assistant"`) and a `content` field (string or structured content array). Must contain at least one message. |
| `stream` | `boolean` | No | If `true`, the response is streamed as Server-Sent Events (SSE). Each event is a `data: {...}` line; the stream ends with `data: [DONE]`. Defaults to `false`. |
| `temperature` | `number` | No | Sampling temperature between `0` and `2`. Higher values produce more random output; lower values are more deterministic. Defaults to `1`. |
| `max_tokens` | `integer` | No | Maximum number of tokens to generate in the response. Must be a positive integer. If omitted, the model's default limit applies. |
| `top_p` | `number` | No | Nucleus sampling threshold between `0` and `1`. The model considers only the tokens comprising the top `top_p` probability mass. An alternative to `temperature`; avoid adjusting both simultaneously. |
| `frequency_penalty` | `number` | No | Penalizes tokens based on how frequently they have appeared so far. Positive values reduce repetition. Typically between `-2.0` and `2.0`. |
| `presence_penalty` | `number` | No | Penalizes tokens that have appeared at all in the conversation so far. Positive values encourage the model to introduce new topics. Typically between `-2.0` and `2.0`. |
| `stop` | `string \| string[]` | No | One or up to **4** sequences at which the model will stop generating further tokens. The stop sequence itself is not included in the output. |
| `tool_choice` | `string \| object` | No | Controls which tool (if any) the model calls. Accepts `"none"`, `"auto"`. |
| `stream_options` | `object` | No | Additional options for streaming. Set `{ "include_usage": true }` to receive a final SSE chunk containing token usage data. Automatically enabled when `stream: true`. |
#### Request
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "What is the capital of France?"
}
],
"stream": false
}
```
#### Response (non-streaming)
{% tabs %}
{% tab title="200" %}
```json
{
"id": "chatcmpl-4dd9fded095b4d86bceed1e91042a",
"object": "chat.completion",
"created": 1774095579,
"model": "google/gemini-2.5-flash",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": "Paris."
},
"finish_reason": "stop"
}
],
"usage": {
"total_credit": 0.25,
"total_cost": 0.0012441,
"breakdown": {
"model": {
"model": "google/gemini-2.5-flash",
"credit": 0.25,
"cost": 0.001244
}
}
}
}
```
{% endtab %}
{% endtabs %}
#### Error Responses
| Status | Condition |
| ------ | --------------------------------------------- |
| `400` | `model` is missing |
| `400` | `messages` is missing, not an array, or empty |
| `400` | `temperature` is outside `0–2` |
| `400` | `top_p` is outside `0–1` |
| `400` | `max_tokens` is not a positive integer |
| `400` | `stop` array contains more than 4 sequences |
| `429` | Rate limit exceeded |
| `504` | Request timed out (3-minute upstream limit) |
| `502` | Upstream provider error or invalid response |
| `500` | Internal server error |
***
#### Related Endpoints
* `GET /api/v1/chat/models` — Returns the list of available models
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# Tool Calls
The API supports OpenAI-compatible function calling. Define your functions in the request; the model decides when to call them, and the server returns the call details for you to execute on the client
### Step 1 — Define tools and get a tool call
```json
import OpenAI from 'openai';
const client = new OpenAI({
apiKey: process.env.API_KEY,
baseURL: 'http://localhost:9000/v1',
});
const completion = await client.chat.completions.create({
model: 'openai/gpt-4o',
messages: [
{ role: 'user', content: 'What is the weather in Tokyo?' }
],
tools: [
{
type: 'function',
function: {
name: 'get_weather',
description: 'Get the current weather for a city',
parameters: {
type: 'object',
properties: {
location: {
type: 'string',
description: 'City name, e.g. Tokyo, Japan'
},
unit: {
type: 'string',
enum: ['celsius', 'fahrenheit'],
description: 'Temperature unit'
}
},
required: ['location']
}
}
}
],
tool_choice: 'auto',
built_in_tools: 'none' // disable server tools so only yours are offered
});
console.log(completion.choices[0].message.tool_calls);
```
**Response — model decides to call your function**
```json
{
"id": "chatcmpl-xyz",
"object": "chat.completion",
"created": 1740700000,
"model": "openai/gpt-4o",
"choices": [
{
"index": 0,
"message": {
"role": "assistant",
"content": null,
"tool_calls": [
{
"id": "call_abc123",
"type": "function",
"function": {
"name": "get_weather",
"arguments": "{\"location\": \"Tokyo, Japan\", \"unit\": \"celsius\"}"
}
}
]
},
"finish_reason": "tool_calls"
}
]
}
```
### Step 2 — Execute the function and send the result back
Parse `arguments`, call your function, then continue the conversation with a `tool` message:
```json
// Parse arguments and call your function
const toolCall = completion.choices[0].message.tool_calls[0];
const args = JSON.parse(toolCall.function.arguments);
// Your own function execution
const weatherResult = await myGetWeather(args.location, args.unit);
// Continue conversation with the tool result
const followUp = await client.chat.completions.create({
model: 'openai/gpt-4o',
messages: [
{ role: 'user', content: 'What is the weather in Tokyo?' },
completion.choices[0].message, // include the assistant's tool_calls message
{
role: 'tool',
tool_call_id: toolCall.id,
content: JSON.stringify(weatherResult)
}
],
tools: [ /* same tool definitions */ ],
built_in_tools: 'none'
});
console.log(followUp.choices[0].message.content);
// "The current weather in Tokyo is 12°C with partly cloudy skies."
```
### Controlling tool selection
| `tool_choice` value | Behaviour |
| ------------------------------------------------------ | -------------------------------------------------------- |
| `"auto"` (default) | Model decides whether to call a tool or respond directly |
| `"none"` | Model must not call any tool |
| `"required"` | Model must call at least one tool |
| `{ "type": "function", "function": { "name": "fn" } }` | Model must call this exact function |
```
// Force a specific function
"tool_choice": { "type": "function", "function": { "name": "get_weather" } }
```
### Multi-tool call in one turn
The model can call multiple tools at once:
```json
{
"choices": [
{
"message": {
"role": "assistant",
"content": null,
"tool_calls": [
{
"id": "call_001",
"type": "function",
"function": { "name": "get_weather", "arguments": "{\"location\":\"Tokyo\"}" }
},
{
"id": "call_002",
"type": "function",
"function": { "name": "get_weather", "arguments": "{\"location\":\"London\"}" }
}
]
},
"finish_reason": "tool_calls"
}
]
}
```
Send all tool results back in one follow-up request, one `tool` message per call:
```json
{
"messages": [
{ "role": "user", "content": "Compare weather in Tokyo and London." },
{ "role": "assistant", "content": null, "tool_calls": [ ...both calls... ] },
{ "role": "tool", "tool_call_id": "call_001", "content": "{\"temp\": 12, \"condition\": \"Cloudy\"}" },
{ "role": "tool", "tool_call_id": "call_002", "content": "{\"temp\": 8, \"condition\": \"Rainy\"}" }
]
}
```
# Built-in Tools
The server's agent has 4 built-in tools that run automatically on the server side — no client execution required. The model calls them internally and the result is integrated into the final response.
### Available built-in tools
| Tool | Trigger | What it does |
| ------------------ | ----------------------------------------------- | ------------------------------------------------------ |
| `image_generation` | "Generate an image of a sunset over the ocean" | Generates images; URL embedded in response as markdown |
| `internet_search` | "Latest news about AI", "What is today's date?" | Web search via Perplexity AI with citations |
| `file_search` | "Summarize the uploaded document" | Searches vector stores from uploaded files |
| `url_content` | "Summarize " | Fetches and reads content from URLs |
### image generation
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{ "role": "user", "content": "Generate an image of a futuristic city at sunset." }
]
}
```
The generated image URL is embedded as a markdown image inside `content`. Image cost is reported in `usage.tool_cost_usd`:
```json
{
"choices": [
{
"message": {
"role": "assistant",
"content": "I've generated the image of a futuristic city at sunset.\n\n"
},
"finish_reason": "stop"
}
]
}
```
### File Search
The `file_search` tool lets the model search documents in pre-indexed file stores. Pass the store names in the request:
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{ "role": "user", "content": "Summarise the Q4 report" }
],
"file_search_store_names": ["fileSearchStores/abc123"]
}
```
The model will automatically call `file_search` with the provided store names when the query is relevant to the documents.
Store names are in the format `fileSearchStores/{storeId}`. You can pass multiple stores:
```
"file_search_store_names": [
"fileSearchStores/abc123",
"fileSearchStores/def456"
]
```
### Internet Search
The `internet_search` tool queries the web via **Perplexity AI** and returns a synthesized, up-to-date answer with source citations. Use it for any question that requires current information beyond the model's training cutoff.
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "What are the latest AI news today?"
}
],
"stream": false
}
```
### URL Content
The `url_content` tool fetches and processes the content of one or more URLs. It uses **Gemini 2.5 Flash** with Google's URL Context capability to retrieve, read, and reason over live web pages.
Use it when the user provides a specific link and asks questions about it — summarisation, extraction, comparison, Q\&A over a page, etc.
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "Summarize this page and also team details: https://www.qolaba.ai/about-us"
}
],
"stream": false
}
```
# Image Generation
\
The `image_generation` tool is a **built-in tool** automatically available on all `/v1/chat/completions` requests. It uses **Google Gemini** (`gemini-3.1-flash-image-preview`) under the hood. You don't configure it — just describe what you want in natural language and the model decides when to invoke it.
#### How It Works
1. You send a normal chat request with an image-related prompt
2. The LLM detects it needs to generate an image and calls the `image_generation` tool internally
3. The tool generates the image and uploads it to GCP CDN
4. The response comes back as a standard chat completion with a markdown image link embedded in the `content`
**Resolutions**
| Value | Description |
| ------ | ---------------------------------- |
| `0.5K` | 512px — quick previews, thumbnails |
| `1K` | Default — standard quality |
| `2K` | High quality |
| `4K` | Maximum detail, upscaling |
**Aspect Ratios**
| Value | Best For |
| ------------- | ------------------------------------------------- |
| `1:1` | Social media posts, profile pictures |
| `16:9` | Landscape, YouTube thumbnails, desktop wallpapers |
| `9:16` | Stories, Reels, TikTok |
| `4:3` | Presentations, traditional photos |
| `3:2` | Photography, prints |
| `21:9` | Cinematic, ultrawide banners |
| `4:5` / `5:4` | Instagram portrait/landscape |
| `1:4` / `4:1` | Tall/wide banners |
### Use Cases & Examples
#### 1. Simple Image Generation
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{ "role": "user", "content": "Generate an image of a futuristic city at sunset with flying cars" }
]
}
```
#### 2. Specific Aspect Ratio + Resolution
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "Generate a 16:9 high quality landscape image of snow-capped mountains with a lake reflection"
}
]
}
```
The model automatically infers `resolution: 2K` and `aspect_ratio: 16:9` from the prompt.
#### **3. Multiple Image Variations**
Returns multiple `` links in the content, cost split per image.
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{ "role": "user", "content": "Generate 3 variations of a minimalist logo for a coffee shop" }
]
}
```
#### 4. Portrait / Story Format
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{ "role": "user", "content": "Create a 9:16 portrait illustration of a woman reading a book in a cozy library" }
]
}
```
#### 5. High-Detail / Infographic (Thinking Mode)
Best for text-heavy images, menus, charts, complex multi-element compositions:
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{ "role": "user", "content": "Create a detailed restaurant menu layout with sections for appetizers, mains, and desserts with prices" }
]
}
```
#### 6. Branded / Product Marketing
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "Create a 4:5 product photo of a luxury perfume bottle on a marble surface with soft lighting, suitable for Instagram"
}
]
}
```
### Tips & Best Practices
| Tip | Details |
| ----------------------- | ---------------------------------------------------------------------------------- |
| **Be specific** | Include style (photorealistic, cartoon, watercolor), lighting, mood, color palette |
| **Mention ratio** | Say "16:9 landscape" or "9:16 vertical" — the model picks up the hint |
| **Multiple variations** | Say "3 variations" or "4 different versions" to get `count > 1` |
| **Text in images** | Mention "clear readable text" — model enables thinking mode automatically |
| **Cost awareness** | 4K images and multiple images multiply cost; 0.5K is cheapest for previews |
***
### Limitations
* Max `count` per request: no hard cap but cost scales linearly
* `use_search_grounding` adds latency and extra cost per query
* Generated images are hosted on `cdn.qolaba.app` — URLs are permanent CDN links
# Internet Search
The `internet_search` tool is a **built-in tool** automatically available on all `/v1/chat/completions` requests. It uses **Perplexity AI Sonar** under the hood to search the live web and return a synthesized answer with citations. You don't configure it — the model invokes it automatically when the prompt requires real-time or current information.
### How It Works
1. You send a normal chat request with a question that needs current data
2. The LLM detects it needs fresh web data and calls `internet_search` internally
3. The tool queries **Perplexity Sonar** (`temperature: 0.1` for accuracy) with your query
4. Perplexity returns a synthesized answer + citation URLs
5. The model wraps the answer into a standard chat completion response
#### Streaming Behavior
Unlike image generation (which delivers the result at the end), internet search **integrates naturally with streaming**. The stream shows:
1. A `tool_calls` chunk announcing `internet_search` was invoked
2. Immediately followed by content chunks streaming the answer word-by-word
3. A final `[DONE]` chunk
4. A trailing `usage` data chunk (if `stream_options.include_usage: true`)
```json
data: {"delta":{"tool_calls":[{"function":{"name":"internet_search",...}}]}}
data: {"delta":{"content":"As"}}
data: {"delta":{"content":" of"}}
...
data: [DONE]
data: {"usage":{...}}
```
### Use Cases & Examples
#### 1. Breaking News / Current Events
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{ "role": "user", "content": "What are the latest AI news today?" }
]
}
```
#### 2. Live Price / Market Data
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{ "role": "user", "content": "What is the current price of Bitcoin?" }
]
}
```
#### 3. Combining Search + Reasoning
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "Search for the latest GPT-5 benchmarks and summarize how it compares to Claude Sonnet"
}
]
}
```
#### 4. Technical / Developer Queries
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{ "role": "user", "content": "What are the breaking changes in Bun 2.0?" }
]
}
```
### Tips & Best Practices
| Tip | Details |
| ---------------------------- | --------------------------------------------------------------------------------- |
| **Ask naturally** | No special syntax needed — the model detects when to search automatically |
| **Be specific** | "Latest React 19 release notes" works better than "React news" |
| **Date context helps** | Adding "as of today" or "current" reinforces real-time lookup |
| **Streaming for UX** | Use `stream: true` — answers start flowing within \~1s while search runs |
| **Cost vs knowledge cutoff** | For questions within the model's training data, search won't trigger (saves cost) |
| **Citations in output** | The model includes source links inline — these are real URLs from Perplexity |
***
### Limitations
* Powered by `perplexity/sonar` — accuracy depends on Perplexity's index freshness
* No control over `numResults` from the request body — handled internally (default 5 citations)
* Does not return raw search results, only the synthesized Perplexity answer
* Adds latency (\~1–3s) compared to non-search requests
* `temperature` is fixed at `0.1` internally for factual accuracy — not overridable
# URL Content
The `url_content` tool is a **built-in tool** automatically available on all `/v1/chat/completions` requests. It uses **Google Gemini 2.5 Flash** with the native `urlContext` tool to fetch, render, and analyze live web pages. The model receives the full rendered page content and answers your question about it.
#### How It Works
1. You include one or more URLs anywhere in your message
2. The LLM detects URLs and calls `url_content` internally with those URLs + your question
3. Gemini 2.5 Flash fetches and processes the full page content using Google's `urlContext` tool
4. Gemini returns an answer grounded in the actual page content
5. The answer is returned as a standard chat completion
#### Use Cases & Examples
#### 1. Summarize a Page
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "Summarize this page and also team details: https://www.qolaba.ai/about-us"
}
]
}
```
#### 2. Extract Specific Information
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "What are the pricing plans listed on https://www.qolaba.ai/pricing?"
}
]
}
```
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "Compare these two pages and tell me the key differences:\nhttps://openai.com\nhttps://anthropic.com"
}
]
}
```
#### 4. Extract Structured Data from a Page
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "List all team members and their roles from https://www.qolaba.ai/about-us as a JSON array"
}
]
}
```
#### 5. Competitor Analysis (3+ URLs)
```json
{
"model": "google/gemini-2.5-flash",
"messages": [
{
"role": "user",
"content": "Compare the features and positioning of these three AI platforms:\nhttps://openai.com\nhttps://anthropic.com\nhttps://www.qolaba.ai"
}
]
}
```
### Tips & Best Practices
| Tip | Details |
| ---------------------- | -------------------------------------------------------------------------------- |
| **Just paste the URL** | No special syntax — include the URL anywhere in the message |
| **Be specific** | "Extract all product names" works better than "tell me about this page" |
| **Multiple URLs** | Put each URL on its own line for clarity — all are fetched together |
| **JS-heavy pages** | Works on SPAs and dynamic pages — Gemini's urlContext renders JavaScript |
| **Large pages** | Cost scales with page size but remains low (Gemini 2.5 Flash is cheap per token) |
| **Ask for format** | "Return as JSON", "Return as a table", "List as bullet points" all work |
***
### Limitations
* **Private/authenticated pages** — cannot access pages behind login walls or paywalls
* **PDFs / binary files** — works best on HTML pages; PDF support depends on Google's urlContext
* **Rate-limited sites** — some sites block scraping; Gemini makes a best-effort attempt
* **Very large pages** — extremely long pages may be truncated by token limits
* **No config from request** — `urls` and `prompt` are extracted by the model; you cannot pass them directly in the request body
# File Search
The `file_search` tool is a **built-in tool** for searching through your uploaded documents. Unlike `internet_search` (live web) and `url_content` (public URLs), this tool searches **your private uploaded files** stored in a **File Search Store**. It uses **Google Gemini 2.5 Flash** with native `fileSearch` grounding to retrieve and answer from document content.
### How It Works
1. You (or your system) upload documents to a **File Search Store** (via a separate upload API)
2. You pass the store name(s) in the `file_search_store_names` field of your request
3. The LLM receives the store names via an injected system message and calls the `file_search` tool automatically
4. Gemini 2.5 Flash searches the store using semantic/vector search and returns grounded answers with citations
5. The answer is returned as a standard chat completion
#### Key Difference from Other Tools
| Tool | Trigger | Source |
| ----------------- | ------------------------------------------- | ----------------------------------- |
| `internet_search` | Auto (from prompt) | Live public web via Perplexity |
| `url_content` | Auto (URL in message) | Specific public URL via Gemini |
| `file_search` | Auto + `file_search_store_names` in request | **Your private uploaded documents** |
#### Use Cases & Examples
#### 1. Summarize an Uploaded Document
```json
{
"model": "google/gemini-2.5-flash",
"file_search_store_names": ["fileSearchStores/defaultstore-31ihhh9rmyef"],
"messages": [
{ "role": "user", "content": "Summarize the uploaded document" }
]
}
```
```json
{
"model": "google/gemini-2.5-flash",
"file_search_store_names": [
"fileSearchStores/q1-reports",
"fileSearchStores/q2-reports"
],
"messages": [
{ "role": "user", "content": "Compare Q1 and Q2 revenue figures from the reports" }
]
}
```
#### 4. Contract / Legal Document Analysis
```json
{
"model": "google/gemini-2.5-flash",
"file_search_store_names": ["fileSearchStores/contracts-store"],
"messages": [
{ "role": "user", "content": "What are the termination clauses in the uploaded contract?" }
]
}
```
#### 5. With a System Prompt
```json
{
"model": "google/gemini-2.5-flash",
"file_search_store_names": ["fileSearchStores/support-docs"],
"messages": [
{
"role": "system",
"content": "You are a helpful support agent. Only answer based on the uploaded documentation."
},
{ "role": "user", "content": "How do I upgrade my plan?" }
]
}
```
#### Tips & Best Practices
| Tip | Details |
| ------------------------------ | --------------------------------------------------------------------------------------- |
| **Always pass store names** | `file_search_store_names` must be in every request — the tool won't activate without it |
| **Pass on every turn** | In multi-turn conversations, include the field on each request |
| **Multiple stores** | Pass an array to search across multiple document collections at once |
| **Any model works** | Store names are injected as a system message — model-agnostic |
| **Be specific** | "What is the refund policy?" retrieves more precisely than "Tell me about the document" |
| **Combine with system prompt** | Use a system prompt to constrain the model to only answer from the documents |
***
### Limitations
* **Requires pre-uploaded documents** — you must upload files to a store before querying (separate upload flow)
* **Store names are static** — if a store is deleted or renamed, queries will fail gracefully (returns an error message without crashing)
* **No raw chunk retrieval** — you get a synthesized answer, not a list of raw document excerpts
* **No filtering by file** — all files in the store are searched together; you can't target a specific file within a store
* **`file_search_store_names` is not a standard OpenAI field** — OpenAI SDK clients must use `extra_body` (Python) or `// @ts-ignore` (TypeScript) to pass it
# File Upload
Upload a file by URL to create a file search store. The returned store\_name can be used in chat completions via file\_search\_store\_names.
#### RAG File Upload
Uploads a file by URL to the AI backend for retrieval-augmented generation.
**Endpoint:** `POST /api/v1/files`
**Auth:** Required (`X-API-Key` or `Authorization: Bearer`)\
**Timeout:** 5 minutes
**Request body:**
| Parameter | Type | Required | Description |
| ------------ | ------ | -------- | -------------------------------- |
| `url` | string | ✅ | Public URL to the file |
| `store_name` | string | — | Custom name for the vector store |
**Allowed file types:**
| Extension | MIME Type |
| --------- | ------------------------------------------------------------------------- |
| `.pdf` | `application/pdf` |
| `.txt` | `text/plain` |
| `.doc` | `application/msword` |
| `.docx` | `application/vnd.openxmlformats-officedocument.wordprocessingml.document` |
#### Request:
```bash
curl -X POST https://qolaba-server-b2b.up.railway.app/api/v1/files \
-H "Content-Type: application/json" \
-H "x-api-key: YOUR_API_KEY" \
-d '{
"url": "https://example.com/document.pdf",
"store_name": "my-store"
}'
```
#### Response `200 OK`
```json
{
"success": true,
"store_name": "fileSearchStores/my-store-31ihhh9rmyef",
"file_name": "document.pdf",
"message": "File uploaded and indexed successfully",
"token_count": 4200,
"estimated_cost_usd": 0.0021,
"creditUtilisation": 2
}
```
#### Response 400 Bad Request
```json
{
"success": false,
"message": "File type '.csv' is not supported. Allowed types: .pdf, .txt, .doc, .docx",
"error": "File type '.csv' is not supported. Allowed types: .pdf, .txt, .doc, .docx"
}
```
#### Using the store in Chat Completions
Pass the `store_name` from the upload response into `file_search_store_names`:
**Request body:**
| Parameter | Type | Required | Description |
| ------------------------- | --------- | -------- | -------------------------------- |
| `messages` | array | ✅ | Chat messages |
| `model` | string | — | Model ID |
| `file_search_store_names` | string\[] | — | Store names from `uploadRagFile` |
| `thread_id` | string | — | Conversation thread ID |
| `user_id` | string | — | User identifier |
| `webhookUrl` | string | — | Webhook for async results |
| `metadata` | object | — | Extra key/value metadata |
```bash
curl -N https://qolaba-server-b2b.up.railway.app/api/v1/chat/completions
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "google/gemini-2.5-flash",
"messages": [
{ "role": "user", "content": "Summarize the uploaded document" }
],
"file_search_store_names": ["fileSearchStores/my-store-31ihhh9rmyef"],
"stream": false
}'
```
{% embed url="" %}
# Chat
Bot API allows you to try out different Large Language Models (LLMs) from providers like Mistral, OpenAI, and Claude.
For more details on the supported LLM models and their capabilities, please refer to the [Broken mention](broken://pages/zF6PdCmIL9GuDtdhKuvb).
## Chat with LLM
`POST` `/chat`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Name | Type | Description |
|---|
| llm | string | -> The llm parameter specifies the type of Large Language Model (LLM) to be used. The supported values are: ClaudeAIOpenAIGeminiAIOpenRouterAI
|
| llm_model | string | -> The llm_model parameter specifies the name of the Large Language Model (LLM) to be used. The supported values for this parameter depend on the llm you have selected. For example, if the llm is OpenAI, the supported llm_model values include: "gpt-4.1-mini-2025-04-14""gpt-4.1-2025-04-14"
Similarly, if the llm is ClaudeAI, the supported llm_model values include: "claude-3-7-sonnet-latest"
Ensure that the llm_model value you provide is compatible with the selected model_type. -> Supported LLMs and their Models are : GeminiAI - gemini-2.5-pro
- gemini-2.5-flash
ClaudeAI - claude-sonnet-4-20250514
- claude-opus-4-1-20250805
OpenAI - gpt-4.1-mini-2025-04-14
- gpt-4.1-nano-2025-04-14
- gpt-4o-mini
- gpt-4.1-2025-04-14
- o1
(Note: Below models for OpenAI LLM must be configured with temperature=1 ,while runninng this model) - o3-mini
- o3
- o4-mini-2025-04-16
- gpt-5-2025-08-07
- gpt-5-mini-2025-08-07
- gpt-5-nano-2025-08-07
OpenRouterAI - x-ai/grok-4
- x-ai/grok-3-mini-beta
- x-ai/grok-3-beta
- perplexity/sonar-pro
- perplexity/sonar-reasoning-pro
- perplexity/sonar-reasoning
- perplexity/sonar-deep-research
- deepseek/deepseek-chat
- deepseek/deepseek-r1
|
| history | List of Dictionary (Python) or map (C++) | -> The history parameter allows you to provide the previous chat history and the last user message. The history should follow a specific pattern: - The history should start with a user message.
- After each user message, there should be a response from the assistant.
- The last message in the history should be a user message or query.
-> The history should be provided as a list of dictionaries, where each dictionary represents a message. The dictionary should have the following structure: {
"role": "user",
"content": {
"text": "please give 50 word story in English",
"image_data": [
{
"url": "string",
"details": "low"
}
]
}
}
The image\_data parameter is a list that can contain up to 5 image URLs. The details parameter is optional and can be used to specify the level of detail required for the image analysis (only for OpenAI models). Here's an example of the history parameter: "history": \[
{
"role": "user",
"content": {
"text": "hey",
"image\_data": \[]
}
},
{
"role": "assistant",
"content": {
"text": "Hello! How can I assist you today?",
"image\_data": \[]
}
},
{
"role": "user",
"content": {
"text": "Please analyze this image",
"image\_data": \[
{
"url": "",
"details": "low"
}
]
}
}
]
|
| temperature | float | -> The temperature parameter accepts a float value between 0 and 1. This parameter helps control the level of determinism in the output from the Large Language Model (LLM). -> Higher temperature values (closer to 1) will result in more diverse and creative output, while lower values (closer to 0) will lead to more deterministic and conservative responses. |
| image\_analyze | bool | -> If you are passing image URLs and want the model to analyze the images, set the image\_analyze parameter to true. |
| enable\_tool | bool | -> To use the tools supported by the Chat API, enable the enable\_tool parameter. The Chat API currently supports two tools: - Vector Search
- Internet Search
-> After enabling the enable\_tool parameter, you can provide the details of the tool you want to use in the tools parameter.
|
| system\_msg | string | -> The system\_msg parameter allows you to set a system message for the Large Language Model (LLM). This message can be used to provide context or instructions to the model, which can influence the tone and behavior of the generated responses. |
| tools | dictionary or map | The tools parameter allows you to configure the capabilities available to the assistant during a conversation. It defines which tools are enabled, how much past context to consider, and specifies settings for embeddings, PDFs, and image generation. This is useful for tailoring the assistant’s functionality to your use case. 🔹 Structure jsonCopyEdit"tools": {
"tool\_list": {
"image\_generation": false,
"image\_generation1": false,
"image\_editing": false,
"search\_doc": false,
"internet\_search": false,
"python\_code\_execution\_tool": false,
"csv\_analysis": false
},
"number\_of\_context": 3,
"pdf\_references": \[],
"embedding\_model": \[
"text-embedding-3-large"
],
"image\_generation\_parameters": {}
}
🔹 Field Descriptions |
| token | string | Authentication token needed for the request. |
| orgID | string | Identifies the organization associated with the request. |
| function\_call\_list | string | Lists the functions called during the process. |
| systemId | string | Specifies the system identifier linked to the request. |
| last\_user\_query | string | Provides the last user query made in the chat. |
Example of Input body parameters :
```
data '{
"llm": "GeminiAI",
"llm_model": "gemini-2.5-flash",
"history": [
{
"role": "user",
"content": {
"text": "please give 50 word story in English",
"image_data": [
{
"url": "string",
"details": "low"
}
]
}
}
],
"temperature": 0.7,
"image_analyze": false,
"enable_tool": false,
"system_msg": "You are a helpful assistant.",
"tools": {
"tool_list": {
"image_generation": false,
"image_generation1": false,
"image_editing": false,
"search_doc": false,
"internet_search": false,
"python_code_execution_tool": false,
"csv_analysis": false
},
"number_of_context": 3,
"pdf_references": [
"output vectorstore1",
"output vectorstore2"
],
"embedding_model": [
"text-embedding-3-large",
"text-embedding-3-large"
],
"image_generation_parameters": {}
},
"token": "123",
"orgID": "string",
"function_call_list": [],
"systemId": "string",
"last_user_query": "string"
}'
```
After passing the necessary parameters and executing the Chat API, you will receive a stream response. A successful response will look similar to the following:
**Response**
{% tabs %}
{% tab title="200" %}
{
"output": null,
"promptTokens": null,
"completionTokens": null
}
{% endtab %}
{% tab title="500" %}
```json
{
"output": null,
"error": string,
"error_data": string
}
```
{% endtab %}
{% endtabs %}
The Chat API response is a streaming response, which means you will receive the output in chunks as the model generates the response. The response will continue to stream until the generation is complete.
The response will contain the following elements:
* `output`: This object contains the generated text output from the model.
The text output from the LLM can be obtained from the `output` parameter. When the response is complete, the final chunk will contain a `null` value in the `output` parameter, indicating the end of the stream.
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# Store File in Vector Database
## Parse File
Use this endpoint to add a PDF, CSV, TXT or DOC/DOCX document to the Qolaba AI database. The API will parse the document and store it in the vector database, returning a unique ID that can be used to retrieve information from the document using the Large Language Model (LLM).
Please note the following guidelines when indexing Document:
* The PDF, DOC/DOCX file should not exceed 200 pages.
* The CSV file should not contain more than 30 columns and 500 rows.
* When uploading a CSV file to the API, the first row must contain the column names. This helps the Large Language Model (LLM) better understand the values in each row of the CSV file.
* Ensure that the document does not contain any sensitive or confidential information.
The unique ID returned after indexing the document can be used in subsequent requests to the Chatbot API to retrieve relevant information from the document, after ensuring enable\_tool and search\_doc to be true.
`POST` `/pdfVectorStore`
**Headers**
| Name | Value |
| ------------- | ------------------ |
| Content-Type | `application/json` |
| Authorization | `Bearer ` |
**Body**
| Name | Type | Description |
| ----- | ------ | -------------------------------------------------------------------- |
| `url` | string | The `url` parameter specifies the URL of the document to be indexed. |
**Response**
{% tabs %}
{% tab title="200" %}
```json
{
"output": null,
"error": null,
"error_data": null
}
```
{% endtab %}
{% tab title="500" %}
```json
{
"output": null,
"error": string,
"error_data": string
}
```
{% endtab %}
{% endtabs %}
Upon successfully indexing a document, the API will return a response with the unique identifier of the indexed document in `output` parameter.
You can use the unique identifier in subsequent requests to the Chat API to retrieve information from the indexed PDF.
## Run the API
To test this API, please use the following link:
{% embed url="" %}
# Pricing
## TEXT TO IMAGE
The credit utilization pricing for various models within the text-to-image feature is outlined below :-
| App ID | Model Name | Credit Utilisation |
|---|
| ap-n2p3fg3gsvbgnYeEEdef | Image Gen 4 | 4 |
| ap-nOpQr7stuvwxYzABcdef | SD 3.5 medium | 9 |
| ap-mNopQ8rstuvwXYZabcde | SD 3.5 | 23 |
| ap-rStUv6xyzabcdPQRSefg | SD 3.5 Turbo | 8 |
| ap-jKlMn5opqzabcXyZtUVw | Recraft V3 | 22 |
| ap-jXyZa9bcdefghijklmnopq | Flux Schnell | 3 |
| ap-fGhKl3mfkdlpqrtsUVWcba | Flux Dev | 8 |
| ap-fGhKl3mfkdlpqrsTuvwxYz | Flux Pro | 14 |
| ap-sdSyd0idsndjnsnsndjsds | Dalle 3 | 11 |
| ap-x7q8hj9kltmNoPqRzabc | Leonardo | 11 |
| ap-hJkLm4nqzxybwvUTSRdca | Ideogram | 22 |
| ap-zuzhawbgipcrnxdtefhjbnvhc | GPT Image | 18 |
### IMAGE TO IMAGE
The credit utilization pricing for various models within the image-to-image feature is outlined below :-
| App ID | Model Name | Credit utilisation |
|---|
| ap-fGhKl3mfkdlpqrshuwwabc | Flux Dev | 8 |
| ap-hTjXy7qplkzvnmwqrsdabc | Ideogram Remix | 8 |
| ap-gFhLq9zvbnmopxkytswabc | Flux Redux | 26 |
| ap-mNqZx4rtyjvbcfghwklpde | Flux Canny | 26 |
| ap-gWfZx8rjvtyqopmnbcdehij | Flux Depth | 26 |
| ap-hJkLm8nqwertyuiopasdfg | Flux PulID | 17 |
| ap-zuzhawbgipcrnxdtefhjbnvhc | GPT Image | 18 |
| ap-tK7gR4jP9sWbC1mNfE8uVzH2 | Flux Kontext Max | 29 |
#### INPAINTING
The credit utilization pricing for INPAINTING within the image-to-image feature is 10.
#### REPLACE BACKGROUND
The credit utilization pricing for REPLACE BACKGROUND within the image-to-image feature is 10.
#### TEXT TO SPEECH
The credit utilization pricing for various voice models within the TEXT TO SPEECH feature is 2.
# Overview
An overview of how Organizations and Workspaces work in Qolaba — credit management, collaboration, access control, and usage visibility.
### **Why Organizations & Workspaces Exist**
Qolaba is designed to work seamlessly for both individuals and teams. As your usage grows—across projects, clients, or departments—you need a structured way to manage credits, organize work, and collaborate efficiently.
**Organizations and Workspaces provide that structure.**
They help you move from isolated usage to a more **organized, collaborative, and scalable setup**, without losing visibility or control.
***
### Key Challenges Addressed
| Challenge | Without Structure | With Organizations & Workspaces |
|---|
| Credit management | Scattered usage across users | Centralized credit pool or Separate Workspace Budgets |
| Collaboration | Disconnected workflows | Shared environment |
| Access control | No clear permissions | Role-based access |
| Organization | Mixed outputs and history | Structured workspaces |
| Visibility | Difficult to track usage | Clear usage tracking |
***
### Core Capabilities
#### **1. Centralized Credit Management**
All usage in Qolaba is credit-based. Instead of managing credits individually, organizations introduce a **shared system**:
* A single subscription and billing source
* Allocate budgets to each workspace or consume from shared pool
* Centralized top-ups and plan management
* Visibility into overall usage
This makes it easier to control costs and avoid fragmented credit usage across multiple users.
***
#### **2. Structured Collaboration**
Organizations and Workspaces allow teams to collaborate in a structured and organized way, while keeping work relevant to each role.
* Different teams or functions can work within their own **dedicated workspaces**
* Each workspace can focus on specific tasks or workflows
* Usage and outputs remain organized and easy to track
{% hint style="info" %}
**Example: Team Workflow**
A team organizes work across multiple workspaces:
* In the **Research workspace**:\
Members use **Chat (LLMs)** to generate insights, content ideas, and strategy inputs
* In the **Design workspace**:\
Members use **Image and Video tools** to create visuals and assets
* In the **Content workspace**:\
Members refine messaging, scripts, and final outputs
Each team works within its own context, while all activity stays connected under the same organization.
{% endhint %}
***
#### **3. Clear Separation of Work**
As more work is created, keeping everything in one place becomes difficult to manage.
Workspaces help you structure work based on your needs, such as:
* Projects or clients
* Teams or departments
* Use cases or workflows
Each workspace acts as an independent environment, helping you keep work cleanly separated without affecting other teams.
***
#### **4. Usage Visibility**
Organizations provide a clear view of how credits are being used across your team.
You can:
* Monitor usage across different workspaces
* Track activity at a member level
* Analyze usage across tools (Chat, Image, Video, Audio)
This level of visibility helps teams stay **in control of usage and spending**.
***
### Summary
Organizations and Workspaces form the foundation for using Qolaba effectively at scale.
They allow you to:
* Manage credits from a single place
* Collaborate without overlap
* Keep work structured and easy to navigate
* Maintain visibility into usage
Whether you're working solo or as part of a team, this structure ensures your workflows remain **organized, flexible, and scalable**.
***
### Suggested Next Steps
To learn more, explore:
* [Creating an Organization](/organization-and-workspaces/organizations/creating-an-organization)
* [Creating and Managing Workspaces](/organization-and-workspaces/workspaces)
* [Inviting and Managing Members](/getting-started/introduction)
* [Credits and Usage Tracking](/organization-and-workspaces/tracking-credits-and-ai-usage)
# Organizations
Understand how Organizations help manage teams, workspaces, billing, and credits in one centralized place.
An **Organization** is the central layer in Qolaba where your team, credits, and workspaces are managed together.
It acts as the **single source of truth** for:
* Billing and credit usage
* Team members and access
* Workspace structure
If you're working with multiple people, projects, or clients, creating an organization allows you to keep everything **centralized, organized, and controlled**.
***
### When to Use an Organization
You should use an organization when:
* You’re working as a **team** and need shared access
* You want to manage **credits centrally** instead of individually
* You need to organize work across **multiple projects or clients**
* You want **visibility into usage** across members and workspaces
***
### What You Can Do with an Organization
Within an organization, you can:
* Create and manage multiple workspaces
* Invite and manage team members
* Control access and permissions
* Monitor credit usage and activity
* Manage billing and subscriptions
This allows you to operate in a **structured and scalable way**, without losing control as your usage grows.
***
### How Organizations Fit Into Your Workflow
Once an organization is created:
1. You set up your **workspaces** based on projects or teams
2. Invite **members** and assign them access
3. Start using AI tools within each workspace
4. Track usage and manage credits centrally
This ensures that all activity remains **organized and easy to manage**.
# Creating an Organization
Learn how to create an Organization in Qolaba, choose the right credit plan, and complete the initial setup for teams, billing, and workspaces.
Creating an organization is the first step to setting up Qolaba for structured usage. It allows you to manage credits centrally, collaborate with others, and organize your work in a scalable way.
An organization acts as the main container for:
* Subscription and billing
* Credit allocation
* Workspaces
* Team members
***
### **1. Access Organization Setup**
* **Step 1**\
Go to your **Qolaba Dashboard**
* **Step 2**\
Click your **profile icon** (top-right corner)
* **Step 3**\
Select **Create Organization**
***
### **2. Organization Setup Flow**
The setup process is guided and takes just a few steps:
* Name your organization
* Select a credit plan
* Add basic details
* Complete checkout
#### **2.1 Enter Organization Name**
Provide a name that represents how you plan to use Qolaba.
{% tabs %}
{% tab title="Company / Brand" %}
* Growth Studio
* FoodCo
* Marketech
{% endtab %}
{% tab title="Team / Department" %}
* Marketing
* Product
* Research
{% endtab %}
{% tab title="Project-Based" %}
* Project Alpha
* Campaign Launch
* Internal Experiments
{% endtab %}
{% endtabs %}
***
#### **2.2 Select a Credit Plan**
Choose a plan based on how you expect to use the platform.
Each plan clearly shows:
* Number of credits included
* Pricing
**How to Choose the Right Plan**
Consider the following:
* **Team size**\
More users typically require more credits
* **Type of work**
* Text-based tasks → lower usage
* Image and video generation → higher usage
* **Frequency of usage**\
Occasional vs. daily workflows
* **Nature of work**
* Lightweight exploration
* High-volume production
{% hint style="info" %}
Credits are shared across the organization either through shared pool or through allocated workspace budgets.
[Learn More About Workspace Credit Allocation *→*](/organization-and-workspaces/workspaces/workspace-credit-allocation)
{% endhint %}
***
#### **2.3 Provide Organization Details**
Add a few details to complete setup.
* **Company size range** (e.g., 2–50, 50–250, etc.)
* **Your role** (e.g., Marketing, Product, Research, Operations)
{% hint style="info" %}
This helps tailor onboarding and recommendations based on how you plan to use Qolaba.
{% endhint %}
***
### **3. Complete Checkout**
* **Step 1**\
Click **Create Organization & Continue**
* **Step 2**\
Proceed to the **payment page**
* **Step 3**\
Complete your subscription
***
### **After Setup**
Once your organization is created:
* Your **subscription becomes active**
* Credits are **allocated immediately**
* You are redirected to the **Organization Dashboard**
* You are assigned the **Owner role**
***
### **What You Can Do Next**
From your organization dashboard, you can:
* [**Create** **workspaces**](/organization-and-workspaces/workspaces/creating-a-workspace) to organize your work
* [**Assign Budgets**](/organization-and-workspaces/workspaces/workspace-credit-allocation) to each workspace
* [**Invite team members**](/organization-and-workspaces/members-and-role-based-access/inviting-members) **(only in team plan)**
* [**Monitor Credit usage**](/organization-and-workspaces/tracking-credits-and-ai-usage)
# Organization Dashboard
{% content-ref url="/pages/n8mXF6ZOO3zqP66EcqAu" %}
[Overview Tab](/organization-and-workspaces/organizations/organization-dashboard/overview-tab)
{% endcontent-ref %}
# Overview Tab
The Overview tab provides a complete summary of your organization’s financial status, credit availability, and usage activity. It combines:
* Organization summary
* Credit controls
* Billing records
* Credit consumption tracking
This is where Owners and Admins monitor and manage AI resources.
***
## 1. Organization Summary
The Organization Summary provides a high-level snapshot of your organization’s AI capacity and team structure. It typically includes:
* Organization name
* Monthly credit allocation
* Remaining credits
* Total members
Each element serves a specific purpose.
***
### Organization Name
This displays the official name of your organization. It:
* Identifies the team environment you are currently operating in
* Helps users confirm they are inside the correct organization
* For organizations managing multiple teams or clients, this helps prevent confusion when switching between environments.
***
### Monthly Credit Allocation
This shows the total number of credits assigned to your organization for the current billing cycle.This value is determined by:
* The subscription plan selected during setup
* Any upgrades made afterward
Credits are refreshed based on your billing cycle.This allocation represents the maximum AI usage capacity for the month.It defines your operational limit for:
* Chatbot usage
* Image generation
* Video generation
* Speech generation
* Knowledge base uploads
This helps teams plan resource usage strategically.
***
### Remaining Credits
This shows how many credits are still available for the current billing period.Credits decrease when:
* Any member uses AI tools
* Content is generated
* Files are processed
Remaining credits update in real time.This metric is critical for:
* Budget monitoring
* Preventing unexpected exhaustion
* Deciding whether to top up credits
* Planning large campaigns
For example:If you are launching a marketing campaign with heavy image and video generation, monitoring remaining credits prevents workflow disruption.
***
### Total Members
This shows the number of members currently part of the organization.It provides visibility into:
* Team size
* Active collaboration scale
* Distribution of credit consumption
This does not display detailed member information here — only the count.It helps leadership understand team footprint within the AI environment.
***
## 2. Credit Management
The Credit Management section allows Owners and Admins to control subscription capacity without leaving the dashboard.It includes two main controls:
* Buy More Credits
* Upgrade Plan
***
### Buy More Credits (Top-Up)
The “Buy More Credits” option allows organizations to instantly add credits to their existing subscription.This is useful when:
* Credits are running low mid-cycle
* A large campaign requires additional AI usage
* A new project begins unexpectedly
* A temporary spike in usage occurs
Top-ups:
* Increase available credits immediately
* Do not change your base subscription tier
* Act as supplemental credit additions
This provides operational flexibility without requiring a full plan upgrade.It prevents downtime and ensures uninterrupted AI workflows.
***
### Upgrade Plan (Change Subscription Tier)
Upgrading your plan increases your monthly credit allocation.This is ideal when:
* Your team has grown
* AI usage has permanently increased
* You consistently exhaust monthly credits
* You need more predictable scaling
Upgrading adjusts:
* Monthly credit allowance
* Subscription cost
* Long-term usage capacity
Unlike top-ups (which are temporary), upgrading changes your recurring subscription level.This is suited for sustainable growth rather than temporary spikes.
***
## 3. Billing Section
The Billing section provides financial transparency and subscription tracking.This is essential for:
* Accounting teams
* Budget reporting
* Finance audits
* Enterprise compliance
***
### Billing History
Billing History records every subscription and payment event.Each entry includes:
#### Date & Time
When the transaction occurred.Useful for:
* Monthly reconciliation
* Tracking subscription cycles
***
#### Plan Name
The name of the subscription plan purchased or renewed.Helps track:
* Plan changes over time
* Upgrade or downgrade history
***
#### Credit Quantity
The number of credits associated with the transaction.This confirms:
* Allocation received
* Top-up quantity purchased
***
#### Payment Amount
The total amount charged.Used for:
* Financial reporting
* Cost tracking
* Expense management
***
#### Subscription Status
Indicates whether the subscription is:
* Active
* Cancelled
* Expired
* Pending
This ensures leadership knows the operational state of the organization.
***
## 4. Credit Utilization Section
While Billing shows money flow, Credit Utilization shows operational AI activity.This section provides insight into how credits are being used across the platform.
***
### Platform-Wide Usage
This table records AI consumption events across all tools.Each entry includes:
***
#### Date & Time
When the AI action occurred.Helps track:
* Usage spikes
* Campaign periods
* High-activity windows
***
#### Tool Type
Specifies which tool consumed credits, such as:
* Chatbot
* Text-to-Image
* Image-to-Image
* Image Editing
* Video Generation
* Speech Generation
* Text-to-Music
* Knowledge Base processing
This helps identify which tools drive the highest usage.For example:If Video Generation consumes most credits, you may adjust strategy accordingly.
***
#### Quantity of Credits Used
Shows how many credits were consumed for that specific action.This enables:
* Cost accountability
* Usage analysis
* Optimization decisions
* Budget forecasting
***
# Profile Tab
## Profile Tab
The Profile tab is the administrative settings area of your organization.It controls:
* Organization identity
* Structural management
* Subscription lifecycle
Access to this tab depends on role:
* **Owner** → Full access
* **Admin** → Can edit most settings
* **Member** → No access
***
## 1. Organization Information
The Organization Information section defines the identity of your organization within Qolaba.It includes:
* Organization logo
* Organization name
This section allows Owners and Admins to customize and maintain the organization’s profile.
***
### Upload Organization Logo
You can upload a logo to visually represent your organization.
#### Purpose of Organization Logo
* Displays branding across the organization dashboard
* Improves team identification
* Helps members distinguish between multiple organizations
* Strengthens professional presentation
For agencies managing multiple organizations or consultants working with multiple clients, this helps avoid confusion when switching between accounts.The logo is purely organizational branding — it does not affect credit usage or functionality.
***
### Edit Organization Name (Owner & Admin Only)
Owners and Admins can modify the organization name at any time.
#### Why Editing May Be Needed
* Rebranding
* Company name change
* Department restructuring
* Project-to-company transition
The organization name:
* Appears in member invitations
* Appears in profile dropdown
* Appears in dashboard headers
#### Role Restriction
Members cannot edit the organization name.This ensures identity consistency and prevents accidental renaming.
***
## 2. Organization Management
This section controls the structural existence of the organization.It includes one critical action:Delete Organization
***
### Delete Organization
This action permanently removes the organization from Qolaba.
#### Access Restriction
Only the **Owner** can delete an organization.Admins cannot delete the organization.This ensures:
* Maximum structural security
* Protection from accidental deletion
* Clear authority boundary
***
#### What Happens When an Organization Is Deleted
Deleting an organization will:
* Remove all workspaces
* Remove all members
* Remove usage history
* Remove billing association
* Permanently erase associated data
This action **cannot be undone**.Once deleted:
* Credits are lost
* Workspace history is removed
* Member access is revoked
* Data cannot be recovered
***
#### When Should You Delete an Organization?
* Company closure
* Project termination
* Migration to a new organization
* Complete discontinuation of service
For temporary discontinuation, canceling subscription is safer than deleting.
***
## 3. Subscription Management
This section controls the lifecycle of your paid plan.It allows Owners and Admins to cancel active subscriptions.
***
### Cancel Subscription
Owners and Admins can cancel the organization’s subscription.Canceling subscription:
* Stops automatic renewal
* Does not immediately disable access
***
#### What Happens After Cancellation
If you cancel:
* Your subscription remains active until the end of the current billing cycle
* Credits remain usable during that period
* After expiration, premium access is discontinued
This ensures:
* No sudden workflow interruption
* Predictable offboarding
* Smooth transition planning
***
#### Important Distinction
Cancel Subscription ≠ Delete OrganizationCanceling:
* Stops future billing
* Keeps organization structure intact
* Ends premium features after billing period
Deleting:
* Permanently removes organization and all data
###
# Members Tab
## Members Tab
The Members tab is the administrative control center for managing users inside an organization.This tab is visible only to:
* Owner
* Admin
Members cannot access this tab.It allows leadership to:
* Monitor individual credit usage
* Assign and modify roles
* Manage workspace access
* Revoke permissions
* Maintain security and accountability
***
## 1. Member Overview Table
The Member Overview Table provides a structured summary of all invited users within the organization.Each row represents one member.Each column provides operational and governance insights.
***
### Email
Displays the registered email address of the member.This is:
* The email used to log into Qolaba
* The identifier for workspace access
* The email used for invitation
Why this matters:
* Ensures correct identity verification
* Prevents duplicate access
* Provides clarity on who is consuming credits
***
### Image & Speech Credits Used
This column shows how many credits the member has consumed across:
* Text-to-Image
* Image-to-Image
* Image Editing
* Video generation
* Speech generation
* Text-to-Music
This helps administrators understand:
* Who is generating creative assets
* Which team members are heavy media users
* Whether usage aligns with responsibilities
For example:If a copywriter is consuming high image credits, this may indicate cross-role usage or inefficiency.
***
### Chatbot Credits Used
This column shows credits consumed specifically for:
* Chat interactions
* Knowledge base usage
* AI reasoning tools
This separation is important because:
* Chatbot usage patterns differ from media generation
* Teams may allocate chatbot usage differently
* Some roles rely heavily on conversational AI
This enables better tool-level monitoring.
***
### Total Credits Used
This column shows the total credits consumed by the member across all AI tools.This provides:
* A complete usage snapshot
* Accountability per user
* Budget visibility
* Usage comparison between team members
This is especially useful for:
* Large teams
* Enterprise governance
* Client-billable environments
***
### Status (Active / Revoked)
This shows the current access status of the member.
#### Active
The member:
* Can log in
* Can access assigned workspace
* Can consume credits
#### Revoked
The member:
* No longer has access
* Cannot log into the organization
* Cannot consume credits
Revoking access does not delete usage history — it only removes permission.This is important for:
* Team transitions
* Employee offboarding
* Contractor termination
* Security enforcement
***
### Role
This shows the assigned role of the member:
* Owner
* Admin
* Member
This column clarifies:
* Who has administrative authority
* Who can manage credits
* Who can modify workspaces
* Who has restricted access
This ensures transparency in organizational hierarchy.
***
### Workspace
This column shows which workspace the member is assigned to.Because workspaces isolate projects or teams, this helps administrators understand:
* Which project the member belongs to
* Which client they are working on
* Where their AI activity is recorded
This prevents cross-project confusion.
***
## 2. Filtering Members
As organizations scale, the number of members increases.Filtering ensures administrative clarity.
***
### View All Workspaces
When “All” is selected:
* You see all members across all workspaces
* Full organizational visibility
This is useful for:
* Organization-wide audits
* Budget review
* High-level reporting
***
### Filter by Specific Workspace
You can filter members by selecting a specific workspace.When filtered:
* Only members assigned to that workspace appear
* Credit usage reflects that context
This is especially useful for:
* Client-level monitoring (agencies)
* Department-level tracking (SMBs)
* Project-level billing (consultants)
Filtering ensures clean separation without mixing unrelated teams.
***
## 3. Managing Members
The Members tab is not just for viewing — it allows administrative actions.
***
### Change Role
Admins and Owners can modify a member’s role.For example:
* Promote Member → Admin
* Demote Admin → Member
Why this is important:
* Team restructuring
* Temporary elevated permissions
* Project leadership changes
* Security adjustments
Role changes immediately affect dashboard access and permissions.
***
### Change Workspace
You can reassign a member to a different workspace.This is useful when:
* Team members shift projects
* Client ownership changes
* Departments reorganize
* A contractor finishes one project and moves to another
Workspace reassignment ensures:
* Correct history isolation
* Accurate credit tracking
* Clean project boundaries
***
### Revoke Access
Revoking access removes the member from the organization.This is used for:
* Employee exits
* Contract completion
* Security incidents
* Temporary suspension
When revoked:
* The member loses access immediately
* Credits are no longer consumable
* Usage history remains for reporting
This maintains operational integrity while preserving historical records.
# History Tab
The History tab allows users to view AI activity across the platform.It provides structured visibility into:
* What was generated
* When it was generated
* Which workspace it belongs to
* What type of content it is
* Whether it was private or public
Access level depends on role:
* **Owner & Admin** → Can view history across all workspaces
* **Member** → Can view history only within assigned workspace
***
## 1. Viewing Platform Activity
The History tab serves as a centralized activity feed.It allows you to:
* Track AI usage
* Revisit past outputs
* Monitor content generation
* Audit credit consumption patterns
Each entry in History represents an AI action, such as:
* Chat interaction
* Image generation
* Video creation
* Audio generation
* Uploaded file
* Edited content
This creates a full operational timeline of your organization’s AI usage.
***
## 1. 1 Enable “Me Mode”
“Me Mode” filters history to show only your own activity.When enabled:
* You see only content generated by your account
* Other team members’ activity is hidden
#### Why Me Mode Exists
For organizations with large teams, history can become extensive.Me Mode allows:
* Personal productivity tracking
* Clean workflow management
* Focused review of your own outputs
* Reduced noise from other team activity
For Members, this is especially useful when:
* They only need to revisit their own generated content
* They want to isolate their own work
For Admins, it helps compare personal usage against total team usage.
***
## 1.2 Filter by Workspace
The workspace filter allows you to isolate activity based on project or team.
***
### Primary Workspace (Default)
When an organization is created, the first workspace created is called the Primary Workspace.By default:
* History shows activity from the Primary Workspace
This ensures that even new organizations have a visible starting point.
***
### Switching Between Workspaces
If multiple workspaces exist, you can switch between them.When you select a workspace:
* History updates to show only activity from that workspace
* Content from other workspaces is hidden
#### Why This Matters
Workspaces isolate projects.For example:Agency:
* Workspace A → Client A
* Workspace B → Client B
Filtering by workspace ensures:
* Client content does not mix
* Clean project-level tracking
* Accurate billing attribution
Members can only view the workspace they are assigned to.Admins can switch between all workspaces.
***
## 1.3 Sort by Date
Sorting controls how activity is displayed chronologically.
***
### Latest First
Displays the most recent activity at the top.Best used for:
* Daily monitoring
* Reviewing recent work
* Tracking new outputs
* Ongoing campaign management
This is typically the default view.
***
### Oldest First
Displays the earliest activity first.Best used for:
* Reviewing long-term project timelines
* Auditing historical usage
* Tracking workflow progression
* Investigating past campaigns
Sorting ensures flexible time-based analysis.
***
## 2. Filter by Content Type
Beyond workspace and user filtering, you can refine history by content category.This allows precision search across generated assets.
***
### Uploaded Images
Displays images that were manually uploaded to the platform.Useful for:
* Locating base images
* Revisiting reference uploads
* Reusing previous assets
***
### Image Content
Displays AI-generated images.Includes:
* Text-to-Image
* Image-to-Image
* Image Editing outputs
Helps users quickly locate visual outputs.
***
### Audio Content
Displays:
* Speech generation
* Text-to-Music outputs
* Audio files created via AI
Useful for creators and media teams working with sound assets.
***
### Video Content
Displays:
* Generated videos
* Image-to-video outputs
* Text-to-video creations
This is especially useful for:
* Campaign review
* Video asset tracking
* Creative production oversight
***
### Private Content
Shows content generated under private session mode.Private content:
* Is visible only to the creator
* Does not appear on the community wall
This filter helps isolate confidential or client-sensitive work.
***
### Public Content
Shows content generated under public mode.Public content:
* Is visible on the community wall
* May be shareable
This filter helps separate:
* Marketing/public campaigns
* Showcase content
* Collaborative outputs
***
### Favorites
Displays content that has been marked as favorite.This is useful for:
* Shortlisting final creatives
* Saving best-performing assets
* Organizing priority outputs
* Quick access to important files
Favorites act as a lightweight bookmarking system.
{% hint style="info" %}
{% endhint %}
# Workspaces
Understand how Workspaces help organize projects, teams, and AI usage within an Organization.
Workspaces are structured environments inside an organization that allow teams to separate projects, clients, or departments while sharing the same subscription. They act as controlled containers for AI usage. Workspaces can access credits directly from the shared pool or through their allocated budgets.
### What is a Workspace?
A workspace is a **project-level container** within an organization designed to structure and manage AI operations.
It is used to:
* Organize AI work by project, team, or client
* Maintain separation between different use cases
* Track credit usage independently
* Preserve clean and isolated activity history
#### Common Use Cases
| User Type | Workspace per... | Example | Benefit |
| --------------- | ---------------- | ----------------------------- | ----------------------------- |
| Agency | Client | Workspace: Nike Campaign | Data isolation, clean billing |
| SMB | Department | Workspace: Marketing | Usage tracking per team |
| Consultant | Engagement | Workspace: Q3 Audit | Client confidentiality |
| Freelancer | Revenue stream | Workspace: Brand A | Isolated outputs |
| Dev / R\&D Team | Experiment | Workspace: GPT vs Claude Test | No production interference |
***
### Key Capabilities
#### 1. Project or Client-Level Structuring
A workspace can represent different operational units such as:
* Clients
* Departments
* Campaigns
* Product lines
* Research initiatives
* Consulting engagements
This prevents overlap between unrelated work and ensures structured execution.
#### 2. Independent Usage Tracking
Although credits belong to the organization, usage is tracked at the workspace level.
Each workspace provides visibility into:
* Image and speech credit consumption
* Chatbot credit usage
* Total credits consumed
This enables accurate:
* Client billing
* Department budgeting
* Resource forecasting
* Performance analysis
#### 3. Isolated AI History
Every workspace maintains its own activity history.
This ensures:
* No cross-workspace visibility of generated content
* Project-specific conversations remain contained
* Outputs and media are properly organized
This isolation supports confidentiality, privacy, and clean workflows.
***
### Primary Workspace
When an organization is created, **Qolaba automatically generates the first workspace**, known as the **Primary Workspace**.
The Primary Workspace:
* Is the first workspace created by default
* Serves as the initial working environment
This ensures the organization is immediately ready for use without additional setup.
***
#### Default Workspace Behavior
The Primary Workspace acts as the default workspace for all initial activities.
This means:
* All initial AI activity is recorded here
* History is stored by default in this workspace
* Members operate within it unless reassigned
If no additional workspaces are created, all activity remains within the Primary Workspace.
#### When Should You Create Additional Workspaces?
You should create new workspaces when:
* Managing multiple clients
* Operating across different departments
* Requiring separate credit tracking per project
* Needing isolated AI history
* Enforcing stricter project-level governance
Workspaces are essential for maintaining scalability, clarity, and operational control.
***
### Organization vs Workspace
| Aspect | Organization | Workspace |
|---|
| Role | Top-level entity | Project-level container |
| Ownership | Owns subscription and credits | Uses allocated or shared credits |
| Management | Manages members | Assigns members per project |
| Function | Contains workspaces | Segments and organizes work |
| Data Scope | Global | Isolated per workspace |
# Creating a Workspace
Learn how to create and configure Workspaces for projects, teams, or clients within your Organization.
### Steps to Create a Workspace
1. Go to the **Organization Dashboard**
2. Open the **Workspaces** tab
3. Click **Create Workspace**
4. Enter the required details
5. Click **Create Workspace**
Once created, the workspace becomes immediately active and ready for use.
{% hint style="info" %}
Only users with **Owner** or **Admin** roles can create workspaces.\
[Learn More about Role Based Access*→*](/organization-and-workspaces/members-and-role-based-access/member-roles-explained)
{% endhint %}
***
### Workspace Details
#### 1. Workspace Name
The workspace name identifies the project, team, or client within the organization.
Use clear and descriptive naming conventions such as:
* Client – Nike Campaign
* Marketing Team
* Product Launch 2024
* Q4 Ad Campaign
The name is used across member assignment, history filters, and credit tracking. A consistent naming approach ensures clarity as the number of workspaces increases.
{% hint style="info" %}
Prefer descriptive names over generic ones\
*Example: “Client – Adidas Q4 Campaign” is more effective than “Workspace 3”*
{% endhint %}
#### 2. Workspace Description
You can add a description to provide context about the workspace.
This may include:
* Project scope or objective
* Client or campaign details
* Timeline or phase
* Responsible team
**Example:**“This workspace is dedicated to AI-generated creatives and chatbot workflows for the Q3 product launch.”
***
### After Creation
Once the workspace is created, you can:
* [Invite members](/organization-and-workspaces/members-and-role-based-access/inviting-members) to the workspace
* [Allocate a budget](/organization-and-workspaces/workspaces/workspace-credit-allocation) to the workspace (if using workspace budget mode)
* [Track credit usage](/organization-and-workspaces/tracking-credits-and-ai-usage)
* Access workspace-specific history
* Update workspace details
* Delete the workspace if no longer needed
All activity within the workspace is automatically tracked and scoped to it.
***
### Best Practices
* Create separate workspaces for distinct clients, teams, or projects
* Maintain consistent naming conventions across the organization
* Avoid mixing unrelated work within a single workspace
* Do not create unnecessary workspaces without clear separation needs
# Workspace Credit Allocation
Understand how credit allocation works across Workspaces using shared pools or individual workspace budgets.
Workspace Credit Allocation defines how credits are distributed across workspaces. It allows organizations to either use a shared credit pool or assign fixed budgets to individual workspaces, enabling controlled and transparent usage.
{% embed url="" %}
***
### Credit Modes
You can switch between modes from the dropdown at the top of the **Workspaces** tab.
#### 1. Shared Pool Mode
All workspaces consume credits from a single shared pool.
* Credits reside in the **Primary Workspace**
* No per-workspace limits are enforced
* All usage deducts from the same central balance
**When to use:**\
Suitable for smaller teams or when centralized control is sufficient.
#### 2. Workspace Budget Mode
Each workspace operates within an assigned credit limit.
* Credits are distributed to individual workspaces
* Usage is restricted to the allocated budget
* Additional credits must be assigned when required
**When to use:**\
Recommended for managing multiple teams, clients, or projects with defined budgets.
***
### Primary Workspace
The **Primary Workspace** acts as the default credit source.
* All purchased or added credits are stored here
* Its balance updates dynamically based on allocations
**Example:**\
If total credits = 10,000
* 2,000 allocated to Workspace A
* 3,000 allocated to Workspace B
Primary Workspace balance = **5,000**
***
### Allocating Credits
Credits can be transferred between workspaces in **Workspace Budget Mode**.
#### Steps
1. Go to **Dashboard → Workspaces tab**
2. Open the **⋯ (three-dot menu)** for a workspace
3. Select **Manage Credits**
4. Choose a source workspace
5. Enter the credit amount
6. Review updated balances
7. Click **Transfer**
***
### Credit Behavior
* Each workspace consumes credits from its own balance (in budget mode)
* The Primary Workspace reflects the remaining organizational balance
* If a workspace runs out of credits, usage is blocked until more credits are assigned
***
### Transfer Rules
* Credits can be moved between any workspaces with available balance
* Transfers cannot exceed available credits in the source workspace
* Changes apply immediately
***
### Deletion Impact
* Remaining credits in a deleted workspace return to the **Primary Workspace**
* The Primary Workspace cannot be deleted
***
### Why This Matters
* Enables controlled distribution of credits
* Prevents uncontrolled usage
* Provides visibility at the workspace level
* Ensures accountability across teams
# Managing Workspaces
Learn how to monitor workspace usage, manage settings, and perform administrative actions from the Organization Dashboard.
Workspaces can be monitored and managed from the **Workspaces** tab in the Organization Dashboard. This section focuses on viewing workspace activity and performing administrative actions.
***
### Workspace View
The Workspaces tab provides a structured overview of all workspaces.
Each row includes:
* **Workspace Name** — Project, team, or client identifier
* **Image & Speech Credits Used** — Media-related usage
* **Chatbot Credits Used** — Text and conversation usage
* **Total Credits Used** — Combined usage across all tools
* **Usage Display**
* Shows consumption against allocation (in budget mode)
* Shows total usage from shared pool (in shared mode)
* **Created By** — Workspace creator
This view helps compare usage and monitor activity across workspaces.
***
### Understanding Usage
Workspace metrics help interpret how resources are being used:
* Higher **Image & Speech usage** indicates creative or production-heavy work
* Higher **Chatbot usage** indicates research or conversational workflows
* **Total usage** reflects the overall resource consumption of the workspace
***
### Workspace Actions
Each workspace provides the following actions:
* **Edit** — Update workspace name or description
* **Delete** — Remove the workspace
If **Workspace Budget Mode** is enabled:
* **Manage Credits** — Opens credit allocation controls (covered in [Workspace Credit Allocation](/organization-and-workspaces/workspaces/workspace-credit-allocation))
{% hint style="info" %}
Only users with **Owner** or **Admin** roles can create workspaces.\
[Learn More about Role Based Access*→*](/organization-and-workspaces/members-and-role-based-access/member-roles-explained)
{% endhint %}
***
### Updating a Workspace
Workspace details can be modified to reflect:
* Project updates
* Naming changes
* Organizational restructuring
These changes do not affect usage data or member assignments.
***
### Deleting a Workspace
Deleting a workspace:
* Removes the workspace and its activity scope
* Revokes workspace-specific access
* Stops further usage
Credits already consumed remain part of organizational usage.
{% hint style="warning" %}
Deleted workspaces cannot be recovered. Archive or export relevant content before deletion.
{% endhint %}
# Members and Role-Based Access
Understand how member roles and workspace-based access help manage collaboration, permissions, and security within your Organization.
## Members & Role-Based Access
Qolaba uses a structured, role-based access system to help organizations collaborate securely, manage credits transparently, and keep workspaces isolated. This section covers everything you need to know about managing who has access to your organization — and what they can do once they're in.
***
### What's in This Section
***
### How It Works — At a Glance
Every Qolaba organization has three role tiers:
* **Owner** — Full control, including the ability to delete the organization
* **Admin** — Manages members, workspaces, and credits; cannot delete the organization
* **Member** — Uses AI tools within their assigned workspace; no administrative access
Members are invited by email, assigned a role and workspace, and gain access after logging in with the invited address. All activity and credit usage is tracked per member, per workspace.
***
### Key Concepts
1. **Workspace Isolation** : Each member is assigned to a specific workspace. They can only see and use the workspace(s) assigned to them. This keeps project history clean and credit usage clearly attributed.
2. **Email-Matched Access :** Invitations are tied to a specific email address. The invited user must log in — or create an account — using that exact email.
3. **Role-Controlled Governance :** Only Owners and Admins can invite members, modify roles, or manage workspaces. Members have no administrative access, ensuring a clear separation between usage and management.
***
### Who Should Read This
* **Owners** setting up their organization for the first time
* **Admins** managing a growing team
* **Anyone** troubleshooting access or onboarding a new team member
# Member Roles Explained
Learn how Owner, Admin, and Member roles control access, permissions, and responsibilities within an Organization.
Qolaba uses role-based access control (RBAC) to keep organizations structured, secure, and easy to manage. Every member of an organization holds one of three roles: **Owner**, **Admin**, or **Member**.
***
### Quick Comparison
| Permission | Owner | Admin | Member |
|---|
| Use AI tools (Chatbot, Image, Video, Speech) | ✅ | ✅ | ✅ |
| View Overview & History | ✅ | ✅ | ✅ (assigned workspace) |
| Invite & remove members | ✅ | ✅ | ❌ |
| Assign & change roles | ✅ | ✅ | ❌ |
| Create, edit & delete workspaces | ✅ | ✅ | ❌ |
| Monitor credit usage | ✅ | ✅ | ❌ |
| Buy credits | ✅ | ✅ | ❌ |
| Upgrade or cancel subscription | ✅ | ✅ | ❌ |
| Edit organization profile | ✅ | ✅ | ❌ |
| Delete the organization | ✅ | ❌ | ❌ |
***
### Owner
The Owner is the highest authority in an organization. The account that creates the organization is automatically assigned the Owner role.
**What the Owner controls:**
* All organization settings
* Subscription and billing
* Credit management
* Member and workspace management
* Structural deletion of the organization
**The one exclusive permission:** Only the Owner can permanently delete the organization. This restriction exists to prevent accidental or unauthorized removal of the entire account structure.
In most cases, an organization has a single Owner. The Owner role cannot be assigned through the standard invite flow — it transfers only through deliberate ownership change.
**Best suited for:** Founders, company principals, or whoever holds final accountability for the account.
***
### Admin
Admins support the Owner in day-to-day management. They have nearly full operational access, with one hard limit: they cannot delete the organization.
**What an Admin can do:**
* Invite and remove members
* Assign and change member roles (excluding ownership transfer)
* Create, edit, and delete workspaces
* Monitor credit usage across the organization
* Purchase additional credits
* Upgrade or cancel the subscription
**What an Admin cannot do:**
* Delete the organization
**Best suited for:** Team leads, operations managers, department heads, or project managers who need to manage people and workspaces without holding ultimate structural authority.
***
### Member
The Member role is designed for users who work within Qolaba — not those who manage it. Members have no administrative access.
**What a Member can do:**
* Access their assigned workspace
* Use all AI tools: Chatbot, Image generation, Video, Speech
* View the Overview tab
* View History within their assigned workspace
**What a Member cannot do:**
* Invite or remove members
* Create or manage workspaces
* Modify or cancel the subscription
* Purchase credits
* Edit organization settings
* Delete the organization
**Best suited for:** Designers, writers, marketers, developers, or any user whose primary need is to use Qolaba's AI tools.
***
### Why Role Separation Matters
Clear role boundaries prevent accidental changes, reduce governance risk, and make accountability straightforward as organizations scale.
**Example — Marketing Agency:**
| Person | Role |
|---|
| Founder | Owner |
| Account & Project Managers | Admin |
| Designers, Copywriters, Strategists | Member |
# Inviting Members
Learn how to invite members, assign roles and workspaces, and manage access within your Organization.
Inviting a member adds them to your organization and grants them access to a specific workspace. The process takes under a minute — enter their email, assign a role, select a workspace, and send.
***
### Step-by-Step
1. Go to the **Members** tab in the Organization Dashboard.
2. Click **Invite Member**.
3. Enter the email address(es) of the person you want to invite.
* You can enter a single address or multiple addresses at once.
* Each address receives a separate invitation email.
4. Assign a **role** — Admin or Member. See [Member Roles Explained](/organization-and-workspaces/members-and-role-based-access/member-roles-explained) if you're unsure.
5. Select a **workspace** from the dropdown.
6. Send the invitation.
{% hint style="info" %}
The invited user must sign in using the exact email address they were invited with. Read more about [Member Activation Flow](/organization-and-workspaces/members-and-role-based-access/member-activation-flow)
{% endhint %}
***
### Workspace Assignment
Each member is assigned to exactly one workspace at the time of invitation. They will only have access to that workspace — nothing else in the organization is visible to them.
If your organization has multiple workspaces, double-check the assignment before sending. You can reassign a member to a different workspace later if needed.
***
### Managing Existing Members
Once a member is active, you can make the following changes from the **Members** tab:
1. **Change Role -** Promote a Member to Admin, or demote an Admin to Member. Role changes take effect immediately.
2. **Change Workspace -** Reassign a member to a different workspace when projects shift or teams reorganize.
3. **Revoke Access** - Removes the member from the organization immediately.
***
### What Happens After You Send the Invitation
* The invited user receives an email notifying them they've been added to your organization and workspace.
* They log in to Qolaba with the invited email address.
* They switch to the organization from their profile dropdown.
* Their status updates to **Active** in the Members tab.
* They can now use AI tools, with all credit usage tracked individually.
For a full walkthrough of the member's side of this process, see [Member Activation Flow ](/organization-and-workspaces/members-and-role-based-access/member-activation-flow)
# Member Activation Flow
Learn how invited members activate their access and join their assigned workspace within an Organization.
After an Admin or Owner sends an invitation, the new member needs to complete a short activation process to access their workspace. This page walks through exactly what they need to do.
***
### Step 1 — Log In with the Invited Email
The invited user receives an invitation email. To activate their access:
1. Go to [Qolaba](https://qolaba.ai).
2. Log in using the **same email address** that received the invitation.
If they don't already have a Qolaba account, they must create one using that exact email address. Access will not be granted if the login email doesn't match the invited email — there are no workarounds for this.
***
### Step 2 — Switch to the Organization
After logging in, the user lands in their personal account by default. To access the organization they were invited to:
1. Click the **profile icon** in the top-right corner.
2. Open the profile dropdown.
3. Select the name of the organization.
The platform switches from personal mode to organization mode. From this point:
* Credits are drawn from the organization's credit pool, not the user's personal balance.
* All activity is recorded within the organization's account.
* Workspace permissions apply.
***
### Step 3 — Access the Assigned Workspace
Once in organization mode, the member is placed directly into their assigned workspace. They can confirm this by checking the workspace name in the top-left of the navigation panel.
Inside the workspace, the member can:
* Use Chatbot
* Generate images
* Create videos
* Use speech tools
* View history for that workspace
**What they can see:**
* Their assigned workspace(s)
* Credits available within the organization
* Their accessible dashboard tabs (Overview, History)
**What they cannot see:**
* Other workspaces within the organization
* Organization management settings
* Member management controls
***
### Troubleshooting
| Issue | Likely Cause | Fix |
|---|
| Invitation email not received | Email in spam, or wrong address entered | Check spam folder; ask Admin to re-invite with correct email |
| Access denied after login | Logged in with a different email | Log out and log in with the invited email address |
| Organization not appearing in dropdown | Account not yet activated | Ensure login email matches invited email exactly |
| Wrong workspace visible | Assigned to incorrect workspace | Ask Admin to reassign via the Members tab |
# Tracking Credits and AI Usage
Monitor how AI credits are being consumed across your organization — broken down by workspace and by individual member.
You can access all usage data from **Dashboard → Members tab** or **Dashboard → Workspaces tab**.
***
#### Workspace-Level Usage
The **Workspaces tab** shows credit consumption for each workspace in your organization.
For each workspace, you can view credits used across:
| Usage Type | What It Tracks |
|---|
| Chat | Conversational AI interactions |
| Image | Image generation requests |
| Speech | Text-to-speech and voice output |
| Total | Combined usage across all types |
Usage is shown relative to the workspace's **allocated budget** (in Budget Mode) or drawn from the **shared organizational pool** (in Shared Pool Mode). If a workspace is approaching or has exhausted its allocation, it will be reflected here.
{% hint style="info" %}
Use workspace-level tracking to identify which projects are consuming the most credits and rebalance allocations if needed. See [Workspace Credit Allocation](/organization-and-workspaces/workspaces/workspace-credit-allocation) for how to transfer credits between workspaces.
{% endhint %}
***
#### Member-Level Usage
The **Members tab** shows AI usage per individual across your organization.
For each member, you can view:
| Usage Type | What It Tracks |
|---|
| Chat | AI chat sessions initiated by the member |
| Image | Image generation requests made by the member |
| Speech | Text-to-speech outputs generated by the member |
| Total | Sum of all usage types for that member |
This helps you spot high-usage individuals, ensure fair credit distribution, and hold team members accountable for their consumption.
***
#### Quick Reference
| Where to look | What you get |
|---|
| Dashboard → Workspaces tab | Credit usage per workspace vs. allocated budget |
| Dashboard → Members tab | Credit usage per individual member |
# Best Practices and Workflows
### 14.1 For Agencies
* Workspace per client
* Assign client-specific team members
### 14.2 For SMBs
* Workspace per department
### 14.3 For Consultants
* Workspace per engagement
### 14.4 For Freelancers
* Workspace per revenue stream
***
## Why This Structure Works
* Fully hierarchical
* Covers every tab and feature
* Separates role-based views
* Includes ICP use cases
* Scalable if features expand
* Layout-independent
* Enterprise-ready documentation
# Chatbot Models
A complete reference for all chatbot models available in Qolaba — context window, input and output credit costs, and best use cases organized by provider
Qolaba's Chatbot gives you access to 30+ large language models across six providers — all from a single interface. Each model has a different context window, credit cost, and area of strength. Use this page as a reference when selecting a model for a specific task.
***
### How to Read This Page
| Column | What It Means |
|---|
| Context Window | Maximum tokens the model can process in a single request — includes your prompt, conversation history, uploaded files, and the model's response. See Model Information Panel → for a detailed explanation of how context windows work. |
| Input Credits / 1K tokens | Credits consumed per 1,000 input tokens — your prompt, files, conversation history, and system instructions |
| Output Credits / 1K tokens | Credits consumed per 1,000 output tokens — the model's generated response, including thinking tokens if Thinking Depth is enabled |
{% hint style="info" %}
Models marked with ⭐ are available on **paid plans only**.
{% endhint %}
***
### Gemini Models
*Google*
Gemini models are Google's family of large language models — strong across long-context tasks, multimodal inputs, and general-purpose generation. The 1M token context window across most Gemini models makes them particularly well-suited for large document analysis, extended research sessions, and long conversations.
| Model | Context Window | Input Credits / 1K | Output Credits / 1K | Best For |
| ---------------------------- | -------------- | ------------------ | ------------------- | --------------------------------------------------------------------------------------- |
| **Gemini 2.5 Flash** | 1M | 0.08 | 0.65 | Fast, cost-efficient general tasks — everyday queries, summarization, quick drafts |
| **Gemini 2.5 Pro** | 1M | 0.33 | 0.39 | Balanced quality and cost — research, analysis, long-document processing |
| **Gemini 3 Flash Preview** | 1M | 0.13 | 0.78 | Fast generation with improved quality over 2.5 Flash — content drafting, quick analysis |
| **Gemini 3 Pro Preview** ⭐ | 1M | 0.52 | 3.12 | High-quality outputs — complex reasoning, detailed analysis, nuanced writing |
| **Gemini 3.1 Pro Preview** ⭐ | 1M | 1.04 | 4.68 | Highest quality Gemini output — advanced reasoning, complex multi-step tasks |
***
### Claude Models
*Anthropic*
Claude models are Anthropic's family of large language models — known for strong instruction following, nuanced writing quality, and reliable performance on long-form content. Claude models have a 200K context window, making them well-suited for detailed documents, complex briefs, and extended reasoning tasks.
| Model | Context Window | Input Credits / 1K | Output Credits / 1K | Best For |
| ----------------------- | -------------- | ------------------ | ------------------- | --------------------------------------------------------------------------------------- |
| **Claude Sonnet 4.6** ⭐ | 1M | 0.78 | 3.90 | Balanced quality and speed — writing, analysis, coding, general professional tasks |
| **Claude Opus 4.6** ⭐ | 200K | 1.30 | 6.50 | Premium quality — complex reasoning, detailed writing, nuanced instruction following |
| **Claude Opus 4.7** ⭐ | 200K | 1.30 | 6.50 | Latest Opus — advanced reasoning, high-complexity tasks, long-form professional content |
***
### OpenAI Models
*OpenAI*
OpenAI models span a wide range — from the most cost-efficient nano models for everyday tasks to advanced reasoning models for complex problem solving. The GPT and o-series models offer strong prompt comprehension, reliable structured output, and broad capability across coding, writing, and analysis.
| Model | Context Window | Input Credits / 1K | Output Credits / 1K | Best For |
| ------------------ | -------------- | ------------------ | ------------------- | --------------------------------------------------------------------------------------- |
| **GPT-4.1** ⭐ | 1M | 0.52 | 2.08 | General-purpose — reliable across writing, coding, analysis, and summarization |
| **GPT-4.1 Mini** | 1M | 0.10 | 0.42 | Cost-efficient general tasks — everyday queries, drafts, quick summaries |
| **GPT-5 Nano** | 128K | 0.03 | 0.10 | Most cost-effective OpenAI model — rapid iteration, high-volume simple tasks |
| **GPT-5 Mini** | 200K | 0.12 | 0.94 | Lightweight everyday tasks — content drafting, quick answers, basic analysis |
| **GPT-5.2** ⭐ | 200K | 0.46 | 3.64 | Balanced quality — professional writing, structured analysis, coding assistance |
| **GPT-5.2 Pro** ⭐ | 200K | 5.46 | 43.68 | Maximum GPT-5.2 capability — highest quality structured outputs, complex reasoning |
| **GPT-5.4** ⭐ | 272K | 0.65 | 3.90 | Strong general capability — detailed analysis, complex writing, multi-step tasks |
| **GPT-5.4 Mini** | 200K | 0.20 | 1.17 | Balanced speed and quality — content creation, moderate complexity tasks |
| **GPT-5.4 Nano** | 128K | 0.05 | 0.33 | Fast, low-cost iteration — simple tasks, drafts, quick queries |
| **GPT-5.5** ⭐ | 1M | 1.30 | 7.80 | Flagship GPT model — advanced reasoning, complex multi-step tasks, high-quality outputs |
| **OpenAI o1** ⭐ | 200K | 4.29 | 17.16 | Advanced reasoning — complex logic, math, coding, multi-step problem solving |
| **OpenAI o3** ⭐ | 200K | 0.52 | 2.08 | Strong reasoning at moderate cost — analytical tasks, structured problem solving |
| **OpenAI o4 Mini** | 200K | 0.29 | 1.14 | Cost-efficient reasoning — logic tasks, coding, analysis at lower credit cost |
***
### DeepSeek Models
*DeepSeek*
DeepSeek models deliver strong technical performance — particularly for coding, mathematical reasoning, and analytical tasks — at highly competitive credit costs. Well-suited for developer workflows and cost-sensitive high-volume use cases.
| Model | Context Window | Input Credits / 1K | Output Credits / 1K | Best For |
|---|
| DeepSeek V3.2 ⭐ | 131K | 0.07 | 0.10 | Cost-efficient general tasks — coding assistance, technical writing, analysis |
| DeepSeek V3.2 Speciale ⭐ | 128K | 0.07 | 0.10 | General-purpose tasks — everyday queries, content drafting, summarization |
| DeepSeek R1 ⭐ | 164K | 0.18 | 0.65 | Reasoning tasks — multi-step logic, math, structured problem solving |
***
### Grok Models
*xAI*
Grok models are xAI's family of large language models — built for fast, real-time responses with strong general capability. The 2M token context window makes Grok models the highest context capacity models available in Qolaba — suited for extremely long documents, large codebases, and extended multi-turn conversations.
| Model | Context Window | Input Credits / 1K | Output Credits / 1K | Best For |
| ------------------- | -------------- | ------------------ | ------------------- | ------------------------------------------------------------------------------------------------------------ |
| **Grok 4.1 Fast** ⭐ | 2M | 0.05 | 0.16 | Fast, cost-efficient responses — everyday tasks, quick analysis, real-time queries |
| **Grok 4.20** ⭐ | 2M | 0.52 | 1.56 | High-quality responses with maximum context — large document analysis, extended conversations, complex tasks |
***
### Perplexity Models
*Sonar*
Perplexity's Sonar models are purpose-built for web-grounded responses — all models have built-in internet search, delivering answers backed by live, up-to-date sources rather than training data alone. Best for research, fact-checking, competitive intelligence, and any query where current information matters.
| Model | Context Window | Input Credits / 1K | Output Credits / 1K | Best For |
| ------------------------- | -------------- | ------------------ | ------------------- | ------------------------------------------------------------------------------------------------ |
| **Sonar** | 127K | 0.26 | 0.26 | Fast web-grounded responses — general research, current events, quick fact-checking |
| **Sonar Pro** | 200K | 0.78 | 3.90 | Higher quality web-grounded responses — detailed research, in-depth analysis with live sources |
| **Sonar Reasoning Pro** ⭐ | 200K | 0.52 | 2.08 | Web-grounded reasoning — research tasks requiring logical analysis of live information |
| **Sonar Deep Research** ⭐ | 128K | 0.52 | 2.08 | Deep, multi-source research — comprehensive reports, competitive analysis, thorough fact-finding |
***
### Choosing the Right Model
With 30+ models available, here is a practical starting point for common use cases:
| Use Case | Recommended Model | Reason |
| ---------------------------------------- | ----------------------------------- | ------------------------------------------------ |
| **Everyday tasks and drafting** | Gemini 2.5 Flash or GPT-4.1 Mini | Low cost, reliable quality for standard tasks |
| **Professional writing and analysis** | Claude Sonnet 4.6 or GPT-5.2 | Strong writing quality and instruction following |
| **Complex reasoning and logic** | OpenAI o3 or DeepSeek R1 | Purpose-built for multi-step reasoning |
| **Advanced reasoning — maximum quality** | OpenAI o1 or Gemini 3.1 Pro Preview | Highest reasoning capability available |
| **Coding and technical tasks** | DeepSeek V3.2 or GPT-5.4 | Strong technical performance at competitive cost |
| **Research with live web data** | Sonar or Sonar Deep Research | Built-in web search for current, sourced answers |
| **Long document analysis** | Grok 4.20 or Gemini 2.5 Pro | 1M–2M context window for large inputs |
| **High-volume, cost-sensitive tasks** | GPT-5 Nano or Grok 4.1 Fast | Lowest credit cost per token |
| **Premium quality — best output** | GPT-5.5 or Claude Opus 4.7 | Flagship models for highest quality output |
# Image Models
A complete reference for all image generation models available in Qolaba — credit costs, quality options, generation limits, and best use cases organized by workflow type.
Qolaba provides access to a curated set of image generation models across text-to-image, image-to-image, and image editing workflows. Each model has distinct strengths, supported quality levels, credit costs, and generation limits. Use this page as a reference when selecting a model for your image generation task.
***
### How to Read This Page
| Column | What It Means |
| ------------------------ | ------------------------------------------------------------------- |
| **Credits / Image** | Credits consumed per generated image at the specified quality level |
| **Quality** | Supported resolution or quality tiers for that model |
| **Max Generations** | Maximum number of images producible in a single run |
| **Max Reference Images** | Maximum number of reference images uploadable (image-to-image only) |
{% hint style="info" %}
Models marked with ⭐ are available on **paid plans only**.
{% endhint %}
***
### Text-to-Image Models
Text-to-image models generate images from written prompts. Select based on the visual style, quality level, and credit budget required for your task.
#### **Flagship Models**
| Model | Quality | Credits / Image | Max Generations | Best For |
| --------------------- | ------- | --------------- | --------------- | ------------------------------------------------------------------------------------------ |
| **Nano Banana 2** | 0.5K | 15 | 4 | General-purpose generation — fast, versatile, strong quality across a wide range of styles |
| | 1K | 21 | | |
| | 2K | 32 | | |
| | 4K | 48 | | |
| **Nano Banana Pro** ⭐ | 1K / 2K | 42 | 4 | Premium quality — higher fidelity for demanding, production-ready outputs |
| | 4K | 75 | | |
***
#### **OpenAI Models**
GPT Image 2 uses quality tiers — **Low**, **Medium**, and **High** — instead of resolution values. These correspond to increasing levels of detail, prompt adherence, and visual fidelity:
* **Low** — fast generation, basic detail, suitable for drafts and concept testing
* **Medium** — balanced quality for most professional use cases
* **High** — maximum detail, photorealism, and prompt accuracy for final production output
| Model | Quality | Credits / Image | Max Generations | Best For |
| ----------------- | ------- | --------------- | --------------- | ------------------------------------------------------------------------------- |
| **GPT Image 2** ⭐ | Low | 4 | 8 | Photorealism, text-in-image, structured scenes with strong prompt comprehension |
| | Medium | 19 | | |
| | High | 69 | | |
***
#### **Google Models**
| Model | Quality | Credits / Image | Max Generations | Best For |
| ---------------------- | ------- | --------------- | --------------- | ---------------------------------------------------------------------------------- |
| **ImageGen 4** | 1K / 2K | 11 | 4 | General-purpose — Google's latest image model, strong all-rounder for varied tasks |
| **ImageGen 4 Fast** | 1K / 2K | 6 | 4 | Fast generation — quick iterations, draft testing, high-volume workflows |
| **ImageGen 4 Ultra** ⭐ | 1K / 2K | 16 | 4 | Maximum quality — highest fidelity tier from Google for production-ready output |
***
#### **Flux Models**
*Black Forest Labs*
| Model | Quality | Credits / Image | Max Generations | Best For |
| ---------------- | -------- | --------------- | --------------- | -------------------------------------------------------------------------------------------- |
| **Flux.2 Pro** ⭐ | Standard | 19 | 4 | Creative, high-fidelity generation — next-generation Flux model for detailed artistic output |
| **Flux.1 Dev** | Standard | 8 | 4 | Developer-friendly experimentation — open model, great for testing and creative exploration |
***
#### **ByteDance Models**
| Model | Quality | Credits / Image | Max Generations | Best For |
| ---------------- | -------- | --------------- | --------------- | ---------------------------------------------------------------------------------------------------- |
| **Seedream 4.5** | Standard | 13 | 6 | Creative and stylized images — ByteDance's flagship, exceptional for artistic and expressive outputs |
***
#### **Recraft Models**
| Model | Quality | Credits / Image | Max Generations | Best For |
| -------------- | -------- | --------------- | --------------- | ----------------------------------------------------------------------------------------------------- |
| **Recraft V4** | Standard | 13 | 4 | Design assets and icons — clean graphic design output, brand-consistent visuals, vector-style imagery |
***
### Image-to-Image Models
Image-to-image models accept one or more reference images to guide generation. Everything else — prompt, keywords, output controls — works the same as text-to-image. The reference images influence composition, style, subject, or structure of the output.
#### **Qolaba Flagship Models**
| Model | Quality | Credits / Image | Max Generations | Max Reference Images | Best For |
| --------------------- | ------- | --------------- | --------------- | -------------------- | -------------------------------------------------------------------------------------- |
| **Nano Banana 2** | 0.5K | 15 | 4 | 13 | General-purpose reference-guided generation — versatile, consistent quality |
| | 1K | 21 | | | |
| | 2K | 32 | | | |
| | 4K | 48 | | | |
| **Nano Banana Pro** ⭐ | 1K / 2K | 42 | 4 | 13 | Premium reference-guided generation — highest fidelity for brand and production assets |
| | 4K | 75 | | | |
***
#### **OpenAI Models**
| Model | Quality | Credits / Image | Max Generations | Max Reference Images | Best For |
|---|
| GPT Image 2 ⭐ | Low | 4 | 8 | 15 | Photorealistic transformations, text-in-image, strong prompt-guided reference editing |
| Medium | 19 | | | |
| High | 69 | | | |
***
#### **Flux Models**
| Model | Quality | Credits / Image | Max Generations | Max Reference Images | Best For |
| ---------------- | -------- | --------------- | --------------- | -------------------- | -------------------------------------------------------------------------------- |
| **Flux.2 Pro** ⭐ | Standard | 19 | 4 | 8 | Creative, high-fidelity style and content transformation with reference guidance |
***
### Image Editing Models
Image editing models are purpose-built tools used within the four editing workflows — Inpainting, Background Removal, Upscaling, and Image Variation. They run automatically based on the tool selected and are not manually chosen in the model selector.
| Model | Used For | What It Does |
| --------------------------- | -------------------- | --------------------------------------------------------------------------------------------------- |
| **BiRefNet V2** | Background Removal | One-click background removal — accurately detects and isolates the subject from any background |
| **Flux General Inpainting** | Inpainting & Cleanup | Mask-based editing — removes or replaces specific areas of an image based on a text prompt |
| **Nano Banana 2** | Image Variation | Generates creative variations inspired by uploaded reference images — up to 13 references supported |
***
### Model Comparison at a Glance
| Use Case | Recommended Model | Reason |
| ---------------------------------- | ---------------------------------- | -------------------------------------------------------------------------------- |
| **General-purpose generation** | Nano Banana 2 | Versatile, strong quality, lowest cost entry point for flagship output |
| **Premium production output** | Nano Banana Pro ⭐ | Highest fidelity for demanding, client-facing creative work |
| **Photorealism and text-in-image** | GPT Image 2 ⭐ | OpenAI's latest — best-in-class for photorealistic scenes and legible text |
| **Creative and artistic output** | Seedream 4.5 | Exceptional for stylized, expressive, and artistic image generation |
| **Design assets and icons** | Recraft V4 | Clean graphic design output with strong brand consistency |
| **Fast iteration and drafts** | ImageGen 4 Fast or Flux.1 Dev | Low cost, fast generation — ideal for prompt testing and concept exploration |
| **Maximum Google quality** | ImageGen 4 Ultra ⭐ | Google's highest quality tier for production-ready output |
| **Reference-guided generation** | Nano Banana 2 or Nano Banana Pro ⭐ | Up to 13 reference images — best for brand consistency and style matching |
| **Most reference images** | GPT Image 2 ⭐ | Supports up to 15 reference images per generation |
| **Background removal** | BiRefNet V2 (auto) | Best-in-class subject isolation — runs automatically via Background Removal tool |
| **Inpainting and cleanup** | Flux General Inpainting (auto) | Precise mask-based editing — runs automatically via Inpainting tool |
# Video Models
A complete reference for all video generation models available in Qolaba — credit costs by duration and resolution, supported features, limitations, and best use cases.
Qolaba provides access to 10+ video generation models — covering text-to-video, image-to-video, multi-reference guided generation, and AI-powered video editing. Credit costs vary by model, duration, and resolution. Use this page as a reference when selecting a model for your video generation task.
***
### How to Read This Page
| Column | What It Means |
|---|
| Credits | Credits consumed per video at the specified duration and resolution combination |
| Duration | Supported video lengths in seconds |
| Resolution | Supported output quality options |
| Reference Images | Whether the model accepts uploaded images as generation input |
| Audio Support | Whether the model supports AI-generated or uploaded audio |
{% hint style="info" %}
Models marked with ⭐ are available on **paid plans only**.
{% endhint %}
***
### **Google Veo Models**
Google's flagship video generation models — delivering cinematic quality, physics-accurate motion, and highly detailed environments.
#### **Veo 3.1** ⭐
| Duration | 720p / 1080p | 4K |
| -------- | ------------ | ----- |
| 4s | 416 | — |
| 6s | 624 | — |
| 8s | 832 | 1,248 |
#### **Veo 3.1 Fast**
| Duration | 720p / 1080p | 4K |
| -------- | ------------ | --- |
| 4s | 156 | — |
| 6s | 234 | — |
| 8s | 312 | 728 |
| Feature | Veo 3.1 | Veo 3.1 Fast |
| ---------------------- | ----------------------------------------------------------------- | ------------------------------------------------------------ |
| **Input** | Text-to-video, Image-to-video | Text-to-video, Image-to-video |
| **Default resolution** | 720p | 720p |
| **Max generations** | 4 | 4 |
| **Best for** | Cinematic quality, physics-accurate motion, detailed environments | Faster generation at lower cost — balanced speed and quality |
**Duration & Resolution Restrictions:**
| Condition | Allowed Durations |
| ----------------------------------------- | ----------------- |
| 720p + text-to-video (no reference image) | 4s, 6s, 8s |
| 720p + reference image (image-to-video) | 8s only |
| 1080p (any input) | 8s only |
| 4K (any input) | 8s only |
{% hint style="info" %}
4K is only available at 8 seconds duration for both Veo models.
{% endhint %}
***
### **Runway Models**
#### **Runway Gen-4.5** ⭐
Credits are calculated at 31.2 credits per second:
| Duration | Credits |
| -------- | ------- |
| 2s | 63 |
| 5s | 156 |
| 10s | 312 |
| Feature | Details |
| ----------------------- | --------------------------------------------------------------------------------- |
| **Input** | Text-to-video, Image-to-video |
| **Supported durations** | 2–10 seconds |
| **Output resolution** | 720p only |
| **Frame rate** | 24fps, 25fps |
| **Max generations** | 4 |
| **Best for** | Industry-leading production quality — reliable for commercial and branded content |
**Aspect Ratio Restrictions:**
| Input Mode | Supported Aspect Ratios |
| -------------- | ------------------------------- |
| Text-to-video | 16:9 only |
| Image-to-video | 16:9, 9:16, 1:1, 4:3, 3:4, 21:9 |
***
### **ByteDance Models**
**Seedance 2.0** and **Seedance 2.0 Fast** are ByteDance's flagship video models — distinguished by their multi-reference input capability, allowing up to 12 reference files (images, videos, and audio) to guide a single generation.
***
#### **Seedance 2.0** ⭐
| Feature | Details |
| ------------------------- | ---------------------------------------------------------------------------------------------------------------- |
| **Input** | Text-to-video, Image-to-video, Video-to-video |
| **Supported durations** | 4–15 seconds (or AI-determined if left blank) |
| **Supported resolutions** | 480p, 720p, 1080p |
| **Aspect ratios** | 16:9, 21:9, 9:16, 3:4, 1:1, 4:3 |
| **Max generations** | 4 |
| **Audio support** | AI-generated audio or uploaded audio |
| **Best for** | Cinematic quality with multi-reference guidance — brand-consistent generation combining images, video, and audio |
#### **Seedance 2.0 Fast** ⭐
| Feature | Details |
| ------------------------- | ------------------------------------------------------------------------ |
| **Input** | Text-to-video, Image-to-video, Video-to-video |
| **Supported durations** | 4–15 seconds |
| **Supported resolutions** | 480p, 720p |
| **Max generations** | 4 |
| **Audio support** | AI-generated audio or uploaded audio |
| **Best for** | Faster generation at lower cost — rapid prototyping and quick iterations |
**Reference Media Support (Both Seedance Models):**
| Media Type | Limit | Size Limit |
| --------------- | ----------------------- | --------------------------------------- |
| Images | Up to 9 | Max 30 MB each |
| Videos | Up to 3 | Combined 2–15 seconds, max 50 MB total |
| Audio | Up to 3 | Combined max 15 seconds, max 15 MB each |
| **Total files** | Max 12 across all types | — |
**How to Reference Uploads in Your Prompt:**
Use tags to tell the model exactly how to use each uploaded file:
* Images: `@Image1`, `@Image2`, etc.
* Videos: `@Video1`, `@Video2`, etc.
* Audio: `@Audio1`, `@Audio2`, etc.
**Example prompt:**
```
The person in @Image1 walks into a futuristic city
while @Audio1 plays softly in the background.
```
> **Note:** Audio cannot be uploaded without at least one image or video reference. Maximum 12 files total across all media types.
***
### **Happy Horse Models**
Happy Horse models are purpose-built for strong character consistency and advanced video editing — the only models in Qolaba that support AI-powered editing of existing video footage.
***
#### **Happy Horse (Generation)** ⭐
| Feature | Details |
| ------------------------- | --------------------------------------------------------------------------------- |
| **Input** | Text-to-video, Image-to-video |
| **Supported durations** | 3–15 seconds (default 5s) |
| **Supported resolutions** | 720p, 1080p (default 1080p) |
| **Aspect ratios** | 16:9, 9:16, 1:1, 4:3, 3:4 |
| **Max generations** | 4 |
| **Max reference images** | Up to 9 images |
| **Best for** | Multi-character video generation with consistent character identity across scenes |
**How Character References Work:** Upload images of your characters — the first uploaded image becomes `character1`, the second becomes `character2`, and so on up to `character9`. Reference them directly in your prompt:
```
A futuristic dance battle between character1 and character2
under neon lights.
```
***
#### **Happy Horse Video Edit** ⭐
Happy Horse Video Edit is a distinct capability from generation — it edits and transforms existing videos rather than creating new ones from scratch.
| Feature | Details |
| ----------------------------- | --------------------------------------------------------------------------------- |
| **Input** | Source video (required) + optional style images |
| **Supported resolutions** | 720p, 1080p |
| **Source video requirements** | MP4 or MOV, 3–60 seconds, under 100 MB, minimum 320px shortest side |
| **Max style images** | Up to 5 |
| **Audio options** | Keep original audio or regenerate with AI |
| **Max output length** | 15 seconds (longer videos are automatically trimmed) |
| **Best for** | Style transfer, element replacement, re-texturing or re-lighting existing footage |
**Example prompt:**
```
Replace the person's jacket with the red leather jacket
shown in @Image1, and make the sky look like a sunset.
```
> **Important:** Even if you upload a 60-second source video, the model processes and returns a maximum of 15 seconds of edited footage.
***
### **Minimax Models**
#### **Hailuo 2.3 Pro** ⭐
| Duration | Resolution | Credits |
| -------- | ---------- | ------- |
| 6s | 1080p | 128 |
| 10s | 768p | — |
| Feature | Details |
| -------------------- | ------------------------------------------------------------------------------- |
| **Input** | Text-to-video, Image-to-video |
| **Default duration** | 6 seconds |
| **Max generations** | 4 |
| **Best for** | Strong general-purpose video generation — reliable motion and scene consistency |
> **Note:** 10-second duration is only available at 768p resolution.
***
### **Kling Models**
*Kuaishou*
#### **Kling O3 Pro** ⭐
| Duration | Credits |
| -------- | ------- |
| 5s | 183 |
| 10s | 365 |
| 15s | 547 |
#### **Kling V3 Pro** ⭐
| Duration | Credits |
| -------- | ------- |
| 5s | 219 |
| 10s | 437 |
| 15s | 656 |
| Feature | Kling O3 Pro | Kling V3 Pro |
| ----------------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------- |
| **Input** | Text-to-video, Image-to-video | Text-to-video, Image-to-video |
| **Supported durations** | 3–15 seconds | 3–15 seconds |
| **Resolution** | 720p / 1080p | 720p / 1080p |
| **Max generations** | 4 | 4 |
| **Best for** | High quality, strong motion — reliable for short-form social and commercial content | Latest Kling generation — improved motion realism and visual detail |
***
### **Vidu Models**
#### **Vidu Q3 Turbo**
| Duration | 360p / 540p | 720p / 1080p |
| -------- | ----------- | ------------ |
| 4s | 37 | 81 |
| 8s | 73 | 161 |
| 16s | 146 | 321 |
| Feature | Details |
| ----------------------- | ---------------------------------------------------------------------------------------------------------- |
| **Input** | Text-to-video, Image-to-video |
| **Supported durations** | 1–16 seconds |
| **Max generations** | 4 |
| **Best for** | Fast and cost-effective generation — quick cuts, looping visuals, short transitions, high-volume iteration |
***
### **Luma Models**
#### **Luma Ray 2**
| Duration | 540p | 720p | 1080p |
| -------- | ---- | ---- | ----- |
| 5s | 130 | 260 | 520 |
| 9s | 234 | 468 | 936 |
| Feature | Details |
| ------------------- | --------------------------------------------------------------------------------------------------- |
| **Input** | Text-to-video, Image-to-video |
| **Max generations** | 4 |
| **Best for** | Cinematic quality with excellent prompt adherence — smooth motion and strong narrative storytelling |
***
### **xAI Models**
#### **Grok Imagine Video** ⭐
| Duration | 480p | 720p |
| -------- | ---- | ---- |
| 5s | 65 | 92 |
| 10s | 130 | 183 |
| 15s | 195 | 274 |
| Feature | Details |
| ----------------------- | --------------------------------------------------------------------------------------------- |
| **Input** | Text-to-video, Image-to-video |
| **Supported durations** | 1–15 seconds |
| **Max generations** | 4 |
| **Best for** | Cost-effective generation across extended durations — creative and experimental video content |
***
### Model Comparison at a Glance
| Use Case | Recommended Model | Reason |
| ---------------------------------------- | --------------------------------- | -------------------------------------------------------------------- |
| **Cinematic quality — maximum fidelity** | Veo 3.1 or Seedance 2.0 ⭐ | Google's flagship or ByteDance's premium model |
| **Fast generation — lower cost** | Veo 3.1 Fast or Seedance 2.0 Fast | Faster variants at reduced credit cost |
| **Multi-reference guided generation** | Seedance 2.0 ⭐ | Only model supporting up to 12 reference files (image, video, audio) |
| **Character-consistent generation** | Happy Horse ⭐ | Dedicated character reference system for multi-character scenes |
| **AI video editing** | Happy Horse Video Edit ⭐ | Only model supporting AI-powered editing of existing video footage |
| **Industry-leading production quality** | Runway Gen-4.5 ⭐ | Reliable for commercial and branded content |
| **Long-duration generation** | Kling O3 Pro or Kling V3 Pro ⭐ | Supports up to 15 seconds |
| **Highest context window** | Grok Imagine Video | Cost-effective across 1–15 second durations |
| **Fast, low-cost iteration** | Vidu Q3 Turbo | Lowest credit cost — good for drafts and quick concepts |
| **Smooth cinematic motion** | Luma Ray 2 | Excellent prompt adherence with cinematic quality |
| **Strong general-purpose** | Hailuo 2.3 Pro | Reliable motion and scene consistency |
# Speech Models
A complete reference for speech generation models in Qolaba — Gemini Flash TTS and Pro TTS, available voices, accent options, and best use cases.
Qolaba's Speech Generation is powered by **Google's Gemini TTS** — two models offering different trade-offs between speed, quality, and credit cost. Both models support single-speaker narration and multi-speaker dialogue generation with customizable voice, accent, and delivery style.
***
### Available Models
| Model | Speed | Quality | Best For |
| -------------------- | --------------- | ------------------------------------ | ------------------------------------------------------------------------ |
| **Gemini Flash TTS** | Fast | Good | Script drafting, quick iterations, testing voice and accent combinations |
| **Gemini Pro TTS** ⭐ | Slightly slower | Higher — more expressive and natural | Final production output, client-ready audio, publishing |
{% hint style="info" %}
Test your script, voice selection, and accent configuration with Flash TTS first. Switch to Pro TTS for the final generation only. This approach saves credits without compromising final output quality.
{% endhint %}
***
### Model Capabilities
Both models share the same core capabilities:
| Capability | Flash TTS | Pro TTS |
| ------------------------------ | ---------------- | ---------------- |
| **Single Speaker Mode** | ✓ | ✓ |
| **Multi-Speaker Mode** | ✓ | ✓ |
| **Voice library** | 30+ voices | 30+ voices |
| **Accent & dialect selection** | ✓ | ✓ |
| **Style instructions** | ✓ | ✓ |
| **Multi-language support** | ✓ | ✓ |
| **Max script length** | 5,000 characters | 5,000 characters |
***
### Voice Library
Both models provide access to a library of 30+ distinct voice profiles. Each voice has a unique combination of tone, pitch, energy, and speaking style. Click any voice in the interface to hear a preview before selecting.
**Available Voices**
| Voice | Character |
| ----------------- | ------------------------------ |
| **Zephyr** | Bright, clear, and energetic |
| **Puck** | Upbeat and playful |
| **Charon** | Informative and measured |
| **Kore** | Firm and confident |
| **Fenrir** | Excitable and expressive |
| **Aoede** | Smooth and warm |
| **Leda** | Youthful and approachable |
| **Orus** | Clear and neutral |
| **Schedar** | Gravelly and deep |
| **Gacrux** | Soft and gentle |
| **Pulcherrima** | Calm and composed |
| **Achird** | Conversational and natural |
| **Zubenelgenubi** | Professional and authoritative |
| **Vindemiatrix** | Storytelling and expressive |
| **Sadachbia** | Warm and personable |
| **Sadaltager** | Crisp and articulate |
| **Sulafat** | Rich and resonant |
{% hint style="info" %}
The full voice library is accessible directly in the [Speech Generation workspace](https://www.qolaba.ai/ai-speech-generator/text-to-speech). Click any voice name to preview it before selecting.
{% endhint %}
***
### Accent & Dialect Support
The output language is determined automatically by the language of your input script — write in any language and the audio is generated in that language. Accent selection refines pronunciation for languages with multiple regional dialects.
#### **Available Accents by Language**
| Language | Available Dialects |
| -------------- | ----------------------------------------------- |
| **English** | United States, United Kingdom, India, Australia |
| **French** | France, Canada |
| **Spanish** | Spain, Latin America |
| **Arabic** | Egypt, Global |
| **Mandarin** | China, Taiwan |
| **Hindi** | India |
| **Portuguese** | Brazil, Portugal |
| **German** | Germany, Austria |
| **Japanese** | Japan |
| **Korean** | Korea |
{% hint style="info" %}
The output language always follows the language of your input text. Accent selection narrows the regional dialect within that language — it does not override the language itself.
{% endhint %}
***
### Style Instructions
Both models support style instructions — a plain-language description of the desired delivery tone and manner entered in the **Style Prompt** field.
**Examples:**
| Intent | Style Instruction |
|---|
| Warm and conversational | "Speak warmly and conversationally, like talking to a friend" |
| Professional narration | "Clear, professional, and authoritative tone" |
| Energetic marketing | "Enthusiastic and high-energy delivery" |
| Calm instructional | "Calm, slow-paced, and easy to follow" |
| Storytelling | "Engaging narrative style with natural pauses and expression" |
***
### Flash TTS vs. Pro TTS — When to Use Each
#### **Use Flash TTS when:**
* Testing a new script for the first time
* Validating voice, accent, and style combinations before final generation
* Producing audio for internal use, drafts, or non-published content
* Working at high volume where credit efficiency matters
#### **Use Pro TTS when:**
* Generating final production audio for publishing
* Delivering client-ready voiceovers, ads, or podcast content
* The naturalness and expressiveness of the voice matters for the audience
* Multi-speaker dialogue needs to sound as realistic as possible
# Music Models
A detailed breakdown of all Music Generation models in Qolaba
Two AI models are available for Music Generation in Qolaba — each with different output length, supported formats, configuration options, and credit costs. Choosing the right model depends on whether you need a short clip or a full-length song, and how much control you want over the output structure.
***
#### Model Overview
| Model | Provider | Duration | Credits | Format | Lyrics |
| ----------------- | -------- | ------------ | ------- | -------- | ------ |
| **Lyria 3 Clip** | Google | \~30 seconds | 11 | MP3 | ✓ |
| **Lyria 3 Pro** ⭐ | Google | Full-length | 21 | MP3, WAV | ✓ |
***
#### Lyria 3 Clip
Lyria 3 Clip is Google's short-form music generation model — producing approximately 30-second high-fidelity clips from text or image prompts. It is the only model available to all users on free and paid plans.
**Capabilities:**
* Text and image prompt support
* Negative prompt support
* Seed support for reproducible output
* Lyrics generation
**Best for:**
* Social media clips and short-form content
* Background audio for videos and presentations
* Quick concept testing before committing to a full-length track
* Users on free plans who need music generation access
***
#### Lyria 3 Pro ⭐
Lyria 3 Pro is Google's full-length music generation model — producing multi-minute songs with complete structure including verses, choruses, and bridges. It is the most capable model for production-ready music output.
**Capabilities:**
* Text and image prompt support
* Negative prompt support
* Seed support for reproducible output
* Lyrics generation with time-sync support
* WAV format support for high-fidelity editing
**Best for:**
* Full-length songs for publishing, streaming, or client delivery
* Production-ready audio requiring WAV format
* Complete narrative songs with structured verses and choruses
* Professional music content creation
***
#### Configuration Options
**Instrumental Only**
Toggle on to generate music without vocals. Available across all models — useful for background tracks, soundscapes, and any content where vocals are not needed.
**Format Selection**
| Format | File Size | Best For |
| ------- | --------- | ---------------------------------------------- |
| **MP3** | Smaller | Sharing, social media, web use |
| **WAV** | Larger | High-fidelity editing, professional production |
{% hint style="info" %}
WAV is only available on Lyria 3 Pro. All other models output MP3 only.
{% endhint %}
**Negative Prompt**
Describe what to exclude from the generation — instruments, styles, tempos, or moods you do not want.
**Examples:**
```
No drums, no distortion, no fast tempo.
```
```
Avoid brass instruments, no vocals, no reverb.
```
**Seed**
Enter a number to make your generation reproducible. Using the same prompt, model, and seed number produces the same output every time — useful for iterating on a specific result or sharing a configuration with a collaborator.
**Magic Prompt**
One-click AI enhancement that rewrites your prompt into a more detailed, model-optimized version before generation.
* **Cost:** \~0.05 credits
* **Best for:** Short or underdeveloped prompts
***
#### Choosing the Right Model
| Need | Recommended Model |
| ------------------------ | ----------------------------- |
| Free plan access | Lyria 3 Clip |
| Quick 30-second clip | Lyria 3 Clip |
| Full-length song | Lyria 3 Pro ⭐ |
| WAV format output | Lyria 3 Pro ⭐ |
| Reference image guidance | Lyria 3 Clip or Lyria 3 Pro ⭐ |
| Most cost-efficient | Lyria 3 Clip (11 credits) |
# Introduction
An overview of the Qolaba Chatbot — what it is, who it's for, and a summary of everything it can do.
Qolaba's Chatbot is a multi-model AI assistant built for professional and team-based workflows. It goes beyond standard chat by combining access to multiple large language models, executable tools, custom agents, and knowledge-aware responses — all within your organization's workspace structure
### Who It's For
The Qolaba Chatbot is built for teams and individuals who need more than a basic AI chat interface:
* **Startups & Creators** — Rapid content generation, product documentation, growth experimentation
* **Marketing Teams** — Campaign ideation, ad copy, SEO drafts
* **Agencies** — Multi-client workspace management with shared credit pools
* **Developers** — Prompt engineering, model comparison, AI experimentation
* **Enterprises** — Structured AI collaboration with governance and audit trails
***
### Key Capabilities
Five capabilities make the Qolaba Chatbot distinct from a standard AI chat tool.
#### **1. Multi-LLM Access**
Most AI tools lock you into a single model. Qolaba gives you access to six leading large language models from one interface — **GPT, Gemini, Claude, DeepSeek, Grok, and Sonar (Perplexity)** — and lets you switch between them freely.
This means you can:
* Run the same prompt across multiple models and compare outputs
* Choose the best model for a specific task — creative writing, coding, research, summarization
* Optimize credit usage by matching task complexity to the right model
* Avoid being locked into one provider's strengths or limitations\
[Learn more about Model Selection →](/model-reference/chatbot-models)
***
#### **2. Agents**
Agents are purpose-built AI assistants that go beyond a one-off chat. Each agent has a defined **role, behavioral instructions, tone, and knowledge base** — so it responds consistently, stays on-topic, and understands your context without you re-explaining it every session.
Qolaba offers two types:
* **Pre-built agents** — Ready-to-use assistants for common roles like Marketing Strategist, Content Creator, and more. Select one and start immediately with no setup required.
* **Custom agents** — Build your own from scratch. Define the agent's name, role, model, expertise, and attach knowledge bases so it answers with your specific context in mind.
Agents are persistent, reusable across sessions, and can be shared within a workspace — making them especially valuable for teams with recurring workflows.
[Learn more about Agents →](/chatbot/agents)
***
#### **3. Toolkit**
The Toolkit turns the Chatbot from a conversational tool into an execution environment. Instead of just generating text, it can actively perform tasks — searching the web, generating media, running code, analyzing files, and more.
Tools can run in **Auto mode**, where Qolaba automatically selects the right tool based on your prompt, or you can enable them manually for full control.
Toolkit includes tools for web search, media generation, code execution, file and URL analysis, and output safety — covering most tasks a professional workflow demands, without leaving the chat interface.
[Learn more about the Toolkit →](/chatbot/toolkit)
***
#### **4. Knowledge Base & Files**
Uploading knowledge base and files lets you extend the chatbot's context with your own material — so it can answer questions, summarize content, and extract insights from documents that are specific to your work.
You can:
* **Upload files directly** into a chat — supported formats include PDF, CSV, Excel, and plain text
* **Create knowledge bases** — organized collections of files that any agent or chat session can reference persistently
This transforms the Chatbot from a generic assistant into a domain-aware one that understands your products, processes, and data.
[Learn more about Knowledge Bases & Files →](/chatbot/adding-context-and-resources)
***
#### **5. Chat Branching**
When a response isn't quite right, you don't need to start over or manually re-prompt. Chat Branching lets you **regenerate any response using a different model** at any point in a conversation — and compare outputs side-by-side across LLMs.
This is particularly useful for:
* Testing how different models interpret the same prompt
* Selecting the best response before using it in production
* Iterating on complex outputs like code, copy, or structured data without losing conversation context
[Learn more about Chat Branching →](/chatbot/model-selection/chat-branching)
***
#### Additional Features
The Chatbot also includes several supporting features covered in their own pages:
* [**Model Settings**](/chatbot/model-selection/model-settings) — Fine-tune Temperature and Thinking Depth to control response style and reasoning
* [**Chat Management**](/chatbot/chat-history-management) — Pin, rename, share, and delete conversations from your history
* [**Prompt Management**](/chatbot/prompt-and-controls) — Save, edit, and reuse prompts across chats and agents
***
#### What's Next
Follow the recommended flow to get started:
1. [Start a New Chat →](/chatbot/starting-a-new-chat)
2. [Select a model and configure settings →](/chatbot/model-selection)
3. [Set up an agent →](/chatbot/agents)
4. [Upload files or create a knowledge base →](/chatbot/adding-context-and-resources)
5. [Explore the Toolkit →](/chatbot/toolkit)
# Starting a New Chat
How to start a new chat in the Qolaba Chatbot, when to do it, and why managing context matters.
Each chat in Qolaba is an isolated conversation thread tied to your current workspace. Starting a new chat gives you a clean context, a fresh message thread, and no influence from previous conversations.
#### Creating a New Chat
1. Open your **Workspace** from the left navigation panel
2. Select **Chatbot**
3. Click **New Chat** in the top right
4. Enter your first prompt and send
A new conversation thread is created automatically, saved to your workspace history, and begins consuming credits from your first message.
***
#### How Conversation Context Works
Every chat maintains its own **context window** — a memory of everything said within that thread, including your prompts, AI responses, follow-up instructions, and any files attached during the session.
This allows the AI to:
* Build on earlier instructions without you repeating them
* Refine outputs progressively across multiple turns
* Handle complex, multi-step tasks within a single conversation
{% hint style="info" %}
Context is chat-specific. Starting a new chat resets conversational memory entirely. AI has no memory of previous chat sessions.
{% endhint %}
***
#### When to Start a New Chat
Start a new chat when you are:
* Switching to a different topic or task
* Working on a new client or project
* Deliberately isolating results from a previous session
{% hint style="info" %}
**Best practice:** One chat per objective. It keeps your history clean, your outputs traceable, and your context uncontaminated.
{% endhint %}
***
#### Resetting Context
The cleanest way to reset context is to **start a new chat**. This ensures the AI has no memory of earlier instructions, files, or outputs — giving you a reliable baseline for experimentation or benchmarking.
Carrying over unintended context can cause the AI to reference outdated instructions, produce inconsistent comparisons, or generate outputs biased by earlier constraints.
# Chat History Management
How to manage your chat history in Qolaba using pin, rename, share, and delete actions.
Every conversation in Qolaba is automatically saved to your workspace history. The three-dot menu **(⋮)** on any chat thread gives you full control over how conversations are organized, shared, and maintained — keeping your workspace clean and easy to navigate.
***
### Viewing Chat History
All conversations are saved automatically in **reverse chronological order** — most recent at the top. Pinned chats remain fixed at the top of the list regardless of newer activity below them.
***
### Searching Chat History
Use the **search bar** in the chat history panel to quickly locate any past conversation. You can search by chat title, keywords from your prompts, or keywords from AI responses. Results filter automatically as you type.
***
### Managing Chats
Hover over any chat in your history panel and click the **⋮ menu** to the right of the chat title to access all management actions.
***
#### **Pin Chat**
Pinning keeps a conversation fixed at the top of your history list, regardless of how many new chats are created after it. Use this for active projects, ongoing client work, threads with finalized outputs, or conversations containing prompts you return to regularly.
{% hint style="info" %}
**Best practice:** Pin only active or high-priority threads. Over-pinning reduces the benefit and clutters your history panel.
{% endhint %}
***
#### **Rename Chat**
Chat titles are auto-generated from your first prompt — which is rarely descriptive enough for a growing history. Renaming makes your conversations scannable, searchable, and easier to share with teammates.
**To rename a chat:**
1. Click the **⋮ menu** on the chat
2. Select **Rename Chat**
3. Enter a clear, descriptive title
4. Save
**Naming conventions that work well:**
* `Client A – Blog Draft`
* `Product Launch – Ad Copy`
* `GPT vs Claude – Benchmark Test`
* `Internal Strategy – Q2 Planning`
Good naming improves searchability, workspace organization, and collaboration — especially in shared workspaces with multiple team members.
***
#### **Share Chat**
Share Chat generates a **read-only link** to a snapshot of the conversation. This is useful for client approvals, internal reviews, handoffs, or documentation.
**To generate a shareable link:**
1. Click the **⋮ menu** on the chat
2. Select **Share Chat**
3. Copy the generated link and distribute it
The recipient can view the conversation content but cannot edit it, access workspace settings, or interact with your credits. Only the conversation itself is shared.
**To revoke access:**
1. Return to **Share Chat** on the same thread
2. Select **Revoke Link**
The link becomes invalid immediately — giving you full control over external visibility and client-specific access.
***
#### **Delete Chat**
Deleting a chat permanently removes it from your workspace history. Use this to clear outdated drafts, test prompts, failed experiments, or irrelevant threads.
{% hint style="info" %}
Once deleted, the conversation cannot be recovered. Credits already consumed during that session are not refunded.
{% endhint %}
# Adding Context and Resources
How to improve chatbot responses by providing your own context through file uploads and knowledge bases.
### How Context Works in Qolaba
When you attach a file or a Knowledge Base to a chat, Qolaba processes and indexes that content using **Retrieval-Augmented Generation (RAG)** — a technique that allows the AI to retrieve relevant sections from your documents and use them as grounded context before generating a response.
This means the model isn't guessing or relying solely on training data. It is actively reading your material and anchoring its responses to what you've provided.
Once a file is uploaded to a chat, the AI retains context of it **throughout the entire session** — you don't need to keep the file selected or re-attach it with every prompt. Your uploaded files are also logged against the chat, so when you return to a previous conversation, you can always see which documents were used.
This is particularly valuable when:
* Working with proprietary information the model was never trained on
* Asking domain-specific questions that require your internal documents
* Maintaining consistency across tasks that rely on the same reference material
* Reducing the need to manually re-explain context in every prompt
***
### Two Ways to Add Context
1. [**Uploading Files**](/chatbot/adding-context-and-resources/uploading-files) — Attach files directly to a conversation for immediate, session-specific context. Best for one-off tasks where you need the AI to reference a specific document in that chat.
2. [**Knowledge Bases**](/chatbot/adding-context-and-resources/knowledge-bases) — Build persistent, reusable collections of documents powered by an upgraded RAG system for more accurate document retrieval and deeper context understanding. Best for recurring workflows where the same material is referenced repeatedly across chats, agents, or team members.
***
#### Which One Should You Use?
| | File Upload | Knowledge Base |
| ---------------------------- | -------------------------------- | ---------------------------------------- |
| **Best for** | One-off context, quick reference | Recurring workflows, team-shared context |
| **Persists across chats?** | No — session only | Yes — reusable across any chat |
| **Supports multiple files?** | Yes | Yes |
| **Shareable with team?** | No | Yes |
| **RAG-powered retrieval?** | Yes | Yes — upgraded, more accurate |
***
### Best Practices
* **One context per task** — Attach only what is relevant to the current prompt. Overloading the AI with unrelated documents reduces retrieval accuracy and response quality.
* **Name your files clearly** — The AI uses file names as part of its context. `brand-guidelines-2026.pdf` is more useful than `document1.pdf`.
* **Use Knowledge Bases for anything recurring** — If you are uploading the same file across multiple chats, it belongs in a Knowledge Base.
* **Trim large files before uploading** — Remove irrelevant pages or sections before uploading. Smaller, focused files improve retrieval precision and consume fewer credits.
* **Combine both methods when needed** — You can attach a Knowledge Base for persistent background context and upload a session-specific file for the task at hand. Both will be referenced together.
* **Review context before sending** — For complex tasks, confirm the right files or Knowledge Base are attached before running a prompt to avoid wasted credits.
# Uploading Files
How to upload files into a Qolaba chat, supported formats, and how to view and manage your upload history.
Upload files directly into a chat to give the LLM immediate context for that session. Qolaba processes your uploaded content using **RAG (Retrieval-Augmented Generation)**, allowing the model to retrieve and reference relevant sections from your documents throughout the conversation.
***
### Supported File Types
| File Type | Common Use |
|---|
| PDF | Reports, research, documentation |
| CSV | Structured data, exports |
| Excel (.xlsx) | Spreadsheets, datasets |
| DOCX | Briefs, SOPs, brand guidelines |
| TXT | Notes, plain-text instructions |
| Images | Visual references, screenshots |
***
### Uploading a File to Chat
**Step 1 —** Open a chat in your workspace.
**Step 2 —** Click the **attachment icon** or the **Plus (+) icon** in the prompt input area.
**Step 3 —** Select your file from your system or drag and drop it into the chat.
**Step 4 —** Wait for the upload to complete. The file name appears in the input area confirming it is attached.
**Step 5 —** Enter your prompt and send. The LLM will reference the uploaded file when generating its response.
{% hint style="info" %}
Once uploaded, the file remains active as context for the **entire chat session** — you do not need to keep it selected or re-attach it with each prompt.
{% endhint %}
***
### Viewing and Managing Uploaded Files
All files uploaded across your workspace — from chat sessions, Knowledge Bases, and other activities — are stored centrally in the **Files section** of the left navigation panel. This acts as a single repository for all your uploaded resources, making it easy to track, preview, and reuse files without uploading them again.
**To access:**
1. Go to the **left navigation panel**
2. Click the **File icon**
Inside, you can view the complete history of uploaded files including PDFs, DOCX, TXT, images, CSV, and other supported types.
***
#### **Previewing a File**
Click the **file name** to open a preview. Use this to verify content before reusing a file in a new chat or Knowledge Base.
***
#### **Deleting a File**
Click the **Delete option** next to the file to remove it from your upload history.
{% hint style="info" %}
If the file is currently used inside a Knowledge Base, deleting it from upload history will affect that Knowledge Base. Review dependencies before deleting.
{% endhint %}
# Knowledge Bases
What Knowledge Bases are, why to use them, supported formats, and how to access them in Qolaba.
A Knowledge Base is a structured, reusable collection of documents that the AI references before generating responses in chat. Instead of copying information into prompts repeatedly, upload your documents once — PDFs, DOCX, TXT files, images, or URLs — and attach the Knowledge Base to any chat or agent whenever that context is needed.
Qolaba's Knowledge Base system is powered by an upgraded **RAG (Retrieval-Augmented Generation)** engine, delivering more accurate document retrieval and deeper context understanding compared to standard file uploads.
***
### Why Use Knowledge Bases?
* **Context-aware responses** — The AI answers based on your actual documents, not just training data
* **No repetitive uploads** — Upload once, reuse across any chat or agent indefinitely
* **Domain-specific accuracy** — Ask questions directly about your reports, SOPs, brand guidelines, or research
* **Team consistency** — Share the same Knowledge Base across workspace members so everyone gets aligned outputs
* **Credit efficiency** — Avoid re-uploading the same files across multiple sessions
***
#### Example
A social media agency creates a Knowledge Base named `Competitor Research – Q1 2026` and uploads:
* Competitor case studies (PDF)
* Content strategy documents (DOCX)
* Analytics reports (PDF)
* Brand tone guidelines (TXT)
When a team member asks *"Create a content strategy based on competitor positioning"*, the model retrieves relevant sections from the uploaded material and grounds its response in that research — automatically, without any copy-pasting.
***
### Supported File Formats & Limits
| File Type | Limit |
|---|
| PDF | Up to 1,000 pages / 200 MB |
| DOCX | Up to 1,000 pages / 200 MB |
| TXT | Up to 200 MB |
| Images | Max 20 MB per image |
| URLs | Max 20 URLs per Knowledge Base |
{% hint style="info" %}
Credits are consumed when uploading documents to a Knowledge Base. Credit deduction varies based on file size — larger files cost more to process.
{% endhint %}
***
#### Accessing Knowledge Bases
1. Go to the **left navigation panel**
2. Click the **Knowledge Base (File) icon**
This opens the Knowledge Base panel where you can view all existing Knowledge Bases or create a new one.
# Creating Knowledge Bases
Step-by-step guide to creating a Knowledge Base in Qolaba, uploading files, and selecting from your upload history.
#### Step 1 — Create a New Knowledge Base
1. Open the **Knowledge Base panel** from the left navigation panel
2. Click **Create New**
3. Enter a clear, descriptive name for your Knowledge Base — e.g., `Competitor Research – Q2 2026`
4. Click **Proceed**
***
#### Step 2 — Add Files
You will be prompted to add files immediately after creation. There are two ways to do this:
***
**Option A: Upload New Files**
Drag and drop files or click **Browse** to select from your system.
**Supported formats:** PDF, DOCX, TXT, Images
**Upload limits:**
| File Type | Limit |
| --------- | ---------------------------------- |
| Images | Max 20 MB per image |
| Documents | Max 1,000 pages or 200 MB per file |
> **Note:** Credits are consumed when uploading documents. Larger files cost more credits to process.
***
**Option B: Choose From Upload History**
Select previously uploaded files from your workspace without re-uploading them. Use the **Filter** option to narrow results by:
* Files
* URLs
* Images
**Selection limits:**
| Type | Limit |
| -------------- | ----------------- |
| Files and URLs | Max 20 selections |
| Images | Max 10 selections |
***
#### Step 3 — Review and Confirm
Once files are selected, they appear at the top of the selection panel. Remove any incorrect selections using the **✕ icon**, then click **Add to Knowledge Base**.
Your Knowledge Base is now created and ready to use in any chat.
# Managing Knowledge Bases
How to view, edit, update, and delete Knowledge Bases and the files within them.
#### Viewing Your Knowledge Bases
1. Go to the **left navigation panel**
2. Click the **Knowledge Base (File) icon**
This opens a list of all your created Knowledge Bases. Select any one to manage it.
***
#### Available Actions
When you select a Knowledge Base, three actions are available:
* **Add to Chat** — Attach the Knowledge Base to your current chat session
* **Edit** — Enter the internal view to modify the Knowledge Base
* **Delete** — Permanently remove the Knowledge Base
***
#### Editing a Knowledge Base
Click the **Navigation icon** on a selected Knowledge Base to enter its internal view. From here you can:
* Rename the Knowledge Base
* Add more files
* Remove existing files
* Select specific files to attach to chat
***
**Adding More Files**
1. Click **Add Files**
2. Choose **Add New** to upload from your system, or **Choose From History** to select previously uploaded files
3. Remove any outdated files if needed
4. Save changes
**Example:** Your agency completed Q2 competitor research. Inside the existing Knowledge Base, remove the Q1 analytics reports, add the Q2 updated reports, and keep the brand strategy documents unchanged — without rebuilding the Knowledge Base from scratch.
***
**Removing Files**
1. Click on the file inside the Knowledge Base
2. Select the **remove/delete** option
3. Save changes
Keep your Knowledge Base lean and relevant — outdated files reduce retrieval accuracy.
***
#### Deleting a Knowledge Base
1. Select the Knowledge Base from the panel
2. Click **Delete**
This permanently removes the Knowledge Base. Files stored in your upload history are not affected and remain in your workspace unless deleted separately.
# Using Knowledge Bases
How to attach a Knowledge Base to a chat session and add context directly from the prompt input area.
#### Method 1 — From the Knowledge Base Panel
1. Open the **Knowledge Base panel** from the left navigation
2. Select the Knowledge Base you want to use
3. Click **Add to Chat**
A file icon appears in the chat interface confirming the Knowledge Base is active. The AI will now retrieve and reference your uploaded documents before generating every response in that session.
**Example:** A product team has a Knowledge Base named `Product Launch – Q3 2026` containing their PRD, competitive landscape report, ICP research, and positioning document. They attach it to chat and prompt: `Draft a go-to-market messaging framework based on our positioning and competitive gaps.`
Instead of producing a generic framework, the model retrieves the relevant sections from the PRD and competitive report and builds the response directly from the team's actual strategy — not assumptions.
***
#### Method 2 — From the Chat Input Area
You can also attach or create a Knowledge Base without leaving the chat interface:
1. Click the **Plus (+) icon** in the prompt input area
2. Select **Create Knowledge Base** to build a new one, or **Upload Knowledge Base** to attach an existing one
***
#### Attaching the Full Knowledge Base vs. Specific Files
When adding a Knowledge Base to chat, you can choose how much of it to attach:
1. **Attach the entire Knowledge Base** when your task requires broad context — strategic planning, long-form analysis, or research-heavy prompts where multiple documents are relevant. The model references all uploaded files.
2. **Attach specific files only** when your task is focused and doesn't need the full collection. Inside the Knowledge Base, select only the files relevant to your current prompt and attach those to chat.
**Example:** Your Knowledge Base contains:
* Brand tone guide
* Three competitor teardowns
* Customer research report
* Six months of campaign performance data
If you are writing a single email campaign, attach only:
* Brand tone guide
* Most recent campaign performance data
Attaching the full Knowledge Base when only two files are relevant adds unnecessary context, reduces retrieval precision, and may produce less accurate responses.
# Prompt and Controls
Every response the AI generates starts with a prompt. The quality, specificity, and structure of what you write directly determines the usefulness of what you get back. Beyond writing prompts, Qolaba gives you tools to save and reuse them — so recurring workflows don't require starting from scratch every time.
***
#### What's in This Section
1. [**Writing Your Prompt**](/chatbot/prompt-and-controls/writing-your-prompt) **→** Learn how to structure prompts for better outputs — covering the four elements of an effective prompt, best practices for iteration, and how to use the **Mic icon** for quick voice input when typing isn't the fastest option.
2. [**Saved Prompts**](/chatbot/prompt-and-controls/saved-prompts) **→** Store prompts you use regularly and insert them into any chat with one click. Covers creating, editing, copying, and deleting saved prompts — and when to use them for maximum efficiency.
# Writing your Prompt
How to write clear, effective prompts in Qolaba — including structure, best practices, and voice input.
#### Prompt Structure
A well-structured prompt typically includes four elements:
| Element | What It Means |
| ----------------- | ------------------------------------- |
| **Objective** | What you want the AI to do |
| **Context** | Background, audience, or purpose |
| **Constraints** | Tone, length, format, or limitations |
| **Output format** | How the response should be structured |
**Example:**
Instead of:
```
Write a blog post.
```
Use:
```
Write a 600-word blog post about AI in retail.
Target audience: startup founders.
Tone: professional but conversational.
Include 3 subheadings and a short conclusion.
```
The second prompt gives the model everything it needs to produce a usable first draft — reducing back-and-forth and credit usage.
***
#### Best Practices
1. **Be specific** — Vague instructions produce vague outputs. Define exactly what you need.
2. **Provide context** — Mention the audience, purpose, background, or constraints relevant to the task.
3. **Define the output format** — Tell the model how to structure the response: bullet points, table, JSON, numbered list, paragraph, etc.
4. **Iterate rather than overload** — Start with a focused prompt and refine with follow-ups. Trying to cover everything in one prompt often produces unfocused responses.
5. **One objective per chat** — Start a new chat when switching to a completely different task. Mixing objectives in one thread affects context quality and output consistency.
***
#### Voice Input — Mic Icon
For quick or natural language input, use the **Mic icon** in the prompt input area. Click it and speak your prompt directly — Qolaba transcribes your speech into text, which you can review and edit before sending.
This is useful when:
* You want to describe a task naturally without typing out a structured prompt
* You are working quickly and want to capture an idea before refining it
* Typing a long, detailed prompt feels slower than speaking it
# Saved Prompts
How to create, manage, and use saved prompts in Qolaba for faster, more consistent workflows.
#### Accessing Saved Prompts
1. Go to the **left navigation panel**
2. Click the **Bookmark icon**
This opens your Saved Prompts library where you can view all existing prompts and create new ones.
***
#### Creating a Saved Prompt
1. Click **New Prompt**
2. Enter your prompt content
3. Save
The prompt appears in your library immediately and is ready to insert into any chat.
***
#### Managing Saved Prompts
**Editing a Prompt**
1. Locate the prompt in your library
2. Click **Edit**
3. Make your changes and click **Update**
**Deleting a Prompt**
1. Locate the prompt in your library
2. Click **Delete**
Deletion is permanent. The prompt is removed from your library immediately.
***
#### Using a Saved Prompt in Chat
**Insert into Chat**
1. Open **Saved Prompts** from the left navigation
2. Locate the prompt
3. Click **Add to Chat**
The prompt populates in your chat input field. Review and edit it if needed before sending.
**Copy a Prompt**
Click **Copy** on any saved prompt to copy it to your clipboard. Use this to reuse the prompt outside Qolaba or duplicate it as the basis for a new saved prompt.
***
#### What Saved Prompts Are Best For
* **Recurring task templates** — Weekly reports, content briefs, meeting summaries
* **Client-specific instructions** — Tone, format, and output requirements per client
* **Benchmarking prompts** — Consistent prompts used across model comparisons
* **Structured outputs** — Prompts that always require a specific format like JSON, tables, or outlines
# Model Selection
An overview of available model providers in Qolaba, their strengths and best use cases, and how to configure and compare models effectively.
Qolaba gives you access to multiple leading large language models from a single interface. Rather than being locked into one provider, you can choose the model that best fits your task — or switch between them to compare outputs.
***
#### Available Model Providers
Qolaba currently supports models from six providers. Each has distinct strengths — use this as a starting point when deciding which model to reach for:
| Provider | Models | Best For |
| ---------------------- | ------------------------------- | ---------------------------------------------------------------------------- |
| **GPT** (OpenAI) | GPT-4o, GPT-4.1, o3, and others | General use, coding, structured outputs, reasoning |
| **Gemini** (Google) | Gemini 2.0, 2.5 Pro and others | Long context tasks, multimodal (text + vision), document analysis |
| **Claude** (Anthropic) | Claude Sonnet, Opus and others | Writing quality, nuanced reasoning, long-form content, instruction following |
| **DeepSeek** | DeepSeek V3, R1 and others | Technical reasoning, coding, cost-efficient performance |
| **Grok** (xAI) | Grok 3, Grok 3 Mini and others | Real-time information, conversational tasks, creative writing |
| **Sonar** (Perplexity) | Sonar, Sonar Pro and others | Web-grounded responses, research, fact-heavy queries |
{% hint style="info" %}
For full model specs, context lengths, capabilities, and plan availability, see [Model Reference→](/model-reference/chatbot-models) section.
{% endhint %}
***
#### Free vs. Paid Models
Model availability depends on your plan. Some models are accessible on all plans; others are available on paid plans only. See [Model Reference →](/model-reference/chatbot-models) for a complete breakdown.
***
#### What's in This Section
1. [**Model Information Panel →**](/chatbot/model-selection/model-information-panel) Understand what each model's information card tells you — context length, capability indicators, and credit costs.
2. [**Model Settings →**](/chatbot/model-selection/model-settings) Control how a model thinks and responds using Thinking Depth and Temperature.
3. [**Chat Branching →**](/chatbot/model-selection/chat-branching) Regenerate any response with a different model and compare outputs side-by-side within the same conversation.
# Model Information Panel
Understanding Model Information Panel in Qolaba — covering context length, capability indicators, and credit usage transparency.
#### 5.2.1 Context Length
* Token capacity
* Impact on performance
#### 5.2.2 Feature Indicators
* Text capability
* Vision capability
* Advanced reasoning capability
#### 5.2.3 Credit Usage Transparency
* Input credits per 1K tokens
* Output credits per 1K tokens
* How credits are calculated
***
## Model Information Breakdown
### 5.2.1 Context Length
This section explains how much information a model can handle in a single request.
#### • Token Capacity
* A **token** is a small unit of text (roughly 3–4 characters in English).
* Token capacity = maximum number of tokens the model can process at once.
* Includes:
* User input
* System instructions
* Uploaded content
* Model output
**Example:**If a model supports 128K tokens, it can handle long documents, multi-step conversations, or large prompts in one go.
***
#### • Impact on Performance
Context length directly affects:
* **Memory** – Larger context = better understanding of long conversations.
* **Document handling** – Can process large PDFs, codebases, reports.
* **Cost** – Larger context models often cost more per request.
* **Latency** – Bigger context windows may slightly increase response time.
**In short:**More context = more capability, but potentially higher cost and slower responses.
***
### 5.2.2 Feature Indicators
This section visually highlights what the model is capable of.
#### • Text Capability
Indicates the model can:
* Generate content
* Summarize
* Translate
* Code
* Answer questions
Almost all LLMs support text capability.
***
#### • Vision Capability
Indicates the model can:
* Analyze images
* Extract text from images
* Describe visuals
* Interpret charts or diagrams
If enabled, the model is multimodal (text + image).
***
#### • Advanced Reasoning Capability
Indicates stronger:
* Logical reasoning
* Multi-step problem solving
* Math and coding accuracy
* Complex decision-making
These models are typically:
* Slower than lightweight models
* More expensive
* Higher accuracy for complex tasks
***
### 5.2.3 Credit Usage Transparency
This section explains how model usage is billed.
#### • Input Credits per 1K Tokens
Cost charged for:
* Prompt text
* Uploaded files
* System instructions
Calculated per 1,000 tokens of input.
***
#### • Output Credits per 1K Tokens
Cost charged for:
* The model’s generated response
Also calculated per 1,000 tokens.
## Why This Structure Matters
* Compare models quickly
* Choose based on performance vs cost
* Understand technical limits before usage
* Avoid unexpected credit consumption
# Model Settings
How to use Thinking Depth and Temperature in Qolaba to control reasoning effort, thinking tokens, and response creativity.
Model Settings let you control how a model thinks and responds. Two settings are available — **Thinking Depth** and **Temperature** — each affecting a different dimension of the output.
***
#### 1. Thinking Depth
Thinking Depth controls how much internal reasoning the model applies before generating a response. When enabled, the model works through a series of reasoning steps — called **thinking tokens** — before producing its final answer.
**What Are Thinking Tokens?**
Thinking tokens are the model's internal reasoning steps — the process it goes through to interpret your prompt, evaluate different approaches, and arrive at a well-considered response before replying. They are visible in the response so you can follow how the model reasoned through your request.
Thinking tokens are counted as **output tokens** and consume credits accordingly. The deeper the thinking level, the more reasoning steps the model takes, and the more credits are used.
Thinking tokens are most valuable for:
* Complex research and analysis
* Multi-step problem solving
* Strategy planning and decision-making
* Advanced coding and debugging
* Tasks where understanding *how* the model reasoned matters as much as the answer itself
**Thinking Depth Levels**
| Level | Reasoning Effort | Credit Usage | Best For |
| -------------- | -------------------------- | ------------ | ---------------------------------------------------------------------- |
| **None** | No thinking tokens | Lowest | Simple Q\&A, formatting, short rewrites |
| **Low** | Minimal reasoning | Low | Basic content writing, casual prompts |
| **Medium** | Balanced reasoning | Moderate | Blog writing, coding assistance, structured business tasks |
| **High** | Deep, multi-step reasoning | High | Complex coding, strategy planning, analytical writing |
| **Extra High** | Maximum reasoning effort | Highest | Advanced research, long-form reasoning chains, complex problem solving |
***
#### 2. Temperature
Temperature controls how creative or predictable the model's responses are — specifically, the randomness applied when the model selects words and constructs its response. In Qolaba, Temperature is set on a scale of **0 to 100**.
* **0** — Fully deterministic. The model picks the most probable word at every step. Responses are consistent, precise, and repeatable.
* **100** — Maximum randomness. The model explores less probable word choices, producing more varied, creative, and sometimes unexpected outputs.
| Range | Output Style | Best For |
|---|
| 0 – 30 | Focused, deterministic, factual | Coding, legal drafts, data analysis, structured outputs (JSON, tables) |
| 40 – 60 | Balanced, natural, controlled | Blog posts, marketing copy, email drafts, general writing |
| 70 – 100 | Creative, varied, less predictable | Storytelling, brainstorming, ad copy, brand naming, ideation |
***
#### Recommended Combinations
| Thinking Depth | Temperature | Output Type |
|---|
| High | 0 – 30 | Precise and structured — technical reports, competitive analysis, complex coding |
| Medium | 40 – 60 | Balanced and reliable — business writing, content drafts, professional communication |
| Low | 70 – 100 | Fast and creative — brainstorming, ideation, headline generation, ad variations |
**Examples:**
* Writing a detailed strategy document → **High Thinking Depth + Temperature 10–20**
* Generating 10 creative campaign name ideas → **Low Thinking Depth + Temperature 80–90**
# Chat Branching
### **What Is It?**
Chat Branching transforms the standard linear chat experience into a dynamic, multi-model conversation workspace. Users can regenerate any AI response using a different language model and continue the conversation from the reply they prefer.
This feature is a **model comparison and education tool**, enabling users to explore how different LLMs think, reason, and communicate side by side, all within the same chat interface.
{% embed url="" %}
***
### **Why It Matters**
Each language model has unique strengths—some excel at creative writing, others at analytical reasoning or concise summarization. Traditional chat interfaces lock users into one model per conversation, making it hard to compare responses.
Chat Branching removes this limitation. By allowing multiple regenerations of the same message, users can:
* **Compare response quality** across models for the same prompt.
* **Identify model strengths** for specific tasks (e.g., coding, analysis, creative writing).
* **Build intuition** about model behavior, improving their ability to choose the right tool.
* **Explore alternative reasoning paths** without losing the original conversation flow.
* **Continue conversations** from any alternative response, pursuing the most promising line of thought.
This is a user-facing feature designed to help everyday users become more informed and effective AI consumers.
# How it Works ?
#### **Step 1: Have a Conversation**
Start a normal chat. Each assistant message is tagged with the model that generated it (e.g., "GPT-4.1", "Claude Sonnet 4.6"), so users always know which model they're interacting with.
#### **Step 2: Regenerate with a Different Model (Branching)**
Users can regenerate any assistant response using a different model. This creates a **branch**—an alternative response to the same question. The branch appears inline alongside the original, allowing users to compare them.
Users can generate up to **5 branches per message**, building a collection of responses from different models. For example:
| Branch | Model | Why |
|---|
| Original | GPT-4.1 | Default response |
| Branch 2 | Claude Sonnet 4.6 | Different writing style |
| Branch 3 | Gemini 2.5 Pro | Compare Google's approach |
| Branch 4 | DeepSeek R1 | Reasoning-focused model |
| Branch 5 | Grok 4 | Another perspective |
Each branch is clearly labeled with its model for easy comparison.
#### **Step 3: Continue from a Branch (Forking)**
After comparing branches, users can continue the conversation from any branch. This creates a **fork**—a new thread that picks up from the selected branch. The original thread remains intact, allowing users to revisit or explore other branches.
Forks can be nested up to **5 levels deep**, enabling exploratory conversation trees.
***
#### **Per-Message Branch Indicators**
Messages with branches display a count of alternative responses (e.g., "1 of 4"). Each response shows:
* **Model name** (with logo).
* **Token usage** (response cost).
* **Reasoning content** (if supported by the model).
#### **Thread Sidebar**
Forked threads are **hidden from the main list** to keep the sidebar clean. They are accessible through the parent thread's conversation tree view.
#### **Full Conversation Tree**
The `/full` endpoint displays the entire conversation tree, showing where branches and forks occurred.
---
[Next Page](/llms-full.txt/1)