You've used AI. You know what an API is. Now learn how Claude actually does things — not just talk about them — by connecting to the tools you already use.
MCP stands for Model Context Protocol. It's the standard that lets an AI like Claude actually use your tools — not just talk about them.
An API is the menu. The kitchen does the work. You order, the server brings back the dish.
An MCP is the server who speaks every language. You sit down with your AI assistant and order in plain English — "I want the candidate notes for Sarah Chen" — and the MCP turns that into the right API call, hits the kitchen (Ashby), and brings the dish back to your AI to plate up.
Without an MCP, an AI can talk about Ashby. With an MCP, it can actually do things in Ashby.
MCP is to AI what USB-C is to electronics — one standard plug, so any tool works with any AI. Build an MCP once, and every AI client (Claude Desktop, Claude.ai, Cursor, etc.) can use it.
You probably already use AI to draft Slack messages, summarize transcripts, or write outreach. That's chat. MCPs unlock the next thing: letting Claude actually take action in your recruiting stack — pulling candidate data from Ashby, fetching transcripts from BrightHire, writing to Coda — all from inside one conversation.
Every MCP setup has three parts: a client (the AI app), a server (the connector), and a set of tools (what the connector can do). Once you see them, you can't unsee them.
The AI app you're using. Claude Desktop, Claude.ai, Cursor, Sidekick, Windsurf — they're all clients. The client is what you actually type into. It speaks the MCP protocol to talk to servers.
Technically, the MCP spec calls the whole app a host, and a "client" is a component inside the host that manages one connection to one server. Most docs (including Anthropic's) loosely call the app "the client" — and so will we, for simplicity.
You'll also hear "harness" — that's a related but distinct concept. A harness is an agent runtime (Claude Code, Sidekick, Devin) that runs the think-act-think loop on its own, over many turns. A chat client lets you steer; a harness lets the agent steer. Both use MCP.
A small program that knows how to do things in some other system. There's an Ashby MCP server (talks to Ashby's API), a BrightHire MCP server (talks to BrightHire's API), a Coda MCP server, a GitHub MCP server, hundreds more. Each one is a translator between the AI and one specific tool.
Servers can run locally (a process on your laptop that Claude Desktop launches in the background) or remotely (hosted on a URL, like a website).
Each server exposes a list of tools the AI can call. A tool is just a named function with a description and inputs. The Ashby MCP, for example, might expose tools like candidate_search, job_list, application_feedback_list. When the AI thinks "I need feedback for this candidate," it calls the right tool.
You type plain English. The AI reads the descriptions of the available tools, picks the right one, fills in the inputs, and shows you the result. You never write candidate_search(query="Sarah Chen") yourself — Claude does that for you behind the scenes.
This is the part most people miss, and it's worth slowing down for.
Claude never sees your Ashby API key, your BrightHire token, or your Slack bot secret. The MCP server holds those credentials. Claude just says "call candidate_search with query='Sarah Chen'." The server adds the auth headers, hits Ashby's real API, and returns the data.
That means three things matter when you install an MCP:
More on this in the security callout in Concept 04.
An API gives one app to one user. An MCP gives one app to any AI assistant. Build a tool once → every AI client can use it. That's the leverage, and that's why MCPs are spreading so fast across the recruiting stack.
Enough theory. Let's actually wire one up in Claude Desktop. Four steps, takes about five minutes, and you'll see Claude grow a new capability in real time.
Before you wire up your first MCP, you need three things in place:
The full setup walkthrough (with Homebrew, Node, and verification commands) lives in the Terminal Basics module. If you haven't done that one, jump there first — it takes about 15 minutes — and come back here. The rest of this section assumes you've got both installed.
Express version: open Terminal, install Homebrew (paste the one-liner from brew.sh), then run brew install node. Verify with node --version.
Download from claude.ai/download. Pick macOS or Windows. Run the installer like any other app. Sign in with the same account you use for Claude.ai. Done.
Important: Claude.ai in a browser is not the same thing — it can connect to "Custom Connectors" (remote MCPs), but it can't run local stdio MCPs. For this tutorial, use Claude Desktop.
Skip Homebrew (it's Mac-only). Download Node directly from nodejs.org — the LTS version. Run the installer with default options. Then verify with node --version in PowerShell or Command Prompt.
A handful of MCPs are Python-only (the official Filesystem MCP isn't one of them — it's Node). If you run into one later, the same Homebrew pattern works: brew install python uv. uv is the modern Python package runner — same role npx plays for Node. You can install both now or wait until you actually need Python.
Claude Desktop reads MCP settings from one specific JSON file:
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json
If the file doesn't exist yet, create it. If it does, you're going to add to it.
For your very first one, use the Filesystem MCP. It's official, safe (read-only by default), and immediately useful — it lets Claude read files in a folder you specify.
Open the config file. If it's empty, paste this whole block. If you already have other servers in there, just add the inside of "mcpServers" to your existing list:
Swap /Users/yourname/Documents for whatever folder you want Claude to read. Start with something small and safe — a "test" folder, not your whole home directory.
Quit completely (Cmd+Q on Mac, not just close the window) and reopen. Claude Desktop reads the config on startup.
Look in the bottom-right of the Claude Desktop input box. You should see a small 🔌 plug icon with a number — that's the count of connected MCP servers. Click it to see the list of tools each one exposes.
Then try a prompt like: "List the files in my Documents folder." Claude will call the list_directory tool, get a real response, and answer you. You just did your first MCP interaction.
99% of the time it's one of three things: (1) the JSON has a syntax error (missing comma, extra bracket), (2) you didn't fully quit Claude Desktop, or (3) Node isn't installed. Open the config file in any text editor — VS Code or even TextEdit — and double-check the JSON. Linters online (like jsonlint.com) catch errors instantly.
Once you've done this once, doing it again is the same four steps. Want Claude to read your Ashby? Install the Ashby MCP, add an entry to the config, restart, done. Want BrightHire transcripts? Same. Want Coda? Same.
The recruiting-relevant MCPs you'll hit next are in the next section.
This is where it stops being abstract. Here's what MCPs you'd actually install, what they let Claude do, and what chained workflows become possible when you wire a few together.
You don't need to install everything — pick the ones that match your stack.
One MCP is useful. Three connected together is a different category of leverage. The same prompt can pull from Ashby, summarize transcripts from BrightHire, and write a debrief Slack thread — all without you switching tabs.
This is a real chain Claude can run with three MCPs connected:
What used to take 45 minutes of tab-switching becomes a single sentence to Claude. Same recruiting judgment, fraction of the time.
Not every workflow needs MCPs. Use plain Claude when:
MCPs pay off when something is repeatable, multi-source, or requires fresh data every time. That's when the install is worth it.
MCPs reach into systems that hold real candidate data. Before you connect one, know what that data is allowed to do.
At Zapier, our People Team data classification rules apply: yellow-tier data (candidate PII, comp ranges, interview notes, scorecards) is fine to use in Claude directly, but routing it through a Zapier-built MCP or skill needs approval. Red-tier data (medical notes, pre-announcement reorg info) is prohibited from any AI tool.
The same data classification applies whether you're pasting into a chat, calling a Zap, or chaining MCPs. The route changes; the rules don't.
If you're not sure whether a workflow is safe, ask your data governance owner. At Zapier, that's #wg-people-ai-transformation. The same rule from the API Basics module applies: better to ask once than to find out the hard way.
Installing other people's MCPs is great. Building one — even a tiny one — is where you officially cross from "user" to "Talent Engineer." It's also way less scary than it sounds.
An MCP server is a small program that does two things: (1) tells Claude "here are the tools I expose," and (2) when Claude calls one of those tools, runs some code and returns a result. That's it. Everything else — the protocol, the message format, the transport — is handled by an SDK.
Anthropic ships official SDKs in Python and TypeScript. You write a function (the tool), decorate it, and start the server. The SDK handles all the protocol plumbing under the hood. A working MCP can be ~20 lines of code.
This is a real, working MCP server. One tool that adds two numbers. Useless in practice, useful for seeing the shape:
That's the whole thing. Save as server.py, add it to Claude Desktop's config (same as Step 2 in Concept 03), restart, and Claude can now do math via a real tool call.
Best first MCPs solve a real annoyance. "Pull this report from Ashby" or "summarize the hiring channel for this role" — pick a recurring task and wrap that.
You usually don't invent a tool from scratch — you wrap an API you already have access to. Take what you learned in API Basics, add the MCP shell, ship.
Same as the API Basics tip: confirm the raw API call works in curl or Postman before you wire it into an MCP. Debug one layer at a time.
Your first MCP shouldn't be able to send emails, delete records, or change comp. Start with read-only scope and earn the write permissions later.
The description you give each tool is what Claude reads when deciding whether to call it. Vague description = wrong tool gets called. Be specific.
Ship a stdio MCP that only you can use on your laptop. Once it's solid, host it on Vercel or Cloudflare so the rest of your team can connect.
You now understand what an MCP is, what the pieces are, how to install one, what they unlock for recruiting, and roughly how to build your own. That puts you ahead of almost everyone in talent.
Next moves, in rough order:
Five quick questions. Click an answer to see if you've got it.