CUSTOMISED
Expert-led training for your team
Dismiss

Build Agentic AIs with Python RAG and MCP training course

A hands-on, code-first course where you build a production-shaped agentic AI system in Python from scratch. Implement a tool-using agent loop with memory, RAG & MCP tool server. patterns.

JBI training course London UK

"Our tailored course provided a well rounded introduction and also covered some intermediate level topics that we needed to know. Clive gave us some best practice ideas and tips to take away. Fast paced but the instructor never lost any of the delegates"

Brian Leek, Data Analyst, May 2022

Public Courses

18/05/26 - 2 days
£2500 +VAT
02/03/26 - 2 days
£2500 +VAT
13/04/26 - 2 days
£2500 +VAT

Customised Courses

* Train a team
* Tailor content
* Flex dates
From £1200 / day
EDF logo Capita logo Sky logo NHS logo RBS logo BBC logo CISCO logo
JBI training course London UK

  • Build a stateful, tool-using agent loop (streaming, retries, timeouts, safety rails)
  • Implement end-to-end RAG: ingestion, embeddings, retrieval, reranking, citations
  • Create an MCP server with schemas, permissions, and real tools
  • Add memory + workflows (ReAct, plan-and-execute, routing patterns)
  • Upgrade to multi-agent systems (router, researcher, critic, executor)
  • Production hardening: testing, evals, logging, retries, caching, deployment
  • Ship a full capstone: chatbot + RAG + tools + multi-agent workflow

Course kickoff + dev setup (code-first)

  • What “agentic” means in practice: tools, memory, planning, orchestration
  • Local environment: Python, venv/uv/poetry, lint/format, pytest, type hints
  • Repo scaffolding: apps/ (agents), services/ (MCP), libs/ (shared)

Python fundamentals (only what we’ll immediately use)

  • Data structures, modules/packages, CLI args, logging
  • OOP vs functional style for agents (dataclasses, protocols/interfaces)
  • Async essentials: asyncio, tasks, queues, timeouts, cancellation
  • HTTP basics: FastAPI (or equivalent), requests/httpx, websockets (optional)

Agent core: a minimal “tool-using” loop

  • Message format + state (conversation, scratchpad, structured outputs)
  • Tool registry pattern (schema, validation, routing, error handling)
  • Safety rails: allowlists, rate limits, redaction, audit logs
  • Evaluation harness: golden tests, replay, deterministic mocks

 

 

 

MCP server (capabilities as tools)

  • MCP concepts: tool discovery, schemas, calling conventions
  • Build a minimal MCP server in Python (hello tool → real tools)
  • Implement 3–5 practical tools:
    • Filesystem (sandboxed), HTTP fetch (restricted), DB query (read-only), calculators, internal APIs
  • Auth + permissions model (per-tool scopes), observability, versioning

Chatbot (the “front door”)

  • Build a simple chat UI/CLI + API backend
  • Streaming responses, tool call UX, citations/grounding display
  • Session storage: in-memory → Redis/Postgres upgrade path

RAG fundamentals (grounded answers)

  • Chunking, embeddings, vector stores (local first, then managed option)
  • Retrieval strategies: hybrid search, metadata filters, reranking
  • Prompting for grounded responses + citation linking
  • RAG evaluation: recall/precision sanity checks, adversarial queries

Agent memory + workflows

  • Short-term memory (session), long-term memory (user profile / notes)
  • Summarisation, decay, and “don’t remember this” controls
  • Workflow patterns: ReAct, plan-and-execute, toolformer-like routing

Exposing capabilities safely

  • Capability design: input contracts, idempotency, side-effect isolation
  • Human-in-the-loop approvals for risky tools
  • Secrets management, policy checks, sandboxing, audit trails

Multi-agent systems

  • When multi-agent helps vs hurts (latency/complexity tradeoffs)
  • Roles: router, researcher, coder, critic, executor
  • Coordination patterns: supervisor, swarm, debate, blackboard, task queue
  • Shared context + shared tools; conflict resolution and consensus

Production concerns (as we harden the build)

  • Tracing + structured logs, metrics, tool call timelines
  • Reliability: retries, timeouts, circuit breakers, fallbacks
  • Cost controls: caching, batching, model selection, token budgeting
  • Deployment: containerise, run MCP + API, config per environment

Capstone project

  • A full agentic app: chatbot + RAG + MCP tool suite + multi-agent workflow
  • Demo scenarios, test suite, and “how to extend” checklist
JBI training course London UK

This course is designed for technical professionals who want to move beyond prompt experimentation and build production-ready agentic AI systems.

Ideal for:

  • Software developers comfortable with basic Python
  • AI/ML engineers building LLM-powered applications
  • Backend engineers integrating AI into products
  • Technical architects designing AI-driven systems
  • Startup founders and product engineers shipping AI features
  • Data professionals expanding into agentic workflows

If you can write basic Python and want to build systems that use tools, memory, RAG, and multi-agent coordination—this course is for you.

 

 


5 star

4.8 out of 5 average

"Our tailored course provided a well rounded introduction and also covered some intermediate level topics that we needed to know. Clive gave us some best practice ideas and tips to take away. Fast paced but the instructor never lost any of the delegates"

Brian Leek, Data Analyst, May 2022



 

 

JBI training course London UK

Newsletter


Sign up for the JBI Training newsletter to receive technology tips directly from our instructors - Analytics, AI, ML, DevOps, Web, Backend and Security.
 



This is a hands-on, code-first course focused on building real agentic AI systems in Python—not just prompt demos. You’ll design and implement a stateful, tool-using agent that can retrieve knowledge with RAG, expose capabilities through an MCP server, and coordinate multiple agents to plan, execute, and verify tasks.

Along the way, you’ll apply practical Python fundamentals, evaluation techniques, safety patterns, and production hardening practices. By the end, you’ll have a complete, extensible agentic application—and the architectural patterns to confidently build and ship your own.

What is the target audience for this course?

This course is for developers with basic Python knowledge who want to build real AI applications.

You don’t need prior AI or machine learning experience. It’s ideal for:

  • Python developers curious about LLMs and chatbots
  • Software engineers exploring AI integration
  • Backend or full-stack developers adding AI features
  • Technical founders building AI products
  • Students wanting practical, hands-on AI skills

If you can write basic Python scripts, you’re ready.

 

CONTACT
+44 (0)20 8446 7555

[email protected]

SHARE

 

Copyright © 2025 JBI Training. All Rights Reserved.
JB International Training Ltd  -  Company Registration Number: 08458005
Registered Address: Wohl Enterprise Hub, 2B Redbourne Avenue, London, N3 2BS

Modern Slavery Statement & Corporate Policies | Terms & Conditions | Contact Us

POPULAR

AI training courses                                                                        CoPilot training course

Threat modelling training course   Python for data analysts training course

Power BI training course                                   Machine Learning training course

Spring Boot Microservices training course              Terraform training course

Data Storytelling training course                                               C++ training course

Power Automate training course                               Clean Code training course