PG Certificate in Applied Generative Engineering & LLM Collab with iHub and IIT Roorkee

Learning objective

Establish the programming, systems and conceptual foundation required to build, test and integrate LLM-powered applications.

Topics 

• Python refreshers for AI applications  
• Virtual environments 
• APIs and SDKs 
• Git workflows 
• Tokens and tokenization  
• Embeddings 
• Transformer architecture  
• Attention 
• Context windows  
• Model families and model-selection criteria 

Tools 
Python, GitHub Copilot, ChatGPT, Streamlit, pandas, matplotlib, Seaborn, scikit-learn, LangSmith, venv, conda, uv, OpenAI SDK, Anthropic SDK, Google SDK, Git, GitHub, OpenRouter, LMSYS Chatbot Arena, SQL, NoSQL 
 
Project 

Model Picker CLI: An object-oriented Python tool that calls OpenAI, Anthropic and Google SDKs for the same prompt, logs tokens and cost via LangSmith, and outputs a cost/latency/quality comparison table. Add a small Streamlit UI and ship it on GitHub with venv/uv setup and a README. 

Learning Objective

Design reliable prompts and structured LLM interactions, and evaluate outputs for correctness, relevance, consistency and safety.

Topics

• System and user prompts 
• Few-shot prompting 
• Prompt templates 
• Chain-of-thought-aware design 
• JSON/schema-constrained outputs  
• Function/tool calling 
• Prompt-injection risks 
• Output quality metrics  
• Test sets and evaluation rubrics  
   

Tools 
LangChain, LangSmith, MLflow, Guardrails AI, Pydantic, OpenAI tool-calling API, Anthropic tool-use API, Promptfoo 

Project  
Support-Ticket Triage Prompt Pack: Prompts that classify a ticket into category, urgency and sentiment, returning a Pydantic-validated JSON schema. Build a 30-case test set, score accuracy in LangSmith/MLflow, run a Promptfoo injection test, and wrap it in a memory-enabled chatbot.  

 Case Study 
Case study 1 (Week ~7) - "Cost, Latency and Trust at ClaimFirst Insurance" 
Context: a mid-size insurer handles 40,000 claims-status queries a month across email and chat. Leadership wants an LLM assistant but caps spend at $4,000/month and requires a p95 response under 3 seconds. Regulator-facing accuracy matters more than fluency. 
Tasks:  
(1) benchmark 3-4 candidate models on a supplied 100-query set for accuracy, cost per 1k queries and latency
(2) design the system/user prompts and a JSON schema for the reply (status, next action, escalate flag)
(3) build a 30-case evaluation set with a rubric and report scores 
(4) test the prompts for injection using adversarial customer messages
(5) recommend a model mix (e.g. small model with escalation to a larger one) with the cost maths shown. 
Deliverable: 5-6 page memo + comparison table + prompt pack + eval results; 10 min presentation. 
Skills assessed: Modules 2-4 (model selection, prompting, structured output, evaluation, injection risk). 

Module Overview

Build robust knowledge-preparation pipelines that make enterprise and domain data searchable and useful for LLM applications.

Topics  

• Document ingestion  
• parsing PDFs 
• web pages and structured data 
• data cleaning; metadata design  
• chunking strategies 
• embedding models  
• similarity metrics 
• vector indices 
• hybrid search  
• reranking 

Tools 
Docling, LlamaParse, LangChain, Chroma, Pinecone, Weaviate, pandas, BM25, Cohere Rerank, BGE Reranker v2 

Projects 
Policy Document Search Engine: Ingest 20-30 PDFs (incl. tables/images) with Docling/LlamaParse, test 3 chunking strategies, embed into Chroma or Pinecone with a metadata schema, and compare vector-only vs hybrid BM25 search with Cohere reranking on a 20-question set.  

Learning Objective  
Design, implement and evaluate end-to-end RAG systems that generate grounded, traceable and context-aware responses.

Topics  

• RAG architecture 
• Query transformation 
• Retrieval strategies 
• Contextual retrieval  
• Parent-child retrieval 
• Citation generation 
• Grounded generation  
• Hallucination mitigation  
• RAG evaluation 
• Faithfulness 
• Answer relevance and context precision 

Tools 
LangChain, LlamaIndex, Neo4j, BM25, SQL, AWS Bedrock (Bedrock Agents), RAGAS 

Project 

Grounded Q&A Bot with Citations: Build the same corpus as naive RAG vs hybrid RAG + RRF vs HyDE or Self-RAG, add parent-child retrieval and inline source citations, then score all variants on faithfulness, answer relevance and context precision with RAGAS and recommend a winner.  
 
Case study 2

(Week ~13) - "Traceable Answers at Northbank Compliance" 
Context: a bank's compliance team must answer policy questions from 5,000 documents - circulars, contracts and scanned annexures - where multiple versions of the same policy coexist and only the latest applies. Every answer must cite the exact clause; an unsourced answer is treated as a failure. 
Tasks:  
(1) design the ingestion and chunking approach for mixed PDF/table/scanned content; 
(2) define a metadata schema that encodes effective dates and supersession so stale versions are filtered out;  
(3) implement at least two retrieval strategies (e.g. hybrid BM25 + vector with reranking, and contextual or parent-child retrieval) and compare them; 
(4) implement clause-level citations;  
(5) evaluate with RAGAS on faithfulness, answer relevance and context precision, and set a go-live threshold;  
(6) propose a refresh and drift-control process. 
Deliverable: architecture document + working prototype + evaluation results + go/no-go recommendation; 10 min presentation. 
Skills assessed: Modules 5-6 (ingestion, embeddings, hybrid retrieval, grounding, RAG evaluation). 

Learning Objective
Build production-oriented LLM applications with scalable API integrations, efficient request handling and reliable user interactions.

Topics 

• REST APIs 
• asynchronous programming 
• streaming responses 
• conversation state 
• session management  
• caching 
• batching  
• rate limits  
• retry logic  
• error handling 
• database integration  
• backend service patterns 
   
  

Tools 
Python (asyncio), FastAPI, REST, Postman, Redis, Kafka, WebSockets, Docker, AWS Lambda, AWS API Gateway, Amazon CloudWatch, AWS EC2, Postgres, SQLAlchemy, DynamoDB 

Projects 
Production Chat API: FastAPI service with streaming responses, session state in Postgres, Redis caching and rate limiting, retry/error handling and structured logging. Test with Postman, containerise with Docker, and deploy to EC2 or as a Lambda behind API Gateway with CloudWatch metrics.

Learning Objective 
Create tool-using AI agents that can reason over tasks, execute multistep workflows and operate within defined guardrails. 

Topics

• Agent anatomy 
• planning and execution loops 
• ReAct pattern 
• tool selection  
• function calling  
• external API integration  
• workflow orchestration  
• human-in-the-loop controls 
• short- and long-term memory  
• agent failure modes 
   
  

Tools  
LangChain, LangChain Deep Agents, OpenAI Agents SDK, Model Context Protocol (MCP), A2A, SQL, NoSQL 

Projects  
Database Research Agent: A ReAct agent with tools for SQL queries, vector search and a web/API call, built once from scratch and once with LangChain or the OpenAI Agents SDK. Expose one tool over MCP, add human-in-the-loop approval for writes, and run agent evals on 15 tasks. 

Learning Objective 
Architect multi-agent systems for complex workflows while balancing autonomy, orchestration, reliability and human oversight. 

Topics 

• Manager-worker architecture 
• Planner-executor architecture  
• Agent communication 
• Delegation 
• Coordination  
• Shared memory  
• Task decomposition  workflow state machines  
• Agent evaluation 
• Enterprise use-case design   
   
  

Tools  
LangGraph, CrewAI, Redis, Markdown, n8n, Zapier, AWS Bedrock AgentCore, LangSmith, Galileo, Arize 

Projects 
Automated Market-Brief Crew: Manager-worker system (researcher, analyst, writer, reviewer) in LangGraph or CrewAI that produces a daily brief, with Redis-backed short/long-term memory and context compression. Rebuild the same flow in n8n and compare; evaluate tool-selection and trajectory quality.  

Case study 3

(Week ~20) - "Exception Handling at Meridian Logistics" 
Context: 1,200 shipments a day generate ~90 exceptions (customs holds, address failures, damage claims). Four coordinators resolve them manually across a TMS, a carrier API and email. Anything involving a credit over $500 or a key account must stay with a human. 
Tasks:  
(1) map the current workflow and pick the automation boundary;  
(2) design a multi-agent system (manager-worker or planner-executor) with named agents, tools and a task-decomposition plan;  
(3) specify memory - what is short-term context vs persisted state, and compression/TTL rules;  
(4) define human-in-the-loop control points and escalation triggers against the $500/key-account rules;  
(5) build a working prototype in LangGraph or CrewAI for two exception types, plus an n8n version of one flow, and compare build effort and control;  
(6) evaluate on tool-selection accuracy, trajectory quality and task completion over 20 scenarios;  
(7) quantify expected time saved and ROI. 
Deliverable: design document with architecture diagram + prototype + eval report + ROI model; 10 min presentation. 
Skills assessed: Modules 7-9 (API/state design, agents, tools, orchestration, memory, agent evaluation). 

Learning Objective

Deploy and operate LLM and agentic systems with the observability, security, governance and reliability needed for real-world use.

Topics 

• Containerisation 
• Deployment patterns 
• CI/CD 
• Prompt and model versioning 
• Tracing 
• Logging  
• Latency and cost monitoring 
• Quality monitoring 
• Access control 
• Secrets management  
• PII protection 
• Safety guardrails  
• Red teaming 
  

 
Tools 
Docker, Kubernetes, AWS EKS, GitHub Actions, MLflow, Git, LangSmith, OpenTelemetry, Promptfoo, Ragas,  AWS Secrets Manager, IAM, Microsoft Presidio, NVIDIA NeMo Guardrails, Guardrails AI, vLLM, TensorRT-LLM  

Projects 
Ship the RAG Bot to Production: Containerise a prior module's app, add a GitHub Actions CI/CD pipeline with Promptfoo/DeepEval eval gates, Langfuse or Arize Phoenix tracing, a Grafana cost/latency dashboard, Presidio PII redaction, NeMo/Guardrails AI guardrails, secrets in Vault, plus a Garak red-team report and rollback runbook. 

Learning objective  
Assess the ethical, governance and business implications of LLM deployments and adapt solutions responsibly to organisational contexts. 

Topics 

• Bias and fairness 
• Responsible AI principles  
• Data governance 
• Model risk management  
• Copyright and IP considerations  
• Privacy-by-design 
• Multilingual application design  
• Domain adaptation 
• Stakeholder and risk assessment 
  

 
Tools 
LangFair, NIST AI RMF, ISO/IEC 42001, EU AI Act, Hugging Face PEFT, LoRA, QLoRA, Unsloth 

Projects 
Governance Pack for an Existing App: run a bias/fairness audit with Fairlearn or LangFair on an earlier project, map risks to NIST AI RMF and EU AI Act tiers, complete an AI impact assessment and model card, then LoRA/QLoRA fine-tune a small model with Hugging Face PEFT and compare it to a RAG baseline. 

Case study 4

(Week ~24) - "Post-Incident Review at Carewell Health" 

Context: a deployed patient-support assistant has two live incidents - transcripts containing patient names and IDs were written to unredacted logs and retained for 90 days, and the triage assistant has been recommending in-person visits at materially different rates across language groups. The board meets in two weeks. 

Tasks:  
(1) run a root-cause analysis from supplied traces and logs 
(2) design the remediation - PII detection/redaction at ingest and log level, guardrails, access control and retention changes 
(3) run a bias/fairness audit on the supplied output data and quantify the disparity with an appropriate metric 
(4) map the system against NIST AI RMF and classify it under EU AI Act risk tiers with justification 
(5) produce an AI impact assessment and a model card 
(6) decide whether remediation needs prompting, RAG changes or a fine-tune, and justify it on evidence 
(7) write an incident runbook and disclosure plan. 

Deliverable: incident report + remediation plan + fairness audit + model card + runbook; 10 min board-style presentation. 

Skills assessed: Modules 10-11 (observability, security, PII, guardrails, fairness, governance, domain adaptation).

Learning Objective 
Apply the complete engineering stack to design and build a deployable LLM, RAG or agentic AI solution addressing a real business problem.

Topics 

• Problem framing 
• Solution architecture  
• Data pipeline development  
• RAG or agent implementation  
• Evaluation plan 
• Deployment blueprint  
• Monitoring strategy 
• Technical documentation  
• Demo and project presentation   

Tools  
Excalidraw, draw.io, LangChain, LlamaIndex, LangGraph, CrewAI, OpenAI Agents SDK, Anthropic Agents SDK, RAGAS, DeepEval, Promptfoo, Docker, AWS EC2, AWS Lambda, AWS Bedrock, LangSmith, GitHub Actions, GitHub 

Project  
Capstone: An end-to-end RAG or agentic solution for a real business problem — scoped problem statement and success metrics, architecture diagram, ingestion and retrieval pipeline, LangGraph/CrewAI or Agents SDK implementation, RAGAS/DeepEval evaluation with pre-agreed pass marks, containerised AWS deployment with CI/CD, Langfuse monitoring dashboard, guardrails and model card, documentation, and a live demo to a review panel via GitHub.