Using MCP servers for sales prospecting

MCP stands for Model Context Protocol. It is an open standard that lets AI agents call external tools during a conversation. Think of it as a USB port for AI: any tool that implements the MCP spec can plug into any agent that supports it.

For sales and GTM teams, MCP is the bridge between an AI coding agent and your data tools. Without MCP, the agent can only think about prospecting. With MCP, it can actually do it. It can find emails, validate addresses, enrich companies, and check your credit balance, all within the same conversation where you described your ICP.

This guide walks through everything: what MCP is, how to connect gtmcli as an MCP server, and how to use it for real prospecting workflows.

What MCP is and why it matters

Before MCP, giving an AI agent access to external tools required custom integrations. You would write wrapper functions, handle authentication, parse responses, and manage errors. Every tool was a bespoke integration.

MCP standardizes this. A tool provider implements the MCP server spec (a JSON-RPC interface over stdio or HTTP). An AI agent implements the MCP client spec. The agent discovers available tools, reads their schemas, and calls them using structured inputs. The protocol handles serialization, error handling, and type safety.

The key insight: MCP lets agents use tools the way humans use APIs. The agent reads the tool description, figures out the right inputs, calls the tool, and processes the response. No hardcoding. No custom glue. The agent adapts to the tool at runtime.

How MCP works under the hood

1. Agent starts → launches MCP server process
2. Agent calls "tools/list" → server returns available tools
3. Each tool has: name, description, input schema (JSON Schema)
4. Agent decides to use a tool → calls "tools/call"
5. Server executes the tool → returns result
6. Agent processes result → continues conversation

All communication is JSON-RPC over stdio.

The agent never sees your API key. Authentication happens inside the MCP server process. The agent only sees tool names, descriptions, and results.

Why MCP matters for sales and GTM teams

Sales prospecting is a data pipeline problem. You start with criteria (industry, company size, titles), discover accounts and contacts, enrich them with verified data, and export the results. Every step requires a different data source.

Without MCP, using an AI agent for prospecting means copy-pasting between the agent and your tools. The agent suggests a company, you look up the domain manually, you paste it into an email finder, you copy the result back. You are the integration layer. That defeats the purpose.

With MCP, the agent does all of this in one uninterrupted flow. It decides when to find an email, calls the tool, gets the result, validates it, and moves on. You describe the goal and review the output. The agent handles the pipeline.

What changes with MCP

Without MCP:
  You: "Find the VP Sales email at Gong"
  Agent: "Try sarah.chen@gong.io — I'm guessing based
          on common patterns. Please verify manually."
  You: *opens email finder, types name, copies result*

With MCP (gtmcli connected):
  You: "Find the VP Sales email at Gong"
  Agent: *calls gtmcli_find_email*
  Agent: "Found sarah.chen@gong.io (97% confidence,
          verified via SMTP, 1 credit used)"

Setting up gtmcli as an MCP server

Three steps. Install, authenticate, configure.

1. Install and authenticate

npm install -g gtmcli
gtmcli auth login
# Enter your API key from gtmcli.com/dashboard

2. Add the MCP config

Open ~/.claude/settings.json and add the gtmcli server:

{
  "mcpServers": {
    "gtmcli": {
      "command": "gtmcli",
      "args": ["mcp", "serve"]
    }
  }
}

If you already have other MCP servers configured, add gtmcli alongside them:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-fs", "/Users/you/projects"]
    },
    "gtmcli": {
      "command": "gtmcli",
      "args": ["mcp", "serve"]
    }
  }
}

3. Verify the connection

Restart claude code and run /mcp to list connected servers. You should see gtmcli with its tools:

> /mcp

Connected MCP Servers:
  gtmcli (7 tools)
    - gtmcli_find_email
    - gtmcli_validate_email
    - gtmcli_enrich_company
    - gtmcli_check_credits
    - gtmcli_batch_find
    - gtmcli_batch_validate
    - gtmcli_export_csv

The gtmcli MCP tools

Here is what each tool does and when the agent uses it.

gtmcli_find_email

Takes a first name, last name, and company domain. Returns the most likely work email with a confidence score. Checks multiple data sources and pattern databases. Costs 1 credit.

Input:  { "first_name": "Alex", "last_name": "Kim",
          "domain": "stripe.com" }
Output: { "email": "alex.kim@stripe.com",
          "confidence": 94, "credits_used": 1 }

gtmcli_validate_email

Takes an email address. Runs DNS lookup, MX record check, and SMTP handshake. Returns status (valid, invalid, catch_all, unknown), plus flags for disposable and role-based addresses. Costs 1 credit.

Input:  { "email": "alex.kim@stripe.com" }
Output: { "status": "valid", "catch_all": false,
          "disposable": false, "role": false,
          "credits_used": 1 }

gtmcli_enrich_company

Takes a domain. Returns company name, industry, employee count, funding stage, location, and description. Costs 1 credit.

gtmcli_check_credits

Returns your current credit balance. Costs 0 credits. The agent calls this before starting a large batch to make sure you have enough credits. It will warn you and ask for confirmation if the estimated cost exceeds your balance.

gtmcli_batch_find and gtmcli_batch_validate

Batch versions of find and validate. Accept arrays of up to 100 records per call. The agent automatically switches to batch mode when processing more than 10 contacts, which is faster because the API parallelizes server-side.

gtmcli_export_csv

Exports the current session results to a CSV file. The agent uses this at the end of a prospecting workflow to save the output.

A complete prospecting workflow with MCP

Here is a full workflow from prompt to output, showing the MCP tool calls the agent makes.

You:
> Build a list of 15 CTOs at developer tool companies
> with 50-200 employees. Verified emails only.
> Export to cto-devtools.csv.

Agent thinks:
  "I need to find ~15 developer tool companies,
  identify the CTO at each, find their emails,
  validate them, and export."

Agent calls: gtmcli_check_credits
  → { "balance": 847 }
  → "Enough credits. Estimated cost: ~30 credits."

Agent calls: gtmcli_enrich_company (×20, to allow for misses)
  → Identifies 20 companies matching criteria
  → Filters to 17 in the 50-200 employee range

Agent calls: gtmcli_batch_find
  → { "contacts": [17 CTO lookups] }
  → Found 15 emails, 2 not found

Agent calls: gtmcli_batch_validate
  → { "emails": [15 found emails] }
  → 14 valid, 1 invalid

Agent calls: gtmcli_export_csv
  → cto-devtools.csv (14 rows, all verified)

Agent: "Exported 14 verified CTO contacts to
  cto-devtools.csv. Used 52 credits. Balance: 795."

Notice the agent over-fetched (20 companies for a 15-contact goal) because it knows some lookups will fail. It also checked the credit balance first. These behaviors emerge naturally from the tool descriptions. You do not need to tell the agent to do this. It reads the tool schema and figures it out.

How the agent manages credits and batching

The gtmcli MCP tools include credit cost information in their descriptions. The agent uses this to make smart decisions:

Before starting a large job, it checks your balance. If the estimated cost exceeds 50% of your remaining credits, it warns you and asks for confirmation. It batches operations when processing more than 10 contacts, which is both faster and more token-efficient. It skips validation for emails from domains it already validated in the same session. It stops early if it hits your target count instead of processing the entire batch.

None of this is hardcoded. The agent reads the tool descriptions and the context of your conversation to make these decisions. Different prompts produce different strategies. If you say "budget is tight, only validate the highest-confidence emails," it will skip validation on low-confidence finds.

Combining gtmcli with other MCP servers

The power of MCP is composability. gtmcli handles the data operations, but you can connect other MCP servers for the rest of your workflow.

{
  "mcpServers": {
    "gtmcli": {
      "command": "gtmcli",
      "args": ["mcp", "serve"]
    },
    "google-sheets": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-google-sheets"]
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-slack"]
    }
  }
}

With this config, the agent can build a lead list with gtmcli, write the results to a Google Sheet, and send a Slack notification when the job finishes. All from a single prompt.

> Build a list of 50 marketing directors at
> e-commerce companies. Verified emails only.
> Write the results to the "Q2 Outbound" Google Sheet.
> Post a summary to #sales-ops in Slack.

One prompt. Three MCP servers. The agent orchestrates all of them. This is what a code-first GTM stack looks like.

Troubleshooting

MCP server fails to start

Run gtmcli mcp serve directly in your terminal. If it fails, you will see the error. Common causes: not authenticated (run gtmcli auth login), outdated version (run npm update -g gtmcli), or Node.js version too old.

Tools not showing up

Make sure the path to gtmcli is in your PATH. Run which gtmcli to confirm. If you installed with npm and it is not in PATH, use the full path in your settings.json: "command": "/usr/local/bin/gtmcli".

Agent not using the tools

Be explicit in your prompt that you want real data. Saying "find verified emails using gtmcli" is clearer than "find some emails." The agent will prefer MCP tools over guessing when it knows they are available, but explicit instructions help.

MCP turns an AI agent from a research assistant into a prospecting system. The protocol is the infrastructure. gtmcli is the data layer. Claude code is the agent. Together, they replace the entire chain of prospecting tools most teams are still paying for separately.