Foundry AI Self-service Tool

Time Range

Total Requests

Successful (2xx)

Total Tokens

~2 min delay

Errors (4xx/5xx)

Median Response Time

end-to-end incl. model generation

Active Users

Rate Limited (429s)

APIM
Foundry
DNS

System Health

Token Usage by User ~2 min delay

Token Usage by Model ~2 min delay

User Management

Standard 500K TPM / 1K RPM Power 750K TPM / 2K RPM Unlimited 1M TPM / 5K RPM

App & Entra Token Access

Recent LLM Requests ~2 min delay

Model Capacity & Rate Limitsclick a model to copy · switch with /model <name> · if one is overloaded (529) try anotherLoading...

Model	Provider	RPM	TPM	Live Health (30m)	Status

Period

~2 min delay on token metrics

Total Tokens

Cost (Foundry metered)

Projected Monthly

Avg Daily Cost

Totals & per-model from Azure Foundry metrics (all traffic, real Vituity rates incl. cache writes). Per-user table is gateway-attributed only.

Daily Token Usage

Daily Cost Trend

Cost by User gateway-attributed · lower bound (excl. direct & cache writes)

Cost by Model

Token Breakdown by Model

Model	Input	Output	Cache Read	Cache Write	Est. Cost

Token Efficiency

User

Period

Gateway-attributed at real Vituity rates · lower bound (excl. cache writes & any direct Foundry use)

Select a user above to view their usage details

Total Tokens

Estimated Cost

Cached Tokens

Avg Daily Tokens

Avg Latency

Daily Token Usage

Model Mix

Tokens & Cost Over Time

Daily Breakdown

Date	Input	Output	Total	Est. Cost

Request Performance

Success Rate (1h)

Success Rate (24h)

Success Rate (7d)

Errors (24h)

Error Rate (24h)

Latency (24h) — Avg vs P95

Response Code Distribution (24h)

Recent Errors

Time	Code	Reason	User

Live Model Health available switch targets · last 30mclick a model to copy · switch with /model <name> if one is overloaded (529) — idle (0 req) models are safe targets

Model	Requests	Success	Overload (529)	Health

Migrate to the Vituity AI Gateway

One terminal-based flow for every OS — follow the quick-start below.

Quick Start to Migrateany OS · terminal-based · ~10 min

Before you start: Save your work — this restarts Claude Code, so save/commit anything in progress and close your current Claude sessions first.

⬇ Download setup package ACTIVATE your API key first — it auto-fills the command below.

1.	Unzip the package — you'll get a `haute-apim-sdk-setup` folder in your Downloads.
2.	Migrate — let Claude do it. Open Claude Code in VS Code (or run `claude` in a terminal). Paste this message, replacing the end with your key: `Read the MIGRATE.md in the haute-apim-sdk-setup folder that is in my Downloads, and migrate me to APIM. My APIM key is [your 32-character key — Per User tab]` Tip: If Claude can't find the folder, right-click the unzipped `haute-apim-sdk-setup` folder → "Copy as path" (Mac: right-click, hold Option → "Copy as Pathname") and paste that full path into the message. Point Claude at the folder, not the `MIGRATE.md` file by itself. Approve the prompts as Claude works. It backs up your settings, makes the changes, and tells you when it's done.
3.	Restart — close all terminals and fully quit VS Code, then reopen.
4.	Set your model — run `/model` → Sonnet 5 (1M). In each old chat window, switch to Sonnet 5 before typing anything — typing on a window still on Opus throws the "log in to Claude" screen and can lock you out of that session.
5.	Verify — open a fresh terminal, run `claude`, then `/status`. It should show API-key auth and apim-haute-sdk.azure-api.net. Then check Per User for your usage.

Didn't work? Run the fix script (no Claude needed) from inside the haute-apim-sdk-setup folder:

Windows: right-click the haute-apim-sdk-setup folder → Open in Terminal, then paste powershell -ExecutionPolicy Bypass -File .\fix-vscode-windows.ps1 (if "blocked," first run Unblock-File .\fix-vscode-windows.ps1)
Mac: open Terminal → type cd → drag the folder in → Enter, then paste bash ./fix-vscode-mac-linux.sh

It prints a PASS/FAIL check and is safe to re-run. Then redo Step 3 (Restart) and Step 4 (Set model).

Help & Reference

Step 1 — Get Your API Key

Go to the Per User tab in this portal
Your subscription key is displayed at the top — click to copy it
If you see "Activate Access", click it to create your subscription automatically

Don't have access? Ask your admin (cloudops@vituity.com).

Step 2 — Install Claude Code Extension

Open VS Code
Press Ctrl+Shift+X to open Extensions
Search for "Claude Code" by Anthropic
Click Install (skip if the extension is already installed)

Step 3 — Configure VS Code

Press Ctrl+Shift+P to open the Command Palette
Type "Preferences: Open User Settings (JSON)" and select it
Your settings.json file will open. Add these lines before the last closing }:

"claudeCode.disableLoginPrompt": true, "claudeCode.environmentVariables": [ {"name": "ANTHROPIC_BASE_URL", "value": "https://apim-haute-sdk.azure-api.net/v2/anthropic"}, {"name": "ANTHROPIC_API_KEY", "value": "paste-your-key-from-step-1"} ]

Windows users: You MUST use the array format [{name, value}] shown above — the object {} format crashes the extension. The disableLoginPrompt line is also required or the extension shows the Claude.ai login screen.

Full example of what your file should look like:

{ "claudeCode.preferredLocation": "panel", "git.openRepositoryInParentFolders": "never", "claudeCode.disableLoginPrompt": true, "claudeCode.environmentVariables": [ {"name": "ANTHROPIC_BASE_URL", "value": "https://apim-haute-sdk.azure-api.net/v2/anthropic"}, {"name": "ANTHROPIC_API_KEY", "value": "paste-your-key-from-step-1"} ] }

Press Ctrl+S to save, then restart VS Code

Step 4 (Optional) — Set Environment Variables (Terminal)

Open PowerShell and run:

setx ANTHROPIC_BASE_URL "https://apim-haute-sdk.azure-api.net/v2/anthropic" setx ANTHROPIC_API_KEY "paste-your-key-from-step-1"

Important: Close and reopen VS Code and any terminal windows after running this. The variables won't take effect until you do.

Step 4b — Set Default Model

Sets claude-sonnet-5 as your default model. Run in PowerShell:

python -c "import json,pathlib; p=pathlib.Path.home()/'.claude'/'settings.json'; s=json.loads(p.read_text()) if p.exists() else {}; s['model']='claude-sonnet-5'; p.write_text(json.dumps(s,indent=2))"

Merges safely — won't overwrite your existing settings.

Step 5 (Optional) — Verify It Works

Open Claude Code in VS Code and test it — if it responds, you're all set!

— or —

Open a new PowerShell window and run:

curl.exe -s https://apim-haute-sdk.azure-api.net/v2/anthropic/v1/messages ` -H "x-api-key: $env:ANTHROPIC_API_KEY" ` -H "anthropic-version: 2023-06-01" ` -H "Content-Type: application/json" ` -d '{"model":"claude-sonnet-4-6","max_tokens":50,"messages":[{"role":"user","content":"Say hello"}]}'

If you see Claude's response with "text":"Hello...", you're all set!

Step 1 — Get Your API Key

Go to the Per User tab in this portal
Your subscription key is displayed at the top — click to copy it
If you see "Activate Access", click it to create your subscription automatically

Don't have access? Ask your admin (cloudops@vituity.com).

Step 2 — Install Claude Code Extension

Open VS Code
Press Cmd+Shift+X to open Extensions
Search for "Claude Code" by Anthropic
Click Install (skip if the extension is already installed)

Step 3 — Configure VS Code

Press Cmd+Shift+P to open the Command Palette
Type "Preferences: Open User Settings (JSON)" and select it
Your settings.json file will open. Add these lines before the last closing }:

"claudeCode.environmentVariables": { "ANTHROPIC_BASE_URL": "https://apim-haute-sdk.azure-api.net/v2/anthropic", "ANTHROPIC_API_KEY": "paste-your-key-from-step-1" }

Important: Add a comma after the line above these new lines. If you already have "claudeCode.environmentVariables" from a Claude AI subscription, replace it.

Full example of what your file should look like:

{ "claudeCode.preferredLocation": "panel", "git.openRepositoryInParentFolders": "never", "claudeCode.environmentVariables": { "ANTHROPIC_BASE_URL": "https://apim-haute-sdk.azure-api.net/v2/anthropic", "ANTHROPIC_API_KEY": "paste-your-key-from-step-1" } }

Press Cmd+S to save, then restart VS Code

Step 4 — Set Environment Variables (Terminal)

Open Terminal and run:

echo '# Foundry AI Gateway export ANTHROPIC_BASE_URL=https://apim-haute-sdk.azure-api.net/v2/anthropic export ANTHROPIC_API_KEY=paste-your-key-from-step-1' >> ~/.zshrc source ~/.zshrc

This adds the variables to your shell profile so they persist across terminal sessions and reboots.

Step 4b — Set Default Model

Sets claude-sonnet-5 as your default model. Run in Terminal:

python3 -c "import json,pathlib; p=pathlib.Path.home()/'.claude'/'settings.json'; s=json.loads(p.read_text()) if p.exists() else {}; s['model']='claude-sonnet-5'; p.write_text(json.dumps(s,indent=2))"

Merges safely — won't overwrite your existing settings.

Step 5 — Verify It Works

Open a new Terminal window and run:

curl -s https://apim-haute-sdk.azure-api.net/v2/anthropic/v1/messages \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "Content-Type: application/json" \ -d '{"model":"claude-sonnet-4-6","max_tokens":50,"messages":[{"role":"user","content":"Say hello"}]}'

If you see Claude's response with "text":"Hello...", you're all set!

Common Errors

Error	Cause	Fix
403 Forbidden	Model isn't included for your tier (e.g., Opus on a Standard key)	Switch model (`/model claude-sonnet-5`) or request a tier upgrade on the Per User tab
401 Unauthorized	Key not set or wrong header	Check env vars are set, use `x-api-key` header
Timeout / TLS reset	Zscaler not connected	Connect Zscaler ZPA — gateway is a private endpoint
"model may not exist"	Old URL in .env file	Check .env files in project folder, update to `/v2/anthropic`
429 Too Many Requests	Rate limited	Wait 1 minute. Check your tier (Standard=500K, Power=750K, Unlimited=1M TPM)
500 / 502 / 503	Backend issue	Check the Health tab
400 "thinking.type.adaptive"	Opus 4.8 + old thinking vars	Remove `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING` and `MAX_THINKING_TOKENS`
Login screen appears (Windows)	`disableLoginPrompt` not set	Add `"claudeCode.disableLoginPrompt": true` to VS Code settings
Extension crashes (Windows)	Object format for env vars	Use array format `[{name,value}]` not object `{}`
"Claude Team" in header	Still logged into Claude.ai	Type `/logout` in Claude Code, restart VS Code

Fix Scripts

Windows — Fix ANTHROPIC_BASE_URL everywhere:

$url = "https://apim-haute-sdk.azure-api.net/v2/anthropic" [System.Environment]::SetEnvironmentVariable("ANTHROPIC_BASE_URL", $url, "User") $env:ANTHROPIC_BASE_URL = $url Get-ChildItem -Recurse -Filter ".env" | ForEach-Object { $c = Get-Content $_.FullName -Raw if ($c -match "ANTHROPIC_BASE_URL") { $c = $c -replace "ANTHROPIC_BASE_URL=.*", "ANTHROPIC_BASE_URL=$url" Set-Content $_.FullName $c; Write-Host "Updated: $($_.FullName)" } } Write-Host "Done. Restart VS Code."

Mac / Linux — Fix ANTHROPIC_BASE_URL everywhere:

URL="https://apim-haute-sdk.azure-api.net/v2/anthropic" sed -i'' -e "s|ANTHROPIC_BASE_URL=.*|ANTHROPIC_BASE_URL=$URL|" ~/.zshrc ~/.bashrc 2>/dev/null find . -name ".env" -exec sed -i'' -e "s|ANTHROPIC_BASE_URL=.*|ANTHROPIC_BASE_URL=$URL|" {} \; export ANTHROPIC_BASE_URL=$URL echo "Done. Restart VS Code."

After Claude Code Updates — Read This

After Claude Code auto-updates, you may see a "Remote Control" / claude.ai sign-in prompt. This is expected — ignore it. Remote Control only works over a direct api.anthropic.com connection, so it can't run through the gateway — your APIM connection is unaffected. The setting below stops the prompt from reappearing.

DO NOT run claude auth login — it overrides your Foundry APIM key setup.

Mac / Linux: Add to ~/.claude/settings.json:

{ "disableRemoteControl": true }

Windows (PowerShell):

$p = "$env:USERPROFILE\.claude\settings.json" if (Test-Path $p) { $s = Get-Content $p | ConvertFrom-Json } else { New-Item "$env:USERPROFILE\.claude" -ItemType Directory -Force | Out-Null; $s = @{} } $s | Add-Member -NotePropertyName "disableRemoteControl" -NotePropertyValue $true -Force $s | ConvertTo-Json -Depth 10 | Set-Content $p Write-Host "Done. Restart VS Code."

Recommended Models

Model	Use Case	Why
claude-haiku-4-5	Quick tasks	Fastest, cheapest
claude-sonnet-5	Everyday coding/reasoning	Best balance, most versatile — the migration default
claude-opus-4-8	Complex tasks	Only needed for the more complex planning/architecture/coding tasks

FAQ

Q: Claude Code still uses my Claude.ai account?

Sign out first: Claude Code panel → account icon → Sign Out. Restart VS Code.

Q: Updated settings.json but nothing changed?

Restart VS Code completely — just saving isn't enough.

Q: It worked yesterday but not today?

Zscaler ZPA has a 7-day session timeout. Check system tray → reconnect.

Q: How do I check which connection I'm using?

Terminal: echo $env:ANTHROPIC_BASE_URL (Win) or echo $ANTHROPIC_BASE_URL (Mac). Should show the gateway URL.

Q: Migrating from Azure Foundry direct? (Mac/Linux)

Remove from ~/.zshrc: CLAUDE_CODE_USE_FOUNDRY, ANTHROPIC_FOUNDRY_RESOURCE, ANTHROPIC_FOUNDRY_API_KEY. Run source ~/.zshrc.

Q: Should I set ANTHROPIC_MODEL?

No — leave unset. It overrides model selection and may disable features like extended context.

Q: Can I use the same models?

Models available depend on your tier — Standard = Sonnet 5 + Haiku (no Opus); Opus needs Power or higher. See "Recommended Models" above, and request an upgrade on the Per User tab if you need more.

Need more help? Contact cloudops@vituity.com · Full migration guide: docs/migration.md in the repo

Getting Started with OpenAI Codex

Use Codex (GPT models) through the same Vituity AI Gateway. Same key as Claude Code.

Step 1 — Get Your API Key

Go to the Per User tab in this portal
Your subscription key is displayed at the top — click to copy it
If you see "Activate Access", click it first

This is the same key you use for Claude Code. One key works for both.

Step 2 — Install Codex

VS Code Extension:

Press Ctrl+Shift+X to open Extensions
Search for "Codex" by OpenAI
Click Install (skip if the extension is already installed)

CLI (optional): Open PowerShell and run:

npm install -g @openai/codex

Step 3 — Set API Key & Create Config File

Open PowerShell and paste this — it sets your API key and creates the config file in one go:

setx OPENAI_API_KEY "paste-your-key-from-step-1" mkdir "$env:USERPROFILE\.codex" -Force | Out-Null; @" model = "gpt-53-codex" model_provider = "vituity" model_reasoning_effort = "medium" [model_providers.vituity] name = "Vituity AI Gateway" base_url = "https://apim-haute-sdk.azure-api.net/v2/openai/v1" env_key = "OPENAI_API_KEY" wire_api = "responses" env_http_headers = { "x-api-key" = "OPENAI_API_KEY" } "@ | Set-Content "$env:USERPROFILE\.codex\config.toml" Write-Host "Done."

Step 4 — Restart VS Code & Test

Restart VS Code, then open the Codex panel and ask it something. If it responds, you're all set!

Using both? Claude Code and Codex run side by side — same key, different panels. Open Claude Code for Claude models, Codex for GPT models.

Developer Guide

Call the AI Gateway from custom apps, SDKs, and pipelines — choose your API format (Anthropic / OpenAI) below. Auth via API key (x-api-key) or Entra token (no keys).

How It Works

The gateway supports two auth methods. Use whichever fits your app:

Method	Best For	Credentials	Token Expires
API Key	Claude Code, Codex CLI	APIM subscription key	Never (until rotated)
Entra Token	Custom apps, SDKs, pipelines	Entra identity (no keys)	1 hour (auto-refreshes)

Both methods hit the same endpoint and models. Choose based on what your client supports.

Path 1 — Azure-Hosted AppManaged Identity (zero credentials)

For apps running on Azure VM, App Service, AKS, or Functions — no credentials needed at all.

Prerequisites:

Enable Managed Identity on your Azure resource
Admin adds the managed identity to sg-haute-foundry-apps via the portal (Operations → Add App)

Code (no secrets):

from azure.identity import ManagedIdentityCredential import requests credential = ManagedIdentityCredential() token = credential.get_token("https://cognitiveservices.azure.com/.default") response = requests.post( "https://apim-haute-sdk.azure-api.net/v2/anthropic/v1/messages", headers={ "Authorization": f"Bearer {token.token}", "Content-Type": "application/json", "anthropic-version": "2023-06-01" }, json={ "model": "claude-sonnet-4-6", "max_tokens": 50, "messages": [{"role": "user", "content": "Hello"}] } ) print(response.json())

Best practice: Always use Managed Identity for Azure-hosted apps. No secrets to rotate, no credentials to leak.

Path 2 — Python App (SDK)azure-identity

Install:

pip install azure-identity requests

Developer laptop (picks up az login session):

from azure.identity import DefaultAzureCredential import requests credential = DefaultAzureCredential() token = credential.get_token("https://cognitiveservices.azure.com/.default") response = requests.post( "https://apim-haute-sdk.azure-api.net/v2/anthropic/v1/messages", headers={ "Authorization": f"Bearer {token.token}", "Content-Type": "application/json", "anthropic-version": "2023-06-01" }, json={ "model": "claude-sonnet-4-6", "max_tokens": 50, "messages": [{"role": "user", "content": "Hello"}] } ) print(response.json())

Service Principal (automated apps):

from azure.identity import ClientSecretCredential import requests credential = ClientSecretCredential( tenant_id="56b24b68-e3c8-4895-89a0-05a74d0f8c84", client_id="your-app-id", client_secret="your-app-secret" ) token = credential.get_token("https://cognitiveservices.azure.com/.default") # Same requests.post() call as above

Path 3 — Developer on LaptopInteractive login

Prerequisites: Azure CLI installed, Vituity account, member of sg-sdk-sandbox-users

Step 1 — Login (one-time):

az login

Step 2 — Get token and call API:

Claude (Anthropic):

TOKEN=$(az account get-access-token --resource https://cognitiveservices.azure.com --query accessToken -o tsv) curl -s https://apim-haute-sdk.azure-api.net/v2/anthropic/v1/messages \ -H "Authorization: Bearer $TOKEN" \ -H "anthropic-version: 2023-06-01" \ -H "Content-Type: application/json" \ -d '{"model":"claude-sonnet-4-6","max_tokens":50,"messages":[{"role":"user","content":"Hello"}]}'

OpenAI / GPT:

TOKEN=$(az account get-access-token --resource https://cognitiveservices.azure.com --query accessToken -o tsv) curl -s "https://apim-haute-sdk.azure-api.net/v2/openai/deployments/gpt-5.5/chat/completions?api-version=2025-04-01-preview" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"messages":[{"role":"user","content":"Hello"}],"max_completion_tokens":50}'

Important — Auth header for OpenAI clients

Use x-api-key for the API key. The OpenAI & Azure-OpenAI SDKs send the key as Authorization: Bearer or api-key by default — the gateway rejects both (401). Send the APIM key in the x-api-key header instead (override via default_headers). Entra tokens do use Authorization: Bearer.

GPT-5.x uses max_completion_tokens (not max_tokens). Chat path needs ?api-version=2025-04-01-preview.

Path 1 — Azure-Hosted AppManaged Identity (zero credentials)

Identity must be in sg-haute-foundry-apps (Operations → Add App). Entra tokens use Authorization: Bearer, so the SDK works without header overrides.

from azure.identity import ManagedIdentityCredential, get_bearer_token_provider from openai import AzureOpenAI token_provider = get_bearer_token_provider( ManagedIdentityCredential(), "https://cognitiveservices.azure.com/.default") client = AzureOpenAI( azure_endpoint="https://apim-haute-sdk.azure-api.net/v2", api_version="2025-04-01-preview", azure_ad_token_provider=token_provider, ) resp = client.chat.completions.create( model="gpt-5.5", messages=[{"role": "user", "content": "Hello"}], max_completion_tokens=50, ) print(resp.choices[0].message.content)

Best practice for Azure-hosted apps — no secrets, auto-refreshing token.

Path 2 — Python App (SDK)API key via x-api-key

pip install openai

API key (note the default_headers override — required):

from openai import AzureOpenAI client = AzureOpenAI( azure_endpoint="https://apim-haute-sdk.azure-api.net/v2", api_version="2025-04-01-preview", api_key="unused", # placeholder; real auth is the header below default_headers={"x-api-key": "YOUR_APIM_KEY"}, ) resp = client.chat.completions.create( model="gpt-5.5", messages=[{"role": "user", "content": "Hello"}], max_completion_tokens=50, ) print(resp.choices[0].message.content)

Path 3 — curl / any languageREST

Chat completions (GPT) — API key:

curl "https://apim-haute-sdk.azure-api.net/v2/openai/deployments/gpt-5.5/chat/completions?api-version=2025-04-01-preview" \ -H "x-api-key: YOUR_APIM_KEY" \ -H "Content-Type: application/json" \ -d '{"messages":[{"role":"user","content":"Hello"}],"max_completion_tokens":50}'

Responses API (Codex):

curl "https://apim-haute-sdk.azure-api.net/v2/openai/v1/responses" \ -H "x-api-key: YOUR_APIM_KEY" \ -H "Content-Type: application/json" \ -d '{"model":"gpt-53-codex","input":"Hello"}'

Entra token (apps) — swap the key header for a Bearer token:

TOKEN=$(az account get-access-token --resource https://cognitiveservices.azure.com --query accessToken -o tsv) curl "https://apim-haute-sdk.azure-api.net/v2/openai/deployments/gpt-5.5/chat/completions?api-version=2025-04-01-preview" \ -H "Authorization: Bearer $TOKEN" \ -H "Content-Type: application/json" \ -d '{"messages":[{"role":"user","content":"Hello"}],"max_completion_tokens":50}'

API Endpoints

Format	Endpoint	Use For
Anthropic	`https://apim-haute-sdk.azure-api.net/v2/anthropic/v1/messages`	Claude models
OpenAI (chat)	`https://apim-haute-sdk.azure-api.net/v2/openai/deployments/{model}/chat/completions`	GPT models
OpenAI (responses)	`https://apim-haute-sdk.azure-api.net/v2/openai/v1/responses`	Codex CLI

Auth header: Authorization: Bearer <token> or x-api-key: <subscription-key>
Rate limits: 1,000 RPM / 500K TPM per identity

Access Groups

Group	For	How to Join
sg-sdk-sandbox-users	Human users	Admin adds via portal → Operations → Add User
sg-foundry-admins	Admins	Entra admin adds directly
sg-haute-foundry-apps	Service principals / managed identities	Admin adds via portal → Operations → Add App

Need access? Contact your Admin.

Network Reachabilityfor Azure servers / VNets

The gateway is a private endpoint — reachable only over the private network, not the public internet. Laptops reach it via Zscaler ZPA; servers reach it via VNet routing (not ZPA). A server/VNet needs both:

Routing — a path to the gateway's private endpoint VNet, typically through the hub (Azure Virtual Network Manager hub-and-spoke + hub firewall/route). Note: VNet peering is not transitive — peering one spoke does not give other spokes access.
DNS — the VNet's resolvers must resolve privatelink.azure-api.net to the private IP (link the private DNS zone to the VNet, or conditionally forward that zone to Azure DNS from a linked VNet).

Symptom: 403 or connection reset from a server is almost always (a) DNS resolving to the public IP, or (b) no route to the private endpoint. Check those two first — then contact the network team for hub routing / DNS forwarding.

MCP Catalog

Download approved packages and setup guides. Unzip and follow the instructions inside.

VScode-APIM-setup New

Ready-to-edit config files — Claude CLI settings.json and VS Code settings.json (with key placeholder) plus a setup guide and where each file goes.

Format: ZIP (settings + guide)
Note: replace __APIM_KEY__ with your key

Download Package

Haute Setup Guide Guide

Complete setup guide for the Haute AI platform. Step-by-step instructions for getting started.

Format: Word document (.docx)

Download Guide

Haute Files Package Bundle

Full Haute platform package — includes ht CLI (Mac/Windows/Linux), MCP configs, setup guides, skills guide, and install scripts.

Size: ~66 MB
Updated: 2026-06-06
Contains: ht CLI, MCP configs, install scripts, setup guides, skills guide

Download Package

Microsoft 365 MCP Internal

Access Outlook email, Teams chat, SharePoint documents, and calendar from Claude Code.

Requires: Vituity M365 account (Okta SSO)

Download Package

ServiceNow MCP Internal

Search incidents, view tickets, check change requests, and query the CMDB from Claude Code.

Requires: ServiceNow credentials

Download Package

Need an MCP that's not listed? Contact your Admin.

Foundry AI Console

Enterprise AI platform providing secure, governed access to AI models with full cost visibility and self-service onboarding.

The Challenge

Without centralization, individual API keys across teams create shadow AI spend — no visibility into who is using what, no cost controls, no audit trail, and no compliance posture. Every team managing their own keys means duplicated costs, security gaps, and zero governance.

What We Built

Cost Control & Visibility

Real-time spend tracking per user and per model. Tiered usage limits prevent runaway costs. Full audit trail for compliance and reporting.

Self-Service Access

Users onboard themselves in under 2 minutes. No tickets, no provisioning delays. Administrators retain full control over access and permissions.

Live Monitoring

Dashboard with usage metrics, health status, and per-user analytics. See exactly where every token goes across all teams and models.

Platform Journey

AI Gateway
(API Key)

Multi-Model
Support

Tool Catalog

Dual
Authentication

Tiered Usage
Controls

Model
Governance

Phase	Milestone	What It Delivered	Status
1	AI Gateway & Admin Portal	Centralized APIM gateway with API key authentication, RBAC-based admin console, self-service user onboarding, and private endpoint networking via Zscaler ZPA.	Live
2	Multi-Model Support	Added OpenAI and Codex models alongside Claude. Single API key works across all providers. Same monitoring, same rate limits, same audit trail.	Live
3	Tool Catalog	MCP package catalog with downloadable tool packages for M365, ServiceNow, and platform setup. One-click install for approved integrations.	Live
4	Dual Authentication	Added Microsoft Entra token authentication alongside API keys — making the gateway dual-auth (API key + developer Entra token). Lets developer apps, SDKs, and pipelines call the gateway with no stored keys (managed identity / service principals).	Live
5	Tiered Usage Controls	Three usage tiers (Standard, Power, Unlimited) with per-user rate limits. Self-service upgrade requests. Admins manage tiers from the dashboard.	Live
6	Model Governance	Gateway-enforced model allow-lists per tier. Standard: Sonnet + Haiku. Power: all deployed models. Unlimited: everything. Blocks premium models (e.g. Opus at ~5x Sonnet cost) for lower tiers to prevent unintended spend.	Live

By the Numbers

Models Available

Usage Tiers

<2 min

Self-Service Onboarding

100%

Private Network

Zero Public Exposure