AI-103 CERTIFICATION BOOTCAMP

# Deploy two models on Global Standard, as in Session 4 (take names and versions from list-models).
# One NON-reasoning chat model (Learn's evaluation page uses gpt-4.1-mini as an example)
# and one reasoning model (the SDK quickstart uses gpt-5-mini).
accountName="<your-foundry-resource-name>"
az cognitiveservices account deployment create \
    -n $accountName -g rg-ai103 \
    --deployment-name "<chat-deployment-name>" \
    --model-name "<non-reasoning-model>" \
    --model-version "<version-from-list-models>" \
    --model-format "<format-from-list-models>" \
    --sku-capacity 1 --sku-name GlobalStandard
# Repeat with --deployment-name "<reasoning-deployment-name>" and the reasoning model.

export FOUNDRY_PROJECT_ENDPOINT="https://<resource-name>.services.ai.azure.com/api/projects/<project-name>"
export FOUNDRY_MODEL_NAME="<chat-deployment-name>"
export FOUNDRY_OPENAI_BASE_URL="https://<resource-name>.openai.azure.com/openai/v1/"
# My own variable name (not Microsoft's):
export REASONING_MODEL_DEPLOYMENT="<reasoning-deployment-name>"

import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

project = AIProjectClient(
    endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()

# The instructions play the part of the system message
INSTRUCTIONS = (
    "You write one-line delivery updates for a logistics firm's customers. "
    "Use only the facts given. If a fact is missing, write 'Update pending'. "
    "Reply in under 25 words, with no greeting."
)
# One worked example (few-shot), then the real case, then a cue ("Update:")
PROMPT = (
    "Facts: parcel LG-104, left Lagos hub Monday, held at customs.\n"
    "Update: LG-104 left our Lagos hub on Monday and is held at customs.\n\n"
    "Facts: parcel LG-221, reached Abuja depot Tuesday, out for delivery.\n"
    "Update:"
)

for temp in (0.0, 1.0, 1.8):
    for run in (1, 2):
        response = openai.responses.create(
            model=os.environ["FOUNDRY_MODEL_NAME"],  # a NON-reasoning deployment
            instructions=INSTRUCTIONS,
            input=PROMPT,
            temperature=temp,
            max_output_tokens=60,
        )
        print(f"temperature={temp} run={run}: {response.output_text}")

temperature=0.0 run=1: LG-221 reached our Abuja depot on Tuesday and is out for delivery.
temperature=0.0 run=2: <almost certainly the same line>
temperature=1.0 run=1: <similar facts, different wording>
...
temperature=1.8 run=2: <the most varied wording; read it for invented facts>

import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

project = AIProjectClient(
    endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()

# A clear goal, firm constraints, an explicit output contract. No "think step by step".
GOAL = (
    "A hospital pharmacy has three fridges. Fridge A holds 40 vials and is 75% full; "
    "B holds 60 and is half full; C holds 25 and is empty. "
    "Place 30 new vials, filling the fullest fridge first. Answer in one line."
)

for effort in ("low", "high"):
    response = openai.responses.create(
        model=os.environ["REASONING_MODEL_DEPLOYMENT"],  # a reasoning deployment
        input=GOAL,
        reasoning={"effort": effort},
        max_output_tokens=4000,  # one cap for reasoning AND visible tokens
    )
    used = response.usage.output_tokens_details.reasoning_tokens
    print(f"effort={effort} reasoning_tokens={used}: {response.output_text}")

# Now add temperature=0.2 to the call above, run it once, and read the error.

effort=low reasoning_tokens=<a number>: 10 vials to Fridge A, 20 to Fridge B.
effort=high reasoning_tokens=<a larger number>: 10 vials to Fridge A, 20 to Fridge B.
<with temperature added: a 400 error saying the parameter is not supported by this model>

# 1. The search service. Basic tier: billed by the hour for as long as it exists.
az search service create \
    --name "<your-search-name>" \
    --resource-group rg-ai103 \
    --sku basic \
    --auth-options aadOrApiKey \
    --aad-auth-failure-mode http401WithBearerChallenge

# 2. Two deployments on your Foundry resource (Session 4 steps):
#    a chat model as before, and text-embedding-3-small for vectors.
az cognitiveservices account deployment create \
    -n "<your-foundry-resource-name>" -g rg-ai103 \
    --deployment-name "<embedding-deployment-name>" \
    --model-name text-embedding-3-small \
    --model-version "<version-from-list-models>" \
    --model-format "<format-from-list-models>" \
    --sku-capacity 1 --sku-name "<sku-from-list-models>"

pip install azure-search-documents
# FOUNDRY_PROJECT_ENDPOINT and FOUNDRY_OPENAI_BASE_URL stay as in Session 5
export FOUNDRY_MODEL_NAME="<chat-deployment-name>"
# My own variable names (not Microsoft's):
export SEARCH_ENDPOINT="https://<your-search-name>.search.windows.net"
export SEARCH_INDEX="ai103-policies"
export EMBEDDING_DEPLOYMENT="<embedding-deployment-name>"

import os
from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from azure.ai.projects import AIProjectClient
from azure.search.documents import SearchClient
from azure.search.documents.models import VectorizedQuery
from openai import OpenAI

credential = DefaultAzureCredential()
embedder = OpenAI(base_url=os.environ["FOUNDRY_OPENAI_BASE_URL"],
                  api_key=get_bearer_token_provider(credential, "https://ai.azure.com/.default"))
search = SearchClient(endpoint=os.environ["SEARCH_ENDPOINT"],
                      index_name=os.environ["SEARCH_INDEX"], credential=credential)
project = AIProjectClient(endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"], credential=credential)
openai = project.get_openai_client()

query = "How many days of compassionate leave can I take?"

# 1 Retrieve: a hybrid query sends the keywords AND the query's own embedding
vector = embedder.embeddings.create(
    model=os.environ["EMBEDDING_DEPLOYMENT"], input=query).data[0].embedding
results = search.search(
    search_text=query,
    vector_queries=[VectorizedQuery(vector=vector, k_nearest_neighbors=3, fields="content_vector")],
    select=["id", "title", "content"],
    top=3,
)
# 2 Augment: label every source with its id so the model can cite it
sources = "\n".join(f"[{doc['id']}] {doc['title']}: {doc['content']}" for doc in results)

# 3 Generate: grounded instructions, then the question and the sources
response = openai.responses.create(
    model=os.environ["FOUNDRY_MODEL_NAME"],
    instructions=("Answer ONLY with facts from the sources. Cite each fact with its [id]. "
                  "If the sources don't contain the answer, say you don't know."),
    input=f"Question: {query}\n\nSources:\n{sources}",
)
print(sources, "\n---\n", response.output_text)

[leave-2] Leave policy: <your paragraph>
[leave-1] Leave policy: <your paragraph>
 ---
 <a short answer using only those paragraphs, with [leave-2] after the fact it came from>

# loop.py: the same imports, client, SHIPMENTS, function and tools as tool_flow.py,
# with Step 1 and Step 2 replaced by this loop.
FUNCTIONS = {"get_shipment_status": get_shipment_status}   # the ONLY functions the model may reach
MAX_STEPS = 5                                              # never let a loop run unbounded

response = openai.responses.create(
    model=MODEL, tools=tools, tool_choice="auto",
    input="Check parcels LG-221, LG-104 and LG-999. Which ones need a follow-up call?",
)
for step in range(1, MAX_STEPS + 1):
    calls = [item for item in response.output if item.type == "function_call"]
    if not calls:
        break                                   # no more tool requests: the model has answered
    outputs = []
    for call in calls:                          # may be several calls in one response
        if call.name not in FUNCTIONS:
            result = {"error": f"unknown tool {call.name}"}
        else:
            result = FUNCTIONS[call.name](**json.loads(call.arguments))
        print(f"TRACE step {step}: {call.name}({call.arguments}) -> {result}")
        outputs.append({"type": "function_call_output",
                        "call_id": call.call_id, "output": json.dumps(result)})
    response = openai.responses.create(model=MODEL, tools=tools,
                                       previous_response_id=response.id, input=outputs)
else:
    print("TRACE: reached MAX_STEPS; the answer below may be incomplete")

print(f"TRACE final: {response.output_text}")

TRACE step 1: get_shipment_status({"tracking_id":"LG-221"}) -> {'status': 'held at customs', ...}
TRACE step 1: get_shipment_status({"tracking_id":"LG-104"}) -> {'status': 'delivered', ...}
TRACE step 1: get_shipment_status({"tracking_id":"LG-999"}) -> {'error': 'unknown tracking id'}
TRACE final: <LG-221 needs a call about customs; LG-999 needs a call to check the tracking id; LG-104 is delivered>

# Week 1 installed 2.3.0 or later; the newest evaluation how-to needs 2.4.0 or later.
# Upgrade once now: 2.4.0 is the course floor from here on.
pip install --upgrade "azure-ai-projects>=2.4.0" azure-identity

# A judge model deployment for AI-assisted evaluators (Session 4 steps).
# Learn's portal page gives gpt-4.1-mini as an example of a judge model.
export FOUNDRY_MODEL_NAME="<judge-deployment-name>"

# eval_data.py: illustrative rows shaped like your Session 7 RAG app's output
SCHEMA = {
    "type": "object",
    "properties": {"query": {"type": "string"}, "context": {"type": "string"},
                   "response": {"type": "string"}},
    "required": ["query", "context", "response"],
}
ROWS = [
    {"query": "How many days of compassionate leave can I take?",
     "context": "[leave-2] Staff may take up to five days of compassionate leave per year.",
     "response": "You can take up to five days a year [leave-2]."},
    {"query": "Can I carry compassionate leave into next year?",
     "context": "[leave-2] Staff may take up to five days of compassionate leave per year.",
     "response": "Yes, unused days roll over for twelve months [leave-2]."},   # fabricated
    {"query": "Who approves leave?",
     "context": "[leave-3] Line managers approve leave requests in the HR portal.",
     "response": "The weather in Lagos is warm this week."},                # irrelevant
]

# Only if you deleted the Session 7 search service. It bills by the hour from now.
az search service create \
    --name "<your-search-name>" \
    --resource-group rg-ai103 \
    --sku basic \
    --auth-options aadOrApiKey \
    --aad-auth-failure-mode http401WithBearerChallenge

# Then, as in Session 7: re-add your two search roles in Access control (IAM),
# redeploy the chat and embedding models, and rebuild the index.
python build_index.py

# After you add the connection in the portal (next step), note its name.
# SEARCH_CONNECTION_NAME is the name Learn's Azure AI Search tool sample uses.
export SEARCH_CONNECTION_NAME="<your-connection-name>"

import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient

project = AIProjectClient(
    endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
)

# What is this project wired to? Credentials are NOT returned unless you ask for them.
for connection in project.connections.list():
    print(f"name={connection.name}")
    print(f"  type={connection.type}  default={connection.is_default}")
    print(f"  target={connection.target}")
    print(f"  auth={connection.credentials.type}")

name=<your-connection-name>
  type=CognitiveSearch  default=<True or False>
  target=https://<your-search-name>.search.windows.net
  auth=AAD
... (other connections your project already has)