Model Online / On-Site
Duration
Modules 6 modules

Course Objective & Scope

Many LLM projects start without a clear picture of what models do well or poorly and why, which leads to wrong expectations and wasted spend. The course explains foundation models, the pretraining and instruction-tuning process, tokens and context windows, sampling parameters such as temperature and top-p, and where hallucinations come from.

Participants compare GPT, Claude and Gemini with open-weight models such as Llama, Qwen and Mistral on the same tasks and build a first model selection matrix for a use case from their own organisation. Examples are adapted to the client's scenarios.

Who Should Attend?

  • Software developers starting LLM-based projects
  • Data scientists and analytics teams
  • Platform and solution architects working on AI products
  • Technical product managers and technical project leads
  • Prerequisite: basic programming skills; no machine learning background required

Key Takeaways

  • Explain how tokens, context windows and sampling parameters affect output
  • Compare closed and open-weight model families on capability, cost and licensing
  • Recognise hallucination risks and choose basic mitigation techniques
  • Decide whether prompting, RAG or fine-tuning fits a given problem
  • Produce a justified model selection matrix for an internal use case

Curriculum

Foundation Models and the Evolution of LLMs
  • Pretraining, instruction tuning and RLHF stages
  • Differences between foundation, chat and reasoning models
Tokens, Context Windows and Sampling
  • Tokenization and token-based pricing
  • Effect of temperature, top-p and maximum output length
Model Families and the Ecosystem
  • OpenAI, Anthropic Claude and Google Gemini APIs
  • Llama, Qwen, Mistral, Gemma, DeepSeek and their licences
Capabilities, Limits and Hallucination
  • Causes of hallucination and grounding approaches
  • Knowledge cut-off, reasoning and arithmetic limits
Prompting, RAG and Fine-Tuning Decision Framework
  • Which approach for which problem: a decision tree
  • Comparing cost, latency and data requirements
Hands-On: Model Selection Matrix
  • Testing models on the same tasks for an internal use case
  • Filling in the matrix with quality, cost and latency criteria

Other Courses in This Category

  • Large Language Models and the Transformer Architecture

    A technical deep dive into the transformer: tokenization, self-attention, RoPE, KV cache, scaling laws, SFT, RLHF/DPO and reasoning models, explored hands-on with PyTorch and Hugging Face Transformers.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View
  • Building Applications with LLM APIs

    Hands-on programme for building a near-production LLM application with the OpenAI, Anthropic Claude and Google Gemini APIs, covering streaming, conversation state, retries, rate limits, fallbacks and basic evals.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View
  • Structured Outputs with LLMs: JSON Schema, Pydantic and Constrained Decoding

    Getting reliable JSON from LLMs with JSON Schema, OpenAI Structured Outputs, Gemini response schemas, Pydantic/Zod, Instructor and constrained decoding, plus validation, repair loops and document data extraction.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View
  • LLM Tool Use and Function Calling

    How to let LLMs safely call APIs, databases and internal systems via tool/function calling: tool schema design, parallel calls, MCP servers, error handling and permission boundaries.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View
  • Prompt and Context Architecture for LLM Applications

    Context engineering for LLM applications: designing how system prompts, templates, few-shot examples, retrieved content, memory and tool definitions fill the context window, with versioning and eval-driven iteration.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View
  • Long-Context LLM Engineering and Context Window Management

    Solving lost-in-the-middle degradation, KV cache cost and latency in large context windows through context compression, hierarchical memory, prompt caching and needle-in-a-haystack evaluation.

    LLM Application Engineering Corporate
    Live Course
    6 modules
    View

Get in touch