> ## Documentation Index
> Fetch the complete documentation index at: https://docs.portkey.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Azure AI Foundry

> Learn how to integrate Azure AI Foundry with Portkey to access a wide range of AI models with enhanced observability and reliability features.

Azure AI Foundry provides a unified platform for enterprise AI operations, model building, and application development. With Portkey, you can seamlessly integrate with various models available on Azure AI Foundry and take advantage of features like observability, prompt management, fallbacks, and more.

## Understanding Azure AI Foundry Deployments

Azure AI Foundry offers three different ways to deploy models, each with unique endpoints and configurations:

1. **AI Services**: Azure-managed models accessed through Azure AI Services endpoints
2. **Managed**: User-managed deployments running on dedicated Azure compute resources
3. **Serverless**: Seamless, scalable deployment without managing infrastructure

You can learn more about the Azure AI Foundry deployment [here](https://learn.microsoft.com/en-us/azure/ai-foundry/concepts/deployments-overview).

<Card href="/integrations/llms/azure-openai" title="Azure OpenAI">
  If you're specifically looking to use OpenAI models on Azure, you might want to use [Azure OpenAI](/integrations/llms/azure-openai) instead, which is optimized for OpenAI models.
</Card>

## Integrate

To integrate Azure AI Foundry with Portkey, you'll need to create a virtual key. Virtual keys securely store your Azure AI Foundry credentials in Portkey's vault, allowing you to use a simple identifier in your code instead of handling sensitive authentication details directly.

Navigate to the [Virtual Keys](https://app.portkey.ai/virtual-keys) section in Portkey and select "Azure AI Foundry" as your provider.

## Creating Your Virtual Key

You can create a virtual key for Azure AI Foundry using one of three authentication methods. Each method requires different information from your Azure deployment:

<Tabs>
  <Tab title="Default (API Key)">
    The recommended authentication mode using API Keys:

    Required parameters:

    * **API Key**: Your Azure AI Foundry API key

    * **Azure Foundry URL**: The base endpoint URL for your deployment, formatted according to your deployment type:
      * For AI Services: `https://your-resource-name.services.ai.azure.com/models`
      * For Managed: `https://your-model-name.region.inference.ml.azure.com/score`
      * For Serverless: `https://your-model-name.region.models.ai.azure.com`

    * **Azure API Version**: The API version to use (e.g., "2024-05-01-preview"). This is required if you have api version in your deployment url. For example:
      * If your URL is `https://mycompany-ai.westus2.services.ai.azure.com/models?api-version=2024-05-01-preview`, the API version is `2024-05-01-preview`

    * **Azure Deployment Name**: (Optional) Required only when a single resource contains multiple deployments.

    <Frame>
      <img src="https://mintcdn.com/portkey-docs/PaRorqtknQiAf2YW/images/product/azure-1.png?fit=max&auto=format&n=PaRorqtknQiAf2YW&q=85&s=6850859958b1c9cd2f229b78a725ea43" alt="Default Authentication Setup" width="2000" height="1941" data-path="images/product/azure-1.png" />
    </Frame>
  </Tab>

  <Tab title="Azure Managed Entity">
    For managed Azure deployments:

    Required parameters:

    * **Azure Managed ClientID**: Your managed client ID

    * **Azure Foundry URL**: The base endpoint URL for your deployment, formatted according to your deployment type:
      * For AI Services: `https://your-resource-name.services.ai.azure.com/models`
      * For Managed: `https://your-model-name.region.inference.ml.azure.com/score`
      * For Serverless: `https://your-model-name.region.models.ai.azure.com`

    * **Azure API Version**: The API version to use (e.g., "2024-05-01-preview"). This is required if you have api version in your deployment url.
      **Examples:**
      * If your URL is `https://mycompany-ai.westus2.services.ai.azure.com/models?api-version=2024-05-01-preview`, the API version is `2024-05-01-preview`

    * **Azure Deployment Name**: (Optional) Required only when a single resource contains multiple deployments.

    <Frame>
      <img src="https://mintcdn.com/portkey-docs/PaRorqtknQiAf2YW/images/product/azure-2.png?fit=max&auto=format&n=PaRorqtknQiAf2YW&q=85&s=7bdc3203e677d4474a1a89450615ae5a" alt="Default Authentication Setup" width="1998" height="1963" data-path="images/product/azure-2.png" />
    </Frame>
  </Tab>

  <Tab title="Azure Entra ID">
    To use this authentication your azure application need to have the role of: `conginitive services user`.
    Enterprise-level authentication with Azure Entra ID:

    Required parameters:

    * **Azure Entra ClientID**: Your Azure Entra client ID

    * **Azure Entra Secret**: Your client secret

    * **Azure Entra Tenant ID**: Your tenant ID

    * **Azure Foundry URL**: The base endpoint URL for your deployment, formatted according to your deployment type:
      * For AI Services: `https://your-resource-name.services.ai.azure.com/models`
      * For Managed: `https://your-model-name.region.inference.ml.azure.com/score`
      * For Serverless: `https://your-model-name.region.models.ai.azure.com`

    * **Azure API Version**: The API version to use (e.g., "2024-05-01-preview"). This is required if you have api version in your deployment url.
      **Examples:**
      * If your URL is `https://mycompany-ai.westus2.services.ai.azure.com/models?api-version=2024-05-01-preview`, the API version is `2024-05-01-preview`

    * **Azure Deployment Name**: (Optional) Required only when a single resource contains multiple deployments. Common in Managed deployments.

    You can Learn more about these [Azure Entra Resources here](https://learn.microsoft.com/en-us/azure/ai-services/authentication)

    <Frame>
      <img src="https://mintcdn.com/portkey-docs/PaRorqtknQiAf2YW/images/product/azure-3.png?fit=max&auto=format&n=PaRorqtknQiAf2YW&q=85&s=f0ebb61941227edc5ea7f3b75fd2f1c2" alt="Default Authentication Setup" width="1994" height="2307" data-path="images/product/azure-3.png" />
    </Frame>
  </Tab>
</Tabs>

## Sample Request

Once you've created your virtual key, you can start making requests to Azure AI Foundry models through Portkey.

<Tabs>
  <Tab title="NodeJS">
    Install the Portkey SDK with npm

    ```sh theme={"system"}
    npm install portkey-ai
    ```

    ```js theme={"system"}
    import Portkey from 'portkey-ai';

    const client = new Portkey({
      apiKey: 'PORTKEY_API_KEY',
      virtualKey: 'AZURE_FOUNDRY_VIRTUAL_KEY'
    });

    async function main() {
      const response = await client.chat.completions.create({
        messages: [{ role: "user", content: "Tell me about cloud computing" }],
        model: "DeepSeek-V3-0324", // Replace with your deployed model name
      });

      console.log(response.choices[0].message.content);
    }

    main();
    ```
  </Tab>

  <Tab title="Python">
    Install the Portkey SDK with pip

    ```sh theme={"system"}
    pip install portkey-ai
    ```

    ```python theme={"system"}
    from portkey_ai import Portkey

    client = Portkey(
      api_key = "PORTKEY_API_KEY",
      virtual_key = "AZURE_FOUNDRY_VIRTUAL_KEY"
    )

    response = client.chat.completions.create(
      model="DeepSeek-V3-0324", # Replace with your deployed model name
      messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Tell me about cloud computing"}
      ]
    )

    print(response.choices[0].message.content)
    ```
  </Tab>

  <Tab title="cURL">
    ```sh theme={"system"}
    curl https://api.portkey.ai/v1/chat/completions \
      -H "Content-Type: application/json" \
      -H "x-portkey-api-key: $PORTKEY_API_KEY" \
      -H "x-portkey-virtual-key: $AZURE_FOUNDRY_VIRTUAL_KEY" \
      -d '{
        "model": "DeepSeek-V3-0324",
        "messages": [
          { "role": "user", "content": "Tell me about cloud computing" }
        ]
      }'
    ```
  </Tab>
</Tabs>

## Advanced Features

### Function Calling

Azure AI Foundry supports function calling (tool calling) for compatible models. Here's how to implement it with Portkey:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={"system"}
    let tools = [{
        type: "function",
        function: {
            name: "getWeather",
            description: "Get the current weather",
            parameters: {
                type: "object",
                properties: {
                    location: { type: "string", description: "City and state" },
                    unit: { type: "string", enum: ["celsius", "fahrenheit"] }
                },
                required: ["location"]
            }
        }
    }];

    let response = await portkey.chat.completions.create({
        model: "DeepSeek-V3-0324", // Use a model that supports function calling
        messages: [
            { role: "system", content: "You are a helpful assistant." },
            { role: "user", content: "What's the weather like in Delhi?" }
        ],
        tools,
        tool_choice: "auto",
    });

    console.log(response.choices[0]);
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={"system"}
    tools = [{
        "type": "function",
        "function": {
            "name": "getWeather",
            "description": "Get the current weather",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City and state"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }]

    response = portkey.chat.completions.create(
        model="DeepSeek-V3-0324", # Use a model that supports function calling
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "What's the weather like in Delhi?"}
        ],
        tools=tools,
        tool_choice="auto"
    )

    print(response.choices[0])
    ```
  </Tab>
</Tabs>

### Vision Capabilities

Process images alongside text using Azure AI Foundry's vision capabilities:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={"system"}
    const response = await portkey.chat.completions.create({
      model: "Llama-4-Scout-17B-16E", // Use a model that supports vision
      messages: [
        {
          role: "user",
          content: [
            { type: "text", text: "What's in this image?" },
            {
              type: "image_url",
              image_url: "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
            },
          ],
        },
      ],
      max_tokens: 500,
    });

    console.log(response.choices[0].message.content);
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={"system"}
    response = portkey.chat.completions.create(
        model="Llama-4-Scout-17B-16E", # Use a model that supports vision
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "What's in this image?"},
                    {
                        "type": "image_url",
                        "image_url": "https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Gfp-wisconsin-madison-the-nature-boardwalk.jpg/2560px-Gfp-wisconsin-madison-the-nature-boardwalk.jpg",
                    },
                ],
            }
        ],
        max_tokens=500,
    )

    print(response.choices[0].message.content)
    ```
  </Tab>
</Tabs>

### Structured Outputs

Get consistent, parseable responses in specific formats:

<Tabs>
  <Tab title="Node.js">
    ```javascript theme={"system"}
    const response = await portkey.chat.completions.create({
      model: "cohere-command-a", // Use a model that supports response formats
      messages: [
        { role: "system", content: "You are a helpful assistant." },
        { role: "user", content: "List the top 3 cloud providers with their main services" }
      ],
      response_format: { type: "json_object" },
      temperature: 0
    });

    console.log(JSON.parse(response.choices[0].message.content));
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={"system"}
    response = portkey.chat.completions.create(
        model="cohere-command-a", # Use a model that supports response formats
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": "List the top 3 cloud providers with their main services"}
        ],
        response_format={"type": "json_object"},
        temperature=0
    )

    import json
    print(json.loads(response.choices[0].message.content))
    ```
  </Tab>
</Tabs>

## Relationship with Azure OpenAI

For Azure OpenAI specific models and deployments, we recommend using the existing Azure OpenAI provider in Portkey:

<Card title="Azure OpenAI Integration" icon="microsoft" href="/integrations/llms/azure-openai">
  Learn how to integrate Azure OpenAI with Portkey for access to OpenAI models hosted on Azure.
</Card>

## Portkey Features with Azure AI Foundry

### Setting Up Fallbacks

Create fallback configurations to ensure reliability when working with Azure AI Foundry models:

```json theme={"system"}
{
  "strategy": {
    "mode": "fallback"
  },
  "targets": [
    {
      "virtual_key": "azure-foundry-virtual-key",
      "override_params": {
        "model": "DeepSeek-V3-0324"
      }
    },
    {
      "virtual_key": "openai-virtual-key",
      "override_params": {
        "model": "gpt-4o"
      }
    }
  ]
}
```

### Load Balancing Between Models

Distribute requests across multiple models for optimal performance:

```json theme={"system"}
{
  "strategy": {
    "mode": "loadbalance"
  },
  "targets": [
    {
      "virtual_key": "azure-foundry-virtual-key-1",
      "override_params": {
        "model": "DeepSeek-V3-0324"
      },
      "weight": 0.7
    },
    {
      "virtual_key": "azure-foundry-virtual-key-2",
      "override_params": {
        "model": "cohere-command-a"
      },
      "weight": 0.3
    }
  ]
}
```

### Conditional Routing

Route requests based on specific conditions like user type or content requirements:

```json theme={"system"}
{
  "strategy": {
    "mode": "conditional",
    "conditions": [
      {
        "query": { "metadata.user_type": { "$eq": "premium" } },
        "then": "high-performance-model"
      },
      {
        "query": { "metadata.content_type": { "$eq": "code" } },
        "then": "code-specialized-model"
      }
    ],
    "default": "standard-model"
  },
  "targets": [
    {
      "name": "high-performance-model",
      "virtual_key": "azure-foundry-virtual-key-1",
      "override_params": {
        "model": "Llama-4-Scout-17B-16E"
      }
    },
    {
      "name": "code-specialized-model",
      "virtual_key": "azure-foundry-virtual-key-2",
      "override_params": {
        "model": "DeepSeek-V3-0324"
      }
    },
    {
      "name": "standard-model",
      "virtual_key": "azure-foundry-virtual-key-3",
      "override_params": {
        "model": "cohere-command-a"
      }
    }
  ]
}
```

## Managing Prompts with Azure AI Foundry

You can manage all prompts to Azure AI Foundry in the [Prompt Library](/product/prompt-library). Once you've created and tested a prompt in the library, use the `portkey.prompts.completions.create` interface to use the prompt in your application.

<Tabs>
  <Tab title="NodeJS">
    ```js theme={"system"}
    const promptCompletion = await portkey.prompts.completions.create({
        promptID: "Your Prompt ID",
        variables: {
           // The variables specified in the prompt
        }
    })
    ```
  </Tab>

  <Tab title="Python">
    ```python theme={"system"}
    prompt_completion = portkey.prompts.completions.create(
        prompt_id="Your Prompt ID",
        variables={
           # The variables specified in the prompt
        }
    )
    ```
  </Tab>
</Tabs>

## Next Steps

Explore these additional resources to make the most of your Azure AI Foundry integration with Portkey:

<CardGroup cols={2}>
  <Card title="Add Metadata" icon="tags" href="/product/observability/metadata">
    Learn how to add custom metadata to your Azure AI Foundry requests.
  </Card>

  <Card title="Gateway Configs" icon="gear" href="/product/ai-gateway/configs">
    Configure advanced gateway features for your Azure AI Foundry requests.
  </Card>

  <Card title="Request Tracing" icon="route" href="/product/observability/traces">
    Trace your Azure AI Foundry requests for better observability.
  </Card>

  <Card title="Setup Fallbacks" icon="shield" href="/product/ai-gateway/fallbacks">
    Create fallback configurations between different providers.
  </Card>
</CardGroup>