AI Engineering Training in Islamabad

🤖 AI Engineering Track

Currently available in Islamabad

---

There is a significant difference between using AI and building AI systems. Millions of developers now use ChatGPT and GitHub Copilot daily — but only a fraction can build the production systems that power those experiences: the retrieval pipelines, the agent architectures, the evaluation frameworks, the cost-optimised inference layers, and the monitoring systems that keep AI features working reliably at scale.

This track trains you to be on the engineering side of that divide. You will work with the OpenAI, Anthropic, and Google Gemini APIs not as a user but as a builder — designing RAG pipelines, orchestrating multi-step LLM agents, managing vector databases, evaluating model outputs programmatically, and deploying AI features that behave predictably in production. The course uses Python throughout and is designed to integrate directly with any of the Full-Stack 2.0 backend stacks.

💡 Why AI Engineering

---

AI Engineering is the fastest-emerging engineering specialisation of the decade. Every company — from startups to enterprises — is actively building AI-powered features into their products and hiring engineers who know how to build them properly. The gap between demand and supply is enormous, and it will not close quickly:

• Every software product is being rebuilt with AI features — search, summarisation, recommendations, assistants, automation
• Prompt engineering alone is not enough — companies need engineers who understand the full stack: retrieval, context management, evaluation, safety, and deployment
• AI engineers command among the highest salaries in software engineering globally
• This skillset is framework-agnostic — it layers on top of your existing backend knowledge in Python, Node.js, Go, or any other stack
• Pakistan's IT export sector is seeing rapid growth in demand for AI engineering skills from international clients

📚 Module Breakdown

---

Week 1 — Phase 0: LLM Foundations for Engineers

Before calling a single API, you need to understand what language models actually are, how they work at a systems level, and what their capabilities and failure modes look like in production. This phase gives engineers the mental model they need to make good architectural decisions throughout the rest of the course.

1. How large language models work: tokens, embeddings, attention, and the transformer architecture — explained for engineers, not researchers
2. Tokenisation in practice: how text becomes tokens, why token counts matter for cost and context limits, and how to measure them with tiktoken
3. Context windows: what they are, how they constrain system design, and current limits across models (GPT-4o, Claude 3.5, Gemini 1.5 Pro)
4. Temperature, top-p, and sampling parameters: what they control and how to set them for different use cases
5. LLM failure modes engineers must understand: hallucination, context loss, sycophancy, prompt injection, and positional bias
6. Model comparison: GPT-4o vs Claude 3.5 Sonnet vs Gemini 1.5 Pro vs open-source (Llama 3, Mistral) — capabilities, pricing, and when to use each
7. Open-source vs proprietary models: self-hosted inference with Ollama and vLLM vs API-based models
8. Cost modelling: estimating and controlling LLM API spend at scale — token budgeting, caching, and model tiering strategies
9. Setting up the AI engineering environment: Python, API keys, environment variable management, and rate limit handling

Week 1–2 — Phase 1: LLM APIs & Prompt Engineering for Production

This phase covers working directly with the three major LLM APIs — OpenAI, Anthropic, and Google Gemini — and the prompt engineering techniques that make the difference between a toy prototype and a reliable production feature.

API fundamentals across providers:

1. OpenAI API: chat completions, function calling, structured outputs, vision, and streaming with the official Python SDK
2. Anthropic API: messages API, system prompts, tool use, vision, and extended thinking with Claude
3. Google Gemini API: multimodal inputs, long context, grounding, and the Gemini SDK
4. Streaming responses: handling token-by-token output in APIs and surfacing it to users in real time
5. Structured output: forcing models to return valid JSON using OpenAI structured outputs, Anthropic tool use, and Instructor library
6. Vision and multimodal inputs: sending images, PDFs, and documents to LLM APIs for analysis
7. Batch API: processing thousands of requests asynchronously at lower cost with OpenAI Batch and Anthropic Batch
8. Rate limiting and retry logic: implementing exponential backoff, request queuing, and graceful degradation
9. Provider abstraction: building a unified LLM client that can swap providers without rewriting application logic

Prompt engineering for engineers:

1. System prompts: writing effective system prompts that define persona, behaviour, output format, and constraints
2. Few-shot prompting: selecting and formatting examples that steer model behaviour reliably
3. Chain-of-thought prompting: making models reason step by step before producing output — when it helps and when it wastes tokens
4. XML and structured prompt formatting: Anthropic's recommended approach to organising complex prompts
5. Prompt templating: building dynamic prompts from user input and context using Jinja2 and f-strings
6. Instruction following: writing prompts that models actually follow — specificity, positive framing, and avoiding ambiguity
7. Output formatting control: requesting JSON, markdown, tables, and code blocks reliably
8. Prompt versioning: treating prompts as code — version control, changelogs, and A/B testing prompt variants
9. Prompt injection: understanding attack vectors and how to defend against them in user-facing applications
10. Context window management: fitting the right information into limited context — summarisation, truncation, and prioritisation strategies

Week 2 — Phase 2: Embeddings & Vector Databases

Embeddings are the foundation of semantic search, RAG pipelines, recommendation systems, and clustering. This phase covers what they are, how to generate them, and how to store and query them at scale using vector databases.

Embeddings in depth:

1. What embeddings are: converting text, images, and structured data into high-dimensional vectors that encode semantic meaning
2. Embedding models: OpenAI text-embedding-3 (small and large), Cohere Embed v3, and open-source alternatives (sentence-transformers, BGE, E5)
3. Embedding dimensions, model selection trade-offs: accuracy vs cost vs latency
4. Similarity metrics: cosine similarity, dot product, and Euclidean distance — when each applies
5. Batching embedding requests: efficient bulk generation for large document corpora
6. Embedding multimodal content: text, images, and code — CLIP and OpenAI vision embeddings
7. Embedding drift: how model updates can change embedding spaces and break existing indexes

Vector databases:

1. pgvector: adding vector similarity search to PostgreSQL — setup, indexing (HNSW vs IVFFlat), and querying
2. Pinecone: managed vector database — indexes, namespaces, metadata filtering, and hybrid search
3. Qdrant: open-source vector database — collections, payload filtering, and self-hosted deployment
4. Weaviate: multi-modal vector search with built-in vectorisation modules
5. Choosing a vector database: decision framework based on scale, cost, latency, and infrastructure constraints
6. Hybrid search: combining dense vector search with sparse BM25 keyword search for better retrieval
7. Metadata filtering: narrowing vector searches by document type, date, user, tenant, or any structured field
8. Vector index performance: understanding HNSW graph construction, ef_construction, and recall/latency trade-offs
9. Re-ranking: using cross-encoders (Cohere Rerank, Voyage Rerank) to improve retrieval precision after vector search

Week 2–3 — Phase 3: RAG — Retrieval-Augmented Generation

RAG is the most important pattern in production AI engineering. It solves the core limitations of LLMs — outdated training data, hallucination, and lack of access to private knowledge — by retrieving relevant context at inference time and injecting it into the prompt. This phase covers RAG from basic implementation to advanced production patterns.

RAG fundamentals:

1. Why RAG: the problem it solves, when to use it, and when fine-tuning is a better answer
2. The basic RAG pipeline: ingest → chunk → embed → store → retrieve → augment → generate
3. Document ingestion: loading PDFs, Word documents, web pages, Notion pages, and databases with LangChain document loaders and LlamaIndex readers
4. Text chunking strategies: fixed-size, recursive character splitting, semantic chunking, and document-structure-aware chunking
5. Chunk size and overlap: how they affect retrieval quality and what to tune for different document types
6. Metadata enrichment: adding document source, page number, section headers, and timestamps to chunks for filtering
7. Embedding and indexing the knowledge base: bulk ingestion pipelines with progress tracking and error handling
8. Query embedding and similarity search: retrieving the top-k most relevant chunks for a user query
9. Context assembly: formatting retrieved chunks into a coherent prompt context block
10. Source attribution: citing which documents the answer was drawn from in the response

Advanced RAG patterns:

1. Query transformation: rewriting user queries with an LLM before retrieval to improve recall
2. HyDE (Hypothetical Document Embeddings): generating a hypothetical answer and using it as the retrieval query
3. Multi-query retrieval: generating multiple query variants and merging their results
4. Parent-child chunking: indexing small child chunks for precision, retrieving their larger parent context for completeness
5. Contextual compression: extracting only the relevant portion of a retrieved chunk rather than including the whole thing
6. Self-RAG: the model decides when to retrieve, what to retrieve, and whether the retrieved context is relevant
7. Corrective RAG (CRAG): evaluating retrieval quality and falling back to web search when the knowledge base is insufficient
8. Multi-vector retrieval: indexing documents by multiple representations (summary + full text + hypothetical questions)
9. Agentic RAG: building retrieval as a tool that an agent calls dynamically rather than a fixed pipeline step
10. RAG evaluation: measuring retrieval quality (context precision, context recall) and generation quality (faithfulness, answer relevancy) with RAGAS

Week 3 — Phase 4: LLM Orchestration — LangChain & LlamaIndex

LangChain and LlamaIndex are the two dominant frameworks for orchestrating LLM applications — managing chains of LLM calls, tool integrations, memory, and retrieval pipelines. This phase teaches both so you can choose the right tool for each job.

LangChain:

1. LangChain architecture: chains, runnables, the LCEL (LangChain Expression Language) pipeline syntax
2. Prompt templates, output parsers, and structured output chains
3. LangChain retrieval chains: building complete RAG pipelines with LCEL
4. Conversation chains and memory: maintaining conversation history across turns with different memory backends
5. LangChain Tools: wrapping functions, APIs, and databases as tools LLMs can call
6. LangChain integrations: connecting to 100+ data sources, vector stores, and LLM providers
7. LangSmith: tracing, debugging, and evaluating LangChain applications in production

LlamaIndex:

1. LlamaIndex architecture: the data framework for LLM applications — nodes, indexes, query engines, and pipelines
2. Document and node processing: readers, transformations, and metadata extractors
3. Index types: VectorStoreIndex, SummaryIndex, KnowledgeGraphIndex, and PropertyGraphIndex
4. Query engines and chat engines: building conversational interfaces over your data
5. Sub-question query engine: decomposing complex questions across multiple data sources
6. LlamaIndex workflows: event-driven, step-based orchestration for complex multi-stage AI pipelines
7. LlamaCloud and LlamaParse: managed document parsing for complex PDFs, tables, and mixed-format documents

When to use which:

1. LangChain vs LlamaIndex vs building from scratch: a practical decision framework with real trade-offs
2. Using both together: LlamaIndex for retrieval, LangChain for orchestration
3. When to avoid frameworks entirely: cases where direct API calls produce simpler, more maintainable code

Week 3–4 — Phase 5: LLM Agents & Tool Use

Agents are LLMs that can take actions — calling tools, browsing the web, writing and executing code, querying databases, and orchestrating other AI models. This phase covers agent architectures from simple tool-calling to complex multi-agent systems.

Tool use and function calling:

1. Function calling fundamentals: defining tools as JSON schemas and letting LLMs decide when and how to call them
2. Parallel tool calls: models that call multiple tools simultaneously and merge the results
3. Tool design principles: writing tools that LLMs use reliably — naming, descriptions, and parameter schemas
4. Built-in tools: web search, code execution, and file reading across OpenAI, Anthropic, and Gemini
5. Custom tools: wrapping REST APIs, database queries, Python functions, and external services as LLM tools

Agent architectures:

1. ReAct (Reasoning + Acting): the foundational agent loop — think, act, observe, repeat
2. OpenAI Assistants API: threads, runs, tool calls, and file search — managed agent infrastructure
3. LangGraph: building stateful, graph-based agent workflows with cycles, branches, and human-in-the-loop steps
4. LlamaIndex Workflows: event-driven agent pipelines with explicit step definitions
5. Memory in agents: short-term (conversation buffer), long-term (vector memory), and entity memory
6. Planning agents: breaking complex goals into sub-tasks and executing them in order
7. Code execution agents: agents that write Python, run it in a sandbox, and iterate based on output
8. Browser agents: agents that navigate web pages and extract information (Playwright + LLM)

Multi-agent systems:

1. Multi-agent patterns: supervisor agents that delegate to specialist sub-agents
2. Agent-to-agent communication: how agents pass context, results, and instructions between each other
3. CrewAI: role-based multi-agent orchestration for structured collaborative workflows
4. AutoGen: Microsoft's multi-agent conversation framework for complex task decomposition
5. Guardrails in agent systems: preventing runaway loops, cost overruns, and unintended actions
6. Human-in-the-loop: checkpoints where agents pause and request human approval before proceeding

Week 4 — Phase 6: Fine-Tuning & Model Customisation

Fine-tuning is not always the right answer — but when it is, it dramatically outperforms prompting alone. This phase covers when fine-tuning makes sense, how to do it correctly, and the alternatives that are often faster and cheaper.

1. Fine-tuning vs RAG vs prompt engineering: the decision framework every AI engineer needs
2. When fine-tuning wins: style consistency, format adherence, domain-specific terminology, and latency-sensitive use cases
3. Dataset preparation: formatting training data as instruction-response pairs, quality filtering, and diversity
4. OpenAI fine-tuning API: uploading datasets, running training jobs, evaluating fine-tuned models, and cost estimation
5. Fine-tuning GPT-4o mini for classification, extraction, and structured output tasks
6. LoRA and QLoRA: parameter-efficient fine-tuning of open-source models (Llama 3, Mistral) on consumer hardware
7. HuggingFace PEFT library: implementing LoRA fine-tuning with the Trainer API
8. Instruction tuning vs continued pre-training: understanding the difference and when each applies
9. RLHF overview: how models are aligned with human preferences — conceptual understanding for engineers
10. Deploying fine-tuned models: serving with vLLM, BentoML, or uploading to HuggingFace Hub

Week 4–5 — Phase 7: AI Safety, Evaluation & Guardrails

Production AI systems fail in ways that are hard to predict and hard to detect. This phase covers the evaluation frameworks, guardrails, and safety layers that make AI features trustworthy in customer-facing applications.

LLM evaluation:

1. Why LLM evaluation is hard: non-determinism, subjective quality, and the absence of ground truth
2. Evaluation metrics: faithfulness, answer relevancy, context precision, context recall, and toxicity
3. RAGAS: automated RAG pipeline evaluation — measuring retrieval and generation quality end-to-end
4. LLM-as-judge: using a strong LLM to evaluate the outputs of another LLM — prompting patterns and limitations
5. Human evaluation: building annotation interfaces and rubrics for systematic human review
6. Regression testing: building an evaluation dataset and running it on every prompt or model change
7. LangSmith and Braintrust: platforms for logging, evaluating, and comparing LLM outputs across runs
8. Evals as code: integrating LLM evaluation into CI/CD pipelines so regressions are caught before deployment

Guardrails and safety:

1. Input guardrails: classifying and filtering user inputs before they reach the LLM
2. Output guardrails: validating, filtering, and post-processing LLM outputs before they reach users
3. Guardrails AI: declarative guardrail definitions with validators for PII, toxicity, and schema conformance
4. Llama Guard: Meta's open-source safety classifier for screening inputs and outputs
5. PII detection and redaction: identifying and masking personal data in inputs and outputs with presidio
6. Jailbreak and prompt injection defence: input sanitisation, instruction hierarchy, and constitutional AI patterns
7. Content moderation: OpenAI Moderation API and building custom classifiers for domain-specific content policies
8. Fallback strategies: graceful degradation when models fail, time out, or produce unsafe output

Week 5 — Phase 8: Production Deployment & Observability

Shipping an AI feature to production is different from shipping a traditional API. Latency is higher, costs vary with usage, outputs are non-deterministic, and failures are often silent. This phase covers everything needed to run AI systems reliably at scale.

Integrating AI features into real applications:

1. AI feature architecture: where AI sits in a full-stack application — synchronous vs asynchronous patterns
2. Streaming AI responses to the frontend: Server-Sent Events in FastAPI and Next.js
3. Background AI jobs: processing documents, generating embeddings, and running batch inference with Celery / ARQ
4. Caching LLM responses: semantic caching with GPTCache and Redis to reduce cost and latency
5. LLM proxy layer: routing requests across providers, implementing fallbacks, and tracking usage with LiteLLM
6. Multi-tenancy: isolating AI features, vector namespaces, and usage quotas per user or organisation

Deploying on AWS:

1. Deploying AI APIs with FastAPI on AWS ECS: containerised inference services with auto-scaling
2. AWS Lambda for lightweight AI features: serverless LLM calls with cold start optimisation
3. AWS Bedrock: accessing Claude, Llama, Titan, and other foundation models through AWS's managed API
4. Amazon OpenSearch with vector engine: AWS-native vector search alternative to Pinecone
5. Secrets management: storing and rotating API keys for OpenAI, Anthropic, and Pinecone with AWS Secrets Manager

Observability for AI systems:

1. LLM observability: what to log — prompts, completions, tokens, latency, cost, and user feedback
2. Langfuse: open-source LLM observability — tracing, scoring, and dataset management
3. OpenTelemetry for AI: tracing LLM calls as spans in distributed traces
4. Cost monitoring: tracking per-user, per-feature, and per-model spend with dashboards and budget alerts
5. Latency monitoring: p50/p95/p99 latency tracking and alerting on degradation
6. Hallucination monitoring: automated detection of factual inconsistencies in production outputs
7. User feedback loops: thumbs up/down, regenerate signals, and using them to improve prompts and retrieval

Week 5 — Capstone: End-to-End AI Feature Build

The final week is a guided capstone project where each student builds a complete, production-ready AI feature integrated into a full-stack application. Examples include:

• A document Q&A system: upload any PDF, ask questions, get answers with cited sources — built with RAG + pgvector + FastAPI + Next.js
• An AI customer support agent: handles FAQs from a knowledge base, escalates to humans when uncertain — built with RAG + LangGraph + guardrails
• A semantic search engine: replacing keyword search with vector search + hybrid retrieval over a product catalogue
• A code review agent: analyses pull request diffs and produces structured feedback using multi-step tool use
• A content generation pipeline: brief → research → draft → review loop with multiple specialised agents

📅 Schedule & Timings

Choose one group only based on your availability. Max 5 candidates per group to ensure individual attention and hands-on support.

Weekday Groups:

• Group 1: Mon–Wed, 10 AM – 1 PM
• Group 2: Mon–Wed, 4 PM – 7 PM

Weekend Groups:

• Group 3: Sat & Sun, 10 AM – 2 PM
• Group 4: Sat & Sun, 4 PM – 8 PM

📍 Location: In-house training in Islamabad
📱 Online option may be arranged for out-of-city participants

🛠️ Tools & Technologies Covered

• LLM APIs: OpenAI (GPT-4o), Anthropic (Claude 3.5), Google Gemini 1.5, AWS Bedrock
• Open-Source Models: Llama 3, Mistral, via Ollama and vLLM
• Embeddings: OpenAI text-embedding-3, Cohere Embed v3, sentence-transformers
• Vector DBs: pgvector, Pinecone, Qdrant, Amazon OpenSearch
• Orchestration: LangChain, LlamaIndex, LangGraph, CrewAI
• Evaluation: RAGAS, LangSmith, Langfuse, Braintrust
• Guardrails: Guardrails AI, Llama Guard, Presidio, OpenAI Moderation API
• Fine-tuning: OpenAI Fine-tuning API, HuggingFace PEFT, LoRA/QLoRA
• Infrastructure: FastAPI, Celery, LiteLLM, Docker, AWS ECS, AWS Lambda
• Observability: Langfuse, OpenTelemetry, GPTCache

✅ Prerequisites

• Comfortable writing Python (functions, classes, async/await)
• Basic understanding of REST APIs and HTTP
• Familiarity with any backend framework (Django, FastAPI, Node.js, etc.)
• No prior AI or ML experience required
• No mathematics background required

🎯 Who This Is For

• Full-stack or backend developers adding AI features to products
• Engineers who have completed any Full-Stack 2.0 program and want to add AI capabilities
• Developers targeting AI engineering roles at product companies or AI startups
• Technical leads evaluating AI tooling and architecture decisions for their teams
• Freelancers building AI-powered products for international clients

💳 Course Fee & Booking

• ⌛ Duration: 5 Weeks
• 🔒 Seats: 5 only per group

👉 Click here to book via WhatsApp