Build AI Applications with OpenAI APIs and ChatGPT Models

In this lecture, you’ll build a clear mental model of what a language model actually does. We’ll talk about how it predicts the next token, why it sometimes makes mistakes, and what that means for you as a developer. By the end, you’ll understand LLMs as a practical tool you can reason about, not magic.

Here you’ll learn how chat-style APIs work under the hood: system vs user vs assistant messages, and how they shape behavior. We’ll demystify tokens (why they matter for length and cost) and temperature (why it makes answers more creative or more stable). After this lecture, you’ll know how to control model behavior instead of just “hoping for a good answer.”

This lecture covers common gotchas when working with LLMs: hallucinations, over-trust, leaking sensitive data, and relying on the model for things it shouldn’t decide. We’ll also discuss when LLMs are a good fit (summarization, retrieval, assistants) and when traditional code or search is a better choice. You’ll leave with a simple mental checklist for “should I use an LLM here?”.

In this lecture, you’ll get a fast, high-level tour of the OpenAI platform from a developer’s point of view. We’ll look at the main model families (chat, embeddings, vision), how requests and responses are structured, and where to find docs, pricing, and usage dashboards. By the end, you’ll be ready to dive into the hands-on demos without feeling lost.

In this lecture, you’ll get your development environment ready for the rest of the course. We’ll walk through installing or confirming VS Code, Python, Node, and a few extensions that make working with APIs easier. We’ll also talk about how the course ZIP files are structured so you can open a demo folder, install dependencies, and run it with minimal friction. By the end, you’ll be confident that your machine is ready for all upcoming demos.

This lecture shows you how to handle your OpenAI API key safely in real projects. We’ll cover using environment variables and a .env file, keeping secrets out of source control, and simple patterns to avoid leaking keys in logs or error messages. You’ll also see how to switch between mock mode and live API calls when running the demos. By the end, you’ll know how to use your API key without hard-coding it or putting it at risk.

In this demo lecture, you’ll build two small HTTP endpoints: one in Python (FastAPI) and one in Node (Express). Each endpoint accepts a user prompt, forwards it to the OpenAI Chat API, and returns the model’s response. We’ll walk through the code structure, environment configuration, and how to test each endpoint with a tool like Postman. After this lecture, you’ll know how to expose a simple “AI endpoint” that your own apps, front-ends, or other services can call.

In this demo, you’ll see how to take a “just okay” prompt and improve it step by step. We’ll compare different prompt versions side by side, look at how small wording changes affect the output, and track simple scores (like clarity or keyword hits). By the end, you’ll know how to debug a weak prompt instead of starting from scratch every time.

This demo shows how the chat message roles actually change behavior. You’ll see the same request run in three ways: just a user prompt, a system+user combo, and a few-shot example with an assistant message. We’ll compare the outputs and discuss when to use each role. After this lecture, you’ll be able to “shape” the model’s personality and style more intentionally.

Here, you’ll learn how to ask the model for structured JSON, not just free-form text. We’ll send a JSON schema to the model, try to parse its response, and handle common problems like extra text, bad quotes, or invalid fields. You’ll also see a simple validation step so your app doesn’t crash on messy output. By the end, you’ll know how to turn model replies into safe, typed data your code can rely on.

In this demo, you’ll build a tiny “prompt pipeline”: one step to plan or clarify the task, and another step to produce the final answer. Then we’ll add simple automated checks to see if the answer meets basic rules (length, keywords, audience, etc.). This helps you catch weak answers early and improve prompts in a systematic way. After this lecture, you’ll see prompts less as one-off calls and more as a small, testable workflow.

This demo focuses on using the model to write real code and then checking that code automatically. We’ll ask the model to implement a small function, extract the code, run tests against it, and see which cases pass or fail. You’ll see how to accept good generations, reject bad ones, and iterate. By the end, you’ll understand how to safely use LLMs for coding tasks instead of blindly trusting whatever comes back.

In this demo, you’ll see the difference between asking the model a question “from scratch” versus giving it relevant docs first. We’ll run the same question with no context and then with product docs injected, and compare the answers. By the end, you’ll understand why RAG matters and when plain prompting isn’t enough.

Here you’ll learn how to turn a small folder of text docs into a searchable vector index using FAISS and OpenAI embeddings. We’ll load documents, generate embeddings, build the index, and run similarity search to find the best matches for a question. After this lecture, you’ll know how to create a simple local “search brain” for your own documentation or notes.

In this demo, we take RAG one step closer to production. You’ll see how to precompute embeddings once, save them, and reuse them at query time instead of recomputing on every request. We’ll wire this into a small pipeline that loads embeddings, retrieves top documents, and calls the chat model with that context. By the end, you’ll understand a realistic RAG flow that’s faster and cheaper to run.

This demo focuses on what to do when your docs don’t fit into the model’s context window. You’ll see how to slice documents into chunks, pick only the most relevant pieces, and “stitch” them into a prompt that stays under a size budget. We’ll compare a naive “stuff everything” approach with a trimmed, stitched prompt. After this lecture, you’ll know how to manage context size so your RAG system stays accurate and efficient.

In this demo, you’ll take a small set of chat-style examples and turn them into a clean training dataset. We’ll check for common issues like missing assistant messages, wrong roles, bad content, or overly long examples, then split into train and eval files. By the end, you’ll understand what a “fine-tuning-ready” dataset looks like and how to catch basic problems before uploading anything.

This demo walks through the full fine-tuning flow using a tiny support dataset. You’ll upload training and eval files, create a fine-tuning job, monitor its status, and then call the resulting tuned model. We’ll compare answers from the base model and the fine-tuned one to see how behavior changes. After this lecture, you’ll know the practical steps and trade-offs involved in fine-tuning, and how to avoid common pitfalls.

In this demo, you’ll explore when you don’t need fine-tuning. We’ll compare three patterns: plain prompting, instruction-heavy prompts, and retrieval-first (RAG) using local docs. You’ll see how far you can get with better prompts and retrieval before paying for a tuned model. By the end, you’ll have a mental checklist for “fine-tune vs RAG vs just better prompts” in real projects.

In this demo, you’ll compare two common ways to host LLM-powered apps: serverless (functions-as-a-service) and serverful (long-running backend). We’ll look at how each affects latency, cost, deployment, and where you keep state. By the end, you’ll understand when a simple serverless endpoint is enough and when you might want a full API server instead.

This demo shows how to build a chat backend that streams model responses token by token. You’ll see how to expose a streaming endpoint, handle partial chunks on the server, and understand the difference between “one big response” and “live typing” behavior. After this lecture, you’ll be ready to power UIs that feel responsive and interactive, not laggy.

Here you’ll build a simple React chat interface that talks to your streaming backend. We’ll render messages in a chat layout, stream tokens into the UI, and support Markdown/code blocks so answers look like a real developer assistant. By the end, you’ll know how to connect a front-end to your AI endpoint and give users a polished chat experience.

In this demo, you’ll see how to give the model a set of tools (functions) it can call and let it decide when to use them. We’ll walk through a simple agent loop: the model plans, calls a tool with arguments, reads the result, and then replies to the user. By the end, you’ll understand the core idea of “tools as capabilities” and how to structure agent prompts so they stay on track.

This demo shows how to let an agent write and run code safely. You’ll build a small tool that executes model-generated code inside a sandbox and runs unit tests against it. The agent can iterate: write some code, run tests, see failures, and try again. After this lecture, you’ll understand how to combine LLMs with execution while keeping a clear safety boundary.

In this demo, you’ll add guardrails around a sensitive tool (like a mock money transfer). We’ll validate tool arguments, block risky requests, and show how pre-checks can stop dangerous prompts before the model or tool runs. You’ll see examples of safe vs blocked flows. By the end, you’ll know how to wrap tools so agents can be powerful without being reckless.

In this demo, you’ll treat LLM prompts like code and actually test them. We’ll create small unit-style checks (for JSON shape, word limits, required headings) and a simple integration test that verifies multi-step behavior. By the end, you’ll know how to detect broken or low-quality responses automatically instead of only relying on manual spot checks.

Here you’ll build a tiny “evaluation harness” that runs a batch of tasks through the model, scores the outputs with simple rules, and decides which ones look good vs which need human review. We’ll write results to JSONL files, including a small queue that a human could review later. After this lecture, you’ll understand how to combine automatic scoring with human-in-the-loop for higher quality.

This demo focuses on seeing what your LLM app is actually doing in practice. You’ll log each request and response with metadata like latency, status, and token usage, then store it in SQLite. We’ll compute basic stats per scenario and talk about how a tool like Grafana could visualize this data. By the end, you’ll know how to instrument your app so you can catch spikes, errors, and costly patterns early.

In this demo, you’ll see how small design choices can dramatically change token usage and cost. We’ll compare a “naive” approach (long, repetitive prompts and separate calls) with an optimized one that trims instructions and batches multiple tasks into a single request. By the end, you’ll know practical tricks to reduce tokens and API calls while keeping the same quality of results.

This demo simulates heavy traffic hitting an LLM backend. You’ll compare a fixed worker pool, an autoscaling pool that spins up more workers under load, and a version that enforces backpressure by limiting the queue. We’ll look at completed requests, timeouts, and latency for each strategy. After this lecture, you’ll understand the trade-offs between “never drop requests” and “keep the system healthy” in real deployments.

Here you’ll explore per-user and global rate limiting using a simple local simulation. We’ll generate traffic from multiple users, apply limits over sliding windows, and see which requests are allowed vs throttled. You’ll learn how rate limiting protects your system, prevents abuse, and keeps things fair across users. By the end, you’ll have a clear mental model of how to add basic throttling to LLM-powered APIs.