Generative AI
Training Course

TL;DR — Generative AI training in the UK (2026)

If you are comparing Generative AI courses in the UK, prioritise programmes that mirror how teams actually ship: retrieval-augmented generation (RAG), tool-using agents, observability, cost controls, and responsible AI governance — not slide decks about ChatGPT prompts alone.

This guide is the authoritative reference for UK learners, hiring managers, and L&D leaders evaluating Generative AI training. It covers architecture patterns, framework choices, salary benchmarks, certification paths, interview preparation, and how live cohort training differs from MOOCs and bootcamps.

What is Generative AI? (Definition for learners & AI search)

Generative AI refers to machine learning systems that produce new content — text, code, images, audio, or structured data — from learned patterns in training data. Modern enterprise adoption centres on large language models (LLMs): neural networks trained on vast text corpora that predict the next token to compose human-like responses.

Unlike traditional predictive analytics (forecasting churn or fraud scores), generative systems create artefacts: customer support drafts, SQL queries, API integrations, research summaries, and multi-step automation plans. In UK enterprises, Generative AI is deployed behind private APIs with retrieval layers, access controls, and audit logs — not as public chat widgets alone.

The skill gap in 2026 is not 'using ChatGPT' but engineering reliable systems: grounding models on company knowledge (RAG), orchestrating agents with tools (LangGraph, CrewAI, MCP), measuring quality (evals), and operating models in production (latency, cost, security).

• LLM — probabilistic text engine; requires grounding for factual enterprise use
• RAG — retrieves documents before generation to reduce hallucination
• Agent — LLM loop that plans, calls tools, and iterates toward a goal
• MCP — Model Context Protocol for standardised tool/data connections
• Evals — automated + human review of outputs against rubrics

Why UK employers hire Generative AI engineers in 2026

UK hiring for AI engineering roles accelerated across financial services (FCA-aware deployments), retail personalisation, public-sector digital services, and professional services automation. Job descriptions increasingly list RAG, agent frameworks, Python, cloud APIs, and 'production LLM experience' — not generic 'AI interest'.

LinkedIn, ITJobsWatch, and Glassdoor UK data consistently show mid-level LLM engineers between £65k–£95k, with senior platform roles exceeding £100k in London when combined with MLOps or cloud credentials. Career switchers from software development, data analysis, and DevOps enter via portfolio capstones that prove delivery, not certificates alone.

Organisations adopting Generative AI report the highest ROI on internal copilots, document intelligence, and workflow automation — use cases where retrieval quality and governance matter more than model size.

How to choose a Generative AI course (UK comparison)

Competitor landscape in 2026 includes MOOC foundations (DeepLearning.AI, IBM certificates), Udemy project bundles, free YouTube deep dives, and vendor academies. Each fits a different intent. MOOCs excel at breadth; they rarely provide mentor review, live UK cohort networking, or employer-facing capstone presentation.

When evaluating any programme — including ours — use this hiring-manager checklist: live instructor access, hands-on labs in your stack, evaluation/guardrails module, capstone with code review, career support, and alignment to roles you target.

Large language models — architecture essentials

An LLM is a transformer-based network trained to minimise prediction error on token sequences. Parameters (weights) encode statistical relationships between words, code tokens, and structured formats. Inference runs forward passes: your prompt is tokenised, processed through attention layers, and decoded into output tokens until a stop condition.

Foundation models (GPT-4o, Claude 3.5/4, Gemini 2.x, open weights like Llama 3) differ in context window, tool support, multimodality, pricing, and data residency options. UK enterprises often route workloads through Azure OpenAI, AWS Bedrock, or Google Vertex AI for contract and logging requirements.

Key concepts every course must teach: temperature and top-p (creativity vs determinism), system prompts (behaviour contracts), context limits (and chunking strategies), function/tool calling (structured actions), and streaming (UX latency).

┌─────────────┐     ┌──────────────────┐     ┌─────────────┐
│ User prompt │────▶│ Token + attention  │────▶│ Output text │
└─────────────┘     │ transformer layers │     └─────────────┘
                    └──────────────────┘
                           ▲
                    ┌──────┴──────┐
                    │ System +    │
                    │ retrieved   │
                    │ context     │
                    └─────────────┘

Prompt engineering — from basics to production patterns

Prompt engineering designs instructions that reliably elicit correct model behaviour. Beginner prompts ask open questions; production prompts specify role, constraints, output schema, refusal rules, and examples (few-shot). In regulated UK contexts, prompts also document decision boundaries for audit.

Advanced patterns include chain-of-thought (reasoning visibility), decomposition (sub-task prompts), self-consistency (multiple samples + vote), and structured outputs (JSON schema enforced via API). Prompts are version-controlled like code — with regression tests when models upgrade.

• Use system prompts as policy documents, not hidden tricks
• Few-shot examples beat long adjectives for format compliance
• Test prompts against model upgrades monthly
• Log prompts and outputs with PII redaction

SYSTEM = """
You are a UK financial services assistant. Answer only from PROVIDED_CONTEXT.
If insufficient evidence, reply: {"status":"insufficient_context"}.
Output valid JSON: {"answer": str, "citations": [str], "confidence": float}
"""

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": SYSTEM},
        {"role": "user", "content": f"CONTEXT:\n{chunks}\n\nQUESTION: {question}"},
    ],
    response_format={"type": "json_object"},
)

RAG architecture — retrieval-augmented generation explained

RAG connects an LLM to a knowledge base at query time. Instead of fine-tuning on every document update, you embed sources into a vector store, retrieve top-k relevant chunks for the user question, and inject them into the prompt. This reduces hallucination and keeps answers current.

A production RAG pipeline includes: ingestion (PDF, HTML, SharePoint, tickets), chunking (size + overlap), embedding model selection, vector database (pgvector, Pinecone, Weaviate, Chroma), reranking, prompt assembly, generation, and citation surfacing to users.

Agentic RAG goes further: the model iteratively reformulates queries, selects tools, or routes sub-questions — essential for multi-document research and complex UK compliance queries.

Ingest → Chunk → Embed → Vector DB
                              ↓
User query → Embed query → Retrieve top-k → Rerank
                              ↓
                    Prompt = system + context + question
                              ↓
                         LLM answer + citations

Agentic AI — LangGraph, CrewAI, AutoGen & workflows

An AI agent loops: observe state → plan → call tools → update memory → repeat until done. Agents excel at multi-step tasks — onboarding workflows, research briefs, ticket triage — where a single prompt is insufficient.

LangGraph models agents as graphs with nodes (functions) and edges (conditions), giving explicit control flow — preferable for production over opaque chains. CrewAI assigns roles (researcher, writer, reviewer) for collaborative tasks. AutoGen (Microsoft) focuses on multi-agent conversations with human-in-the-loop gates.

UK teams adopt agents when API integrations, audit trails, and failure recovery are first-class — not when a chatbot skin is enough.

• LangChain — composable primitives; good for prototypes
• LangGraph — stateful graphs; strong for regulated workflows
• CrewAI — role-based multi-agent tasks
• AutoGen — conversational agents + human approval
• OpenAI Assistants / Responses API — managed tools with less infra

Model Context Protocol (MCP) — connecting tools & data

MCP standardises how LLM applications discover and invoke tools, databases, and filesystems through a host-server pattern. Instead of bespoke integrations per tool, MCP servers expose capabilities with schemas the model host can call securely.

For enterprise architects, MCP reduces integration sprawl: one protocol for internal APIs, CRM lookups, knowledge bases, and devops actions — with authentication boundaries enforced at the server layer.

In training, engineers implement MCP servers wrapping internal mock services, then wire them to agent hosts — mirroring how 2026 AI platforms consolidate tool access.

┌────────────┐   MCP    ┌─────────────┐
│ LLM Host   │◀────────▶│ MCP Server  │
│ (agent app)│          │ (tools/API) │
└────────────┘          └─────────────┘
       │                        │
       └──── audit log ─────────┘

OpenAI, Google Gemini & Anthropic Claude — when to use each

OpenAI models (GPT-4o, o-series reasoning models) lead in general reasoning, tool calling maturity, and developer ecosystem. Azure OpenAI is the default for many UK enterprises requiring Microsoft contractual coverage.

Google Gemini excels at multimodal inputs, long context in Gemini 2.x, and native integration with Google Cloud (Vertex AI). Choose Gemini when workloads already live on GCP or require strong image/document understanding at scale.

Anthropic Claude emphasises long-context analysis, nuanced writing, and safety-oriented refusals — popular for legal, policy, and research assistants in UK professional services.

Open-weight models (Llama, Mistral) suit air-gapped or cost-sensitive batch workloads when teams can manage hosting and safety filters themselves.

LangChain & LangGraph — hands-on engineering patterns

LangChain provides abstractions for prompts, retrievers, tools, and output parsers. LangGraph adds cyclic state machines — critical for retries, human approval nodes, and checkpointing long workflows.

Course labs progress from simple LCEL chains to graph-based customer-support agents with retrieval, SQL tools, and escalation to humans — the pattern UK employers ask about in interviews.

# Nodes: retrieve → generate → verify
# Edges: if low confidence → rewrite query → retrieve again

def retrieve(state):
    state["docs"] = vector_store.similarity_search(state["question"], k=6)
    return state

def generate(state):
    state["answer"] = llm.invoke(build_prompt(state["docs"], state["question"]))
    return state

def verify(state):
    state["ok"] = eval_rubric.score(state["answer"], state["docs"]) >= 0.8
    return state

AI evaluation, monitoring & observability

Production Generative AI without evals is experimental. Teams define metrics: faithfulness to sources, answer relevance, toxicity, latency, cost per session, and task success rate. Automated evals (RAGAS, DeepEval, custom LLM-as-judge with safeguards) run in CI; human review samples run weekly.

Observability stacks trace prompt → retrieval → tool calls → final output with correlation IDs. UK regulated environments retain logs per data policy, often with PII scrubbing and retention limits.

When models or embeddings change, regression suites prevent silent quality drops — the same discipline as software test pipelines.

• Golden datasets — curated Q&A from subject matter experts
• Online metrics — thumbs feedback, escalation rate, time-to-resolution
• Alerting — spike in refusals, latency, or cost anomalies
• Dashboards — LangSmith, Weights & Biases, OpenTelemetry exporters

AI governance, ethics & responsible AI (UK context)

UK organisations align Generative AI with ICO guidance on data protection, sector regulators (FCA, NHS DSPT where applicable), and internal AI policies. Responsible AI includes bias testing, transparency to users ('AI-assisted'), human oversight for high-impact decisions, and documented model change management.

Security topics cover prompt injection, data exfiltration via tools, insecure plugins, and secrets in prompts. Courses must teach red-team basics and defence patterns: input sanitisation, tool allowlists, output filtering, and least-privilege API scopes.

Ethical deployment is a competitive advantage in UK public-sector and B2B sales — buyers ask for governance artefacts in RFPs.

Deploying Generative AI to production

Production patterns mirror microservices: API gateway, auth, rate limiting, async workers for long jobs, caching for repeated retrievals, and feature flags for model versions. Containerise agent services; secrets in vaults; config via environment — never hard-coded keys in notebooks.

Cost optimisation strategies: embed cache, smaller models for routing, batch embeddings off-peak, truncate context intelligently, and monitor token usage per customer/account. UK startups and enterprises alike fail budgets without token dashboards.

Capstone projects in the Ismart Skills programme deliver a portfolio-ready deployment — documentation, architecture diagram, eval report, and demo URL — what hiring managers want to see.

AI automation — beyond chatbots

AI automation connects LLM decisions to business systems: CRM updates, ticket routing, report generation, code scaffolding, and compliance checks. Pair agents with workflow engines (n8n, Temporal, Azure Logic Apps) for durable execution.

UK consultancies and in-house teams charge premium day rates for automation that saves operational headcount — engineers who understand both LLMs and integration patterns capture that value.

Enterprise use cases & case study patterns

Document intelligence — extract clauses from contracts, compare to playbooks, cite page numbers. Reduces legal review hours; requires strong RAG and citation UX.

Operations copilot — SOP Q&A for warehouse and logistics teams with mobile-friendly UI. Success metric: reduced escalations to team leads.

Customer support assist — draft replies grounded on knowledge base; human agent approves before send. Metric: average handle time down, CSAT stable.

Sales enablement — personalised outreach from CRM + product docs with strict brand guardrails. Metric: meeting booking rate with compliance sign-off.

Capstone projects in our cohort mirror these patterns with anonymised enterprise datasets — learners leave with stories for interviews, not toy chatbots.

Generative AI interview questions (UK hiring managers)

Prepare concise architecture narratives: draw RAG on a whiteboard, explain when fine-tuning beats retrieval, describe an eval you would run before launch, and discuss a failure mode (hallucination, injection) you have mitigated.

• Explain RAG vs fine-tuning vs long-context-only approaches
• How do you detect and reduce hallucinations?
• Describe agent loop termination and human-in-the-loop
• How would you log and audit LLM decisions for FCA-regulated content?
• Walk through cost estimate for 1M monthly queries
• What is prompt injection and how do you defend against it?
• Compare LangGraph vs simple chain for a compliance workflow
• How do you evaluate retrieval quality independently from generation?

Certifications & learning paths (2026)

Vendor-neutral and cloud certifications complement portfolio work: cloud AI associate credentials (AWS/Azure/GCP), IBM RAG & Agentic AI certificates, NVIDIA RAG workshops, and internal employer badges. Certificates open doors; capstones close offers.

The Ismart Skills programme includes mock assessments, portfolio review, and institutional certification recognised by hiring partners — mapped to the skills above, not exam cramming alone.

Why train with Ismart Skills in London & online UK

Ismart Skills runs live cohorts from Barking, East London (IG11 8RT) with full online participation UK-wide. Instructors are active practitioners — not career trainers reading slides. Each week combines conceptual clarity, live coding, lab assignments, and mentor feedback.

You receive 40+ live hours, 1:1 mentorship access, certification prep, mock interviews, CV review, and introductions through our career support network. Recordings and templates remain available for revision.

Corporate teams book private cohorts with custom datasets and governance workshops — contact us for enterprise training proposals.

Fine-tuning vs RAG vs long context — decision guide

Teams often ask whether to fine-tune a model on proprietary data. Fine-tuning adjusts model weights — useful for style, format, or domain language — but it is expensive to maintain and slow to refresh when documents change weekly.

RAG keeps the base model frozen and retrieves fresh context per query — ideal for knowledge bases, policies, and product catalogues. Long-context models (100k+ tokens) suit single large dossiers but cost more per request and still benefit from retrieval for accuracy.

Enterprise pattern: start with RAG + evals; fine-tune only when retrieval-proven insufficient and you have curated training sets and MLOps capacity.

Vector databases & embedding strategies

Vector stores index embedding vectors for approximate nearest-neighbour search. pgvector inside PostgreSQL suits teams wanting SQL ops; managed options (Pinecone, Weaviate) optimise scale; Chroma accelerates prototypes.

Embedding strategy matters as much as store choice: chunk by semantic boundaries (headings, slides), preserve metadata (source URL, ACL tags), and filter retrieval by user permissions before the LLM sees content — mandatory for UK enterprise ACL models.

Hybrid search (BM25 + vectors) improves recall on SKU codes, legal references, and ticket IDs that pure semantic search misses.

• Re-embed when switching embedding models — plan migration jobs
• Store chunk hashes to avoid duplicate ingestion
• Monitor recall@k and nDCG on golden questions
• Use metadata filters for department / region scoping

AI cost optimization & scaling

Token spend dominates Gen AI opex. Optimise with: routing classifiers (small model triage), cached embeddings, summarised memory for agents, batch API for offline jobs, and prompt compression (remove redundant context).

UK finance teams require chargeback dashboards per product line — instrument token usage from day one in labs so learners speak the language of CFOs.

Autoscaling agent workers horizontally; cap max agent iterations to prevent runaway loops — a production incident class in 2025–2026 deployments.

Generative AI security — threats & defences

OWASP LLM Top 10 highlights prompt injection, insecure output handling, training data poisoning, and excessive agency. Defences combine input/output filters, tool allowlists, human approval for financial actions, and secrets isolation (never in prompts).

Red-team exercises in the course simulate jailbreak attempts and data exfiltration via malicious PDFs — learners document mitigations in their capstone security appendix.

• Separate system and user channels; treat user content as untrusted
• Sign and audit tool calls with service accounts
• Use VPC endpoints for cloud LLM APIs where available
• Rotate API keys; prefer workload identity over static keys

10-week learning path — what you will build

Weeks 1–2 establish LLM APIs, prompt patterns, and data hygiene. Weeks 3–4 introduce vector search and baseline RAG. Weeks 5–6 add agents, tool use, and evaluation pipelines. Weeks 7–8 are industry labs with mentor review. Weeks 9–10 cover certification drills, interview prep, and capstone delivery.

Each learner maintains a GitHub portfolio (private templates provided) with README architecture diagrams, eval scores, and demo scripts — the artefact hiring managers request in UK screeners.

genai-capstone/
├── README.md          # Architecture + business outcome
├── docs/eval-report.md
├── src/rag_pipeline.py
├── src/agent_graph.py
├── tests/test_evals.py
└── infra/docker-compose.yml

What UK hiring managers look for

Hiring managers prioritise candidates who explain trade-offs, not buzzwords. Expect whiteboard prompts: design customer-support RAG, estimate cost, define eval metrics, and describe rollback if quality drops after a model upgrade.

Soft skills matter — AI engineers partner with legal, ops, and product. Communication clarity in capstone presentations often decides offers for career switchers.

CrewAI & AutoGen — multi-agent patterns

CrewAI models teams of agents with roles, goals, and delegated tasks — useful for research reports and marketing briefs where specialization helps. AutoGen excels at conversational problem-solving with optional human approval between steps.

Production lesson: multi-agent does not mean better — each agent adds latency and failure points. Start single-agent with strong tools; split roles only when evals prove benefit.

GEO — optimising for AI search engines

Generative Engine Optimization (GEO) ensures ChatGPT, Gemini, Claude, Perplexity, and Google AI Overviews can cite your content accurately. Use clear definitions, structured FAQs, comparison tables, authoritative references, and consistent entity naming (Ismart Skills, Barking London, 10-week cohort).

This guide is structured for extractability: TL;DR boxes, step lists, glossary terms, and citation-friendly statistics with sources. Update the 'Updated' date when refreshing curriculum or salary bands.

Week-by-week curriculum deep dive

Week 1 — Foundations: You configure cloud or vendor API access, learn token economics, and implement your first structured prompt with JSON output validation. Labs compare GPT-4o, Claude, and Gemini on the same task to internalise vendor differences early.

Week 2 — Data & prompts: Document ingestion pipelines, chunking experiments, and embedding benchmarks. You build a mini knowledge base from sample UK policy PDFs and measure retrieval precision — the same workflow enterprises use before any public launch.

Week 3 — Automation: Event-driven workflows trigger summarisation, classification, and routing. You connect webhooks and queue workers — patterns common in UK insurtech and logistics copilots.

Week 4 — Advanced integration: Multi-step chains with error handling, retries, and fallback models. Introduce tool calling: calendar lookup, SQL, internal REST APIs with mock services.

Week 5 — Evaluation pipelines: Build golden datasets, implement RAGAS-style metrics, and wire CI jobs that fail builds when faithfulness drops below threshold.

Week 6 — Deployment & performance: Containerise services, add health checks, streaming SSE endpoints, and load-test with realistic concurrency. Dashboard token spend per user story.

Weeks 7–8 — Industry labs: Two mentor-reviewed projects simulating client briefs — e.g., compliance Q&A assistant and sales enablement copilot with approval gates.

Week 9 — Certification & interviews: Mock technical screens, system design whiteboards, and behavioural STAR stories tied to your labs.

Week 10 — Capstone: Present end-to-end solution to instructors and peers; receive written feedback for portfolio and LinkedIn case study.

OpenAI API — patterns for UK production

The OpenAI API (often via Azure OpenAI in UK enterprise) supports chat completions, assistants/responses with tools, embeddings, and batch jobs. Production clients implement exponential backoff, idempotency keys for write tools, and request IDs correlated to support tickets.

Structured outputs via JSON schema reduce parsing errors in downstream systems — critical when feeding CRM or data warehouses. Streaming improves perceived latency for chat UIs; batch API cuts cost for offline enrichment jobs.

Azure OpenAI adds private networking, content filtering policies, and regional deployment — common requirements in FCA-regulated firms. Labs cover both direct OpenAI and Azure endpoint configuration.

from openai import OpenAI
client = OpenAI()

def embed_texts(texts: list[str]) -> list[list[float]]:
    resp = client.embeddings.create(
        model="text-embedding-3-small",
        input=texts,
    )
    return [d.embedding for d in resp.data]

Anthropic Claude & Google Gemini in enterprise stacks

Claude's long-context windows suit contract review, policy comparison, and multi-document synthesis where citations must map to source spans. Teams use Claude when nuance and safety refusals align with legal review workflows.

Gemini via Vertex AI integrates with Google Cloud IAM, BigQuery, and multimodal inputs (PDF, image, audio). Retail and media clients on GCP often standardise on Gemini for catalogue enrichment and content moderation assist.

Multi-vendor architecture routes tasks: Gemini for vision-heavy ingestion, Claude for long doc synthesis, OpenAI for tool-rich agents — unified behind an internal gateway with unified logging.

Generative AI training in London, Manchester & UK cities

Search intent varies by location: 'Generative AI course London' emphasises classroom + networking; 'AI training Manchester' and 'LLM course Birmingham' reflect regional hub demand; 'online Generative AI UK' captures nationwide remote learners.

Ismart Skills serves all three intents: London HQ sessions in Barking (East London), live online cohorts for Manchester, Birmingham, Leeds, Bristol, and programmatic location pages with city-specific FAQs linking back to this hub.

Local EEAT signals include verifiable address (IG11 8RT), phone 020 3819 0333, named instructors with team pages, and transparent curriculum documentation on this page.

• Generative AI course London — in-person + online
• AI engineer training Manchester — live online cohort
• LLM bootcamp UK — 10-week structured programme
• RAG training course — enterprise labs included
• Agentic AI course — LangGraph & MCP modules

Content gaps competitors miss (and we cover)

Many MOOCs teach notebook RAG but skip permission-aware retrieval, cost dashboards, and change-management for model upgrades. Short workshops demo agents without evals or incident playbooks.

Free YouTube courses (including popular 10-hour agent compilations) lack mentor feedback, employer introductions, and accountable schedules — fine for awareness, insufficient for career transition.

IBM and NVIDIA free tracks excel at specific tools; they do not combine UK career support, live cohort accountability, and capstone presentation to hiring panels.

This page closes gaps with: MCP architecture, vectorless RAG concepts, governance for UK GDPR, hiring-manager interview prep, and comparison tables honest about trade-offs.

Portfolio projects & GitHub examples

Capstone templates include: Internal policy assistant (RAG + ACL metadata), Customer ticket summariser (classification + CRM tool), Sales call prep agent (CRM + web search + human approval), and Code review assistant (static analysis tool + LLM explanation).

Learners document architecture decisions in ADR format — Architecture Decision Records — valued by UK engineering managers. Public GitHub is optional; many use private repos with README exports for interviews.

Example interview story: 'I reduced unsupported answers 34% by adding hybrid search and a faithfulness eval gate before responses reach users' — backed by lab metrics, not vanity demos.

Corporate & enterprise team training

L&D teams book private cohorts with customised datasets (under NDA), governance workshops for legal/compliance stakeholders, and progress dashboards for managers. Delivery formats: onsite at your office, our Barking HQ, or virtual.

Enterprise outcomes include reduced vendor consultancy spend, internal champions who maintain RAG indices, and playbooks for safe Copilot-style rollouts. Request a corporate proposal via contact with team size and target use cases.

Action checklist — before you enrol

Use this checklist to confirm readiness and compare providers objectively.

• Define target role: AI engineer, ML engineer, automation specialist, or product manager with AI depth
• Audit schedule: can you commit 6–10 hours weekly for 10 weeks?
• Verify live instruction vs recorded ratio
• Confirm capstone includes mentor code review
• Ask about evals, governance, and security modules — not only prompts
• Check career support scope: CV, mocks, introductions
• Review instructor credentials on /team pages
• Book free consultation if unsure which cohort fits

UK salary trends by city (2026)

London commands premium for LLM roles — especially finance and consulting — but cost of living adjusts net benefit. Manchester and Birmingham show strong demand with slightly lower bands but growing remote-first employers.

Edinburgh and Glasgow attract fintech and public-sector AI roles; Bristol and Leeds hub health-tech and scale-ups. Online training removes geography barriers — employers hire on portfolio regardless of city.

Voice & conversational search queries answered

People ask assistants: 'What is the best Generative AI course near me in London?' — Answer: compare live cohorts with capstones; Ismart Skills offers London HQ plus online UK attendance.

'How do I learn RAG and LangChain?' — Answer: structured 10-week path with weekly labs beats random tutorials; start with embeddings and retrieval before agents.

'Can I switch careers into AI without a PhD?' — Answer: yes; UK employers hire software engineers, analysts, and DevOps professionals who demonstrate RAG/agent portfolios.

'How much does AI training cost in the UK?' — Contact for current cohort fees; compare total value including mentorship hours, not just headline price.

Frequently asked questions

Glossary

LLM

Large Language Model — neural network trained to generate text/code from token predictions.

RAG

Retrieval-Augmented Generation — fetches relevant documents before answering.

Embedding

Numeric vector representation of text used for semantic search.

Agent

System where an LLM plans and executes tool calls in a loop.

MCP

Model Context Protocol — standard for connecting AI hosts to tools/data.

Eval

Automated or human assessment of AI output quality against rubrics.

Hallucination

Confident but incorrect model output not grounded in sources.

Prompt injection

Attack where user input overrides system instructions — requires defences.

References & further reading

• ICO AI guidance (UK)
• OpenAI API documentation
• Anthropic Claude documentation
• Google Gemini API
• LangChain documentation
• LangGraph documentation
• Model Context Protocol