Specialization 2: Connect AI to Your Systems (MCP)

AI that knows your data — connect Claude to your files, tools, and APIs so it can actually help with your real work.

INFO

Time: ~4-6 hours
Difficulty: Intermediate
Prerequisites: Core Modules + Flagship Project

This Page Covers

Why connecting AI to your data changes everything
MCP fundamentals: servers, configuration, the registry
First connection: filesystem access
Connecting SaaS tools (Notion, GitHub, Slack)
Connecting your company's APIs as MCP data sources
Security, compliance, and governance
Troubleshooting common issues

Why Connect AI to Your Data?

In Specialization 1, your agent works with local files in your workspace. That is powerful — but your data does not only live in files. It lives in:

SaaS tools — Notion, Slack, GitHub, Google Drive, Airtable
Databases — PostgreSQL, SQLite, your company's data warehouse
Internal APIs — your company's REST services, admin panels, dashboards
Cloud storage — S3 buckets, SharePoint, Dropbox

Without MCP, Claude only knows what you paste into the chat. With MCP, Claude can reach into these systems directly. The difference:

Without MCP:

"Here's the data from our CRM, I copied it into a spreadsheet, then pasted it here. Can you analyze it?"

With MCP:

"Look at our CRM data for Q4. Which accounts are at risk of churning?"

MCP turns a general-purpose AI into your AI — one that understands your specific context, your specific data, your specific systems.

The Business Case

Connecting AI to your systems saves time in three ways:

No more copy-pasting — the agent reads data directly from the source
Always current — the agent queries live data, not a stale export
Cross-system queries — "Compare what's in our project tracker with what's in Slack" becomes a single question

MCP Fundamentals

What MCP Is

MCP (Model Context Protocol) is a standard for connecting AI models to external data sources and tools. It defines how an AI agent communicates with "servers" that provide access to specific systems.

Think of MCP servers as adapters. Each server translates between the AI agent's requests and a specific system's API:

The filesystem server translates requests into file system operations
The Notion server translates requests into Notion API calls
A custom server could translate requests into your company's internal API calls

How It Works

You configure MCP servers in a JSON file
When the agent starts, it connects to each configured server
The servers tell the agent what tools are available (read file, search notes, query database, etc.)
During conversation, the agent calls these tools as needed
The server executes the action and returns results to the agent

You configure it once. After that, the agent uses it automatically whenever it needs data from that source.

The MCP Registry

The official MCP Registry lists available servers: https://registry.modelcontextprotocol.io/

Official reference servers (maintained by the MCP team):

filesystem — read/write local files
git — interact with Git repositories
fetch — retrieve web content
memory — persistent memory across conversations
sequentialthinking — structured reasoning

Community servers cover everything from Notion and Slack to PostgreSQL and AWS.

Configuration Format

All MCP servers are configured in a JSON file. The structure is consistent:

json

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "package-name", "additional-args"],
      "env": {
        "API_KEY": "your-key-here"
      }
    }
  }
}

command — how to run the server (usually npx for Node.js servers)
args — the package to run and any configuration arguments
env — environment variables (API keys, tokens)

You can configure multiple servers — just add more entries inside mcpServers.

First Connection: Filesystem Access

Start here. The filesystem server is the most useful and requires no API keys or accounts.

Step 1: Install Claude Desktop

If you have not already:

Go to claude.ai/download
Download for your operating system (Mac or Windows)
Install and sign in

Step 2: Find the Configuration File

On Mac:

~/Library/Application Support/Claude/claude_desktop_config.json

To find it: open Finder, press Cmd + Shift + G, paste the path.

On Windows:

%APPDATA%\Claude\claude_desktop_config.json

To find it: press Windows + R, type %APPDATA%\Claude, press Enter.

If the file does not exist, create it.

Step 3: Add Filesystem Access

Prerequisite: Node.js must be installed. Download from nodejs.org (LTS version).

Open the config file in a text editor and add:

Mac:

json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/yourname/Documents"]
    }
  }
}

Windows:

json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "C:\\Users\\yourname\\Documents"]
    }
  }
}

Replace the folder path with the directory you want Claude to access.

To grant access to multiple folders:

json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/Documents",
        "/Users/yourname/Projects"
      ]
    }
  }
}

Step 4: Restart and Test

Quit Claude Desktop completely (Cmd+Q on Mac, or right-click system tray → Quit on Windows)
Reopen Claude Desktop
Start a conversation and ask: "What files are in my Documents folder?"

If Claude lists your files, the connection is working.

What You Can Do Now

With filesystem access, try:

"Read quarterly-report.pdf and summarize the key points"
"Find all spreadsheets related to budget in my Documents"
"Search my files for anything about project timeline"
"How many files are in my Projects folder?"

Connecting SaaS Tools

Once filesystem access is working, add connections to the tools where your data lives.

Notion

Connect Claude to search and read your Notion workspace.

Setup:

Create a Notion integration at notion.so/my-integrations
Copy the integration token
In Notion, share the pages/databases you want Claude to access with your integration

Configuration:

json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/yourname/Documents"]
    },
    "notion": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-notion"],
      "env": {
        "NOTION_API_KEY": "your-integration-token-here"
      }
    }
  }
}

What Claude can do:

Search your Notion pages by keyword
Read page contents
Find information across your workspace

Example prompts:

"Search my Notion for anything about quarterly planning"
"What's in my project tracker database?"
"Find all pages I created this month"

GitHub

Connect Claude to your repositories.

Configuration:

json

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
      }
    }
  }
}

Generate a personal access token at github.com/settings/tokens.

What Claude can do:

Search your repositories
Read code files
List issues and pull requests
Search commit history

Slack

Connect Claude to search your Slack message history (read-only).

Setup: Create a Slack app at api.slack.com/apps and add the necessary read permissions.

What Claude can do:

Search message history
Read channel messages
Find conversations about specific topics

Other Popular Servers

Google Drive — access cloud documents (requires Google Cloud credentials)
SQLite — query local databases with natural language
Memory — give Claude persistent memory across conversations
PostgreSQL — query production databases (use read-only credentials!)

Browse the full list at the MCP Registry.

Multi-Source Queries

The real power of MCP shows when you combine sources:

"Compare what's in my project notes (filesystem) with the open issues on GitHub. Am I missing anything?"

"Search both my Notion workspace and local files for anything about the marketing campaign"

Each MCP server is independent — Claude can use multiple servers in a single conversation, cross-referencing data between them.

Connecting Your Company's APIs

Many organizations have internal REST APIs: customer databases, inventory systems, internal dashboards, admin tools. MCP lets you wrap these APIs so Claude can query them directly.

Understanding API Authentication

Before connecting an API, you need to know how it authenticates requests. Most APIs use one of these methods:

API Keys (most common):

An API key is a secret string that identifies you. You include it in every request, typically as a header:

Authorization: Bearer your-api-key-here

Or sometimes as a query parameter:

https://api.example.com/data?api_key=your-key-here

API keys are the simplest authentication method. You generate them in a dashboard and include them in your MCP server configuration.

OAuth 2.0 (when acting on behalf of a user):

OAuth is used when the API needs to know which user is making the request — for example, accessing a user's Google Calendar or Slack workspace.

The flow:

User authorizes your application
The service gives you an access token
You use the token in API requests

OAuth tokens expire and need refreshing. If your MCP server needs OAuth, it must handle the token refresh cycle.

Bearer Tokens and JWTs:

Many APIs use JWT (JSON Web Token) as their bearer token. A JWT contains encoded information about who you are and what you can access. You include it in the Authorization: Bearer header.

For MCP purposes, what matters is: get the token, put it in the env configuration, and let the server handle including it in requests.

Building or Configuring a Custom MCP Server

For a company API, you need an MCP server that wraps it. There are two approaches:

Approach 1: Use an existing generic server

The fetch MCP server can make arbitrary HTTP requests:

json

{
  "mcpServers": {
    "company-api": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch"],
      "env": {
        "API_BASE_URL": "https://api.yourcompany.com",
        "API_KEY": "your-key-here"
      }
    }
  }
}

This gives Claude the ability to make HTTP requests, but it does not know your API's structure. You would need to tell Claude which endpoints exist.

Approach 2: Build a custom MCP server

For a purpose-built connection, create an MCP server that exposes your API's operations as specific tools. Claude then sees tools like "search_customers" or "get_order_details" instead of raw HTTP endpoints.

The MCP SDK provides templates for building servers in TypeScript and Python. A minimal server:

Defines the tools it provides (name, description, input parameters)
Implements each tool as a function that calls your API
Handles authentication using environment variables

Example tool definition (conceptual):

Tool: search_customers
Description: Search the CRM for customers by name, email, or company
Parameters:
  - query (string): The search term
  - limit (number, optional): Max results to return (default 10)

When Claude needs customer data, it calls search_customers instead of constructing raw API requests. The MCP server handles the HTTP details.

For building custom MCP servers, see the MCP documentation.

Rate Limits and Error Handling

APIs limit how often you can call them. Your MCP server (or your usage of the fetch server) needs to respect these limits:

Common Limits	Typical Values
Requests per second	3-10
Requests per minute	60-100
Requests per day	1,000-10,000

How to handle rate limits:

Check response headers: Many APIs return X-RateLimit-Remaining and Retry-After headers
Exponential backoff: If you get a 429 Too Many Requests error, wait and retry — doubling the wait time each attempt (1s, 2s, 4s, 8s)
Cache responses: If you ask the same question twice, a cached response avoids a second API call

Custom MCP servers should implement rate limiting internally. When using the generic fetch server, be aware that Claude might make requests faster than the API allows — add guidance in your prompts if needed.

Data Transformation

APIs return data in their own format. Claude handles most transformations naturally — you ask a question in plain language, and Claude interprets the API response. But for complex data:

Nested structures: Company APIs often return deeply nested JSON. A well-built MCP server can flatten this before returning it to Claude.
Pagination: If an API returns data in pages (100 items at a time), your MCP server should handle fetching all pages.
Field mapping: If the API calls it customer_id but you think of it as "account number," document these mappings for Claude.

Security, Compliance, and Governance

Connecting AI to your data is powerful, but it demands care.

Think Before You Connect

Before setting up any MCP server, ask:

What data will AI be able to access?

If you connect your Documents folder, Claude can read everything in it
If you connect Notion, Claude can access all pages shared with the integration
If you connect your company CRM, Claude can see customer records

Who else might see this data?

Conversations with Claude are processed by Anthropic's servers
Data sent to the AI model may be subject to data processing agreements

What NOT to Connect

Do Not Connect	Why
Password files or credential stores	Never give AI access to authentication secrets
Financial records	Bank statements, tax documents, investment details
Medical records	Health information requires special handling
Unredacted personal data	Full customer databases with PII need careful scoping
Work confidential	Unless explicitly allowed by your employer

Least Privilege Principle

Give each MCP server the minimum access it needs:

Read-only connections for databases — prevent accidental writes
Scoped API tokens — create tokens with only the permissions needed
Specific folders instead of your entire home directory
Filtered data — if possible, create API views that exclude sensitive fields

Example: safe filesystem setup

json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/yourname/AI-Accessible"]
    }
  }
}

Put only the files you want Claude to access in that specific folder.

Audit and Review

Review connections periodically — check which MCP servers are configured and whether you still need them
Rotate API keys — especially if you suspect exposure
Log what the agent accesses — custom MCP servers can log every tool call for auditing
Remove unused connections — if you stop using a service, remove its MCP server

Regulatory Considerations

If you work in a regulated industry or handle EU data:

GDPR: Personal data sent to AI systems must comply with data processing requirements. Ensure your use of MCP is covered by appropriate legal bases (consent, legitimate interest, etc.)
EU AI Act: Know the risk classification of your AI usage. Most MCP-connected workflows are "limited risk" but check if your use case falls into higher categories
Industry regulations: Healthcare (HIPAA), finance (SOX, PCI-DSS), and other sectors have specific rules about data processing with external services
Data residency: Some data may not be allowed to leave certain geographic regions

When in doubt, consult your legal or compliance team before connecting sensitive company data to AI systems.

Troubleshooting

Problem: Configuration Syntax Error

Symptom: Claude Desktop will not start, or MCP servers do not load.

Common causes:

Missing comma between items
Missing closing brace }
Extra comma after the last item

Solution: Validate your JSON:

Copy your config file contents
Go to jsonlint.com
Paste and click "Validate JSON"
Fix any errors it highlights

Example — wrong:

json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx"
      "args": ["-y", "@modelcontextprotocol/server-filesystem"]
    }
  }
}

Example — correct (comma added):

json

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem"]
    }
  }
}

Problem: Server Not Connecting

Symptom: Configuration is correct, but MCP tools do not appear.

Try:

Restart Claude Desktop completely — quit (not just close), wait, reopen
Check Node.js is installed — run node --version in terminal. If error, install from nodejs.org
Verify the folder path — check for typos, use forward slashes / on Mac, double backslashes \\ on Windows
Check network — some MCP servers download packages on first run and need internet access

Problem: Permission Denied

Symptom: Claude says it cannot access a file or folder.

Solutions:

Check folder permissions — verify your user account can access the folder
Check the folder is in your config — Claude can only access folders explicitly listed
On Mac: Grant Full Disk Access — System Settings > Privacy & Security > Full Disk Access > add Claude Desktop

Problem: API Connection Fails

Symptom: SaaS tool MCP server connects but returns errors.

Check:

API key is valid — regenerate if expired
Permissions are correct — the token needs the right scopes (e.g., read access for Notion pages)
Resource is shared — for Notion, pages must be shared with your integration
Rate limits — if you are getting 429 errors, you are making too many requests too fast

Problem: Changes Not Taking Effect

Symptom: You updated the config but nothing changed.

Solution: You must fully restart Claude Desktop:

Mac: Cmd+Q to quit, then reopen
Windows: right-click system tray icon → Quit, then reopen

Closing the window is not enough — the app must fully restart to reload configuration.

Mini Project: Multi-Source Setup

Goal

Configure Claude Desktop with filesystem access plus one SaaS tool connection. Demonstrate a query that uses both sources.

Steps

1. Configure filesystem access

Follow the steps above to connect your Documents (or a specific folder).

2. Add a second data source

Choose one based on what you use:

Notion — if you keep notes and docs there
GitHub — if you have code repositories
Slack — if you want to search message history

Follow the configuration instructions for your chosen service.

3. Restart and verify

Restart Claude Desktop. Test each connection independently:

"List files in my Documents folder" (filesystem)
"Search my Notion for recent pages" (Notion)

4. Cross-source query

Ask Claude a question that requires both sources:

"Compare the project notes in my files with the project pages in Notion — am I missing anything?"
"Find all mentions of [topic] across both my local files and my Notion workspace"
"What GitHub issues relate to the project described in my local project-brief.md?"

5. Document your setup

Create a note in your workspace (from Specialization 1) documenting:

Which MCP servers you configured
What data each can access
Any quirks or limitations you noticed

Key Takeaways

MCP connects Claude to your actual data — files, SaaS tools, databases, and APIs
Setup involves a JSON configuration file — copy the templates and adjust paths/keys
Start with filesystem access — it is the most useful and requires no accounts
Add SaaS connections incrementally — Notion, GitHub, Slack, or whatever you use
Company APIs can be wrapped as MCP servers — authentication, rate limits, and data transformation are the key considerations
Security matters — apply least privilege, scope access narrowly, review regularly
Always restart after config changes — Claude Desktop must fully restart to load new servers
Multi-source queries are the real payoff — asking questions across all your data at once

Next Steps

Specialization 1: Your AI-Native Workspace — Set up the local workspace that MCP connects to external systems
Specialization 3: Agentic Browser Automation — Use Playwright MCP to give your agent browser control
MCP Documentation — Build your own custom MCP servers

Specializations

Specialization 2: Connect AI to Your Systems (MCP) ​

This Page Covers ​

Why Connect AI to Your Data? ​

The Business Case ​

MCP Fundamentals ​

What MCP Is ​

How It Works ​

The MCP Registry ​

Configuration Format ​

First Connection: Filesystem Access ​

Step 1: Install Claude Desktop ​

Step 2: Find the Configuration File ​

Step 3: Add Filesystem Access ​

Step 4: Restart and Test ​

What You Can Do Now ​

Connecting SaaS Tools ​

Notion ​

GitHub ​

Slack ​

Other Popular Servers ​

Multi-Source Queries ​

Connecting Your Company's APIs ​

Understanding API Authentication ​

Building or Configuring a Custom MCP Server ​

Rate Limits and Error Handling ​

Data Transformation ​

Security, Compliance, and Governance ​

Think Before You Connect ​

What NOT to Connect ​

Least Privilege Principle ​

Audit and Review ​

Regulatory Considerations ​

Troubleshooting ​

Problem: Configuration Syntax Error ​

Problem: Server Not Connecting ​

Problem: Permission Denied ​

Problem: API Connection Fails ​

Problem: Changes Not Taking Effect ​

Mini Project: Multi-Source Setup ​

Goal ​

Steps ​

Key Takeaways ​

Next Steps ​

Want to explore AI automation for your business?

Specialization 2: Connect AI to Your Systems (MCP)

This Page Covers

Why Connect AI to Your Data?

The Business Case

MCP Fundamentals

What MCP Is

How It Works

The MCP Registry

Configuration Format

First Connection: Filesystem Access

Step 1: Install Claude Desktop

Step 2: Find the Configuration File

Step 3: Add Filesystem Access

Step 4: Restart and Test

What You Can Do Now

Connecting SaaS Tools

Notion

GitHub

Slack

Other Popular Servers

Multi-Source Queries

Connecting Your Company's APIs

Understanding API Authentication

Building or Configuring a Custom MCP Server

Rate Limits and Error Handling

Data Transformation

Security, Compliance, and Governance

Think Before You Connect

What NOT to Connect

Least Privilege Principle

Audit and Review

Regulatory Considerations

Troubleshooting

Problem: Configuration Syntax Error

Problem: Server Not Connecting

Problem: Permission Denied

Problem: API Connection Fails

Problem: Changes Not Taking Effect

Mini Project: Multi-Source Setup

Goal

Steps

Key Takeaways

Next Steps