Microsoft AI

The fastest way to demystify Azure AI is to walk a real application from before-AI to after-AI. Same example as the Vertex AI page for direct comparison: ZoomedIn.us — a (hypothetical, in-development) skill-matching service. LinkedIn-shaped, but agent-first. We'll show how it's built, deployed, and made vendor-agnostic on Microsoft's stack.

# pip install azure-ai-projects azure-identity openai
from azure.identity import DefaultAzureCredential
from openai import AzureOpenAI

# Auth via Entra ID - no API keys in code, ever
credential = DefaultAzureCredential()
client = AzureOpenAI(
    azure_endpoint="https://zoomedin-aoai.openai.azure.com/",
    api_version="2024-10-21",
    azure_ad_token_provider=lambda: credential.get_token(
        "https://cognitiveservices.azure.com/.default"
    ).token,
)

def embed(text: str) -> list[float]:
    """1536-dim vector via Azure OpenAI. ~40ms."""
    resp = client.embeddings.create(
        model="text-embedding-3-large",  # your AOAI deployment name
        input=text,
    )
    return resp.data[0].embedding

# Then index via Azure AI Search (hybrid retrieval)
profile_vec = embed("Python wizard, 8 years, ML pipelines, AWS")

Vendor-locked vs vendor-agnostic — Azure-flavored

Azure's vendor-agnostic story is structurally similar to Vertex's: the same orchestration layer (Foundry) lets you call OpenAI models OR open-weight / partner models via the Model Catalog. The discipline is in how YOU write the code.

from openai import AzureOpenAI

client = AzureOpenAI(
    azure_endpoint=AOAI_URL,
    api_version="2024-10-21",
    azure_ad_token_provider=...
)

def explain_match(role, candidate):
    resp = client.chat.completions.create(
        model="gpt-4o",  # hard-coded
        messages=[{"role":"user","content":f"Why {candidate} fits {role}?"}],
    )
    return resp.choices[0].message.content
# Every call site assumes GPT-4o.

# Llama 3 via Foundry Model Catalog:
from azure.ai.inference import ChatCompletionsClient
from azure.identity import DefaultAzureCredential

client = ChatCompletionsClient(
    endpoint=FOUNDRY_LLAMA_ENDPOINT,  # config
    credential=DefaultAzureCredential(),
)

def explain_match(role, candidate):
    resp = client.complete(messages=[
        {"role":"user","content":f"Why {candidate} fits {role}?"}
    ])
    return resp.choices[0].message.content
# Same shape works for Mistral, Cohere, Phi.
# Swap endpoint config to swap models.

Agents on both sides — the dance is the same

The two-sided agent dance — application-level choreography between an employer agent and a user agent — is platform-neutral as a design pattern. The same shape (register → discover → push role → notify matches → accept/decline → continuous-learning) maps cleanly onto either Vertex Agent Engine or Azure AI Foundry agents. The managed-agent surfaces themselves aren't a 1:1 protocol equivalent (different SDKs, different async semantics, different identity wiring), so consider the table below a concept-mapping aid rather than a drop-in substitution guide. See the dance diagram + 6-stage sequence on the Vertex AI page — the application-level flow is the part that translates directly:

Where everything runs on Azure

The Azure deployment topology — every box is a managed service, every arrow is an SDK call. From `git push` to production is mostly `az containerapp up` + `az ai project create` + a few deployment YAML files.

# Frontend (Next.js) - Azure Container Apps, scale-to-zero
az containerapp up --name zoomedin-web --resource-group rg-zd \
   --image $REGISTRY/zoomedin-web:latest --ingress external

# Backend (FastAPI) - same pattern
az containerapp up --name zoomedin-api --resource-group rg-zd \
   --image $REGISTRY/zoomedin-api:latest --ingress external

# Matchmaker agent - Azure AI Foundry
python -c "
from azure.ai.projects import AIProjectClient
from azure.identity import DefaultAzureCredential

# Current SDK (replaces older from_connection_string pattern):
project = AIProjectClient(
    endpoint='https://zoomedin.services.ai.azure.com/api/projects/zd',
    credential=DefaultAzureCredential(),
)
project.agents.create_agent(
    model='gpt-4o',                # or Llama via Catalog
    name='zoomedin-matchmaker',
    instructions=MATCHMAKER_PROMPT,
    tools=[skill_search_tool, scoring_tool],
)"

# AI Search index (one-time)
az search service create --name zoomedin-skills \
   --resource-group rg-zd --sku standard

# Done. Foundry endpoint is what your backend POSTs to.

Hub-and-spoke topology centered on Azure AI Foundry. Developers reach Foundry directly or via GitHub Copilot; Foundry orchestrates model access via Azure OpenAI and governance via the Responsible AI Toolbox; every output flows through the compliance wrapper (Entra ID identity, Azure regional residency, M365 integration) before landing in Production.

The four pillars of Microsoft's enterprise AI stack. For each: what it IS, why you NEED it, and how you actually USE it. Hover any underlined term for a full definition.