MCP Workshop: Building and Governing Model Context Protocol Servers

An MCP workshop for engineering teams: design, build and secure Model Context Protocol servers that connect AI agents to your internal tools and data.

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
  1. What MCP changes
  2. Who should attend
  3. Core concepts in plain terms
  4. Hands-on: building a first server
  5. Governance and security
  6. From workshop to production
  7. Format and preparation
  8. FAQ
  9. Tools from the jocapps ecosystem

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:

ConceptWhat it means in practice
ServerA process that offers capabilities to AI clients over MCP
Client or hostThe AI application that connects to servers, for example a coding agent
ToolsActions the model can call, with a name, description and input schema
ResourcesData the client can read, such as documents or records
PromptsReusable prompt templates a server can offer
TransportHow 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:

  1. 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.
  2. Write descriptions for the model. Say what the tool does, when to use it and what it returns. Include constraints like maximum results.
  3. Design inputs and outputs. Strict input schemas, compact outputs. Large raw API payloads waste context and confuse the model.
  4. Connect a client. Register the server with a coding agent and watch how it uses the tools on realistic questions.
  5. 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.

Tools from the jocapps ecosystem

Want this done right, and fast?

Talk to our AI Code Engineers and AI architects. In a free 30-minute call we look at your idea, prototype or roadmap and tell you honestly what it takes to ship it.

24/7 call support in English and German.

Free call

Free intro call

Tell us which task an AI agent should take responsibility for. We show how our platform, AI Code Engineers and operations plug into your stack.

  • 30 minutes, no obligation
  • Honest feasibility check
  • Concrete next step
Rather talk now? 24/7 call support in English and German+49 761 519 751 50