.svg)
Overview
Claude Desktop is powerful on its own, but connecting it to external tools through the Model Context Protocol (MCP) transforms it into something far more capable. MCP servers let Claude interact with your local filesystem, databases, APIs, and custom tools—turning conversational AI into an integrated part of your workflow.
This guide walks through everything you need to set up MCP servers in Claude Desktop: from understanding what MCP actually does, to configuring your first server, to troubleshooting the issues that trip up most users. Whether you're looking to give Claude access to your project files or connect it to external services, you'll have a working setup by the end.
What Is the Model Context Protocol?
MCP is an open protocol that standardizes how AI applications connect to external data sources and tools. Think of it as a universal adapter between Claude and everything else—your files, databases, third-party APIs, or custom scripts.
Before MCP, giving an AI access to external tools meant building custom integrations for each connection. Every API required its own implementation. MCP changes this by providing a standard interface that any tool can implement once and any AI application can consume.
Why MCP Matters for GTM Teams
For teams running automated outbound pipelines, MCP opens up new possibilities. You can connect Claude to your CRM data, let it query your prospect database, or have it interact with enrichment tools directly. Instead of copying data between systems manually, Claude can pull the context it needs in real-time.
The protocol supports three main capabilities:
- Resources: Read-only access to data (files, database records, API responses)
- Tools: Functions Claude can invoke to take actions (write files, send requests, run queries)
- Prompts: Reusable prompt templates that can be populated with context
Most GTM use cases focus on resources and tools. Resources let Claude read your CRM field mappings or prospect data. Tools let it write outputs back to your systems or trigger downstream workflows.
Prerequisites and Requirements
Before setting up MCP servers, make sure you have:
node --version in your terminal.
mcp package requires Python 3.10 or higher.
If you're on macOS, you likely have Python pre-installed but may need to install Node.js separately. Use brew install node if you have Homebrew, or download directly from nodejs.org.
Configuring MCP Servers in Claude Desktop
Claude Desktop reads MCP server configurations from a JSON file. The location varies by operating system:
| Operating System | Configuration File Path |
|---|---|
| macOS | ~/Library/Application Support/Claude/claude_desktop_config.json |
| Windows | %APPDATA%\Claude\claude_desktop_config.json |
| Linux | ~/.config/Claude/claude_desktop_config.json |
If the file doesn't exist, create it. The basic structure looks like this:
{
"mcpServers": {
"server-name": {
"command": "executable",
"args": ["arg1", "arg2"],
"env": {
"ENV_VAR": "value"
}
}
}
}Each entry in mcpServers defines one server. The key (server-name) is how you'll reference it. The configuration tells Claude Desktop how to launch the server process.
Configuration Fields Explained
- command: The executable to run (e.g.,
npx,python,node) - args: Arguments passed to the command
- env: Environment variables the server needs (API keys, paths, etc.)
Setting Up the Filesystem Server
The filesystem server is the most common starting point. It gives Claude read and write access to directories you specify—essential for working with project files, configuration, or runtime instructions that inform your AI workflows.
Step-by-Step Installation
open ~/Library/Application\ Support/Claude/claude_desktop_config.json
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-filesystem",
"/Users/yourname/projects",
"/Users/yourname/Documents"
]
}
}
}Only grant access to directories you actually need. Claude will be able to read and write files in these locations, so avoid including sensitive directories like your SSH keys or system folders.
Connecting to Databases
Database MCP servers let Claude query your data directly—useful for pulling prospect information, checking account signals, or analyzing pipeline data without exporting CSVs.
PostgreSQL Server Setup
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-postgres",
"postgresql://user:password@localhost:5432/database"
]
}
}
}SQLite Server Setup
{
"mcpServers": {
"sqlite": {
"command": "npx",
"args": [
"-y",
"@modelcontextprotocol/server-sqlite",
"/path/to/your/database.db"
]
}
}
}Once connected, you can ask Claude to query your database naturally. It will translate your requests into SQL and return the results. This is particularly powerful when combined with AI-powered research workflows—Claude can pull account data, analyze patterns, and generate insights without you writing queries manually.
Popular MCP Servers for GTM Workflows
Beyond filesystem and database access, several MCP servers are particularly useful for go-to-market teams building automated workflows.
GitHub Server
If your team stores playbooks, templates, or configuration in GitHub, the GitHub MCP server provides direct access:
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "your_token_here"
}
}
}
}Brave Search Server
For AI research workflows, web search capabilities let Claude gather real-time information about prospects and companies:
{
"mcpServers": {
"brave-search": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-brave-search"],
"env": {
"BRAVE_API_KEY": "your_api_key"
}
}
}
}Slack Server
Connect Claude to your team's Slack for reading channel history or searching messages—helpful when you need context from team discussions:
{
"mcpServers": {
"slack": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-slack"],
"env": {
"SLACK_BOT_TOKEN": "xoxb-your-token",
"SLACK_TEAM_ID": "T0123456789"
}
}
}
}You can run multiple MCP servers simultaneously. Just add each to your configuration under different keys. Claude will have access to all of them and can use tools from any server in the same conversation.
Troubleshooting Common Issues
MCP setup can be finicky. Here are the most common problems and how to fix them.
Server Not Appearing
If your MCP server doesn't show up in Claude's tool list:
- Check JSON syntax: A misplaced comma or bracket will break the entire configuration. Use a JSON validator.
- Verify the path: Make sure the config file is in the correct location for your OS.
- Restart fully: Quit Claude Desktop completely (check your system tray/menu bar) and reopen.
- Check the logs: On macOS, look at
~/Library/Logs/Claude/for error messages.
Permission Denied Errors
Common with filesystem servers:
- Make sure the paths in your configuration actually exist
- Check that your user account has read/write permissions for those directories
- On macOS, you may need to grant Terminal (or the Claude app) full disk access in System Preferences
Server Crashes on Startup
If the server starts but immediately fails:
- Missing dependencies: Try running the npx command manually in your terminal to see detailed error output
- Invalid credentials: Double-check API keys and connection strings in your env variables
- Port conflicts: Some servers use specific ports. Make sure nothing else is using them
Checking Server Logs
Claude Desktop writes MCP-related logs that can help diagnose issues. The exact location depends on your platform, but on macOS you can find them in Console.app by filtering for "Claude" or check the logs directory directly.
FAQ
No. MCP servers only run when Claude Desktop is open, and they only have access to what you explicitly configure. Each tool invocation also shows up in Claude's interface so you can see exactly what actions are being taken.
No. Claude Desktop manages the server processes internally. Once configured, servers start automatically when you open Claude Desktop and stop when you close it.
Yes. The MCP specification is open, and you can build servers in Python, TypeScript, or any language that can handle JSON-RPC over stdio. Point your configuration to your local script instead of an npm package.
Environment differences are the usual culprit. Claude Desktop may not inherit your shell's PATH or environment variables. Try specifying absolute paths to executables and explicitly setting any required environment variables in the config.
Minimal for most use cases. Servers are lightweight processes that sit idle until Claude needs them. However, servers that maintain persistent connections (like database servers) do consume some resources while active.
The configuration file itself can be shared, but be careful with credentials. Store API keys and tokens in environment variables or a secrets manager rather than committing them to version control.
From Local Setup to Production Workflows
Setting up MCP servers in Claude Desktop is a powerful starting point for experimenting with AI-assisted workflows. You can prototype research-to-qualification pipelines, test how Claude handles your specific data, and build proofs of concept quickly.
But Claude Desktop is fundamentally a single-user tool. When you need the same capabilities across your team—with consistent context, shared access to data sources, and the ability to trigger workflows programmatically—the architecture changes.
What you actually need at that point is a centralized context layer that maintains connections to your CRM, enrichment tools, and sequencers, keeps data synchronized, and provides AI access to unified context without each team member managing their own configurations.
This is where platforms like Octave fit in. Instead of every GTM engineer maintaining local MCP configs and hoping their data stays current, Octave provides a shared context graph that connects to your entire stack. Your AI workflows can query prospect data, trigger enrichment, and push to sequences—all from a single platform that handles the orchestration and keeps everything in sync.
For teams running AI-powered outbound at scale, it's the difference between prototyping in Claude Desktop and actually operationalizing those workflows for consistent, team-wide execution.
Conclusion
MCP servers transform Claude Desktop from a standalone chat interface into an integrated tool that can read your files, query your databases, and interact with external services. The setup isn't complicated once you understand the configuration format—it's mostly JSON files and environment variables.
Start with the filesystem server to give Claude access to your project files. From there, add database connections or API integrations based on what your workflows need. The key is starting small and expanding as you discover what's actually useful.
For GTM teams, the real value emerges when Claude can access the same data sources you use for prospecting, qualification, and outreach. Context is the bottleneck in most AI workflows—MCP servers are one way to start solving that problem at the individual level.