Short answer
An MCP workshop teaches teams to connect AI agents to internal systems through Model Context Protocol servers that are small, well described and safe. The practical core is building one real server against an internal API, then adding authentication, permission scoping, logging and a review process before anyone else can use it.
On this page
What MCP changes
The Model Context Protocol (MCP) is an open protocol that lets AI applications and agents connect to external tools and data sources in a standard way. Instead of every agent needing its own plugin for your ticketing system, wiki or database, you build an MCP server once and any MCP-capable client can use it: coding agents such as Claude Code, desktop assistants and increasingly enterprise agent platforms.
That standardization is powerful and slightly dangerous. An MCP server can expose read access to sensitive data or write access to production systems with a few lines of code. Teams need to learn both how to build servers that agents use well and how to govern them so the organization does not end up with dozens of unreviewed integrations. At neooutput our MCP workshop covers both halves.
Who should attend
- Platform and integration engineers who will build and operate servers
- Developers who want their coding agents to reach internal tools
- Security engineers responsible for approving integrations
- Architects defining how AI agents access enterprise systems
A mix of these roles in one room leads to better designs, because security questions come up while the code is still being written.
Core concepts in plain terms
We start with a short conceptual block so everyone shares the same vocabulary:
| Concept | What it means in practice |
|---|---|
| Server | A process that offers capabilities to AI clients over MCP |
| Client or host | The AI application that connects to servers, for example a coding agent |
| Tools | Actions the model can call, with a name, description and input schema |
| Resources | Data the client can read, such as documents or records |
| Prompts | Reusable prompt templates a server can offer |
| Transport | How client and server talk: locally over standard input and output, or remotely over HTTP |
The key insight for designers: the model chooses tools based on their names and descriptions. A badly described tool is called at the wrong time or with wrong arguments, however good the implementation is.
Hands-on: building a first server
Participants build an MCP server against a real internal system, usually something read-mostly like a ticket tracker, a documentation store or a service catalogue. We use one of the official SDKs in a language the team knows. The exercise follows these steps:
- Choose three tools, not thirty. Start with the narrowest useful set, for example search tickets, get ticket details and list recent changes for a component.
- Write descriptions for the model. Say what the tool does, when to use it and what it returns. Include constraints like maximum results.
- Design inputs and outputs. Strict input schemas, compact outputs. Large raw API payloads waste context and confuse the model.
- Connect a client. Register the server with a coding agent and watch how it uses the tools on realistic questions.
- Iterate on behaviour. Adjust names, descriptions and output formats based on what the agent actually did.
Step five is usually where the biggest improvements happen, and it is the step most tutorials skip.
Governance and security
Once a server works, the workshop shifts to making it safe for others. We cover:
Authentication and authorization
Remote servers need proper authentication. The server should act with the permissions of the user, not a powerful service account, wherever possible. We discuss how that maps to your identity provider and where a gateway helps.
Scoping write access
Read tools and write tools carry very different risk. We recommend separate servers or clearly separated tools for writes, with confirmation steps in the client and tighter approval.
Prompt injection through data
If a tool returns content written by others, such as ticket descriptions or wiki pages, that content can contain instructions aimed at the model. We demonstrate the risk and discuss mitigations: treating tool output as data, limiting what write tools can do after reading untrusted content, and keeping humans in the loop for consequential actions. The secure agentic coding workshop covers this topic in more depth.
Logging and audit
Who called which tool, with what arguments, and what came back? Logs are essential for debugging and for audit. We define a minimal logging format during the session.
A registry and review process
Organizations need to know which servers exist, who owns them and which clients may use them. We draft a lightweight review checklist: owner, data classification, auth model, write capabilities, logging, and a review date.
From workshop to production
A typical path after the workshop:
- Two or three servers built and reviewed in the first month
- An internal catalogue of approved servers
- Default configurations for coding agents that include approved servers
- A process for teams to propose new servers
For integrations with core business systems such as SAP, SharePoint or CRM, the stakes are higher. Our article on MCP servers for enterprise integration looks at those patterns specifically. When AI agents move beyond engineering into business processes, a governed orchestration layer becomes important. kalAIDoCreate provides that with audit trails, SSO, integrations and EU data residency.
Format and preparation
We run the MCP workshop as one intensive day or two half days. Teams should prepare:
- Access to one internal API in a test environment
- A coding agent or AI client that supports MCP
- A development environment for the chosen SDK language
- Someone from security available at least for the governance block
neooutput delivers it remotely or on site in English or German. Teams new to coding agents may want to start with the Claude Code workshop for engineering teams and add MCP as a second step.
FAQ
Do we need to build our own MCP servers?
Not always. Many tools offer MCP servers already. Building your own makes sense for internal systems or when you need tighter control over what is exposed.
Which programming languages can we use?
Official SDKs exist for several common languages. In the workshop we use whichever the team is most comfortable with, since the concepts are the same.
Is a local server safer than a remote one?
Local servers run on the user's machine with the user's access, which limits exposure but makes central control harder. Remote servers centralize control and logging but need proper authentication. Most organizations use both.
How do we stop agents from doing damage through write tools?
Keep write tools narrow, require confirmation in the client, use the user's own permissions and log every call. Start with read-only servers until the review process is established.