AI-103 CERTIFICATION BOOTCAMP

# For recognition only: how Learn's Python quickstart declares vector search
SearchField(
    name="DescriptionVector",
    type=SearchFieldDataType.Collection(SearchFieldDataType.Single),
    searchable=True,
    vector_search_dimensions=1536,
    vector_search_profile_name="my-vector-profile",
)
vector_search = VectorSearch(
    algorithms=[HnswAlgorithmConfiguration(name="my-hnsw-vector-config-1")],
    profiles=[VectorSearchProfile(
        name="my-vector-profile",
        algorithm_configuration_name="my-hnsw-vector-config-1",
    )],
)

import os
from azure.identity import DefaultAzureCredential
from azure.search.documents import SearchClient
from azure.search.documents.models import VectorizableTextQuery

client = SearchClient(
    endpoint=os.environ["AZURE_SEARCH_SERVICE_ENDPOINT"],
    index_name=os.environ["SEARCH_INDEX"],  # course-own name
    credential=DefaultAzureCredential(),
)
QUESTION = "<a question your users really ask>"

def text_vector(k):
    # The index's vectorizer turns the text into a vector at query time
    return VectorizableTextQuery(
        text=QUESTION, k_nearest_neighbors=k, fields="text_vector", kind="text"
    )

runs = {
    "keyword": dict(search_text=QUESTION, top=5),
    "vector": dict(vector_queries=[text_vector(5)]),
    "hybrid + semantic": dict(
        search_text=QUESTION,
        vector_queries=[text_vector(50)],
        query_type="semantic",
        semantic_configuration_name=os.environ["AZURE_SEARCH_SEMANTIC_CONFIG"],
        top=5,
    ),
}
for label, args in runs.items():
    print(f"\n=== {label} ===")
    for r in client.search(select=["title", "chunk"], **args):
        rerank = r.get("@search.reranker_score")
        print(f"{r['@search.score']:.4f} rerank={rerank} {r['title']}: {r['chunk'][:60]}")

=== keyword ===
<score> rerank=None <title>: <first 60 characters of the chunk>
...
=== vector ===
<score> rerank=None <title>: <...>
...
=== hybrid + semantic ===
<score> rerank=<reranker score> <title>: <...>

import os
from azure.identity import DefaultAzureCredential
from azure.ai.projects import AIProjectClient
from azure.ai.projects.models import (
    AzureAISearchTool, AzureAISearchToolResource, AISearchIndexResource,
    AzureAISearchQueryType, PromptAgentDefinition,
)

project = AIProjectClient(
    endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
    credential=DefaultAzureCredential(),
)
openai = project.get_openai_client()
connection_id = project.connections.get(os.environ["SEARCH_CONNECTION_NAME"]).id

search_tool = AzureAISearchTool(azure_ai_search=AzureAISearchToolResource(
    indexes=[AISearchIndexResource(
        project_connection_id=connection_id,
        index_name=os.environ["SEARCH_INDEX"],
        query_type=AzureAISearchQueryType.VECTOR_SEMANTIC_HYBRID,
    )]
))
agent = project.agents.create_version(agent_name="index-agent", definition=PromptAgentDefinition(
    model=os.environ["FOUNDRY_MODEL_NAME"],
    instructions="Answer only from the search tool, cite every source, "
                 "and say you don't know if the index has no answer.",
    tools=[search_tool],
))
response = openai.responses.create(
    input="<a question your index can answer>",
    tool_choice="required",
    extra_body={"agent_reference": {"name": agent.name, "type": "agent_reference"}},
)
print(response.output_text)
for item in response.output:
    if item.type == "message" and item.content[-1].type == "output_text":
        for annotation in item.content[-1].annotations:
            if annotation.type == "url_citation":
                print("Citation:", annotation.url)
project.agents.delete_version(agent_name=agent.name, agent_version=agent.version)

<the agent's answer, built from passages in your index>
Citation: <a reference to a document in your index>

import os
from azure.identity import DefaultAzureCredential
from azure.ai.documentintelligence import DocumentIntelligenceClient
from azure.ai.documentintelligence.models import AnalyzeResult

client = DocumentIntelligenceClient(
    os.environ["DOCUMENTINTELLIGENCE_ENDPOINT"], DefaultAzureCredential()
)
PATH = "receipt.jpg"  # your own photo, personal details covered

# Stages 1 and 2: OCR and layout in one call
with open(PATH, "rb") as f:
    poller = client.begin_analyze_document("prebuilt-layout", body=f)
layout: AnalyzeResult = poller.result()
for page in layout.pages:
    print(f"Page {page.page_number}: {len(page.lines or [])} lines")
    for line in (page.lines or [])[:5]:
        print("  OCR:", line.content)
print("Tables:", len(layout.tables or []))
if layout.styles and any(style.is_handwritten for style in layout.styles):
    print("Handwritten content found")

# Stage 3: field extraction with a prebuilt model
with open(PATH, "rb") as f:
    poller = client.begin_analyze_document("prebuilt-receipt", body=f, locale="en-US")
receipts: AnalyzeResult = poller.result()
for receipt in receipts.documents or []:
    merchant = receipt.fields.get("MerchantName")
    if merchant:
        print(f"MerchantName: {merchant.get('valueString')} ({merchant.confidence})")
    date = receipt.fields.get("TransactionDate")
    if date:
        print(f"TransactionDate: {date.get('valueDate')} ({date.confidence})")

Page 1: <number> lines
  OCR: <first line of your receipt>
  ...
Tables: <number>
MerchantName: <the shop name> (<confidence between 0 and 1>)
TransactionDate: <the date> (<confidence>)

import os
from azure.identity import DefaultAzureCredential
from azure.ai.contentunderstanding import ContentUnderstandingClient
from azure.ai.contentunderstanding.models import AnalysisResult

client = ContentUnderstandingClient(
    endpoint=os.environ["CONTENTUNDERSTANDING_ENDPOINT"],
    credential=DefaultAzureCredential(),
)

# A short PDF of your own with headings and at least one table
with open("policy.pdf", "rb") as f:
    poller = client.begin_analyze_binary(
        analyzer_id="prebuilt-documentSearch",
        binary_input=f.read(),
    )
result: AnalysisResult = poller.result()

content = result.contents[0]
print(content.markdown[:1500])  # headings and tables survive as Markdown
with open("policy.md", "w", encoding="utf-8") as out:
    out.write(content.markdown)

# <your first heading>
<paragraph text>
<table rows, as HTML or Markdown depending on the analyzer's table format>
...

import os
from azure.identity import DefaultAzureCredential
from azure.ai.contentunderstanding import ContentUnderstandingClient
from azure.ai.contentunderstanding.models import (
    ContentAnalyzer, ContentAnalyzerConfig, ContentCategoryDefinition,
    ContentFieldSchema, ContentFieldDefinition, ContentFieldType, GenerationMethod,
)

client = ContentUnderstandingClient(
    endpoint=os.environ["CONTENTUNDERSTANDING_ENDPOINT"],
    credential=DefaultAzureCredential(),
)
ANALYZER_ID = "ai103_s29_video"
config = ContentAnalyzerConfig(return_details=True, enable_segment=True, content_categories={
    "product-demo": ContentCategoryDefinition(
        description="A part of the video where an object is shown or demonstrated"),
    "other": ContentCategoryDefinition(
        description="Everything else, such as the introduction and closing"),
})
summary = ContentFieldDefinition(
    type=ContentFieldType.STRING, method=GenerationMethod.GENERATE,
    description="What happens in this segment, in one sentence")
client.begin_create_analyzer(analyzer_id=ANALYZER_ID, resource=ContentAnalyzer(
    base_analyzer_id="prebuilt-video", config=config,
    field_schema=ContentFieldSchema(name="segments", fields={"summary": summary}),
    models={"completion": "gpt-5.2", "embedding": "text-embedding-3-large"},
)).result()

with open("clip.mp4", "rb") as f:
    result = client.begin_analyze_binary(analyzer_id=ANALYZER_ID, binary_input=f.read()).result()
for content in result.contents:
    field = (content.fields or {}).get("summary")
    print(f"{content.start_time_ms}-{content.end_time_ms} ms [{content.category}]",
          field.value if field else "")
client.delete_analyzer(analyzer_id=ANALYZER_ID)

0-8000 ms [other] <a short introduction>
8000-52000 ms [product-demo] <what is demonstrated>
52000-60000 ms [other] <closing remarks>

import base64, 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()

def image_part(path, detail="low"):
    with open(path, "rb") as f:
        data = base64.b64encode(f.read()).decode("utf-8")
    return {"type": "input_image", "image_url": f"data:image/jpeg;base64,{data}", "detail": detail}

paths = ["site-1.jpg", "site-2.jpg", "site-3.jpg"]
content = [image_part(p) for p in paths]
content.append({"type": "input_text", "text":
    "These photos are from a warehouse safety walk. For each image, in order, "
    "write a concise caption of at most 12 words. Then write one detailed "
    "paragraph comparing all three."})

response = openai.responses.create(
    model=os.environ["FOUNDRY_MODEL_NAME"],  # a vision-enabled deployment
    input=[{"role": "user", "content": content}],
)
print(response.output_text)

1. <concise caption for site-1>
2. <concise caption for site-2>
3. <concise caption for site-3>
<one detailed paragraph comparing the three>