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

06/07/26 - 2 days
£2500 +VAT
17/08/26 - 2 days
£2500 +VAT
28/09/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.
 

AI Knowledge Hub Content Plan

 

Pillar Page 3: Model Context Protocol (MCP) Explained

 

Introduction

Model Context Protocol (MCP) is becoming a key standard for connecting AI models to enterprise systems, databases, tools, and applications. It provides a secure and consistent method for AI systems to access external resources and perform actions.

As organisations deploy AI agents at scale, MCP is emerging as an important technology for integration and interoperability.

 

What is Model Context Protocol (MCP)?

MCP is an open standard that enables AI systems to connect securely with external tools, applications, APIs, and data sources.

Why is MCP important?

MCP reduces integration complexity and provides a standard way for AI assistants and agents to interact with enterprise systems.

What can MCP connect to?

MCP can connect AI systems to databases, CRM platforms, document repositories, project management tools, cloud services, APIs, and business applications.

Is MCP only used for AI agents?

No. MCP can be used by AI assistants, copilots, chatbots, and agent-based systems whenever access to external resources is required.

Why is MCP often compared to USB-C?

Just as USB-C standardised device connectivity, MCP aims to standardise how AI systems connect to external tools and information sources.

What is Retrieval-Augmented Generation (RAG)?

Retrieval-Augmented Generation (RAG) is an AI architecture that combines Large Language Models with external knowledge sources. Instead of relying solely on information learned during training, a RAG system retrieves relevant information from documents, databases, or company knowledge repositories before generating a response.

RAG helps organisations build AI solutions that provide more accurate, up-to-date, and context-aware answers while reducing hallucinations. It is commonly used in enterprise chatbots, knowledge assistants, customer support systems, and internal search platforms.
 

What is Model Context Protocol (MCP)?

Model Context Protocol (MCP) is an open standard that allows AI models to securely connect to external tools, applications, databases, and business systems. It provides a consistent way for AI assistants and agents to access information and perform actions beyond their built-in capabilities.

MCP is often described as the "USB-C for AI" because it creates a standard interface between AI systems and external services. Organisations use MCP to integrate AI agents with CRM systems, document repositories, databases, project management platforms, and other enterprise applications.

What Is the Difference Between RAG and Fine-Tuning?

RAG and fine-tuning are two different approaches to improving AI performance.

RAG enhances responses by retrieving relevant information from external knowledge sources at runtime. This allows AI systems to access current information without retraining the model.

Fine-tuning modifies the model itself by training it on additional datasets to improve performance for specific tasks or domains.

Many enterprise AI solutions use RAG because it is faster, less expensive, easier to update, and better suited for knowledge that changes frequently.

What is RAG?

Retrieval-Augmented Generation (RAG) is an AI architecture that combines Large Language Models with external knowledge sources. A RAG system retrieves relevant information from documents, databases, or knowledge repositories before generating a response, improving accuracy and reducing hallucinations.


 


 

 

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