
Explore building apps with OpenAI's API, libraries, models, and the agent SDK, from setup and hello world to advanced tool use and RAG.
Understand how the Udemy review system affects course visibility and standing, and why five-star reviews and messages requesting improvements matter.
Vibe coding uses prompts to generate code with an llm, guiding it with clear resources. Watch attention limits, context window constraints, and library version issues to ensure accurate, library-specific code.
Explore core LLM concepts, including model versions and specialized tasks, prompt engineering, system versus user prompts, tokens and costs, context windows, and common hallucinations.
Learn to set up the OpenAI project on Mac or Windows, test a Hello World with an LLM, and instantiate the OpenAI client with required and optional parameters.
Install and configure a macOS Python project using uv for environments, brew for tools, and a .env file with OpenAI API keys to run main.py that calls the API.
Learn to set up a Windows development environment for the OpenAI SDK: install uv, create a virtual environment, install OpenAI and python-dotenv, and run a hello world example.
Instantiate the OpenAI client with a mandatory API key (via environment variables or a parameter), and access the libraries and objects by configuring timeout, max retries, and default headers.
Explore text generation fundamentals with two APIs—the responses API and the chat completions API—covering differences, roles, multi-turn conversations, streaming, reusable prompts, deep research, and structured output.
Compare the chat completions and responses APIs, show why the responses API is faster, more agentic, cache-enabled, and supports extended tool use, with optional state; note no audio support yet.
Explore generating responses from an LLM by selecting models, prompts, system instructions, and reasoning options, including multi-turn prompts, tools, and temperature controls.
Explore the api roles—developer, user, and assistant—and how to structure input as a message array. Learn that the system role is deprecated and replaced by developer for multi-turn conversations.
Create and continue multi-turn conversations with the Conversations API by obtaining a Conversation ID and passing it to the Responses API, enabling server-side storage and context across calls.
Explore using deep research with the Responses API, including web search tools and background mode. Learn to poll updates and manage token use with a practical project example.
Learn how streaming enables real-time generation by returning tokens as they are produced, using the stream flag and handling delta events, completion, and errors.
Create reusable prompts in the OpenAI console, define variables and tools, attach a developer message, and retrieve the prompt in code to generate consistent LLM responses.
Explore structured output from LLM responses using either a Pydantic model to coerce data into objects or a JSON mode for JSON output, with the JSON keyword required in prompts.
Compare the responses and images APIs to generate and edit images from image and text inputs, explore multi-turn editing, and examine vision limitations and streaming outputs.
The responses API supports multimodal reasoning with image input and text or image output, while the images API focuses on one-shot image generation and editing.
Learn to provide images as input for the responses API via URL, base64, or file ID, with PDF, JPEG, webp, and non-animated GIFs, and adjust detail level to downscale.
Generate an image with the responses API using a multimodal engine, passing the image generation tool and handling base64 data to save cat.png.
Learn to perform multi turn image generation with the responses API, iteratively refining images by referencing prior results. Use an action parameter to generate or edit images across turns.
Identify the major limitations of the responses API image generation and vision. English prompts perform best; other languages and medical use are restricted, with spatial, rotation, and small-text reading issues.
Explore image generation with the images API, including parameters like N, quality, size, streaming, and timeout, and code examples using images.generate to produce and store base64 PNGs.
Use an image as input for the image API, accepting a single image or a list, enabling vision and image generation with a prompt to generate a stylized tropical bird.
Use the images API to edit images by supplying input images and an optional mask to apply targeted changes, such as adding a UFO in the upper left corner.
Enable streaming for image generation by setting stream to true and partial_images to up to three, then observe progress through intermediate images and the final image in the Images API.
Identify image generation limitations in the images API, including latency, imperfect text rendering, and consistency across edits. Learn how composition, element counting, and prompt refinements affect outputs.
Sora has been discontinued and the app will shut down in April 2026, with API access lasting until September 2026 due to cost issues.
Explore video generation from prompts to endpoints, including rendering, progress tracking, and downloading. Seed videos from an image or a character, animate movements, and apply edits within system limitations.
Start with Sora 2 for cost-efficient video generation, then upgrade to Sora 2 Pro. Poll video ID and download the 20-second video via an asynchronous workflow after starting the render.
Use an image reference as the first frame to animate a robot, matching the target video size and generating a 4-second video via API with no people or text.
Create a 2 to 4 second animation from a character reference by uploading the character to videos/characters, then generate final video in a futuristic charging station, monitoring progress until completion.
Edit generated videos by supplying a video ID and a prompt to the edit endpoint, producing neon, flashy results via the Sora backend; personalize and queue edits.
Explore audio and speech APIs, including speech-to-speech input/output and transcription-to-speech pipelines, plus end-to-end systems from transcription to speech.
Explore the audio and speech APIs used in voice-enabled AI, including real-time, chat completions, transcriptions, speech, and responses APIs.
Demonstrate speech-to-speech via a browser-based web app using the real-time API, converting spoken input to natural audio responses from an LLM, and moving from Python to a web server demonstration.
Learn to process audio input with the chat completions API by converting a wav file to base64, passing it as input audio with modalities text, and receiving text output.
Shows how to generate audio output with the chat completions API by setting modalities to audio, choosing a voice and format, converting base64 to wav, and coordinating text and audio.
Explore how the transcription API converts audio to text, passes the result through the responses API, and then converts it into speech, with English best and a 25 MB limit.
Learn how the Speech API converts text to audio speech with multiple voices and personalization for accent and intonation. See code example with input model prompts and an mp3 output.
Convert audio input with the transcription API to text. Process the text with the responses API using GPT 5.5 and output audio with the speech API in an end-to-end flow.
Explore tools for OpenAI models, covering categories of tools, function tools, built-in tools like web search and shell access, skills, MCP protocol, and code interpreters, plus the user–LLM workflow.
Learn how tools extend model capabilities by enabling actions like data retrieval and API calls, using built-in and custom tools, and coordinating single or multiple tool calls in designed workflows.
Expose custom tools to the model by defining functions with clear names, descriptions, and input parameters via JSON. See a getWeather function invoked and results returned via the responses API.
Discover how custom tools enable flexible, parameterless function calls by handling arbitrary strings, with a practical example of a generic SQL query tool querying a PostgreSQL database.
Learn to integrate the web search tool into models, filter allowed and blocked domains, request complete sources with full URLs, and use user location for contextual results.
Explore how the Shell tool provides a sandboxed environment for the model, with admin-controlled access to an OpenAI hosted container and commands to inspect the environment.
Discover how OpenAI skills extend tools into versatile missions, using the agent skill standard, skills.md, and a sandboxed container. Build, package, and invoke skills with prompts, code, and resources.
Connect your model to external capabilities via the model context protocol, effectively acting as an api to access data, tools, and functionality on a hosted server.
Explore the code interpreter tool to run Python code in a sandbox, generating code, executing it in an auto container, and returning Fibonacci numbers, factorials, and primes with explanations.
Explore retrieval augmented generation, its problems and solutions, then set up a vector store with proprietary data to enable the model to research questions.
Learn how retrieval augmented generation enables access to private knowledge by embedding data, creating a vector store, and enabling the model to retrieve relevant information via OpenAI APIs.
Set up OpenAI's vector store by uploading PDFs as embeddings with the vector stores API, create the store and obtain its ID to enable model retrieval.
Demonstrates retrieval using a vector store and file search tool, limiting results and including sources, then queries two files for answers on King Sverre of Norway and FIS disciplines.
Explore token counting and cost awareness, manage long-running conversations with state and compaction, trigger model reasoning, and optimize workflows with background tasks, WebSockets, and prompt caching.
Count input and output tokens to estimate costs when sending requests. Track tokens across messages, conversations, images, and tool use to understand total consumption.
Explore three methods to maintain conversation state: send all messages with every request, use a response ID, or manage a backend conversation ID via the Conversations API.
Learn how compaction summarizes long conversations to fit the model's context window. See how the responses API compacts dialogue to reduce tokens, lower costs, and speed responses.
Explore how reasoning lets newer models plan, use tools, and consider alternatives, with variable effort levels and potential latency, while balancing token limits and costs.
Learn to run long reasoning tasks asynchronously in the background, keeping the main thread unblocked while streaming tokens. Manage background tasks by checking progress and canceling when needed.
Learn how to use WebSockets to maintain an open connection to a back-end endpoint, authenticate with an OpenAPI key, exchange JSON payloads and responses, and close the socket when finished.
Harness prompt caching to reuse the same prompts across requests, reducing latency and costs, using a cache key and 24-hour retention, as shown with a catalog example.
Explore how evaluations automate testing for the system built with LLMs, outlining the full run from datasets and input data to tasks, grader parameters, and the final generated report.
Explore evaluations by outlining the dataset, prompts, developer role, graders, and run workflow that assess model outputs. See how automated checks and behavior-driven development keep behavior correct as features grow.
Explore datasets as test cases with inputs and expected outputs, evaluate model responses using multiple graders, and create a customer support dataset uploaded as JSON via the OpenAI client.files API.
Define the task by configuring setup, evaluation, input schema, and data source config to declare available and required test data, then create an eval with a name and testing criteria.
Graders define testing criteria by evaluating the model's response against the input and expected result using string checks, with two graders and operations like equal, not equal, like, and I like.
Define the data source, instructions, and user prompt, then run and evaluate the responses, grade the results, and generate a run report to verify test outcomes.
This course is a complete, hands-on guide to mastering the OpenAI API and building modern AI applications with the latest OpenAI tools and technologies.
This is an Engineer's guide to using OpenAI and its libraries to build robust and efficient apps using AI and Agents.
OpenAI is at the center of the AI revolution, powering everything from chatbots and coding assistants to AI agents, voice systems, image generation, retrieval systems, and autonomous workflows. Knowing how to use these APIs effectively is becoming one of the most valuable skills in software engineering and AI development.
In this course, you will go from zero to advanced OpenAI development step by step.
Every section is designed around practical, real-world workflows and production-ready patterns.
We will cover:
• Responses API and multi-turn conversations
• Prompt engineering, structured outputs, and streaming
• Vision models, image generation, and image editing
• Video generation with Sora
• Speech, transcription, and voice workflows
• Function tools, MCP, shell tools, and code interpreter
• Retrieval Augmented Generation (RAG) and vector stores
• Evaluations, datasets, graders, and eval runs
• Agent SDK, orchestration, guardrails, and sandboxing
• Human In The Loop workflows (HITL) and approval systems
By the end of this course, you will be confident building real AI applications using the OpenAI ecosystem, from simple prompts to advanced multi-agent systems and production-ready AI workflows.