@trylighthouse/mcp-server 0.1.101

package/README.md

@@ -0,0 +1,198 @@
+# Lighthouse MCP Server
+
+An [MCP](https://modelcontextprotocol.io/) server that connects AI assistants (Claude, Cursor, etc.) to the Lighthouse CRM API.
+
+## Setup
+
+### 1. Get your API key
+
+Go to **Settings → API Keys** in Lighthouse and generate a key.
+
+### 2. Configure your AI client
+
+#### Claude Desktop
+
+Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "lighthouse": {
+      "command": "npx",
+      "args": ["-y", "@trylighthouse/mcp-server@latest"],
+      "env": {
+        "LIGHTHOUSE_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+#### Claude Code
+
+```bash
+claude mcp add lighthouse -- npx -y @trylighthouse/mcp-server@latest
+```
+
+Set the env var: `export LIGHTHOUSE_API_KEY=your-api-key`
+
+#### Cursor
+
+Add to `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "lighthouse": {
+      "command": "npx",
+      "args": ["-y", "@trylighthouse/mcp-server@latest"],
+      "env": {
+        "LIGHTHOUSE_API_KEY": "your-api-key"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### Records
+
+Records support built-in types (`company`, `person`, `deal`) and custom object types (use the permalink as `record_type`).
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_crm_search_records` | Search/filter records with CRM-style filters and sorting |
+| `lighthouse_crm_get_record` | Get a single record by ID |
+| `lighthouse_crm_create_record` | Create a new record |
+| `lighthouse_crm_update_record` | Update a record's fields |
+| `lighthouse_crm_delete_record` | Delete a record |
+
+### Attributes & Options
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_crm_get_attributes` | List all field definitions for a record type |
+| `lighthouse_crm_get_attribute` | Get a single field definition |
+| `lighthouse_crm_create_attribute` | Create a custom field |
+| `lighthouse_crm_update_attribute` | Update a custom field |
+| `lighthouse_crm_delete_attribute` | Delete a custom field |
+| `lighthouse_crm_get_color_palette` | Get available colors for select options |
+| `lighthouse_crm_list_options` | List options for a select/status field |
+| `lighthouse_crm_create_option` | Create a field option |
+| `lighthouse_crm_delete_option` | Delete a field option |
+
+### Lists
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_crm_list_lists` | Get all CRM lists |
+| `lighthouse_crm_create_list` | Create a new list |
+| `lighthouse_crm_get_list` | Get a single list |
+| `lighthouse_crm_update_list` | Update a list |
+| `lighthouse_crm_delete_list` | Delete a list |
+| `lighthouse_crm_get_list_records` | Get records in a list |
+| `lighthouse_crm_add_to_list` | Add a record to a list |
+| `lighthouse_crm_remove_from_list` | Remove a record from a list |
+| `lighthouse_crm_share_list_with_teams` | Share a list with teams |
+| `lighthouse_crm_revoke_list_from_teams` | Revoke team access to a list |
+| `lighthouse_crm_update_list_sharing` | Update list sharing scope |
+
+### Notes
+
+Notes can be linked to multiple records at once (via the `records` map). After creation, use the link/unlink tools to add or remove associations.
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_crm_list_notes` | List notes for a record |
+| `lighthouse_crm_create_note` | Create a note linked to one or more records |
+| `lighthouse_crm_get_note` | Get a single note |
+| `lighthouse_crm_delete_note` | Delete a note |
+| `lighthouse_crm_link_note_record` | Link an existing note to an additional record |
+| `lighthouse_crm_unlink_note_record` | Remove a note's link to a record |
+
+### Tasks
+
+Tasks can be linked to any record type including custom objects. Use the permalink as the key in `records` (e.g., `{"company": [ids], "news": [ids]}`).
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_crm_list_tasks` | List tasks with optional filtering and sorting |
+| `lighthouse_crm_get_task` | Get a single task |
+| `lighthouse_crm_create_task` | Create a task, optionally linked to records |
+| `lighthouse_crm_update_task` | Update a task |
+| `lighthouse_crm_delete_task` | Delete a task |
+
+### Files
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_crm_list_files` | List files attached to a record |
+| `lighthouse_crm_upload_file` | Upload a file and attach it to a record |
+| `lighthouse_crm_download_file` | Download a file |
+| `lighthouse_crm_delete_file` | Delete a file |
+
+### Views
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_crm_list_views` | List saved CRM views |
+| `lighthouse_crm_get_view` | Get a single view |
+| `lighthouse_crm_update_view` | Update a view |
+| `lighthouse_crm_delete_view` | Delete a view |
+| `lighthouse_crm_share_view_with_teams` | Share a view with teams |
+| `lighthouse_crm_revoke_view_from_teams` | Revoke team access to a view |
+| `lighthouse_crm_update_view_sharing` | Update view sharing scope |
+
+### Workspace
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_workspace_me` | Get current authenticated user |
+| `lighthouse_workspace_list_users` | List workspace users |
+| `lighthouse_workspace_get_user` | Get a workspace user |
+| `lighthouse_workspace_list_teams` | List workspace teams |
+| `lighthouse_workspace_get_team` | Get a workspace team |
+
+### Discovery
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_discovery_get_attributes` | Get discovery filter attributes |
+| `lighthouse_discovery_search_companies` | Search the company database |
+| `lighthouse_discovery_search_investors` | Search investors (VC funds, angels, etc.) |
+| `lighthouse_discovery_search_organizations` | Search non-profits, governments, and other organizations |
+| `lighthouse_discovery_search_schools` | Search schools and universities |
+| `lighthouse_discovery_search_people` | Search the people database |
+| `lighthouse_discovery_lookup_by_domain` | Look up companies by domain |
+| `lighthouse_discovery_lookup_by_linkedin` | Look up companies by LinkedIn URL |
+| `lighthouse_discovery_lookup_people_by_linkedin` | Look up people by LinkedIn URL |
+| `lighthouse_discovery_get_saved_searches` | List saved discovery searches |
+| `lighthouse_discovery_get_search_results` | Get results of a saved search |
+| `lighthouse_discovery_get_locations` | Get location filter options |
+| `lighthouse_discovery_get_industries` | Get industry filter options |
+| `lighthouse_discovery_get_tags` | Get tag filter options |
+
+### Reports & Dashboards
+
+| Tool | Description |
+|------|-------------|
+| `lighthouse_reports_list_dashboards` | List dashboards |
+| `lighthouse_reports_create_dashboard` | Create a dashboard |
+| `lighthouse_reports_get_dashboard` | Get a dashboard |
+| `lighthouse_reports_update_dashboard` | Update a dashboard |
+| `lighthouse_reports_delete_dashboard` | Delete a dashboard |
+| `lighthouse_reports_list_widgets` | List widgets in a dashboard |
+| `lighthouse_reports_create_widget` | Create a widget |
+| `lighthouse_reports_update_widget` | Update a widget |
+| `lighthouse_reports_delete_widget` | Delete a widget |
+| `lighthouse_reports_get_widget_data` | Get widget data |
+| `lighthouse_reports_share_dashboard_with_teams` | Share a dashboard with teams |
+| `lighthouse_reports_revoke_dashboard_from_teams` | Revoke team access to a dashboard |
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `LIGHTHOUSE_API_KEY` | Yes | Your Lighthouse API key |
+| `LIGHTHOUSE_API_URL` | No | Override API base URL (default: `https://api.trylighthouse.vc`) |

package/build/api.d.ts

@@ -0,0 +1,38 @@
+export declare class LighthouseAPI {
+    private baseUrl;
+    private apiKey;
+    private currentTool;
+    constructor(apiKey?: string);
+    setCurrentTool(toolName: string | null): void;
+    private request;
+    get(path: string, params?: Record<string, unknown>): Promise<{
+        status: number;
+        data: unknown;
+        error: unknown;
+        meta?: unknown;
+    }>;
+    post(path: string, body?: Record<string, unknown>): Promise<{
+        status: number;
+        data: unknown;
+        error: unknown;
+        meta?: unknown;
+    }>;
+    patch(path: string, body?: Record<string, unknown>): Promise<{
+        status: number;
+        data: unknown;
+        error: unknown;
+        meta?: unknown;
+    }>;
+    put(path: string, body?: Record<string, unknown>): Promise<{
+        status: number;
+        data: unknown;
+        error: unknown;
+        meta?: unknown;
+    }>;
+    delete(path: string, body?: Record<string, unknown>): Promise<{
+        status: number;
+        data: unknown;
+        error: unknown;
+        meta?: unknown;
+    }>;
+}

package/build/api.js

@@ -0,0 +1,59 @@
+const DEFAULT_BASE_URL = "https://api.trylighthouse.vc";
+export class LighthouseAPI {
+    baseUrl;
+    apiKey;
+    currentTool = null;
+    constructor(apiKey) {
+        const key = apiKey || process.env.LIGHTHOUSE_API_KEY;
+        if (!key) {
+            throw new Error("LIGHTHOUSE_API_KEY environment variable is required. " +
+                "Generate one at Settings → API Keys in Lighthouse.");
+        }
+        this.apiKey = key;
+        this.baseUrl = (process.env.LIGHTHOUSE_API_URL || DEFAULT_BASE_URL).replace(/\/$/, "");
+    }
+    setCurrentTool(toolName) {
+        this.currentTool = toolName;
+    }
+    async request(method, path, body) {
+        const versioned = (/^\/v\d+\//.test(path) || path.startsWith("/mcp/")) ? path : `/v1${path}`;
+        const url = `${this.baseUrl}${versioned}`;
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json",
+            "X-Lighthouse-Origin": "mcp",
+        };
+        if (this.currentTool) {
+            headers["X-Lighthouse-MCP-Tool"] = this.currentTool;
+        }
+        const res = await fetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        const json = await res.json();
+        return json;
+    }
+    async get(path, params) {
+        const qs = params
+            ? "?" +
+                Object.entries(params)
+                    .filter(([, v]) => v !== undefined && v !== null)
+                    .map(([k, v]) => `${k}=${encodeURIComponent(typeof v === "object" ? JSON.stringify(v) : String(v))}`)
+                    .join("&")
+            : "";
+        return this.request("GET", path + qs);
+    }
+    async post(path, body) {
+        return this.request("POST", path, body);
+    }
+    async patch(path, body) {
+        return this.request("PATCH", path, body);
+    }
+    async put(path, body) {
+        return this.request("PUT", path, body);
+    }
+    async delete(path, body) {
+        return this.request("DELETE", path, body);
+    }
+}

package/build/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export { createServer } from "./server.js";
+export { LighthouseAPI } from "./api.js";

package/build/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createServer as createHttpServer } from "node:http";
+import { createServer } from "./server.js";
+export { createServer } from "./server.js";
+export { LighthouseAPI } from "./api.js";
+async function main() {
+    const port = process.env.PORT;
+    if (port) {
+        const sessions = new Map();
+        const httpServer = createHttpServer(async (req, res) => {
+            res.setHeader("Access-Control-Allow-Origin", "*");
+            res.setHeader("Access-Control-Allow-Headers", "Content-Type, mcp-session-id");
+            res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+            res.setHeader("Access-Control-Expose-Headers", "mcp-session-id");
+            if (req.method === "OPTIONS") {
+                res.writeHead(204);
+                res.end();
+                return;
+            }
+            if (req.url === "/health") {
+                res.writeHead(200, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ status: "ok" }));
+                return;
+            }
+            const parsedUrl = new URL(req.url || "/", `http://localhost:${port}`);
+            if (parsedUrl.pathname !== "/mcp") {
+                res.writeHead(404);
+                res.end("Not found. Use /mcp");
+                return;
+            }
+            const apiKey = parsedUrl.searchParams.get("api_key");
+            if (!apiKey) {
+                res.writeHead(401, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Missing api_key query parameter" }));
+                return;
+            }
+            const sessionId = req.headers["mcp-session-id"];
+            if (sessionId && sessions.has(sessionId)) {
+                const session = sessions.get(sessionId);
+                if (session.apiKey !== apiKey) {
+                    res.writeHead(403, { "Content-Type": "application/json" });
+                    res.end(JSON.stringify({ error: "This session belongs to a different api_key" }));
+                    return;
+                }
+                await session.transport.handleRequest(req, res);
+                return;
+            }
+            if (req.method === "POST") {
+                const mcpServer = createServer(apiKey);
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => crypto.randomUUID(),
+                });
+                transport.onclose = () => {
+                    const sid = transport.sessionId;
+                    if (sid)
+                        sessions.delete(sid);
+                };
+                await mcpServer.connect(transport);
+                await transport.handleRequest(req, res);
+                const sid = transport.sessionId;
+                if (sid) {
+                    sessions.set(sid, { server: mcpServer, transport, apiKey });
+                }
+            }
+            else {
+                res.writeHead(405);
+                res.end("Method not allowed. Send POST to start a session");
+            }
+        });
+        httpServer.listen(Number(port), () => {
+            console.error(`Lighthouse MCP server running on http://0.0.0.0:${port}/mcp`);
+        });
+    }
+    else {
+        const server = createServer();
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        console.error("Lighthouse MCP server running on stdio");
+    }
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/build/leanDiscovery.d.ts

@@ -0,0 +1,11 @@
+export declare function leanCompany(item: unknown): unknown;
+export declare function leanPerson(item: unknown): unknown;
+type DiscoveryType = "company" | "person";
+export declare function leanItems(items: unknown, type: DiscoveryType): unknown;
+export declare function leanDiscovery(res: {
+    status?: number;
+    data?: unknown;
+    error?: unknown;
+    meta?: unknown;
+} | null | undefined, type: DiscoveryType | "auto"): typeof res;
+export {};

package/build/leanDiscovery.js

@@ -0,0 +1,93 @@
+const COMPANY_DROP = ["growth_metrics", "growth_metrics_v2", "workforce_data", "signals", "signals_v2"];
+const PERSON_DROP = ["signals", "signals_v2"];
+const COMPANY_ASSOCIATED_PEOPLE_CAP = 10;
+const PERSON_ASSOCIATED_COMPANIES_CAP = 10;
+const PERSON_EDUCATION_CAP = 8;
+function isPlainObject(v) {
+    return v != null && typeof v === "object" && !Array.isArray(v);
+}
+function capArray(value, cap) {
+    return Array.isArray(value) ? value.slice(0, cap) : value;
+}
+export function leanCompany(item) {
+    if (!isPlainObject(item))
+        return item;
+    const lean = { ...item };
+    for (const key of COMPANY_DROP)
+        delete lean[key];
+    if ("associated_people" in lean) {
+        lean.associated_people = capArray(lean.associated_people, COMPANY_ASSOCIATED_PEOPLE_CAP);
+    }
+    return lean;
+}
+export function leanPerson(item) {
+    if (!isPlainObject(item))
+        return item;
+    const lean = { ...item };
+    for (const key of PERSON_DROP)
+        delete lean[key];
+    if ("associated_companies" in lean) {
+        lean.associated_companies = capArray(lean.associated_companies, PERSON_ASSOCIATED_COMPANIES_CAP);
+    }
+    if ("education" in lean) {
+        lean.education = capArray(lean.education, PERSON_EDUCATION_CAP);
+    }
+    return lean;
+}
+export function leanItems(items, type) {
+    if (!Array.isArray(items))
+        return items;
+    const project = type === "person" ? leanPerson : leanCompany;
+    return items.map((item) => project(item));
+}
+function inferType(item) {
+    if ("associated_companies" in item ||
+        "education" in item ||
+        "founder_score" in item ||
+        "first_name" in item ||
+        "last_name" in item) {
+        return "person";
+    }
+    return "company";
+}
+function leanOne(item, type) {
+    if (!isPlainObject(item))
+        return item;
+    const t = type ?? inferType(item);
+    return t === "person" ? leanPerson(item) : leanCompany(item);
+}
+export function leanDiscovery(res, type) {
+    if (!res || res.error)
+        return res;
+    const t = type === "auto" ? undefined : type;
+    const data = res.data;
+    if (Array.isArray(data)) {
+        return { ...res, data: data.map((item) => leanOne(item, t)) };
+    }
+    if (isPlainObject(data)) {
+        const next = { ...data };
+        let touched = false;
+        if (Array.isArray(next.items)) {
+            const itemType = next.type === "company" || next.type === "person" ? next.type : t;
+            next.items = next.items.map((item) => leanOne(item, itemType));
+            touched = true;
+        }
+        if (Array.isArray(next.results)) {
+            next.results = next.results.map((item) => leanOne(item, t));
+            touched = true;
+        }
+        if (Array.isArray(next.companies)) {
+            next.companies = next.companies.map((item) => leanOne(item, "company"));
+            touched = true;
+        }
+        if (Array.isArray(next.people)) {
+            next.people = next.people.map((item) => leanOne(item, "person"));
+            touched = true;
+        }
+        if (!touched) {
+            return { ...res, data: leanOne(data, t) };
+        }
+        return { ...res, data: next };
+    }
+    return res;
+}

package/build/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function createServer(apiKey?: string): McpServer;