Explain the host, client and server architecture that the Model Context Protocol defines.
Digital Transformation & Artificial Intelligence
Connecting AI Agents to Business Systems with the Model Context Protocol
Connect AI agents to CRM, ERP and other business systems using the Model Context Protocol, with security, approval and audit controls designed in from the start.
🗓️Duration5 training days
📚Content4 modules · 8 sessions
🎓On completionAccredited attendance certificate
About the programme
Course Overview
An AI agent is only as useful as the systems it can safely reach: a customer record in a CRM, a ticket queue, an approval step in an ERP workflow. The Model Context Protocol gives agents a standard way to discover and call those systems, but taking it from a demonstration into production raises architecture, security and governance questions a proof of concept never has to answer. The first modules work through the protocol's host, client and server architecture and then build MCP servers that wrap CRM, ERP and ticketing systems behind tool and resource schemas an agent can use reliably, including composing several servers into one multi-step workflow. The second half is built around control: least-privilege credentials instead of embedded secrets, a human approval step before any irreversible transaction, full audit logging of every tool call, and the rate limits and change-approval process that keep a growing catalogue of connected systems safe as it scales. Delegates finish with a working, secured integration pattern rather than only a protocol diagram.
Expected Learning Outcomes
Design tool and resource schemas that let an AI agent call a business system safely.
Wrap CRM, ERP and ticketing system APIs as MCP tools with clear contracts and error handling.
Compose multiple MCP servers into a single agent workflow spanning several business systems.
Apply least-privilege access control and short-lived credentials to agent-to-system connections.
Insert human approval steps before an agent executes an irreversible business transaction.
Monitor, audit and govern agent tool use across a growing catalogue of connected systems.
Who Should Attend
Software engineers building AI agents that need to call internal business systems.
Enterprise architects designing integration patterns between AI agents and core systems.
Security and platform teams responsible for access control on AI agent integrations.
IT leaders evaluating the Model Context Protocol for enterprise AI agent deployment.
Automation and RPA teams extending existing integrations to support autonomous agents.
Technical product owners governing which business systems AI agents may access.
Course Modules
Select any module to see its sessions and points.
01Model Context Protocol Architecture and Core Concepts
2 sessions · 8 points
Session 1How Hosts, Clients and Servers Interact
- Mapping the host, client and server architecture that separates an AI agent from the systems it calls.
- Distinguishing tools, resources and prompt templates as the three primitives a server exposes.
- Explaining the capability negotiation that happens between a client and server at connection time.
- Comparing local and remote transport choices for different deployment and latency requirements.
Session 2Designing Tool and Resource Schemas
- Writing tool names, descriptions and parameter schemas clear enough for an agent to select correctly.
- Exposing read-only resources for context separately from tools that change system state.
- Versioning a server's tool contract so agent behaviour does not break silently after an update.
- Documenting expected error responses so an agent can recover gracefully or escalate to a human.
02Building MCP Servers for Core Business Systems
2 sessions · 8 points
Session 1Wrapping CRM, ERP and Ticketing Systems
- Translating an existing REST or database API of a CRM or ERP system into MCP tool definitions.
- Deciding which internal operations are safe to expose to an agent versus kept for human-only workflows.
- Handling pagination, rate limits and long-running jobs behind a simple, agent-friendly tool interface.
- Mapping legacy system error codes into responses an agent can actually interpret and act on.
Session 2Composing Multiple Servers for a Single Agent Task
- Registering several MCP servers with one agent to combine lookup, calculation and action tools.
- Resolving naming conflicts and overlapping responsibilities when servers expose similar tools.
- Sequencing multi-step tasks that call more than one business system in the correct order.
- Testing composed workflows against realistic multi-system scenarios before any production rollout.
03Security, Access Control and Human Oversight
2 sessions · 8 points
Session 1Authentication, Authorisation and Least Privilege
- Scoping each MCP server's credentials to the minimum operations a given agent task requires.
- Issuing short-lived tokens instead of embedding long-lived secrets in agent prompts or configuration.
- Separating read tools from write tools so destructive actions require an explicit permission tier.
- Revoking or rotating a server's access promptly when a task or integration is retired.
Session 2Human-in-the-Loop Approval and Audit Trails
- Inserting a confirmation step before an agent executes an irreversible business transaction.
- Logging every tool call with its inputs, outputs and requesting agent session for later audit.
- Red-teaming an agent's tool use to surface prompt injection attempts hidden in untrusted data.
- Reviewing audit logs on a fixed schedule to catch scope creep in agent permissions early.
04Deploying, Monitoring and Governing Agent Integrations
2 sessions · 8 points
Session 1Operating MCP Servers in Production
- Setting rate limits and timeouts so a misbehaving agent cannot overload a business system.
- Monitoring latency, error rate and cost per tool call across every connected server.
- Maintaining a registry of approved internal servers so teams reuse rather than duplicate integrations.
- Planning rollback procedures for when a server update unexpectedly changes tool behaviour.
Session 2Governance Across Vendor and Model Changes
- Keeping the integration layer model-agnostic so switching the underlying language model needs no rewrite.
- Defining a change-approval process for any new tool added to a shared, organisation-wide server.
- Setting organisation-wide policy on which business systems may ever be exposed to autonomous agents.
- Reviewing incidents where an agent used a tool incorrectly to refine schemas and guardrails afterwards.
What the participant receives
4 course modules
A structured syllabus
8 training sessions
across 5 days
32 detailed points
Applied, detailed content
Accredited attendance certificate
On completing the programme
Complete your registration
We will contact you within one business day to confirm.
Ready to start?
Reserve your seat and start building the skill.