@updately/mcp-server 1.0.1

package/README.md

@@ -0,0 +1,95 @@
+# Updately MCP Server
+
+Model Context Protocol server for **Updately LinkedIn Outreach**. Lets AI assistants (Claude, Gemini, Cursor, etc.) manage your LinkedIn campaigns, contacts, signals, and ICP via natural language.
+
+## Setup
+
+### 1. Install
+```bash
+npm install
+npm run build
+```
+
+### 2. Generate an API Key
+```bash
+curl -X POST https://api.updately.ai/org/api-key/generate \
+  -H "Authorization: Bearer YOUR_ORG_ID" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "MCP Server"}'
+```
+
+### 3. Configure your IDE
+
+**Claude Desktop / Cursor** — add to your MCP config:
+```json
+{
+  "mcpServers": {
+    "updately": {
+      "command": "node",
+      "args": ["/absolute/path/to/updately-mcp-server/build/index.js"],
+      "env": {
+        "UPDATELY_API_KEY": "api_key_your-key-here",
+        "UPDATELY_API_URL": "https://api.updately.ai"
+      }
+    }
+  }
+}
+```
+
+## Available Tools (30)
+
+### Campaigns
+- `list_campaigns` — List all campaigns
+- `get_campaign` — Get campaign details
+- `create_campaign` — Create a campaign
+- `update_campaign_status` — Activate/pause/stop
+- `delete_campaign` — Delete a campaign
+- `get_campaign_stats` — Get metrics (invited, accepted, replied)
+
+### Workflow Steps
+- `list_steps` — List steps in a campaign
+- `upsert_step` — Create/update a step
+- `delete_step` — Delete a step
+
+### Contacts
+- `list_contacts` — List enrolled contacts
+- `enroll_contacts` — Add LinkedIn profiles
+- `remove_contact` — Remove a contact
+
+### Scheduler
+- `run_campaign` — Trigger processing
+- `process_contact` — Process one contact now
+
+### Inbox
+- `get_contact_messages` — Message history for a contact
+- `send_message` — Send a LinkedIn message
+
+### LinkedIn Accounts
+- `list_accounts` — List connected accounts
+- `get_account_usage` — Daily usage stats
+
+### Lead Lists
+- `list_lead_lists` — List all lists
+- `get_leads_in_list` — Get leads in a list
+- `create_lead_list` — Create a list
+
+### Signals
+- `list_signals` — List signals
+- `get_signal` — Get signal details
+- `create_signal` — Create a signal
+- `update_signal` — Update config
+- `run_signal` — Trigger a run
+- `delete_signal` — Delete
+
+### ICP (Ideal Customer Profile)
+- `list_icps` — List ICPs
+- `create_icp` — Create an ICP
+- `update_icp` — Update an ICP
+- `delete_icp` — Delete an ICP
+
+## Development
+
+```bash
+npm run dev          # Watch mode
+npm run inspect      # Test with MCP Inspector
+```

package/build/api-client.d.ts

@@ -0,0 +1,16 @@
+/**
+ * HTTP client wrapper for the Updately backend API.
+ * Sends all requests with the API key as Bearer token.
+ */
+export interface ApiResponse<T> {
+    success: boolean;
+    data: T;
+    message?: string;
+    count?: number;
+}
+export declare function apiGet<T>(path: string): Promise<ApiResponse<T>>;
+export declare function apiPost<T>(path: string, body?: Record<string, unknown>): Promise<ApiResponse<T>>;
+export declare function apiPut<T>(path: string, body?: Record<string, unknown>): Promise<ApiResponse<T>>;
+export declare function apiDelete<T>(path: string): Promise<ApiResponse<T>>;
+/** Format API response as MCP text content */
+export declare function formatResponse(data: unknown): string;

package/build/api-client.js

@@ -0,0 +1,74 @@
+/**
+ * HTTP client wrapper for the Updately backend API.
+ * Sends all requests with the API key as Bearer token.
+ */
+const API_URL = process.env.UPDATELY_API_URL || "https://api.updately.ai";
+const API_KEY = process.env.UPDATELY_API_KEY || "";
+if (!API_KEY) {
+    console.error("[updately-mcp] UPDATELY_API_KEY env var is required.");
+}
+export async function apiGet(path) {
+    const url = `${API_URL}${path}`;
+    const res = await fetch(url, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${API_KEY}`,
+            Accept: "application/json",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`GET ${path} failed: ${res.status} ${res.statusText}`);
+    }
+    return (await res.json());
+}
+export async function apiPost(path, body) {
+    const url = `${API_URL}${path}`;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${API_KEY}`,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        throw new Error(`POST ${path} failed: ${res.status} ${text}`);
+    }
+    return (await res.json());
+}
+export async function apiPut(path, body) {
+    const url = `${API_URL}${path}`;
+    const res = await fetch(url, {
+        method: "PUT",
+        headers: {
+            Authorization: `Bearer ${API_KEY}`,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    if (!res.ok) {
+        throw new Error(`PUT ${path} failed: ${res.status} ${res.statusText}`);
+    }
+    return (await res.json());
+}
+export async function apiDelete(path) {
+    const url = `${API_URL}${path}`;
+    const res = await fetch(url, {
+        method: "DELETE",
+        headers: {
+            Authorization: `Bearer ${API_KEY}`,
+            Accept: "application/json",
+        },
+    });
+    if (!res.ok) {
+        throw new Error(`DELETE ${path} failed: ${res.status} ${res.statusText}`);
+    }
+    return (await res.json());
+}
+/** Format API response as MCP text content */
+export function formatResponse(data) {
+    return JSON.stringify(data, null, 2);
+}

package/build/index.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Updately MCP Server — entry point.
+ *
+ * Exposes LinkedIn outreach management tools (campaigns, contacts, inbox,
+ * signals, ICP, etc.) over the Model Context Protocol via stdio transport.
+ *
+ * Required env vars:
+ *   UPDATELY_API_KEY  — API key generated from the Updately settings
+ *   UPDATELY_API_URL  — Backend URL (default: https://api.updately.ai)
+ */
+export {};

package/build/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * Updately MCP Server — entry point.
+ *
+ * Exposes LinkedIn outreach management tools (campaigns, contacts, inbox,
+ * signals, ICP, etc.) over the Model Context Protocol via stdio transport.
+ *
+ * Required env vars:
+ *   UPDATELY_API_KEY  — API key generated from the Updately settings
+ *   UPDATELY_API_URL  — Backend URL (default: https://api.updately.ai)
+ */
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server.js";
+async function main() {
+    const server = createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("[updately-mcp] Server running on stdio");
+}
+main().catch((err) => {
+    console.error("[updately-mcp] Fatal error:", err);
+    process.exit(1);
+});

package/build/server.d.ts

@@ -0,0 +1,5 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Creates and configures the Updately MCP server with all tools registered.
+ */
+export declare function createServer(): McpServer;

package/build/server.js

@@ -0,0 +1,32 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerCampaignTools } from "./tools/campaigns.js";
+import { registerStepTools } from "./tools/steps.js";
+import { registerContactTools } from "./tools/contacts.js";
+import { registerSchedulerTools } from "./tools/scheduler.js";
+import { registerInboxTools } from "./tools/inbox.js";
+import { registerAccountTools } from "./tools/accounts.js";
+import { registerLeadTools } from "./tools/leads.js";
+import { registerSignalTools } from "./tools/signals.js";
+import { registerIcpTools } from "./tools/icp.js";
+import { registerOutreachTools } from "./tools/outreach.js";
+/**
+ * Creates and configures the Updately MCP server with all tools registered.
+ */
+export function createServer() {
+    const server = new McpServer({
+        name: "updately",
+        version: "1.0.0",
+    });
+    // Register all tool groups
+    registerCampaignTools(server);
+    registerStepTools(server);
+    registerContactTools(server);
+    registerSchedulerTools(server);
+    registerInboxTools(server);
+    registerAccountTools(server);
+    registerLeadTools(server);
+    registerSignalTools(server);
+    registerIcpTools(server);
+    registerOutreachTools(server);
+    return server;
+}

package/build/tools/accounts.d.ts

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

package/build/tools/accounts.js

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { apiGet, formatResponse } from "../api-client.js";
+export function registerAccountTools(server) {
+    server.tool("list_accounts", "List all connected LinkedIn accounts for the org", {}, async () => {
+        const res = await apiGet("/unipile/linkedin/accounts");
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("get_account_usage", "Get daily usage stats for a LinkedIn account — invitations sent, DMs sent, limits", {
+        unipileAccountId: z.string().describe("The LinkedIn account ID"),
+    }, async ({ unipileAccountId }) => {
+        const res = await apiGet(`/unipile/linkedin/accounts/${unipileAccountId}/usage`);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+}

package/build/tools/campaigns.d.ts

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

package/build/tools/campaigns.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiPut, apiDelete, formatResponse } from "../api-client.js";
+export function registerCampaignTools(server) {
+    server.tool("list_campaigns", "List all LinkedIn outreach campaigns for your org", {}, async () => {
+        const res = await apiGet("/campaigns");
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("get_campaign", "Get details of a specific campaign by ID", { campaignId: z.string().describe("The campaign ID") }, async ({ campaignId }) => {
+        const res = await apiGet(`/campaigns/${campaignId}`);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("create_campaign", "Create a new LinkedIn outreach campaign", {
+        name: z.string().describe("Campaign name"),
+        unipileAccountId: z.string().describe("LinkedIn account ID to use"),
+        sourceListId: z.string().optional().describe("Lead list ID to import contacts from"),
+    }, async (args) => {
+        const res = await apiPost("/campaigns", args);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("update_campaign_status", "Activate, pause, or stop a campaign. Valid statuses: ACTIVE, PAUSED, STOPPED", {
+        campaignId: z.string().describe("The campaign ID"),
+        status: z.enum(["ACTIVE", "PAUSED", "STOPPED"]).describe("New status"),
+        force: z.boolean().optional().describe("Force activation even if validation issues exist"),
+    }, async ({ campaignId, status, force }) => {
+        const body = { status };
+        if (force !== undefined)
+            body.force = force;
+        const res = await apiPut(`/campaigns/${campaignId}/status`, body);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("delete_campaign", "Delete a campaign permanently", { campaignId: z.string().describe("The campaign ID") }, async ({ campaignId }) => {
+        const res = await apiDelete(`/campaigns/${campaignId}`);
+        return { content: [{ type: "text", text: res.message || "Campaign deleted" }] };
+    });
+    server.tool("get_campaign_stats", "Get campaign metrics: total contacts, invited, accepted, replied, and acceptance/reply rates", { campaignId: z.string().describe("The campaign ID") }, async ({ campaignId }) => {
+        const res = await apiGet(`/campaigns/${campaignId}/stats`);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+}

package/build/tools/contacts.d.ts

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

package/build/tools/contacts.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiDelete, formatResponse } from "../api-client.js";
+export function registerContactTools(server) {
+    server.tool("list_contacts", "List all contacts enrolled in a campaign, including their status (PENDING, IN_PROGRESS, COMPLETED, REPLIED, ERROR), chatId, and step progress", { campaignId: z.string().describe("The campaign ID") }, async ({ campaignId }) => {
+        const res = await apiGet(`/campaigns/${campaignId}/contacts`);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("enroll_contacts", "Enroll LinkedIn profiles into a campaign. Provide an array of LinkedIn profile URLs. Contacts are deduplicated by slug within the campaign.", {
+        campaignId: z.string().describe("The campaign ID"),
+        linkedinProfileUrls: z
+            .array(z.string())
+            .describe("Array of LinkedIn profile URLs to enroll"),
+    }, async ({ campaignId, linkedinProfileUrls }) => {
+        const res = await apiPost(`/campaigns/${campaignId}/contacts`, {
+            linkedinProfileUrls,
+        });
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("remove_contact", "Remove a contact from a campaign", {
+        campaignId: z.string().describe("The campaign ID"),
+        contactId: z.string().describe("The contact ID to remove"),
+    }, async ({ campaignId, contactId }) => {
+        const res = await apiDelete(`/campaigns/${campaignId}/contacts/${contactId}`);
+        return {
+            content: [{ type: "text", text: res.message || "Contact removed" }],
+        };
+    });
+}

package/build/tools/icp.d.ts

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

package/build/tools/icp.js

@@ -0,0 +1,77 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiPut, apiDelete, formatResponse, } from "../api-client.js";
+export function registerIcpTools(server) {
+    server.tool("list_icps", "List all ICP (Ideal Customer Profile) definitions for the org", {}, async () => {
+        const res = await apiGet("/icp");
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("create_icp", "Create a new ICP (Ideal Customer Profile) to filter and score captured leads", {
+        name: z.string().describe("ICP name (e.g. 'VP Sales at SaaS')"),
+        targetJobTitles: z
+            .array(z.string())
+            .optional()
+            .describe("Job titles to match (e.g. ['VP of Sales', 'Head of Sales'])"),
+        targetIndustries: z
+            .array(z.string())
+            .optional()
+            .describe("Industries (e.g. ['SaaS', 'FinTech'])"),
+        companySizes: z
+            .array(z.string())
+            .optional()
+            .describe("Company sizes (e.g. ['51-200', '201-500'])"),
+        targetLocations: z
+            .array(z.string())
+            .optional()
+            .describe("Locations (e.g. ['United States', 'United Kingdom'])"),
+        companyTypes: z
+            .array(z.string())
+            .optional()
+            .describe("Company types (e.g. ['Startup', 'Enterprise'])"),
+        mandatoryKeywords: z
+            .array(z.string())
+            .optional()
+            .describe("Keywords that MUST appear in the lead's profile"),
+        excludeKeywords: z
+            .array(z.string())
+            .optional()
+            .describe("Keywords that should EXCLUDE a lead"),
+        excludeServiceProviders: z
+            .boolean()
+            .optional()
+            .describe("Exclude consultants/agencies"),
+        excludeOpenToWork: z
+            .boolean()
+            .optional()
+            .describe("Exclude people with 'Open to Work' badge"),
+        additionalCriteria: z
+            .string()
+            .optional()
+            .describe("Free-text additional filtering criteria"),
+        leadMatchingMode: z
+            .enum(["DISCOVERY", "STRICT"])
+            .optional()
+            .describe("DISCOVERY = broader match, STRICT = exact match"),
+    }, async (args) => {
+        const res = await apiPost("/icp", args);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("update_icp", "Update an existing ICP profile", {
+        icpId: z.string().describe("The ICP ID to update"),
+        name: z.string().optional().describe("Updated name"),
+        targetJobTitles: z.array(z.string()).optional().describe("Updated job titles"),
+        targetIndustries: z.array(z.string()).optional().describe("Updated industries"),
+        companySizes: z.array(z.string()).optional().describe("Updated company sizes"),
+        targetLocations: z.array(z.string()).optional().describe("Updated locations"),
+        mandatoryKeywords: z.array(z.string()).optional().describe("Updated mandatory keywords"),
+        excludeKeywords: z.array(z.string()).optional().describe("Updated exclude keywords"),
+    }, async ({ icpId, ...body }) => {
+        const res = await apiPut(`/icp/${icpId}`, body);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("delete_icp", "Delete an ICP profile", { icpId: z.string().describe("The ICP ID to delete") }, async ({ icpId }) => {
+        const res = await apiDelete(`/icp/${icpId}`);
+        return {
+            content: [{ type: "text", text: res.message || "ICP deleted" }],
+        };
+    });
+}

package/build/tools/inbox.d.ts

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

package/build/tools/inbox.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+import { apiGet, apiPost, formatResponse } from "../api-client.js";
+export function registerInboxTools(server) {
+    server.tool("get_contact_messages", "Get the full message history for a contact's LinkedIn chat. Use the chatId from list_contacts to identify the conversation.", {
+        chatId: z.string().describe("The chat ID (from the contact's chatId field)"),
+    }, async ({ chatId }) => {
+        const res = await apiGet(`/unipile/linkedin/inbox/chats/${chatId}/messages`);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("send_message", "Send a text message to a LinkedIn contact via their chat. First get the chatId from list_contacts.", {
+        chatId: z.string().describe("The chat ID"),
+        message: z.string().describe("The message text to send"),
+    }, async ({ chatId, message }) => {
+        const res = await apiPost(`/unipile/linkedin/inbox/chats/${chatId}/messages`, { message });
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+}

package/build/tools/leads.d.ts

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

package/build/tools/leads.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { apiGet, apiPost, formatResponse } from "../api-client.js";
+export function registerLeadTools(server) {
+    server.tool("list_lead_lists", "List all lead lists for the org. Each list contains captured LinkedIn leads from signals or manual imports.", {}, async () => {
+        const res = await apiGet("/leads/lists");
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("get_leads_in_list", "Get all leads in a specific lead list. Returns LinkedIn profiles with name, title, company, intent, and ICP match info.", {
+        listId: z.string().describe("The lead list ID"),
+    }, async ({ listId }) => {
+        const res = await apiGet(`/leads/lists/${listId}/contacts`);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("create_lead_list", "Create a new empty lead list", {
+        name: z.string().describe("Name for the lead list"),
+    }, async ({ name }) => {
+        const res = await apiPost("/leads/lists", { name });
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+}

package/build/tools/outreach.d.ts

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

package/build/tools/outreach.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { apiPost, formatResponse } from "../api-client.js";
+export function registerOutreachTools(server) {
+    server.tool("reach_out", "Send a LinkedIn message or connection invitation to one or more profiles. " +
+        "Auto-detects connection status: sends a DM if already connected, " +
+        "or a connection invitation with the message as a note if not connected. " +
+        "Auto-picks the org's LinkedIn account if not specified.", {
+        linkedinProfileUrls: z
+            .array(z.string())
+            .describe("Array of LinkedIn profile URLs to reach out to (e.g. ['https://linkedin.com/in/johndoe'])"),
+        message: z
+            .string()
+            .describe("Message text — used as DM (if connected) or invitation note (if not connected, max 300 chars)"),
+        unipileAccountId: z
+            .string()
+            .optional()
+            .describe("LinkedIn account ID to send from (auto-picks the default if omitted)"),
+    }, async ({ linkedinProfileUrls, message, unipileAccountId }) => {
+        const body = {
+            linkedinProfileUrls,
+            message,
+        };
+        if (unipileAccountId)
+            body.unipileAccountId = unipileAccountId;
+        const res = await apiPost("/unipile/linkedin/outreach/reach-out", body);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+}

package/build/tools/scheduler.d.ts

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

package/build/tools/scheduler.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { apiPost, formatResponse } from "../api-client.js";
+export function registerSchedulerTools(server) {
+    server.tool("run_campaign", "Trigger the campaign scheduler to process pending contacts. Executes the next workflow step for each eligible contact.", {
+        campaignId: z.string().describe("The campaign ID"),
+        force: z.boolean().optional().describe("Force-process even if campaign is paused"),
+    }, async ({ campaignId, force }) => {
+        const body = {};
+        if (force !== undefined)
+            body.force = force;
+        const res = await apiPost(`/campaigns/${campaignId}/scheduler/run`, body);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("process_contact", "Process a single specific contact immediately — executes their next pending workflow step right now", {
+        campaignId: z.string().describe("The campaign ID"),
+        contactId: z.string().describe("The contact ID to process"),
+    }, async ({ campaignId, contactId }) => {
+        const res = await apiPost(`/campaigns/${campaignId}/contacts/${contactId}/process`);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+}

package/build/tools/signals.d.ts

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

package/build/tools/signals.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiPut, apiDelete, formatResponse, } from "../api-client.js";
+export function registerSignalTools(server) {
+    server.tool("list_signals", "List all configured signals. Signals auto-capture LinkedIn leads matching keyword groups or job searches.", {}, async () => {
+        const res = await apiGet("/signals");
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("get_signal", "Get detailed configuration of a specific signal", { signalId: z.string().describe("The signal ID") }, async ({ signalId }) => {
+        const res = await apiGet(`/signals/${signalId}`);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("create_signal", "Create a new signal to auto-capture LinkedIn leads. Types: KEYWORD_GROUP (monitors posts matching keywords) or LINKEDIN_JOBS (scrapes job postings for hiring signals).", {
+        name: z.string().describe("Signal name"),
+        type: z
+            .enum(["KEYWORD_GROUP", "LINKEDIN_JOBS"])
+            .describe("Signal type"),
+        listIds: z
+            .array(z.string())
+            .describe("Lead list IDs to fan captured leads into"),
+        // KEYWORD_GROUP fields
+        keywordGroupIds: z
+            .array(z.string())
+            .optional()
+            .describe("Keyword group IDs to monitor (for KEYWORD_GROUP type)"),
+        keywordGroupNames: z
+            .array(z.string())
+            .optional()
+            .describe("Keyword group names (parallel to keywordGroupIds)"),
+        // LINKEDIN_JOBS fields
+        jobTitle: z
+            .string()
+            .optional()
+            .describe("Job title to search (for LINKEDIN_JOBS type, e.g. 'VP of Sales')"),
+        location: z
+            .string()
+            .optional()
+            .describe("Location filter (e.g. 'United Kingdom')"),
+        runFrequencyHours: z
+            .number()
+            .optional()
+            .describe("How often to run in hours (min 24, default 24)"),
+        icpId: z
+            .string()
+            .optional()
+            .describe("ICP profile ID to filter captured leads"),
+        enabled: z.boolean().optional().describe("Enable signal (default: true)"),
+    }, async (args) => {
+        const res = await apiPost("/signals", args);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("update_signal", "Update an existing signal's configuration", {
+        signalId: z.string().describe("The signal ID"),
+        name: z.string().optional().describe("Updated name"),
+        listIds: z.array(z.string()).optional().describe("Updated list IDs"),
+        enabled: z.boolean().optional().describe("Enable/disable"),
+        jobTitle: z.string().optional().describe("Updated job title"),
+        location: z.string().optional().describe("Updated location"),
+        icpId: z.string().optional().describe("Updated ICP ID (use '__none__' to clear)"),
+    }, async ({ signalId, ...body }) => {
+        const res = await apiPut(`/signals/${signalId}`, body);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("run_signal", "Manually trigger a signal run right now. For LINKEDIN_JOBS, scrapes jobs and captures leads. For KEYWORD_GROUP, runs a backfill.", {
+        signalId: z.string().describe("The signal ID"),
+        force: z
+            .boolean()
+            .optional()
+            .describe("Force-run even if signal is disabled"),
+    }, async ({ signalId, force }) => {
+        const path = `/signals/${signalId}/run${force ? "?force=true" : ""}`;
+        const res = await apiPost(path);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("delete_signal", "Delete a signal permanently", { signalId: z.string().describe("The signal ID") }, async ({ signalId }) => {
+        const res = await apiDelete(`/signals/${signalId}`);
+        return {
+            content: [{ type: "text", text: res.message || "Signal deleted" }],
+        };
+    });
+}

package/build/tools/steps.d.ts

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

package/build/tools/steps.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { apiGet, apiPost, apiDelete, formatResponse } from "../api-client.js";
+export function registerStepTools(server) {
+    server.tool("list_steps", "List all workflow steps in a campaign (INVITATION, MESSAGE, etc.)", { campaignId: z.string().describe("The campaign ID") }, async ({ campaignId }) => {
+        const res = await apiGet(`/campaigns/${campaignId}/steps`);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("upsert_step", "Create or update a campaign workflow step. Types: INVITATION (step 1), MESSAGE (follow-ups). Include templateId or inline message/subject.", {
+        campaignId: z.string().describe("The campaign ID"),
+        stepOrder: z.number().describe("Step order (1-based)"),
+        type: z.enum(["INVITATION", "MESSAGE"]).describe("Step type"),
+        templateId: z.string().optional().describe("Template ID to use for this step"),
+        message: z.string().optional().describe("Inline message text (if no templateId)"),
+        subject: z.string().optional().describe("Subject line for InMail (optional)"),
+        delayHours: z.number().optional().describe("Hours to wait before executing this step (after previous step)"),
+    }, async (args) => {
+        const { campaignId, ...body } = args;
+        const res = await apiPost(`/campaigns/${campaignId}/steps`, body);
+        return { content: [{ type: "text", text: formatResponse(res.data) }] };
+    });
+    server.tool("delete_step", "Delete a workflow step from a campaign", {
+        campaignId: z.string().describe("The campaign ID"),
+        stepOrder: z.number().describe("Step order to delete"),
+    }, async ({ campaignId, stepOrder }) => {
+        const res = await apiDelete(`/campaigns/${campaignId}/steps/${stepOrder}`);
+        return { content: [{ type: "text", text: res.message || "Step deleted" }] };
+    });
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@updately/mcp-server",
+  "version": "1.0.1",
+  "description": "MCP server for Updately LinkedIn Outreach — exposes campaign management, contacts, inbox, signals, ICP and more as AI-callable tools.",
+  "type": "module",
+  "main": "./build/index.js",
+  "bin": {
+    "updately-mcp-server": "./build/index.js"
+  },
+  "files": [
+    "build"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node build/index.js",
+    "inspect": "npx @modelcontextprotocol/inspector node build/index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.0",
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}