Microsoft Azure AI Fundamentals

AI systems can harm people when no one is watching, so principles come first. You study fairness, reliability, privacy, inclusiveness, transparency and accountability, and learn how they show up in real design choices.

• Fairness and how bias enters a system
• Reliability and safety under unexpected input
• Privacy and security of data
• Inclusiveness and accessibility
• Transparency and accountability
• Content safety and filtering

You build A responsible AI review of one sample solution, with a risk and a mitigation under each principle.

You do not need a research degree to use a model well, but you do need a picture of what is inside. You learn how text becomes tokens and embeddings, how a model is trained, and why it can write well and still be wrong.

• Tokens, embeddings and context
• Training, parameters and what a model learns
• Transformers in plain terms
• Pre-training, fine-tuning and grounding compared
• Text, image and multimodal models
• Why models make things up

You build A short explainer, in your own words and drawings, of how a prompt becomes an answer.

Picking a model is a trade between ability, cost and speed. You compare models by what they can do, choose a deployment option, and set parameters such as temperature and output length to shape behavior.

• Reading a model’s capabilities and limits
• Size, cost and speed trade-offs
• Deployment options for a model
• Temperature, top-p and maximum output
• Testing a model on your own examples

You build A comparison of two models on the same task, with the settings you chose and why.

Foundry is where the hands-on work happens. You set up a project, understand the resources and endpoints behind it, sign in safely, and make your first call from Python with the Foundry SDK.

• The Foundry portal and projects
• Resources, endpoints and authentication
• Deploying a model in a project
• Calling a model from Python
• Keeping keys out of your code

You build A Foundry project with a deployed model and a Python script that calls it.

A chat app is a loop around a prompt. You write system and user prompts, add examples to steer the output, keep the conversation history, and build a simple chat client that streams answers back.

• System prompts and user prompts
• Giving examples to shape the answer
• Keeping conversation history
• Streaming responses
• Testing a prompt against awkward input

You build A Python chat client with a system prompt and memory of the conversation.

An agent goes beyond answering: it follows instructions and uses tools. You create a single agent in Foundry, give it instructions and a source of knowledge, and test how it behaves on tasks and edge cases.

• What an agent adds to a chat
• Writing agent instructions
• Giving an agent knowledge to draw on
• Adding a tool the agent can call
• Running and testing an agent

You build A single agent that answers questions from a small document set and calls one tool.

Language and voice are everywhere in business. You build small apps that find sentiment, key phrases and entities in text, translate and summarize it, and convert speech to text and text to speech.

• Sentiment, key phrases and entities
• Summarizing and translating text
• Speech to text
• Text to speech and voice choices
• Combining text and speech in a small app

You build A small app that transcribes a spoken message and returns its sentiment and a summary.

Models can now see as well as read. You send images to a model and ask questions about them, generate images from prompts, and learn where visual models are unreliable.

• Sending an image to a multimodal model
• Describing and asking questions about images
• Generating images from prompts
• Limits and safety of image models
• Choosing between vision approaches

You build An app that answers questions about an uploaded image and generates a variant from a prompt.

Invoices, forms and contracts hold data that nobody wants to retype. You use Content Understanding to define the fields you need, run documents through it, and check the confidence of what comes back.

• What information extraction does
• Content Understanding analyzers and fields
• Running documents and reading the results
• Confidence and when to ask a person
• Extracting from images, audio and video

You build A pipeline that pulls fields from sample invoices and flags those it is unsure about.

One small project uses what you have learned. You pick a problem, choose the workload and model, build the app in Foundry, check it against the responsible AI principles, and show it working.

• Choosing a problem and workload
• Selecting and configuring the model
• Building the app with Foundry
• Reviewing it against responsible AI principles
• Demonstrating and explaining your choices

You build A finished small AI app, with a short review of its risks and how you handled them.