MCP Servers Explained: Why L&D Professionals Should Care About the Model Context Protocol

Okay So I Found Something and I Need to Tell You About It

You know that workflow where you open a Google Doc with your SME notes, copy a chunk, paste it into Claude, ask Claude to turn it into learning objectives, copy Claude's output, paste it back into your outline doc, go back to the Google Doc, copy the next section, and do the whole thing over again? I was doing that constantly. Like, embarrassing amounts of copy-pasting. My entire workday sometimes felt like I was a human clipboard shuttling text between windows.

If you use AI for any part of your instructional design work, you know exactly what I'm talking about. You're the middleman between your content and the AI. Every single interaction means manually hauling information back and forth between source docs, chat windows, spreadsheets, project tools. The AI is genuinely powerful, but it's stuck in a text box. It only knows what you hand-feed it.

That's the problem MCP solves. And honestly, when I first stumbled onto this, I lost an entire evening going down the rabbit hole (classic me, brain supposedly stops at 7pm but here I am at midnight reading documentation). It's quietly becoming the standard way AI tools connect to your actual workspace, and I haven't seen anyone in L&D talking about it yet. So here we are.

What MCP Actually Is (No Developer Jargon, I Promise)

MCP stands for Model Context Protocol. Anthropic (the company behind Claude) created it and released it as an open standard back in late 2024. Here's the simplest way I can explain it:

MCP is a universal adapter that lets AI assistants plug into your actual tools and data.

Think about USB. Before USB, every device had its own weird proprietary connector. Printers, keyboards, cameras -- all different plugs. USB created one standard port that everything could use. MCP does the same thing but for AI connections. Instead of every AI tool building its own custom integration with Google Drive, Slack, GitHub, and databases, MCP provides one standard protocol that any AI tool can use to connect to any data source.

In real-life terms: instead of copying text from a Google Doc and pasting it into Claude, Claude can just read the Google Doc directly. Instead of exporting a CSV from your LMS and uploading it, Claude can query your database and pull the learner data itself. Instead of summarizing Slack messages in your own words and typing them into a prompt, Claude can read the actual Slack channel where your SME left feedback at 11pm (because SMEs apparently never sleep).

The AI stops being a disconnected chatbot and becomes an assistant that can actually see and interact with your work environment. When I first got this working, I literally said "oh no" out loud because I realized how much time I'd been wasting.

How MCP Servers Work (Less Scary Than It Sounds)

The word "server" sounds intimidating. I know. When I first saw it I pictured server rooms and IT departments and things way above my pay grade. But MCP servers are actually small, lightweight plugins. Think of each one as a translator that sits between Claude and one of your tools.

Here's how it works:

• You install an MCP server for the tool you want to connect (Google Drive, Slack, your file system, a database, etc.)
• You configure it by telling it where to connect and giving it credentials (like an API key or login)
• Claude discovers it and now has access to that tool's capabilities

So if you install the Google Drive MCP server, Claude can search your Drive, read documents, and even create new files. Install the Slack MCP server and Claude can read channels and messages. Install the filesystem MCP server and Claude can read and write files on your computer -- which is a game changer when you're building web-based training or managing course files.

You can have multiple MCP servers running at once. My current setup usually has three going: my local file system (so Claude can read my project files and write new ones -- this is how I build my PWO games and everything on my portfolio site), a database connection for pulling analytics, and GitHub for version control. When I need Slack or Google Drive access for a project at work, I spin those up too.

Each server is independent. You add and remove them based on what you need for a given project. It's modular, which I love.

Why This Matters for Instructional Design Work

Okay here's where it gets fun. Let me walk through some real scenarios where MCP has changed my actual workflow -- not hypothetical future stuff, but things I'm genuinely doing now.

Reading Source Documents and Writing Course Files

This is the most immediately useful MCP connection for any instructional designer, hands down. With the filesystem MCP server, Claude can see your entire project folder. When I'm building a web-based training module (which is like... most of what I do these days between my day job and my own projects), Claude can read source documents in my project folder, understand the content, and then write HTML, CSS, and JavaScript files directly into my output folder.

Last week I had a 35-page procedures manual to work with. Instead of copying sections into Claude one at a time like I used to, I pointed Claude at the PDF in my project folder and said: "Read the manual and create a 5-module interactive training outline. For Module 1, generate the full HTML with scenario-based questions." Claude read the entire document, created the outline, and wrote the Module 1 HTML file right into my project. I reviewed it, gave feedback, and Claude edited the file in place. No copy-pasting. No losing context between conversations.

If you've ever built scenario-based eLearning the way I have -- writing branching HTML files with interactive elements -- you understand why having Claude directly read your source material AND write your output files is such a massive workflow shift. It's the difference between being a courier and being a creative director.

Pulling SME Feedback From Slack

My subject matter experts do not give feedback in neat, organized documents. They drop comments in Slack threads at random hours. (Healthcare people keep wild schedules, which honestly I respect as a fellow person who should be asleep but isn't.) With the Slack MCP server connected, I can tell Claude: "Read the last week of messages in the #training-review channel and compile all SME feedback into a prioritized action list."

Claude reads the actual Slack messages, parses the feedback, identifies what's a content correction versus a suggestion versus a question, and gives me a clean summary with specific action items tied to specific modules.

This used to take me 30-40 minutes of scrolling through Slack threads, copying quotes, and organizing them manually. Now it takes about 90 seconds. I am not exaggerating.

Querying Learner Data

If your organization stores completion data, assessment scores, or engagement metrics in a database, the Postgres (or MySQL, or SQLite) MCP server lets Claude query it directly. I've used this to pull completion rates by department, identify modules with high failure rates, and analyze which quiz questions aren't performing well -- all by asking Claude in plain English.

"Show me the average score and completion rate for each module in the Q4 onboarding course, broken down by department" turns into a SQL query, runs against the database, and comes back as a formatted table with insights. I didn't write a single line of SQL or open a database tool. As someone who's been in this field less than two years, being able to do data analysis like this without a data science background feels like a superpower.

Working With Google Drive Content

Most of us live in Google Drive. Course outlines, storyboards, review documents, client briefs -- they're all in Docs and Sheets. The Google Drive MCP server means Claude can search your Drive, read document contents, and even create new documents. When I get a brief in Google Docs, I don't need to download it or copy the text. Claude reads it directly and starts working with the full context.

What You Need to Get Started

I want to be real with you about the current state of things: MCP is incredibly powerful, but the setup process is still geared toward people who are comfortable with a terminal. It's not point-and-click yet. Here's what you actually need:

The Prerequisites

• Claude Code -- This is Anthropic's command-line interface for Claude. It runs in your terminal (that black window with text that looks very hackery). MCP servers currently work through Claude Code, not through the regular Claude chat at claude.ai. You need a Claude Pro ($20/month) or Max subscription.
• Node.js -- Most MCP servers are built with Node.js, so you'll need it installed. It's free and the install is straightforward -- just download from nodejs.org and run the installer.
• Basic comfort with the terminal -- You don't need to be a developer. I'm not a developer. I'm a vibe coder who switched careers from teaching two years ago. If I can figure this out, I promise you can too. If you've ever typed a command into a terminal window and hit enter, you have enough skill for this.

Step-by-Step: Your First MCP Server

The easiest MCP server to start with is the filesystem server, because it doesn't require any API keys or external accounts. Here's how:

Step 1: Open your terminal and install Claude Code if you haven't already:

npm install -g @anthropic-ai/claude-code

Step 2: Navigate to your project folder and start Claude Code:

cd ~/Documents/my-training-project && claude

Step 3: Claude Code automatically has filesystem access to whatever folder you start it in. That's it for the filesystem server -- it's built in. You can immediately say "read all the files in this folder and summarize what this project contains."

The first time I did this, I opened Claude Code in one of my PWO game project folders and asked it to read through everything and tell me what it found. Watching it map out my entire project structure and understand how all the files connected was the moment I realized this was different from regular chatbot interactions.

Step 4: To add more MCP servers (like Slack or Google Drive), you configure them in Claude Code's settings file. Each server has its own setup instructions, usually involving installing a package and adding an API key. The MCP documentation at modelcontextprotocol.io lists all available servers with setup guides.

The Limitations (Keeping It Honest)

I'm not going to pretend MCP is perfect. I like it a lot but here's where it falls short right now:

It requires Claude Code (a terminal tool). If you're not comfortable in a command line environment, the barrier to entry is real. Anthropic has been making Claude Code more accessible, and the Remote Control feature lets you interact with it from your phone, but the initial setup still happens in a terminal. I expect this to change as MCP gets integrated into more visual interfaces, but as of March 2026, terminal is the primary way in.

Not every service has an MCP server yet. There are servers for Google Drive, Slack, GitHub, Postgres, MySQL, the filesystem, Brave Search, and dozens more. But there's no MCP server for Articulate 360, no direct connector for Rise or Storyline, no integration with Workday Learning or most LMS platforms. The ecosystem is growing fast -- someone built a Notion server, there are Jira and Linear connectors -- but niche L&D tools haven't caught up yet. (If someone wants to build a Storyline MCP server, the L&D community would lose its collective mind. Just saying.)

Security requires attention. When you give Claude access to your file system or your Slack workspace, you're granting real access. Claude Code asks for permission before every action (reading a file, writing a file, sending a message), so it's not running wild. But you need to be thoughtful about which folders you give access to and which workspaces you connect -- especially if you're working with sensitive employee data or proprietary training content. I work in healthcare, so I'm very mindful about what I connect and what stays separate.

Configuration can be finicky. API keys expire. OAuth tokens need refreshing. Sometimes a server crashes and you need to restart it. If you're used to tools that "just work" out of the box, the current MCP setup experience will feel rough. It's getting better monthly, but it's fair to say this still feels like early-adopter territory. Which, honestly, is kind of exciting if you're into that.

The Bigger Picture: This Is Becoming a Standard

Here's why I'm writing about MCP now even though it's still somewhat technical to set up: it's not staying in the terminal forever, and it's not staying Claude-only.

Anthropic released MCP as an open protocol, which means any AI tool can adopt it. And they are. OpenAI announced MCP support in early 2025. Microsoft has been integrating MCP into its developer tools. Google's AI tools are exploring MCP compatibility. The major AI coding assistants -- Cursor, Windsurf, Cline -- all support MCP servers already.

This matters because it means the MCP servers being built today will work across AI tools tomorrow. If someone builds an Articulate Storyline MCP server, it won't just work with Claude -- it'll work with ChatGPT, Gemini, Copilot, and whatever comes next. Learning how MCP works now pays off as the ecosystem grows.

I think about it like this: I switched from teaching to instructional design almost two years ago. In that time, I went from not knowing what an MCP server was to having Claude build entire interactive training modules by reading my project files directly. The pace of change in this space is wild. The people who start understanding the underlying infrastructure now -- not just the flashy chatbot surface -- are going to be way ahead when this stuff becomes mainstream.

What I Think This Means for L&D

Here's my take, and I know I'm relatively new to this field so take it for what it's worth -- but I think that's actually an advantage here because I came into ID already thinking AI-first.

Instructional design work is fundamentally about pulling information from a bunch of different sources -- SME interviews, policy documents, learner data, stakeholder feedback, brand guidelines, compliance requirements -- and turning all of that into learning experiences. We're synthesizers. That's the job.

The bottleneck has never been the AI's ability to help with that synthesis. Claude is genuinely great at turning messy source material into structured learning content. The bottleneck has been getting the information to the AI in the first place, and getting the output back into your actual files and tools. It's been the copy-pasting. The downloading and uploading. The manual shuttling of context.

MCP removes that bottleneck. When Claude can read your source docs, pull your SME feedback from Slack, check your learner data, and write directly into your project files, the whole content-to-course pipeline gets dramatically faster. You stop being a copy-paste intermediary and start being a creative director -- reviewing, guiding, and refining while the AI handles the mechanical work of moving information between systems.

PowerPoints and facilitator-led lectures are already dying. The future is interactive, scenario-based, personalized training -- and building that kind of stuff fast enough to keep up with business needs requires exactly the kind of connected AI workflow that MCP enables. I've been building this way for my PWO games and client projects, and I can tell you: once you work with AI that can actually see your files and tools, going back to copy-paste feels like going back to dial-up.

Try This Today