How to deploy AI21's Jamba family models with Azure AI Studio

In this article, you learn how to use Azure AI Studio to deploy AI21's Jamba family models as a serverless API with pay-as-you-go billing.

The Jamba family models are AI21's production-grade Mamba-based large language model (LLM) which leverages AI21's hybrid Mamba-Transformer architecture. It's an instruction-tuned version of AI21's hybrid structured state space model (SSM) transformer Jamba model. The Jamba family models are built for reliable commercial use with respect to quality and performance.

Deploy the Jamba family models as a serverless API

Certain models in the model catalog can be deployed as a serverless API with pay-as-you-go billing, providing a way to consume them as an API without hosting them on your subscription, while keeping the enterprise security and compliance organizations need. This deployment option doesn't require quota from your subscription.

Prerequisites

• An Azure subscription with a valid payment method. Free or trial Azure subscriptions won't work. If you don't have an Azure subscription, create a paid Azure account to begin.

• An AI Studio hub. The serverless API model deployment offering for Jamba family models is only available with hubs created in these regions:

  • East US
  • East US 2
  • North Central US
  • South Central US
  • West US
  • West US 3
  • Sweden Central

  For a list of regions that are available for each of the models supporting serverless API endpoint deployments, see Region availability for models in serverless API endpoints.

• An Azure AI Studio project.

• Azure role-based access controls (Azure RBAC) are used to grant access to operations in Azure AI Studio. To perform the steps in this article, your user account must be assigned the owner or contributor role for the Azure subscription. Alternatively, your account can be assigned a custom role that has the following permissions:

  • On the Azure subscription—to subscribe the AI Studio project to the Azure Marketplace offering, once for each project, per offering:

    • Microsoft.MarketplaceOrdering/agreements/offers/plans/read
    • Microsoft.MarketplaceOrdering/agreements/offers/plans/sign/action
    • Microsoft.MarketplaceOrdering/offerTypes/publishers/offers/plans/agreements/read
    • Microsoft.Marketplace/offerTypes/publishers/offers/plans/agreements/read
    • Microsoft.SaaS/register/action

  • On the resource group—to create and use the SaaS resource:

    • Microsoft.SaaS/resources/read
    • Microsoft.SaaS/resources/write

  • On the AI Studio project—to deploy endpoints (the Azure AI Developer role contains these permissions already):

    • Microsoft.MachineLearningServices/workspaces/marketplaceModelSubscriptions/*
    • Microsoft.MachineLearningServices/workspaces/serverlessEndpoints/*

  For more information on permissions, see Role-based access control in Azure AI Studio.

Create a new deployment

These steps demonstrate the deployment of AI21 Jamba 1.5 Large or AI21 Jamba 1.5 Mini models. To create a deployment:

1. Sign in to Azure AI Studio.

2. Select Model catalog from the left sidebar.

3. Search for and select a AI21 model like AI21 Jamba 1.5 Large or AI21 Jamba 1.5 Mini or AI21 Jamba Instruct to open its Details page.

4. Select Deploy to open a serverless API deployment window for the model.

5. Alternatively, you can initiate a deployment by starting from your project in AI Studio.

   1. From the left sidebar of your project, select Components > Deployments.

   2. Select + Create deployment.

   3. Search for and select a AI21 model like AI21 Jamba 1.5 Large or AI21 Jamba 1.5 Mini or AI21 Jamba Instruct to open the Model's Details page.

   4. Select Confirm to open a serverless API deployment window for the model.

6. Select the project in which you want to deploy your model. To deploy the AI21-Jamba family models, your project must be in one of the regions listed in the Prerequisites section.

7. In the deployment wizard, select the link to Azure Marketplace Terms, to learn more about the terms of use.

8. Select the Pricing and terms tab to learn about pricing for the selected model.

9. Select the Subscribe and Deploy button. If this is your first time deploying the model in the project, you have to subscribe your project for the particular offering. This step requires that your account has the Azure subscription permissions and resource group permissions listed in the Prerequisites. Each project has its own subscription to the particular Azure Marketplace offering of the model, which allows you to control and monitor spending. Currently, you can have only one deployment for each model within a project.

10. Once you subscribe the project for the particular Azure Marketplace offering, subsequent deployments of the same offering in the same project don't require subscribing again. If this scenario applies to you, there's a Continue to deploy option to select.

11. Give the deployment a name. This name becomes part of the deployment API URL. This URL must be unique in each Azure region.

12. Select Deploy. Wait until the deployment is ready and you're redirected to the Deployments page.

13. Return to the Deployments page, select the deployment, and note the endpoint's Target URL and the Secret Key. For more information on using the APIs, see the Reference section.

14. You can always find the endpoint's details, URL, and access keys by navigating to your Project overview page. Then, from the left sidebar of your project, select Components > Deployments.

To learn about billing for the AI21-Jamba family models deployed as a serverless API with pay-as-you-go token-based billing, see Cost and quota considerations for Jamba Instruct deployed as a serverless API.

Consume Jamba family models as a serverless API

You can consume Jamba family models as follows:

1. From your Project overview page, go to the left sidebar and select Components > Deployments.

2. Find and select the deployment you created.

3. Copy the Target URL and the Key value.

4. Make an API request.

For more information on using the APIs, see the reference section.

Reference for Jamba family models deployed as a serverless API

Jamba family models accept both of these APIs:

• The Azure AI Model Inference API on the route /chat/completions for multi-turn chat or single-turn question-answering. This API is supported because Jamba family models are fine-tuned for chat completion.
• AI21's Azure Client. For more information about the REST endpoint being called, visit AI21's REST documentation.

Azure AI model inference API

The Azure AI model inference API schema can be found in the reference for Chat Completions article and an OpenAPI specification can be obtained from the endpoint itself.

Single-turn and multi-turn chat have the same request and response format, except that question answering (single-turn) involves only a single user message in the request, while multi-turn chat requires that you send the entire chat message history in each request.

In a multi-turn chat, the message thread has the following attributes:

• Includes all messages from the user and the model, ordered from oldest to newest.
• Messages alternate between user and assistant role messages
• Optionally, the message thread starts with a system message to provide context.

The following pseudocode is an example of the message stack for the fourth call in a chat request that includes an initial system message.

[
    {"role": "system", "message": "Some contextual information here"},
    {"role": "user", "message": "User message 1"},
    {"role": "assistant", "message": "System response 1"},
    {"role": "user", "message": "User message 2"},
    {"role": "assistant"; "message": "System response 2"},
    {"role": "user", "message": "User message 3"},
    {"role": "assistant", "message": "System response 3"},
    {"role": "user", "message": "User message 4"}
]

AI21's Azure client

Use the method POST to send the request to the /v1/chat/completions route:

Request

POST /v1/chat/completions HTTP/1.1
Host: <DEPLOYMENT_URI>
Authorization: Bearer <TOKEN>
Content-type: application/json

Request schema

Payload is a JSON formatted string containing the following parameters:

The messages object has the following fields:

• role: [string, required] The author or purpose of the message. One of the following values:
  • user: Input provided by the user. Any instructions given here that conflict with instructions given in the system prompt take precedence over the system prompt instructions.
  • assistant: A response generated by the model.
  • system: Initial instructions to provide general guidance on the tone and voice of the generated message. An initial system message is optional, but recommended to provide guidance on the tone of the chat. For example, "You are a helpful chatbot with a background in earth sciences and a charming French accent."
• content: [string, required] The content of the message.

The tool object has the following fields:

• type (required; str) - The type of the tool. Currently, only "function" is supported.
• function (required; object) - The function details.
  • name (required; str) - The name of the function to be called.
  • description (optional; str) - A description of what the function does.
  • parameters (optional; object) - The parameters the function accepts, described as a JSON Schema object.

The document object has the following fields:

• id (optional; str) - unique identifier. will be linked to in citations. up to 128 characters.
• content (required; str) - the content of the document
• metadata (optional; array of Metadata)
  • key (required; str) - type of metadata, like ‘author’, ‘date’, ‘url’, etc. Should be things the model understands.
  • value (required; str) - value of the metadata

Request example

Single-turn example Jamba 1.5 large and Jamba 1.5 mini

{
   "model":"jamba-1.5-large",  <jamba-1.5-large|jamba-1.5-mini>
   "messages":[
      {
         "role":"user",
         "content":"I need help with your product. Can you please assist?"
      }
   ],
   "temperature":1,
   "top_p":1,
   "n":1,
   "stop":"\n",
   "stream":false
}

Single-turn example Jamba 1.5 large and Jamba 1.5 mini with documents

{
   "model":"jamba-1.5-large",  <jamba-1.5-large|jamba-1.5-mini>
   "messages":[
      {
         "role":"system",
         "content":'''<documents>
          # Documents

          You can use the following documents for reference:

          ## Document ID: 0
          Text: Harry Potter is a series of seven fantasy novels written by British author J. K. Rowling.

          ## Document ID: 1
          Text: The Great Gatsby is a novel by American writer F. Scott Fitzgerald.
          </documents>'''},

       {
           "role":"user",
           "content":"Who wrote Harry Potter?"
       }
   ],
   "temperature":0.4,
   "top_p":1,
   "n":1,
   "stop":"\n",
   "stream":false
}

Chat example (fourth request containing third user response)

{
  "model": "jamba-instruct",
  "messages": [
     {"role": "system",
      "content": "You are a helpful genie just released from a bottle. You start the conversation with 'Thank you for freeing me! I grant you one wish.'"},
     {"role":"user",
      "content":"I want a new car"},
     {"role":"assistant",
      "content":"🚗 Great choice, I can definitely help you with that! Before I grant your wish, can you tell me what kind of car you're looking for?"},
     {"role":"user",
      "content":"A corvette"},
     {"role":"assistant",
      "content":"Great choice! What color and year?"},
     {"role":"user",
      "content":"1963 black split window Corvette"}
  ],
  "n":3
}

Response schema

The response depends slightly on whether the result is streamed or not.

In a non-streamed result, all responses are delivered together in a single response, which also includes a usage property.

In a streamed result,

• Each response includes a single token in the choices field.
• The choices object structure is different.
• Only the last response includes a usage object.
• The entire response is wrapped in a data object.
• The final response object is data: [DONE].

The response payload is a dictionary with the following fields.

The choices response object contains the model-generated response. The object has the following fields:

The message response object contains the model-generated response. The object has the following fields:

The tool_calls response object contains the model-generated response. The object has the following fields:

The function response object contains the model-generated response. The object has the following fields:

The usage response object contains the following fields.

Non-streaming response example

{
  "id":"cmpl-524c73beb8714d878e18c3b5abd09f2a",
  "choices":[
    {
      "index":0,
      "message":{
        "role":"assistant",
        "content":"The human nose can detect over 1 trillion different scents, making it one of the most sensitive smell organs in the animal kingdom."
      },
      "finishReason":"stop"
    }
  ],
  "created": 1717487036,
  "usage":{
    "promptTokens":116,
    "completionTokens":30,
    "totalTokens":146
  }
}

Streaming response example

data: {"id": "cmpl-8e8b2f6556f94714b0cd5cfe3eeb45fc", "choices": [{"index": 0, "delta": {"role": "assistant"}, "created": 1717487336, "finish_reason": null}]}
data: {"id": "cmpl-8e8b2f6556f94714b0cd5cfe3eeb45fc", "choices": [{"index": 0, "delta": {"content": ""}, "created": 1717487336, "finish_reason": null}]}
data: {"id": "cmpl-8e8b2f6556f94714b0cd5cfe3eeb45fc", "choices": [{"index": 0, "delta": {"content": " The"}, "created": 1717487336, "finish_reason": null}]}
data: {"id": "cmpl-8e8b2f6556f94714b0cd5cfe3eeb45fc", "choices": [{"index": 0, "delta": {"content": " first e"}, "created": 1717487336, "finish_reason": null}]}
data: {"id": "cmpl-8e8b2f6556f94714b0cd5cfe3eeb45fc", "choices": [{"index": 0, "delta": {"content": "mpe"}, "created": 1717487336, "finish_reason": null}]}
... 115 responses omitted for sanity ...
data: {"id": "cmpl-8e8b2f6556f94714b0cd5cfe3eeb45fc", "choices": [{"index": 0, "delta": {"content": "me"}, "created": 1717487336, "finish_reason": null}]}
data: {"id": "cmpl-8e8b2f6556f94714b0cd5cfe3eeb45fc", "choices": [{"index": 0, "delta": {"content": "."}, "created": 1717487336,"finish_reason": "stop"}], "usage": {"prompt_tokens": 107, "completion_tokens": 121, "total_tokens": 228}}
data: [DONE]

Cost and quotas

Cost and quota considerations for Jamba family models deployed as a serverless API

The Jamba family models are deployed as a serverless API and is offered by AI21 through Azure Marketplace and integrated with Azure AI studio for use. You can find Azure Marketplace pricing when deploying or fine-tuning models.

Each time a workspace subscribes to a given model offering from Azure Marketplace, a new resource is created to track the costs associated with its consumption. The same resource is used to track costs associated with inference and fine-tuning; however, multiple meters are available to track each scenario independently.

For more information on how to track costs, see Monitor costs for models offered through the Azure Marketplace.

Quota is managed per deployment. Each deployment has a rate limit of 200,000 tokens per minute and 1,000 API requests per minute. However, we currently limit one deployment per model per project. Contact Microsoft Azure Support if the current rate limits aren't sufficient for your scenarios.

Content filtering

Models deployed as a serverless API are protected by Azure AI content safety. With Azure AI content safety enabled, both the prompt and completion pass through an ensemble of classification models aimed at detecting and preventing the output of harmful content. The content filtering system detects and takes action on specific categories of potentially harmful content in both input prompts and output completions. Learn more about Azure AI Content Safety.

Related content

• What is Azure AI Studio?
• Azure AI FAQ article
• Region availability for models in serverless API endpoints