Azure-AI_Foundry

Lesson 1: Exploring Models in the Catalog

Overview

The Azure AI Foundry Model Catalog contains hundreds of models from Microsoft, OpenAI, Meta, Mistral, Cohere, and other providers. This lesson teaches you how to browse, filter, compare, and select the right model for your use case.

Browsing the Model Catalog

In the Azure AI Foundry Portal

  1. Navigate to Azure AI Foundry
  2. Click Model catalog in the left navigation
  3. Browse models organized by:
    • Collection — filter by provider (OpenAI, Meta, Microsoft, Mistral, Cohere, etc.)
    • Task — filter by capability (chat completion, text embedding, image generation, audio, etc.)
    • License — filter by open-weight vs proprietary
    • Deployment option — filter by Serverless API, Managed Compute, or Azure OpenAI

Model Cards

Each model has a model card containing:

Filtering by Task

Task Category Models Use Cases
Chat Completion GPT-4o, GPT-4o-mini, Llama 3.1, Mistral Large, Phi-4 Conversational AI, reasoning, content generation
Text Embedding text-embedding-3-small, text-embedding-3-large, Cohere Embed v3 RAG, semantic search, similarity
Image Generation DALL-E 3 Creative content, mockups, visual assets
Audio / Speech Whisper, TTS, gpt-4o-audio Transcription, voice assistants, narration
Code Generation GPT-4o, Codestral, Phi-4 Code completion, review, translation
Vision GPT-4o, Llama 3.2-Vision, Phi-3.5-Vision Image understanding, document analysis, OCR

Model Comparison Guide

GPT-4o vs GPT-4o-mini

Dimension GPT-4o GPT-4o-mini
Quality Highest reasoning quality Good quality, occasional gaps on complex tasks
Speed ~40-80 tokens/sec ~80-150 tokens/sec
Cost (per 1M tokens) ~$2.50 input / $10 output ~$0.15 input / $0.60 output
Context Window 128K tokens 128K tokens
Multimodal Text + Image + Audio Text + Image
Best For Complex reasoning, production apps High-volume, cost-sensitive, simple tasks

GPT-4o vs Phi-4

Dimension GPT-4o Phi-4 (14B)
Provider OpenAI (proprietary) Microsoft (open-weight, MIT license)
Parameters Not disclosed 14 billion
Quality Best-in-class Competitive on reasoning, math, code
Deployment Azure OpenAI Service Serverless API or Managed Compute
Cost Pay-per-token (higher) Significantly cheaper, self-hostable
Best For Maximum quality, enterprise Cost-sensitive, edge, custom fine-tuning

Llama 3.1 (Meta) vs Mistral Large

Dimension Llama 3.1 70B Mistral Large
License Llama Community License Commercial
Multilingual Good Excellent (native multilingual)
Code Strong Excellent (Codestral-class)
Deployment Serverless API or Managed Compute Serverless API
Best For General-purpose, fine-tuning Multilingual enterprise, code

Model Selection Decision Framework

Use this decision tree to pick the right model:

What is your primary task?
│
├── Chat / Reasoning
│   ├── Need highest quality? → GPT-4o or o3
│   ├── Cost-sensitive, good quality? → GPT-4o-mini
│   ├── Need open weights / fine-tuning? → Llama 3.1 70B or Phi-4
│   └── Multilingual focus? → Mistral Large
│
├── Embeddings / Search
│   ├── Best quality embeddings? → text-embedding-3-large (3072 dims)
│   ├── Cost-effective embeddings? → text-embedding-3-small (1536 dims)
│   └── Multilingual embeddings? → Cohere Embed v3
│
├── Image Generation → DALL-E 3
│
├── Audio
│   ├── Speech-to-text? → Whisper
│   └── Text-to-speech? → TTS (alloy, echo, fable, onyx, nova, shimmer)
│
└── Vision / Document Analysis
    ├── Best quality? → GPT-4o (with image input)
    └── Open-weight? → Llama 3.2 Vision or Phi-3.5 Vision

Browsing Models with Python

from azure.ai.ml import MLClient
from azure.identity import DefaultAzureCredential

credential = DefaultAzureCredential()
ml_client = MLClient(
    credential=credential,
    subscription_id="your-subscription-id",
    resource_group_name="your-rg",
    workspace_name="your-ai-foundry-project"
)

# List models from the Azure ML registry, filtering by task
models = ml_client.models.list(registry_name="azureml")

chat_models = [m for m in models if "chat" in (m.tags or {}).get("task", "").lower()]
for model in chat_models[:10]:
    print(f"  {model.name} (v{model.version})")

Retrieving a Specific Model Card

model = ml_client.models.get(
    name="Phi-4",
    version="latest",
    registry_name="azureml"
)

print(f"Name: {model.name}")
print(f"Version: {model.version}")
print(f"Description: {model.description[:200]}")
print(f"Tags: {model.tags}")
print(f"License: {model.tags.get('license', 'N/A')}")

Using the Benchmarks Tab

The Benchmarks view in the portal lets you compare models on standardized evaluations:

Benchmark Measures Key Models
MMLU General knowledge / reasoning GPT-4o > Llama 3.1 405B > Phi-4
HumanEval Code generation GPT-4o ≈ Codestral > Phi-4
GSM8K Math reasoning GPT-4o > Phi-4 > Llama 3.1 70B
MTEB Embedding quality text-embedding-3-large > Cohere v3
HellaSwag Commonsense reasoning GPT-4o > Mistral Large > Phi-4

💡 Tip: Benchmarks are a starting point, not a final answer. Always test models on your own data with representative prompts before committing.

Tips for Model Selection

💡 Start small, scale up. Begin with GPT-4o-mini or Phi-4. If quality is insufficient, move to GPT-4o. This iterative approach minimizes cost.

💡 Consider total cost, not just token price. A cheaper model that requires 3x more tokens to get the right answer may cost more overall.

💡 Check regional availability. Not all models are available in all Azure regions. Verify availability before designing your architecture.

💡 Open-weight ≠ free. Models like Llama and Phi are free to use, but you still pay for compute (Managed Compute) or per-token (Serverless API).

💡 Test with your real prompts. Model cards show benchmark scores, but your use case may differ significantly. Use the Playground to test with actual inputs before deploying.

Summary

Next: Lesson 2 — Deploying Models