Certification in Agentic AI Program

Python Programming:

Build fluency in variables, data types, conditions, loops, collections, functions and modules so learners can solve problems and write reusable programs independently.

Files, Errors and Type-Safe Code:

Work with files, exceptions and type hints while learning to structure programs that are easier to understand, validate and maintain.

Debugging and Testing:

Use systematic debugging, assertions and introductory automated tests to identify failures rather than relying on trial-and-error coding.

Developer Workflow:

Set up notebooks, VS Code and the command line, and use Git and GitHub to manage code, changes and reproducible technical work.

APIs and Data Acquisition:

Understand HTTP, REST and JSON, and use Python requests, environment variables and API credentials to work safely with external data sources.

Data Preparation:

Use NumPy, Pandas and basic SQL to inspect, clean, transform and combine data before it enters a machine learning or AI workflow.

Machine Learning Fundamentals:

Understand supervised and unsupervised learning, features and targets, regression and classification, and how real questions become measurable learning tasks.

Transformer and LLM Foundations:

Build a high-level mental model of tokenisation, embeddings, positional information, self-attention and decoder-only transformers, without entering unnecessary mathematical detail.

Pre-Training and LLM Limitations:

Connect next-token pre-training and instruction tuning to hallucination, prompt sensitivity, context limits, stale knowledge and non-determinism, establishing why LLM systems require evaluation and control.

LLM APIs and Prompt Design:

Call language models through APIs and structure instructions, messages, context and examples while decomposing complex tasks into manageable steps.

Structured Outputs and Reliability:

Generate schema-constrained outputs, validate responses, handle failures and balance quality against context, latency and cost.

Agentic Workflow Design:

Understand degrees of autonomy, task decomposition and the difference between deterministic workflows and systems that dynamically decide their next action.

Tools and Structured Actions:

Implement tools as typed Python functions with validated inputs, outputs and error handling before introducing any agent framework.

Reason + Act (ReAct):

Build the reasoning-action-observation loop in raw Python so an agent can select a tool, use its result, iterate and stop under explicit conditions.

Reflection and Planning:

Introduce generator-critic, evaluator-optimizer and plan-and-execute patterns for controlled iteration, feedback and replanning.

Early Agent Evaluations:

Define success criteria, create representative test cases and use basic error analysis to compare agent behaviour across system versions.

Embeddings, Retrieval and RAG:

Represent meaning with embeddings and build grounded LLM responses over chunked documents using semantic retrieval, metadata, source evidence and citations.

RAG Quality:

Recognise chunking, retrieval and grounding failures and apply introductory checks for retrieval relevance and answer faithfulness.

LangChain Essentials:

Use model, prompt, structured-output, retriever and tool abstractions to rebuild first-principles LLM and agent workflows with reusable components.

LangGraph and Stateful Orchestration:

Represent execution through nodes, edges, state and conditional routing, with introductory checkpointing and human intervention.

Agent State and Memory:

Distinguish context, state and memory while introducing short-term and long-term memory, persistence, summarisation, context trimming and basic privacy considerations.

Workflow Orchestration:

Use LangGraph state, routing and conditional edges to combine retrieval, structured tools and model decisions in controlled multi-step workflows.

Memory and Persistence:

Add conversation memory, persistent checkpoints, context management and resumable execution to support reliable multi-turn interactions.

Reliability and Human Control:

Introduce retries, fallbacks, tool-error handling, approval steps and basic protection against prompt injection.

Evaluation and Automated Testing:

Create representative test cases and use pytest, structured assertions and mocked tools to check outputs, tool use, retrieval, memory and failure paths.

FastAPI Services:

Expose an agent through typed FastAPI routes using Pydantic request and response models, validation, configuration, error handling and basic streaming.

Deployment Basics:

Add structured logging, request identifiers, a simple interface and a deployable configuration that takes the application beyond a notebook.