🤖

LLM Engineering

Prompt engineering, fine-tuning, function calling, context windows, and building production applications with large language models.

90 concepts19 questions14 projects

Overview

LLM Engineering is the discipline of building reliable, production-grade applications powered by large language models. It spans the full lifecycle from prompt design to deployment and monitoring.

Core skills include prompt engineering (crafting effective prompts, few-shot learning, chain-of-thought reasoning), fine-tuning (LoRA, QLoRA, RLHF, DPO for adapting models to specific tasks), function calling (enabling LLMs to use tools and APIs), and managing context windows effectively.

Production concerns include hallucination mitigation, output validation, cost optimization (token management, model routing), latency reduction, and evaluation frameworks. Understanding when to prompt vs. fine-tune vs. use RAG is a critical engineering decision that depends on your use case, data, and requirements.

LLM Engineering

Overview

ML Concepts

Compare zero-shot, few-shot, and chain-of-thought prompting. When would you use each?

When would you fine-tune an LLM vs using prompting?

Explain function calling in LLMs. How does the model decide when to use tools?

What causes LLM hallucinations? How do you detect and prevent them?

How do you evaluate LLM outputs? What metrics matter?

How do you manage context windows in LLM applications?

Explain RAG (Retrieval-Augmented Generation). When and how would you use it?

Compare GPT-4, Claude, and open-source LLMs. When would you use each?

How do you ensure LLMs output valid structured data (JSON, specific formats)?

When would you use fine-tuning vs RAG vs prompt engineering? How do you decide?

AI Orchestration: How do you coordinate multiple AI agents in workflows?

How do you choose the number of epochs? Explain early stopping and gradient descent optimizers.

How do you prepare training data for fine-tuning? How much data do you need and how do you ensure quality?

Deep-Dive Concepts (from Projects)

How Embeddings Work

Vector Similarity Explained

Chunking Strategies Compared

Two-Stage Retrieval Architecture

Prompt Engineering for RAG

Evaluating RAG Systems

Multi-Agent Architecture

LangGraph State Machines

Agent Communication Patterns

Tool Integration and Error Handling

LangSmith Observability: Complete Guide

Production Optimization

Multi-Modal AI Pipelines

Prompt Engineering for Creative AI

Character Consistency in AI Art

Server-Sent Events (SSE)

Professional PDF Generation

AI Content Safety

AWS Bedrock Architecture Deep-Dive

RAG with Bedrock Knowledge Bases

Content Safety with Bedrock Guardrails

Gemini 1.5's 2M Token Context Window

Multi-Cloud AI Abstraction Patterns

Azure OpenAI Service Architecture

Three-Cloud Decision Framework

Cost Optimization Strategies for Cloud AI

QLoRA: Quantized Low-Rank Adaptation

vLLM Inference Optimization

TGI: Text Generation Inference

FSDP: Fully Sharded Data Parallel

DeepSpeed ZeRO: Zero Redundancy Optimizer

Multi-Node Training Networking

MCP Protocol Deep Dive

Copilot Studio Architecture

Power Platform Security Model

AI Builder Capabilities

Dataverse for AI Workloads

Low-Code AI Governance

Parallelism Taxonomy

Chinchilla Scaling Laws

BM25 Algorithm

Inverted Index

HNSW Algorithm

Hybrid Search Fusion

Two-Stage Retrieval

Search Evaluation Metrics

Query Understanding

RAG Architecture

The A2A Protocol Architecture

Agent Discovery and Capability Negotiation

AutoGen Architecture: Conversation-First Design

Human-in-the-Loop Patterns

Server-Sent Events (SSE)

Fine-Tuning: What, Why, and How

LoRA (Low-Rank Adaptation)

QLoRA (Quantized LoRA)

Tokens and Tokenization

Temperature and Sampling

Embeddings and Vector Search

RAG (Retrieval Augmented Generation)

Prompt Injection and LLM Security

Context Window and Attention

The Agent Loop