lakewave-mcp 1.0.0__tar.gz

lakewave_mcp-1.0.0/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Lynbrook Solutions LLC, DBA Lakewave.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

lakewave_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.5
+Name: lakewave-mcp
+Version: 1.0.0
+Summary: Lakewave MCP server: verified people at named accounts, email verdicts, public-sector contract signals and drafted campaigns as tools for agents.
+Project-URL: Homepage, https://lakewave.ai/agents/
+Project-URL: Documentation, https://lakewave.ai/agents/
+Project-URL: Source, https://github.com/taylorsec/lakewave-mcp
+Author-email: "Lakewave.ai" <support@lakewave.ai>
+License: MIT
+License-File: LICENSE
+Keywords: agents,email-verification,lakewave,mcp,model-context-protocol,prospecting,sales
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.2
+Requires-Dist: requests>=2.31
+Description-Content-Type: text/markdown
+
+# Lakewave MCP server
+
+Gives any MCP client (Claude Desktop, Cursor, Claude Code, agent frameworks) Lakewave's outcomes as tools:
+verified people at named accounts, verdicts on a list of addresses, a company's email convention,
+public-sector contracts ending in a territory, and campaigns filled with drafts that a person approves inside Lakewave.
+
+mcp-name: ai.lakewave/lakewave-mcp
+
+## Install
+
+    uvx lakewave-mcp            # or: pip install lakewave-mcp && lakewave-mcp
+
+Set `LAKEWAVE_API_KEY` (Lakewave app → Integrations → API keys). Keys are scoped, rate limited,
+can be capped per day, and can never send email.
+
+Claude Desktop / Cursor config:
+
+    {"mcpServers": {"lakewave": {"command": "uvx", "args": ["lakewave-mcp"],
+                                 "env": {"LAKEWAVE_API_KEY": "lw_live_..."}}}}
+
+## Tools
+
+`account`, `find_people`, `get_job`, `verify_emails`, `verify_list`, `get_list`, `email_format`,
+`my_contacts`, `contracts_ending`, `create_campaign`, `get_campaign`.
+
+Pricing is the same as inside the app and is charged to the key owner's credits: 4 per verified
+person, 1 per definitive verdict; signals, conventions and your own contacts are free. Sending is
+deliberately not exposed: drafts an agent creates wait in Lakewave for a human to approve.
+
+Docs and a Clay recipe: https://lakewave.ai/agents/

lakewave_mcp-1.0.0/README.md

@@ -0,0 +1,30 @@
+# Lakewave MCP server
+
+Gives any MCP client (Claude Desktop, Cursor, Claude Code, agent frameworks) Lakewave's outcomes as tools:
+verified people at named accounts, verdicts on a list of addresses, a company's email convention,
+public-sector contracts ending in a territory, and campaigns filled with drafts that a person approves inside Lakewave.
+
+mcp-name: ai.lakewave/lakewave-mcp
+
+## Install
+
+    uvx lakewave-mcp            # or: pip install lakewave-mcp && lakewave-mcp
+
+Set `LAKEWAVE_API_KEY` (Lakewave app → Integrations → API keys). Keys are scoped, rate limited,
+can be capped per day, and can never send email.
+
+Claude Desktop / Cursor config:
+
+    {"mcpServers": {"lakewave": {"command": "uvx", "args": ["lakewave-mcp"],
+                                 "env": {"LAKEWAVE_API_KEY": "lw_live_..."}}}}
+
+## Tools
+
+`account`, `find_people`, `get_job`, `verify_emails`, `verify_list`, `get_list`, `email_format`,
+`my_contacts`, `contracts_ending`, `create_campaign`, `get_campaign`.
+
+Pricing is the same as inside the app and is charged to the key owner's credits: 4 per verified
+person, 1 per definitive verdict; signals, conventions and your own contacts are free. Sending is
+deliberately not exposed: drafts an agent creates wait in Lakewave for a human to approve.
+
+Docs and a Clay recipe: https://lakewave.ai/agents/

lakewave_mcp-1.0.0/bundle/build-bundle.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# Build lakewave.mcpb (Claude Desktop one-click install). Needs node + python3.
+set -euo pipefail
+cd "$(dirname "$0")"
+rm -rf server/vendor server/lakewave_mcp && mkdir -p server/vendor
+cp -r ../src/lakewave_mcp server/lakewave_mcp
+python3 -m pip install -q -t server/vendor "mcp>=1.2" "requests>=2.31"
+npx -y @anthropic-ai/mcpb validate manifest.json
+npx -y @anthropic-ai/mcpb pack . ../dist/lakewave.mcpb
+echo "built ../dist/lakewave.mcpb  (serve it at https://lakewave.ai/agents/lakewave.mcpb)"

lakewave_mcp-1.0.0/bundle/manifest.json

@@ -0,0 +1,43 @@
+{
+  "manifest_version": "0.4",
+  "name": "lakewave",
+  "display_name": "Lakewave.ai",
+  "version": "1.0.0",
+  "description": "Verified people at named accounts, email verdicts, contract signals and drafted campaigns for B2B sellers.",
+  "long_description": "Lakewave finds and verifies the people a seller needs at named accounts, re-verifies lists, surfaces public-sector contracts ending soon, and fills campaigns with drafts a human approves inside Lakewave. Outcome priced on your Lakewave credits. Never sends email.",
+  "author": { "name": "Lakewave.ai", "email": "support@lakewave.ai", "url": "https://lakewave.ai" },
+  "homepage": "https://lakewave.ai/agents/",
+  "documentation": "https://lakewave.ai/agents/",
+  "support": "mailto:support@lakewave.ai",
+  "license": "MIT",
+  "keywords": ["sales", "prospecting", "email verification", "b2b", "government contracts"],
+  "server": {
+    "type": "python",
+    "entry_point": "server/main.py",
+    "mcp_config": {
+      "command": "python3",
+      "args": ["${__dirname}/server/main.py"],
+      "env": { "LAKEWAVE_API_KEY": "${user_config.api_key}" }
+    }
+  },
+  "user_config": {
+    "api_key": {
+      "type": "string",
+      "title": "Lakewave API key",
+      "description": "From app.lakewave.ai > Integrations > API keys (starts with lw_live_)",
+      "sensitive": true,
+      "required": true
+    }
+  },
+  "tools": [
+    { "name": "account", "description": "Plan, credits and limits for this key" },
+    { "name": "find_people", "description": "Verified people by title at named companies" },
+    { "name": "verify_emails", "description": "Verdicts for up to 25 addresses" },
+    { "name": "verify_list", "description": "Verdicts for up to 5,000 addresses" },
+    { "name": "email_format", "description": "A company's email convention" },
+    { "name": "my_contacts", "description": "Search your verified contacts" },
+    { "name": "contracts_ending", "description": "Public-sector contracts ending in a territory" },
+    { "name": "create_campaign", "description": "Create a campaign and optionally draft emails for approval" }
+  ],
+  "compatibility": { "claude_desktop": ">=0.10.0", "platforms": ["darwin", "win32", "linux"], "runtimes": { "python": ">=3.10" } }
+}

lakewave_mcp-1.0.0/bundle/server/main.py

@@ -0,0 +1,7 @@
+# Claude Desktop bundle entry: vendored deps in ./vendor, server code in ./lakewave_mcp.
+import os, sys
+_here = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(_here, "vendor"))
+sys.path.insert(0, _here)
+from lakewave_mcp.server import main  # noqa: E402
+main()

lakewave_mcp-1.0.0/glama.json

@@ -0,0 +1,4 @@
+{
+  "$schema": "https://glama.ai/mcp/schemas/server.json",
+  "maintainers": ["taylorsec"]
+}

lakewave_mcp-1.0.0/publish.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Publish lakewave-mcp to PyPI, then the MCP Registry. Run from /root/saas/mcp on a machine with Python 3.10+.
+#   PYPI_TOKEN=pypi-...  ./publish.sh            # PyPI only
+#   ./publish.sh registry                        # after DNS verification (see below)
+set -euo pipefail
+cd "$(dirname "$0")"
+if [ "${1:-}" != "registry" ]; then
+  : "${PYPI_TOKEN:?set PYPI_TOKEN (an API token from pypi.org, scope: entire account for the first upload)}"
+  python3 -m pip install -q --upgrade build twine
+  rm -rf dist && python3 -m build
+  TWINE_USERNAME=__token__ TWINE_PASSWORD="$PYPI_TOKEN" python3 -m twine upload dist/*
+  echo "published: pip install lakewave-mcp   |   uvx lakewave-mcp"
+  exit 0
+fi
+# --- MCP Registry (official): namespace ai.lakewave/* is proven by a DNS TXT record on lakewave.ai ---
+# 1. install:  curl -L https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_linux_amd64.tar.gz | tar xz
+# 2. key:      openssl genpkey -algorithm ed25519 -out mcp-publisher.key
+#              openssl pkey -in mcp-publisher.key -pubout -outform DER | tail -c 32 | base64     -> PUBKEY
+# 3. DNS:      add TXT at lakewave.ai:   v=MCPv1; k=ed25519; p=<PUBKEY>
+# 4. login:    ./mcp-publisher login dns --domain lakewave.ai --private-key "$(openssl pkey -in mcp-publisher.key -noout -text | grep -A3 priv | tail -n +2 | tr -d ' :\n')"
+# 5. publish:
+./mcp-publisher publish

lakewave_mcp-1.0.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "lakewave-mcp"
+version = "1.0.0"
+description = "Lakewave MCP server: verified people at named accounts, email verdicts, public-sector contract signals and drafted campaigns as tools for agents."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [{ name = "Lakewave.ai", email = "support@lakewave.ai" }]
+keywords = ["mcp", "model-context-protocol", "sales", "prospecting", "email-verification", "lakewave", "agents"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Topic :: Office/Business",
+]
+dependencies = ["mcp>=1.2", "requests>=2.31"]
+
+[project.urls]
+Homepage = "https://lakewave.ai/agents/"
+Documentation = "https://lakewave.ai/agents/"
+Source = "https://github.com/taylorsec/lakewave-mcp"
+
+[project.scripts]
+lakewave-mcp = "lakewave_mcp.server:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/lakewave_mcp"]

lakewave_mcp-1.0.0/server.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "ai.lakewave/lakewave-mcp",
+  "description": "Verified people at named accounts, email verdicts, public-sector contract signals and drafted campaigns for B2B sellers. Outcome priced; never sends email.",
+  "version": "1.0.0",
+  "websiteUrl": "https://lakewave.ai/agents/",
+  "packages": [
+    {
+      "registryType": "pypi",
+      "registryBaseUrl": "https://pypi.org",
+      "identifier": "lakewave-mcp",
+      "version": "1.0.0",
+      "runtimeHint": "uvx",
+      "transport": { "type": "stdio" },
+      "environmentVariables": [
+        { "name": "LAKEWAVE_API_KEY", "description": "Lakewave API key (app.lakewave.ai > Integrations > API keys)", "isRequired": true, "isSecret": true }
+      ]
+    }
+  ]
+}

lakewave_mcp-1.0.0/smithery.yaml

@@ -0,0 +1,13 @@
+# Smithery listing (https://smithery.ai). Local stdio server published on PyPI.
+startCommand:
+  type: stdio
+  configSchema:
+    type: object
+    required: [lakewaveApiKey]
+    properties:
+      lakewaveApiKey:
+        type: string
+        title: Lakewave API key
+        description: From app.lakewave.ai > Integrations > API keys (lw_live_...)
+  commandFunction: |-
+    (config) => ({ command: "uvx", args: ["lakewave-mcp"], env: { LAKEWAVE_API_KEY: config.lakewaveApiKey } })

lakewave_mcp-1.0.0/src/lakewave_mcp/__init__.py

@@ -0,0 +1,3 @@
+"""Lakewave MCP server: verified people, verdicts, signals and drafted campaigns as agent tools."""
+__version__ = "1.0.0"
+from .server import main, mcp  # noqa: F401

lakewave_mcp-1.0.0/src/lakewave_mcp/server.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+Lakewave MCP server. Gives an agent (Claude Desktop, Cursor, Claude Code,
+any MCP client) Lakewave's outcomes as tools: verified people at named
+accounts, verdicts on a list of addresses, a company's email convention,
+public-sector contracts ending in a territory, and campaigns filled with
+drafts that a person approves inside Lakewave.
+
+Setup
+    pip install 'mcp>=1.2' requests      (1.x and 2.x both work)
+    export LAKEWAVE_API_KEY=lw_live_...      (Lakewave app > Integrations > API keys)
+
+Claude Desktop / Cursor (claude_desktop_config.json or mcp.json):
+    {"mcpServers": {"lakewave": {"command": "python", "args": ["/path/to/lakewave_mcp.py"],
+                                 "env": {"LAKEWAVE_API_KEY": "lw_live_..."}}}}
+
+Pricing is the same as inside the app and is charged to the key owner's
+credits: 4 per verified person, 1 per definitive verdict; signals and
+convention lookups are free. Nothing in this server sends email.
+"""
+import os
+import sys
+import time
+import json
+
+import requests
+try:                                   # mcp 2.x
+    from mcp.server.mcpserver import MCPServer as _Server
+except ImportError:                    # mcp 1.x
+    from mcp.server.fastmcp import FastMCP as _Server
+
+BASE = os.environ.get("LAKEWAVE_API_BASE", "https://app.lakewave.ai/api/v1").rstrip("/")
+KEY = os.environ.get("LAKEWAVE_API_KEY", "").strip()
+mcp = _Server("lakewave", instructions=(
+    "Lakewave finds and verifies the people a seller needs at named accounts, re-verifies lists, "
+    "surfaces public-sector contracts ending soon, and fills campaigns with drafts a human approves. "
+    "Tools return finished outcomes. Costs: 4 credits per verified person, 1 per definitive email verdict; "
+    "everything else is free. Call account() first if you need the balance."))
+
+
+def _call(method, path, **kw):
+    if not KEY:
+        return {"error": "LAKEWAVE_API_KEY is not set. Create one in the Lakewave app under Integrations."}
+    headers = {"Authorization": f"Bearer {KEY}", "Content-Type": "application/json", "User-Agent": "lakewave-mcp/1.0"}
+    try:
+        r = requests.request(method, f"{BASE}{path}", headers=headers, timeout=90, **kw)
+    except requests.RequestException as e:
+        return {"error": f"Lakewave is unreachable: {e}"}
+    try:
+        data = r.json()
+    except ValueError:
+        data = {"error": f"HTTP {r.status_code}: {r.text[:300]}"}
+    if r.status_code >= 400 and "error" not in data:
+        data["error"] = f"HTTP {r.status_code}"
+    return data
+
+
+def _wait(path, seconds, done_statuses=("done", "failed", "completed", "error")):
+    deadline = time.time() + max(0, seconds)
+    last = None
+    while True:
+        last = _call("GET", path)
+        if last.get("error") or last.get("status") in done_statuses or time.time() >= deadline:
+            return last
+        time.sleep(4)
+
+
+@mcp.tool()
+def account() -> dict:
+    """Plan, remaining credits, prices and request limits for this API key."""
+    return _call("GET", "/me")
+
+
+@mcp.tool()
+def find_people(companies: list[str], titles: list[str], location: str = "", location_mode: str = "",
+                wait_seconds: int = 240) -> dict:
+    """Find and verify the people in the given roles at the given companies.
+    companies: 1-25 company names. titles: 1-5 role titles (e.g. "Director of IT").
+    location: optional territory ("Texas", "Bay Area"); location_mode "hq" keeps
+    companies headquartered there, "people" keeps people located there.
+    Returns only people at Lakewave's 4-star verified bar: name, title, company,
+    email, stars, LinkedIn. Costs 4 credits per verified person; a search that
+    finds nobody costs nothing. Waits up to wait_seconds; if still running,
+    returns the job_id to resume with get_job."""
+    body = {"companies": companies, "titles": titles, "location": location, "location_mode": location_mode}
+    started = _call("POST", "/people/find", data=json.dumps(body))
+    if started.get("error") or not started.get("job_id"):
+        return started
+    out = _wait(f"/jobs/{started['job_id']}", wait_seconds)
+    if out.get("status") not in ("done", "failed"):
+        out["note"] = "Still running. Call get_job(job_id) in a minute."
+    return out
+
+
+@mcp.tool()
+def get_job(job_id: str) -> dict:
+    """Status and results of a find_people job. People are included once the job is done."""
+    return _call("GET", f"/jobs/{job_id}")
+
+
+@mcp.tool()
+def verify_emails(emails: list[str]) -> dict:
+    """Verdict per address, synchronous for up to 25 addresses: valid, invalid,
+    catch_all (accept-all domain), unknown, dead_domain or bad_syntax, each with a
+    reason and a 0-5 star rating. 1 credit per definitive verdict (valid or
+    invalid); the rest are free. For more than 25 use verify_list."""
+    return _call("POST", "/emails/verify", data=json.dumps({"emails": emails}))
+
+
+@mcp.tool()
+def verify_list(emails: list[str], name: str = "agent list", wait_seconds: int = 240) -> dict:
+    """Re-verify a larger list (up to 5,000 addresses) as a background job.
+    Same verdicts and pricing as verify_emails. Waits up to wait_seconds, then
+    returns results or the job_id to resume with get_list."""
+    started = _call("POST", "/emails/verify-list", data=json.dumps({"emails": emails, "name": name}))
+    if started.get("error") or not started.get("job_id"):
+        return started
+    out = _wait(f"/lists/{started['job_id']}", wait_seconds)
+    if out.get("status") != "done":
+        out["note"] = "Still running. Call get_list(job_id) shortly."
+    return out
+
+
+@mcp.tool()
+def get_list(job_id: str) -> dict:
+    """Status and results of a verify_list job."""
+    return _call("GET", f"/lists/{job_id}")
+
+
+@mcp.tool()
+def email_format(domain: str, first: str = "", last: str = "") -> dict:
+    """A company's email convention. 'confirmed' means Lakewave has verified real
+    addresses at that domain in that shape; 'evidence' means seen publicly;
+    'guess' means nothing on record yet. With first and last, returns rendered
+    candidate addresses labelled by basis. Free. Candidates are not verified
+    until you run verify_emails on them."""
+    return _call("GET", "/emails/format", params={"domain": domain, "first": first, "last": last})
+
+
+@mcp.tool()
+def my_contacts(q: str = "", company: str = "", domain: str = "", min_stars: float = 4, limit: int = 100) -> dict:
+    """Search the key owner's own verified contacts (already paid for, never charged
+    again). q matches name, title or company. Free."""
+    return _call("GET", "/contacts", params={"q": q, "company": company, "domain": domain, "min_stars": min_stars, "limit": limit})
+
+
+@mcp.tool()
+def contracts_ending(states: str = "", months: int = 6, terms: str = "", tech_only: bool = True,
+                     statewide_only: bool = False, page: int = 1) -> dict:
+    """Public-sector (state, county, city, K-12, higher-ed) contracts ending inside
+    the window: agency, incumbent vendor, title, end date, amount and source link.
+    states: comma-separated two-letter codes ("CA,TX"); terms: free text matched
+    against title, agency, vendor and vehicle. These are purchases an agency has
+    to re-buy, i.e. rebid and competitive-takeout targets. Free."""
+    params = {"states": states, "months": months, "terms": terms, "page": page}
+    if tech_only:
+        params["cat"] = "tech"
+    if statewide_only:
+        params["scope"] = "statewide"
+    return _call("GET", "/signals/contracts", params=params)
+
+
+@mcp.tool()
+def create_campaign(name: str, companies: list[str], titles: list[str] = None, location: str = "",
+                    draft: bool = False) -> dict:
+    """Create a Lakewave campaign with a target set of companies. With draft=true
+    and titles given, Lakewave finds the best person at each company and writes a
+    personalized draft for each (4 credits per verified person plus 1 per draft).
+    Drafts wait in the Lakewave app for a human to approve and schedule; this tool
+    never sends email. Returns the campaign id and the app link."""
+    body = {"name": name, "companies": companies, "titles": titles or [], "location": location, "draft": draft}
+    return _call("POST", "/campaigns", data=json.dumps(body))
+
+
+@mcp.tool()
+def get_campaign(campaign_id: str) -> dict:
+    """Campaign rollup: company statuses, draft / approved / sent counts, drafting progress."""
+    return _call("GET", f"/campaigns/{campaign_id}")
+
+
+def main():
+    if not KEY:
+        print("warning: LAKEWAVE_API_KEY is not set; every tool will return an error until it is.", file=sys.stderr)
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()