mcp-server-andru-intelligence 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andru (H&S)
+
+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.

package/README.md

@@ -0,0 +1,99 @@
+# Andru Revenue Intelligence MCP Server
+
+Strategic revenue intelligence for technical SaaS founders. ICP scoring, persona profiling, competitive positioning, buyer journey mapping, and pre-meeting briefs — powered by 20 years of B2B sales wisdom.
+
+## Installation
+
+```bash
+npm install -g @andru/mcp-server-intelligence
+```
+
+Or run directly:
+
+```bash
+ANDRU_API_KEY=sk_live_... npx @andru/mcp-server-intelligence
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `ANDRU_API_KEY` | Yes | — | Your Andru Platform API key |
+| `ANDRU_API_URL` | No | `https://api.andru.ai` | API base URL |
+
+Get your API key at [app.andru.ai/settings/api-keys](https://app.andru.ai/settings/api-keys).
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "andru-intelligence": {
+      "command": "npx",
+      "args": ["@andru/mcp-server-intelligence"],
+      "env": {
+        "ANDRU_API_KEY": "sk_live_your_key_here"
+      }
+    }
+  }
+}
+```
+
+### Claude Code
+
+```bash
+claude mcp add andru-intelligence npx @andru/mcp-server-intelligence \
+  --env ANDRU_API_KEY=sk_live_your_key_here
+```
+
+## Available Tools
+
+| Tool | Description | Latency |
+|------|-------------|---------|
+| `get_icp_fit_score` | Score a company against your ICP criteria | <100ms |
+| `get_persona_profile` | Look up buyer persona from ICP data | <50ms |
+| `get_disqualification_signals` | 3-layer opportunity classification | <200ms |
+| `get_messaging_framework` | MBTI-adapted messaging frameworks | <50ms |
+| `get_competitive_positioning` | Competitive battlecards and positioning | <100ms |
+| `classify_opportunity` | Full opportunity classification | <200ms |
+| `get_account_plan` | Structured account plan with MEDDICC | <100ms |
+| `get_capability_profile` | Machine-readable capability profile | <50ms |
+| `get_evaluation_criteria` | 6-value alignment scoring | <100ms |
+| `get_icp_profile` | Full Pure Signal ICP profile (5 layers) | <100ms |
+| `discover_prospects` | AI-powered prospect discovery | 15-30s |
+| `get_pre_brief` | Pre-meeting brief with talk track | 10-20s |
+| `get_syndication_status` | CRM syndication status | <200ms |
+| `trigger_syndication` | Trigger CRM syndication | 5-15s |
+| `batch_fit_score` | Batch score up to 50 companies | <500ms |
+
+## Available Resources
+
+| URI | Description |
+|-----|-------------|
+| `andru://icp/profile` | Canonical ICP profile |
+| `andru://pipeline/runs` | Pipeline run summaries |
+| `andru://accounts` | Account and prospect data |
+
+## How It Works
+
+This MCP server is a thin proxy that authenticates with your Andru API key and forwards tool/resource requests to the Andru backend. All intelligence generation, ICP scoring, and data access happens server-side — the MCP server itself is stateless.
+
+```
+Claude Desktop/Code  →  MCP Server (stdio)  →  Andru API (HTTPS)
+```
+
+## A2A Protocol
+
+Andru also supports the Agent-to-Agent (A2A) protocol for direct agent-to-agent communication. The AgentCard is available at:
+
+```
+https://api.andru.ai/.well-known/agent.json
+```
+
+## License
+
+MIT

package/glama.json

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

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "mcp-server-andru-intelligence",
+  "version": "0.1.0",
+  "description": "Andru Revenue Intelligence MCP Server — ICP scoring, persona profiling, competitive positioning, and buyer intelligence for technical SaaS founders.",
+  "type": "module",
+  "bin": {
+    "andru-mcp": "./src/index.js"
+  },
+  "main": "./src/index.js",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "mcp-server",
+    "andru",
+    "revenue-intelligence",
+    "icp",
+    "buyer-intelligence",
+    "sales-intelligence",
+    "gtm",
+    "b2b",
+    "saas"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "author": "Andru (H&S)",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/geter-andru/mcp-server-andru-intelligence.git"
+  },
+  "homepage": "https://andru.ai",
+  "bugs": {
+    "url": "https://github.com/geter-andru/mcp-server-andru-intelligence/issues"
+  }
+}

package/server.json

@@ -0,0 +1,35 @@
+{
+  "name": "andru-intelligence",
+  "title": "Andru Revenue Intelligence",
+  "description": "Strategic revenue intelligence for technical SaaS founders. ICP scoring, persona profiling, competitive positioning, buyer journey mapping, champion selling, and pre-meeting briefs — powered by 20 years of B2B sales wisdom.",
+  "version": "0.1.0",
+  "websiteUrl": "https://andru.ai",
+  "repository": {
+    "url": "https://github.com/geter-andru/mcp-server-andru-intelligence.git",
+    "source": "github"
+  },
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "mcp-server-andru-intelligence",
+      "version": "0.1.0",
+      "transport": {
+        "type": "stdio"
+      },
+      "environmentVariables": [
+        {
+          "name": "ANDRU_API_KEY",
+          "description": "Your Andru Platform API key. Get one at https://app.andru.ai/settings/api-keys",
+          "isRequired": true,
+          "isSecret": true
+        },
+        {
+          "name": "ANDRU_API_URL",
+          "description": "Andru API base URL (default: https://api.andru.ai)",
+          "isRequired": false,
+          "default": "https://api.andru.ai"
+        }
+      ]
+    }
+  ]
+}

package/src/client.js

@@ -0,0 +1,98 @@
+/**
+ * Andru API Client
+ *
+ * Thin HTTP client that proxies MCP operations to the Andru backend.
+ * Authenticates via X-API-Key header.
+ */
+
+const DEFAULT_API_URL = 'https://api.andru.ai';
+const REQUEST_TIMEOUT_MS = 60_000; // 60s for AI-calling tools
+const PACKAGE_VERSION = '0.1.0';
+
+export class AndruClient {
+  /**
+   * @param {string} apiKey - Andru Platform API key
+   * @param {string} [baseUrl] - API base URL (default: https://api.andru.ai)
+   */
+  constructor(apiKey, baseUrl = DEFAULT_API_URL) {
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/+$/, ''); // Strip trailing slashes
+  }
+
+  /**
+   * List all available MCP tools.
+   * @returns {Promise<{ tools: Array<{ name: string, description: string, inputSchema: object }> }>}
+   */
+  async listTools() {
+    return this.post('/api/mcp/tools/list', {});
+  }
+
+  /**
+   * Execute an MCP tool.
+   * @param {string} name - Tool name
+   * @param {object} args - Tool arguments
+   * @returns {Promise<{ content: Array<{ type: string, text: string }>, isError?: boolean }>}
+   */
+  async callTool(name, args) {
+    return this.post('/api/mcp/tools/call', { tool: name, arguments: args });
+  }
+
+  /**
+   * List all available MCP resources.
+   * @returns {Promise<{ resources: Array<{ uri: string, name: string, description: string, mimeType: string }> }>}
+   */
+  async listResources() {
+    return this.post('/api/mcp/resources/list', {});
+  }
+
+  /**
+   * Read an MCP resource by URI.
+   * @param {string} uri - Resource URI (e.g., "andru://icp/profile")
+   * @returns {Promise<{ contents: Array<{ uri: string, mimeType: string, text: string }> }>}
+   */
+  async readResource(uri) {
+    return this.post('/api/mcp/resources/read', { uri });
+  }
+
+  /**
+   * @private
+   */
+  async post(path, body) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-Key': this.apiKey,
+          'User-Agent': `andru-mcp-server/${PACKAGE_VERSION}`,
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        const errorBody = await response.text().catch(() => '');
+        let errorMessage;
+        try {
+          const parsed = JSON.parse(errorBody);
+          errorMessage = parsed.error || parsed.message || `HTTP ${response.status}`;
+        } catch {
+          errorMessage = `HTTP ${response.status}: ${errorBody.slice(0, 200)}`;
+        }
+        throw new Error(errorMessage);
+      }
+
+      return await response.json();
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        throw new Error(`Request to ${path} timed out after ${REQUEST_TIMEOUT_MS / 1000}s`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+}

package/src/index.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+/**
+ * Andru Revenue Intelligence MCP Server
+ *
+ * Standalone entry point for use with Claude Desktop, Claude Code,
+ * or any MCP-compatible client.
+ *
+ * Environment variables:
+ *   ANDRU_API_KEY  (required) — Your Andru Platform API key
+ *   ANDRU_API_URL  (optional) — API base URL (default: https://api.andru.ai)
+ *
+ * Usage:
+ *   ANDRU_API_KEY=sk_live_... npx @andru/mcp-server-intelligence
+ *
+ * Claude Desktop config (claude_desktop_config.json):
+ *   {
+ *     "mcpServers": {
+ *       "andru-intelligence": {
+ *         "command": "npx",
+ *         "args": ["@andru/mcp-server-intelligence"],
+ *         "env": {
+ *           "ANDRU_API_KEY": "sk_live_your_key_here"
+ *         }
+ *       }
+ *     }
+ *   }
+ */
+
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { AndruClient } from './client.js';
+import { createServer } from './server.js';
+
+const apiKey = process.env.ANDRU_API_KEY;
+
+if (!apiKey) {
+  console.error('[Andru MCP] Error: ANDRU_API_KEY environment variable is required');
+  console.error('[Andru MCP] Get your API key at https://app.andru.ai/settings/api-keys');
+  process.exit(1);
+}
+
+const apiUrl = process.env.ANDRU_API_URL || 'https://api.andru.ai';
+
+const client = new AndruClient(apiKey, apiUrl);
+const server = createServer(client);
+const transport = new StdioServerTransport();
+
+await server.connect(transport);
+
+console.error('[Andru MCP] Server running on stdio transport');
+console.error(`[Andru MCP] API endpoint: ${apiUrl}`);

package/src/server.js

@@ -0,0 +1,93 @@
+/**
+ * Andru MCP Server (Thin Proxy)
+ *
+ * Creates an MCP server that proxies all tool and resource requests
+ * to the Andru backend API via the AndruClient.
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+/**
+ * Create an MCP server backed by the Andru API.
+ *
+ * @param {import('./client.js').AndruClient} client
+ * @returns {Server}
+ */
+export function createServer(client) {
+  const server = new Server(
+    {
+      name: 'andru-intelligence',
+      version: '0.1.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {},
+      },
+    }
+  );
+
+  // --- Tool handlers (proxy to backend) ---
+
+  server.setRequestHandler(
+    ListToolsRequestSchema,
+    async () => {
+      const result = await client.listTools();
+      return { tools: result.tools };
+    }
+  );
+
+  server.setRequestHandler(
+    CallToolRequestSchema,
+    async (request) => {
+      const { name, arguments: args } = request.params;
+      try {
+        return await client.callTool(name, args || {});
+      } catch (error) {
+        return {
+          content: [{
+            type: 'text',
+            text: JSON.stringify({ error: error.message }),
+          }],
+          isError: true,
+        };
+      }
+    }
+  );
+
+  // --- Resource handlers (proxy to backend) ---
+
+  server.setRequestHandler(
+    ListResourcesRequestSchema,
+    async () => {
+      const result = await client.listResources();
+      return { resources: result.resources };
+    }
+  );
+
+  server.setRequestHandler(
+    ReadResourceRequestSchema,
+    async (request) => {
+      const { uri } = request.params;
+      try {
+        return await client.readResource(uri);
+      } catch (error) {
+        return {
+          contents: [{
+            uri,
+            mimeType: 'text/plain',
+            text: JSON.stringify({ error: error.message }),
+          }],
+        };
+      }
+    }
+  );
+
+  return server;
+}