ReachDirect MCP
OfficialClick on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ReachDirect MCPDraft an intro email to Marie at Laurent Remorques, show it before sending"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ReachDirect MCP
Live demo: https://reach-direct-mcp.vercel.app (mock mode, nothing is sent) · deploys automatically on every push to main
An MCP server that lets Claude Desktop, Cursor or any MCP client do personal outreach for you: send an email through Brevo, send a WhatsApp message through WhatsApp Web, and log every contact to an Excel file. You state your name, sender address and message in the chat. Your assistant fills in the template, shows you the final text, and sends it once you say yes.
MCP server | Python 3.10+ · FastMCP · httpx (Brevo v3 API) · Playwright (WhatsApp Web) · openpyxl · phonenumbers |
Web demo | React 18 · TypeScript · Tailwind CSS · Vite, deployed on Vercel |
Tools
Tool | What it does |
| Fills |
| Sends one email through the Brevo transactional API over HTTPS. You need no SMTP setup or password, only |
| Opens WhatsApp Web in a browser and sends one message. On first use, a QR code is saved as an auto-refreshing |
| Appends Date, Name, Company, Email, Phone, Channel, Status and Notes to |
| Shows the latest rows of the log. |
| Records someone who asked not to be contacted. Later sends to that address or number are refused. |
Built-in safeguards:
Messages with unfilled
{{placeholders}}are refused.Email addresses are validated, and phone numbers must parse in international format.
Sends are capped per channel per day (
REACHDIRECT_DAILY_LIMIT, default 50).WhatsApp messages are URL-encoded, so
&,#and line breaks arrive intact.
Related MCP server: ManyContacts MCP Server
Install
git clone https://github.com/weblinkify/reach-direct-mcp
cd reach-direct-mcp
python -m venv .venv && source .venv/bin/activate # Windows: .venv\Scripts\activate
pip install -e .
playwright install chromiumMCP client config:
{
"mcpServers": {
"reachdirect": {
"command": "/ABSOLUTE/PATH/reach-direct-mcp/.venv/bin/reachdirect",
"env": {
"BREVO_API_KEY": "xkeysib-your-key",
"REACHDIRECT_OUTPUT_DIR": "~/Desktop",
"REACHDIRECT_DAILY_LIMIT": "50"
}
}
}
}Variable | Default | Purpose |
| — | Brevo → Settings → SMTP & API → API keys. The free plan sends 300 emails/day. |
| Desktop, else |
|
|
| WhatsApp browser profile, daily counters, do-not-contact list. |
|
| Max sends per channel per day. |
| bundled Chromium | Use |
Before the first email, verify your sender address or domain in Brevo (Senders, domains & IPs) and set up SPF/DKIM. Otherwise Brevo rejects the send, and the tool tells you why.
Example prompt
I'm Daniel Weber (daniel@weber-parts.example). Write to Marie Laurent
(marie.laurent@laurent-remorques.example, +33 6 12 34 56 78) at Laurent Remorques
about our trailer axle range.
1. preview_message with a short intro, then show me the text.
2. After I approve: send_email, then send_whatsapp with a one-line heads-up.
3. save_outreach_contact for Marie with channel "email+whatsapp".Web demo
cd frontend
npm install
npm run dev # http://localhost:5173You can pick a fictional contact and a template, edit the placeholders and see the email or WhatsApp preview. A mock "send" applies the same validation, do-not-contact and daily-limit rules as the server and logs the attempt. Nothing leaves the browser.
Vercel: import the repo and set Root Directory to frontend; frontend/vercel.json does the rest.
Development
pip install -r requirements-dev.txt
pytest -q # Brevo calls are mocked; the WhatsApp browser flow is not run in tests
cd frontend && npm test && npm run buildResponsible use
Send one-to-one messages to people with a reason to hear from you, honour opt-outs (add_do_not_contact)
and follow the rules where you operate (GDPR / ePrivacy, CAN-SPAM, KVKK). WhatsApp's terms restrict
automated and bulk messaging; misuse can get your number banned. This tool sends one approved message
per call on purpose.
License
MIT
Available Tools
6 toolsadd_do_not_contactAdd Do Not ContactB
Record that someone asked not to be contacted. Future sends to them are refused.
| Name | Required | Description | Default |
|---|---|---|---|
| email_or_phone | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and usefully discloses the downstream effect ('future sends to them are refused'), which is genuine behavioral context. However, it omits idempotency, what happens if the contact already exists, permission requirements, and error behavior for a mutation tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences: purpose first, consequence second, with zero filler. Both sentences earn their place and the effect is front-loaded after the core action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists so return values needn't be explained, and the purpose plus effect are covered. But for an unannotated mutation tool the description leaves gaps on idempotency, dedup behavior, and parameter format that an agent would benefit from.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description never explains the single parameter. It says 'someone' but doesn't clarify that the identifier is an email or phone, expected format, or whether both are accepted. The self-descriptive name 'email_or_phone' partly rescues it, but the description adds no meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Record that someone asked not to be contacted,' and the second sentence clarifies the effect ('future sends... are refused'), which implicitly distinguishes it from the send_* siblings. It stops short of naming siblings explicitly, so it's clear but not sibling-differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The trigger ('someone asked not to be contacted') is implied clearly enough to know when to reach for it, but there is no explicit when-not guidance and no sibling is named as an alternative. Adequate but reasonably inferential.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_outreach_contactsList Outreach ContactsC
Latest rows of the outreach log.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, and it discloses only one trait: results are the "latest" rows (an implicit recency ordering). It says nothing about read-only safety, pagination or truncation behavior, what happens above the default limit of 50, or whether contact PII is exposed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
It is short with zero waste, but the brevity is under-specification rather than economy: a single sentence fragment that omits the verb and the resource. Front-loading is moot when there is only one clause.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described, but for a list tool with a limit parameter, no annotations, and a send/contact-management sibling set, the definition should at minimum say it is a read operation, its ordering, and its scope. None of that is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The single parameter `limit` has 0% schema description coverage and is never mentioned in the description, so its meaning (max rows returned? default 50, max cap?) is undocumented everywhere. The word "latest" hints at a window but not how it interacts with limit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
"Latest rows of the outreach log" is a noun fragment that restates the title (List Outreach Contacts) without a verb or the object actually being listed (contacts). It implies recency ordering, but an agent learns nothing about what a "row" contains or whether contacts are being read or written.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance at all, and no comparison to the available siblings (preview_message, send_email, save_outreach_contact, add_do_not_contact). The agent must infer from the name alone that this is the read-side listing tool in an otherwise write/send-heavy toolset.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
preview_messagePreview MessageD
Fill {{first_name}}, {{name}}, {{company}} and any extra {{placeholders}} (fallbacks: {{first_name|there}}).
| Name | Required | Description | Default |
|---|---|---|---|
| extra | No | ||
| company | No | ||
| template | Yes | ||
| recipient_name | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden, yet it never discloses that this is a safe/non-mutating render step, nor what happens with unresolved placeholders. It adds only syntax-level detail (fallback form '{{first_name|there}}'), which is a small piece of behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
It is very short with no filler, but it is a sentence fragment rather than a front-loaded purpose statement, so its brevity comes at the cost of the essential information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists so return values need not be described, but the description omits the core behavior (no-send preview), the parameter-to-placeholder mapping, and how 'extra' merges with the template. For a 4-parameter tool with zero schema coverage, this is insufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, so the description must explain all four parameters. It hints at company and extra placeholders, but never connects the 'recipient_name' parameter to the {{first_name}}/{{name}} tokens it names, and never explains that 'extra' is a key-value map of custom placeholder values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description is a fragment about template placeholder syntax, not a statement of what the tool does. It never says the tool renders/previews a message without sending it, so an agent must infer the verb and resource from the name alone.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no guidance on when to use this versus send_email or send_whatsapp, and no explicit statement that this is a non-sending preview. The agent is left to guess whether calling it has side effects.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
save_outreach_contactSave Outreach ContactB
Append a row to outreach_contacts.xlsx (Date, Name, Company, Email, Phone, Channel, Status, Notes).
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| No | |||
| notes | No | ||
| phone | No | ||
| status | No | contacted | |
| channel | No | ||
| company | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must carry the full behavioral burden. It usefully says the operation appends a row rather than overwriting existing data, but it does not disclose duplicate handling, file creation behavior, permissions, or failure modes for a write operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with no wasted text. It immediately conveys the action, destination file, and written columns.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is a write operation with seven parameters, zero schema descriptions, and no annotations. Although an output schema exists and reduces the need to explain return values, the description is too thin about usage conditions, parameter defaults, and append semantics for an agent to call it with confidence.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description needed to compensate. It maps parameters to spreadsheet columns, but does not explain the required 'name', defaults such as status='contacted' and channel='email', allowed values, or why 'Date' appears in the column list but not in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and target resource: append a row to outreach_contacts.xlsx, and it enumerates the columns written. This clearly distinguishes saving a contact from sibling tools like list_outreach_contacts and send_email.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus alternatives such as list_outreach_contacts or add_do_not_contact. The intended usage is only implied by the tool name and append action.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
send_emailSend EmailB
Send one email through Brevo (needs BREVO_API_KEY and a sender verified in Brevo).
| Name | Required | Description | Default |
|---|---|---|---|
| dry_run | No | Validate and return the payload without sending. | |
| message | Yes | ||
| subject | Yes | ||
| reply_to | No | ||
| sender_name | Yes | ||
| sender_email | Yes | ||
| recipient_name | No | ||
| recipient_email | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description does carry real weight: it discloses the required API key environment variable and the Brevo-side constraint that the sender must be pre-verified. It omits the key behavioral fact for a mutation tool — that sending is an irreversible external side effect with no undo — and says nothing about rate limits or failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with zero filler; the provider and the two prerequisites are packed into one clause.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need no explanation. But for an 8-parameter outbound mutation with no annotations, the definition is thin — the 'one email' scope limit, irreversible delivery, and message-format expectations all go unstated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 13% (just dry_run), and the description elaborates on only one concept: that sender_email must correspond to a Brevo-verified sender. It says nothing about message format (plain text vs HTML), subject constraints, or reply_to/recipient_name handling across the remaining seven parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Send one email') plus the delivery provider (Brevo), which implicitly separates it from send_whatsapp and preview_message. It stops short of naming any sibling explicitly, so disambiguation relies on the agent noticing the channel word.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
'Send one email' implies single-message, not bulk, and the parenthetical states the prerequisites (BREVO_API_KEY, verified sender). However, it never says when to prefer preview_message or the schema's dry_run flag before actually dispatching, and gives no exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
send_whatsappSend WhatsappA
Send one WhatsApp message through WhatsApp Web (a browser window opens; first run asks for a QR scan).
| Name | Required | Description | Default |
|---|---|---|---|
| message | Yes | ||
| phone_number | Yes | International format, e.g. "+90 532 123 45 67". National numbers need default_region. | |
| default_region | No | ISO country code used when the number has no + prefix, e.g. "TR". |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry behavioral disclosure. It usefully states that a browser window opens and first run requires a QR scan, but it does not describe delivery behavior, authentication persistence, rate limits, or failure modes for an external send operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single front-loaded sentence with zero wasted text. The parenthetical setup caveat is operationally useful and does not obscure the main action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be explained. The description covers the main action plus browser/QR setup, but for a send tool with no annotations it leaves important context about immediacy, authentication state, and delivery outcomes unstated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 67%, with phone_number and default_region well documented in the schema. The description adds no parameter syntax or constraints beyond what the schema provides, and the message parameter remains undescribed in both places.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: send one WhatsApp message via WhatsApp Web. It is distinguishable from send_email by channel, though it does not explicitly contrast with sibling tools such as preview_message.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by 'Send one WhatsApp message,' and the first-run QR note helps with setup context. However, it does not say when to choose this over send_email or preview_message, nor does it give exclusions or prerequisites beyond the QR scan.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
6 tool updates
v1.0.0- First observed
add_do_not_contact - First observed
list_outreach_contacts - First observed
preview_message - First observed
save_outreach_contact - First observed
send_email - First observed
send_whatsapp
TDQS
Scored across 6 tools
Each tool has a distinct action target: listing rows, previewing templates, sending via two clearly separated channels, appending rows, and recording DNC. Minor blur between list_outreach_contacts (outreach log) and save_outreach_contact (outreach_contacts.xlsx), which appear to touch the same data under different resource names.
All six names are snake_case verb_noun (list_, preview_, send_, save_, add_) with predictable patterns, including the parallel send_email/send_whatsapp pair.
Six tools cover the core read/send/save/suppress flow without bloat. The set is slightly thin — there is no status-update or lookup tool — but each tool clearly earns its place.
The surface handles listing, templating, sending on two channels, saving, and DNC, but the Status field in the saved row has no update tool, there is no way to remove or inspect DNC entries, and no contact lookup/search or reply tracking. These gaps will leave agents unable to close the loop after a send.
Maintenance
Related MCP Connectors
Unified inbox MCP for WhatsApp, Telegram, Email, voice — read/send messages, search, AI agents.
Hosted MCP server for MuntuAI outreach campaigns, leads, senders, domains, and analytics.
LinkedIn outreach MCP server — 19 tools for AI agents to prospect, sequence, and manage contacts.
B2B outreach CRM for AI agents: contacts, verification, approved campaigns, replies, follow-ups.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables sending WhatsApp messages through Claude Desktop and other MCP-compatible LLMs. Supports single and bulk messaging, phone number validation, and session management via the zapr.link service.MIT
- AlicenseBqualityDmaintenanceMCP server for ManyContacts WhatsApp Business CRM that enables AI agents to manage contacts, send messages, run campaigns, and configure auto-replies through comprehensive CRM operations.5522 npmMIT
- FlicenseNot gradedqualityDmaintenanceEnables automated lead generation, AI enrichment, personalized messaging, and outreach orchestration through MCP tools and n8n workflows.-
- AlicenseNot gradedqualityCmaintenanceEnables users to run an autonomous sales pipeline through MCP tools for lead generation, enrichment, personalized message drafting, and simulated or live outreach. It supports n8n orchestration and Streamlit dashboard monitoring with SQLite-backed lead and message tracking.MIT