Applied Generative AI with Python

Module 1 — Generative AI and LLMs

• Overview of Generative AI: Definition, history, and applications.
• Understanding Large Language Models (LLMs): Architecture, capabilities, and limitations.
• Ethical considerations in AI development and deployment.

Module 2 — Introductory Machine Learning and Deep Learning

• Compare supervised, unsupervised and reinforcement learning at an introductory level.
• Deep Learning basics: Neural networks, activation functions, and backpropagation.
• Implement selected small ML and neural-network examples using scikit-learn and a compatible TensorFlow/Keras environment.

Module 3 — Hosted APIs and Local Inference

• Understanding APIs: RESTful APIs, authentication, and data exchange formats.
• Use the supported OpenAI API/SDK for a selected text-generation task; keep keys outside source code.
• Compare Hugging Face Transformers inference with hosted APIs; use the runtime and hardware required by the selected model.
• Compare DeepSeek's API integration pattern and provider-specific model availability, data handling and limits.

Module 4 — Prompting and Evaluation

• Designing effective prompts: Principles and best practices.
• Compare zero-shot and few-shot instructions; use prompting techniques appropriate to the model rather than assuming explicit chain-of-thought requests improve every model.
• Generate and compare prompt variants using a small evaluation set.
• Hands-on activity: Crafting prompts for various AI tasks.

Module 5 — Chains, Agents and State

• Introduction to LangChain: Purpose and core components.
• Build a narrow chain or tool-using agent; distinguish orchestration from autonomous production authority.
• Implementing memory and state management in applications.
• Guided exercise: a small conversational workflow with bounded state and clear failure handling.

• Use current supported LangChain interfaces, such as create_agent for an appropriate agent example.
• Restrict tool access, validate results and provide review points rather than run unrestricted automation.

Module 6 — Retrieval-Augmented Generation

• RAG architecture, potential grounding benefits and remaining retrieval/generation failure modes.
• Implementing RAG for document retrieval and question answering.
• Evaluate retrieval relevance, answer grounding, latency and failure cases; RAG does not guarantee factual accuracy.
• Exercise: a source-grounded document Q&A or summarisation prototype with references checked against the retrieved material.

Module 7 — Selected Python Techniques

Decorators:

• Understanding decorators and their use cases.
• Use decorators for reusable logging and monitoring; discuss how wrappers fit into, rather than replace, authentication controls.

Recursion:

• Concept of recursion and its applications.
• Solving problems involving deeply nested data structures.

Parallel Computing:

• Introduction to multiprocessing and multithreading in Python.
• Choose concurrency patterns suited to the workload, with bounded resource use and error handling.

Module 8 — Application Prototype

• Chatbot example combining a selected model interface and LangChain.
• Document-assistance example using retrieval and source checking.
• Code-assistance example with review and controlled execution.
• Develop one scoped prototype incorporating selected course techniques; compare the other application patterns through demonstrations.

Module 9 — Packaging, Deployment and Operational Review

• Containerizing applications using Docker.
• Demonstrate deployment in one selected cloud or learning environment; compare AWS and Azure requirements without deploying to every platform.
• Discuss monitoring, maintenance, cost and scaling considerations and identify gaps before production use.

• Evaluate the prototype against sample tasks and document incorrect or unsupported responses.
• Review secret handling, input/output validation, resource usage and remaining production requirements.