Cross-track

Bridge topics

These bridges map one idea across both tracks: Practical (B) is shipping—APIs, RAG, LangGraph, evals, guardrails—while Under the hood (A) is depth—attention, training objectives, alignment, efficient serving. Use this page when you study or teach so you know where to drill down vs where to stay product-focused.

Transformers & LLM behavior

B: Chat vs completions, streaming, native tool/function calling, error codes and retries.
A: Self-attention, positional encodings (incl. RoPE), decoder-only stacks, why depth × context drives compute.

Path A — Transformer architecture · Path A — Pretraining objectives · Path B — LLM APIs

Tokenization, context & sampling

B: Billing in tokens, BPE intuition, tiktoken-style counting, context limits, temperature / top_p / max_tokens / stop, lost-in-the-middle when stuffing RAG context.
A: How token IDs feed embeddings, why attention cost grows with sequence length, sampling as decoding policy.

Path A — Text as data · Path B — Tokens & pricing · Path B — Context & sampling

Prompt engineering, CoT & structured I/O

B: System/user/assistant framing, few-shot and dynamic examples, chain-of-thought and scratchpads, JSON mode / schema-constrained outputs, parser + retry loops, function calling contracts.
A: Instruction tuning (SFT), why models follow formats after alignment, limitations of single forward passes vs multi-step reasoning literature.

Path A — Pretraining & instruction phase · Path A — Alignment · Path B — Prompting · Path B — Structured outputs · Path B — Function calling

Fine-tuning vs RAG vs prompting

B: When to retrieve vs stuff context vs change behavior; cost, latency, freshness, compliance; LoRA/QLoRA “when” and Ollama-style local serving at a glance.
A: Data curation, PEFT/LoRA mechanics, training vs eval loss, HF tooling.

Path A — Fine-tuning · Path A — Hugging Face stack · Path B — When to RAG · Path B — Prompt vs RAG vs fine-tune · Path B — LoRA / QLoRA · Path B — Ollama & local APIs

RAG systems & retrieval quality

B: Ingestion pipelines, chunking, embeddings + vector stores, conversational query rephrasing, hybrid BM25 + dense retrieval, reranking, HyDE and parent–child chunks, citations, auth-aware filters, offline metrics (RAGAS-style) tied to prod regressions.
A: Embedding geometry, contrastive training intuition, optional retriever fine-tuning / deeper IR theory as you grow.

Path B — Chunking · Path B — Embeddings & search · Path B — RAG architecture · Path B — Conversational RAG · Path B — Hybrid search · Path B — Rerank, HyDE, parent–child · Path B — RAG quality

Orchestration: LangChain / LangGraph / memory

B: LCEL pipes, parallel branches for RAG, streaming chains, prompt templates with history placeholders, RunnableWithMessageHistory, LangGraph state/checkpointers/interrupts/Send, supervisor-style routing.
A: Less framework-specific—focus on data flow, state machines, and how these map to classic DL “forward” vs control flow.

Path B — LCEL building blocks · Path B — Templates & session memory · Path B — LangGraph · Path B — Orchestration patterns

Agents, tools & MCP

B: Agents vs fixed workflows, tool schemas and descriptions, ReAct loops, AgentExecutor vs LangGraph, streaming steps, multi-agent supervision, Model Context Protocol servers/adapters, budgets and circuit breakers.
A: Tool-use as policy / RLHF background, alignment constraints on autonomous action (read Path A safety + alignment).

Path A — Alignment · Path B — Agents vs workflows · Path B — Tool design · Path B — Executors & streaming · Path B — MCP · Path B — Planning & control · Path B — Multi-agent

Safety, injection & guardrails

B: Direct and indirect (RAG) prompt injection, allowlisted tools, schema validation before side effects, moderation layers, human-in-the-loop for risky tools.
A: Alignment objectives (RLHF/DPO), refusal behavior, robustness / red-teaming mindset.

Path A — Safety overview · Path B — Injection & untrusted context · Path B — Guardrails

Evaluation, observability & production metrics

B: Golden datasets, CI eval gates, LLM-as-judge with rubrics, retrieval metrics + RAG suites, structured logging (tokens, cost, latency), LangSmith-style tracing and experiment diffs, drift monitoring.
A: Formal eval design, benchmark literacy, statistical caution—Path A eval topics for methodology.

Path A — Evaluation & robustness · Path B — Observability · Path B — Eval & LangSmith

Inference efficiency & cost

B: Router patterns, cache stable prompts, token and $ per task dashboards, batch vs realtime APIs.
A: KV-cache, quantization, batching, serving tradeoffs.

Path A — Efficient inference · Path B — Cost & efficiency

Deployment, serving & async pipelines

B: Health/readiness for slow warmups, secrets injection, long-lived SSE streams and LB timeouts, event-driven ingestion (Kafka-style) for embed jobs, cost tagging at the service boundary.
A: Model serving fundamentals, hardware-aware deployment—pair with Path A serving + efficient inference.

Path A — Serving basics · Path B — Deployment & async patterns

Multimodal

B: VLM chat payloads, OCR vs native vision routing, redaction and compliance for uploads.
A: Alignment across modalities, patching, CLIP/VLM architecture themes.

Path A — Vision-language models · Path B — VLMs & files · Path B — Multimodal agent stretch

Capstones (putting both paths together)

B: End-to-end copilot: RAG + LangGraph + tools + traces + guardrails (see Path B capstone checklist).
A: Training/eval capstone on Path A; merge with B when you need a portfolio slice that proves both reliability and depth.

Path A capstone · Capstone brief (reference) · Path B — Applied capstone