@aicryptorisk/mcp-server 1.0.0

package/README.md

@@ -0,0 +1,133 @@
+# AI Crypto Risk MCP Server
+
+An MCP (Model Context Protocol) server that provides AI assistants with cryptocurrency risk analysis capabilities.
+
+## Features
+
+- **Token Risk Analysis**: Analyze any crypto token for scam indicators
+- **Deep Research**: Request comprehensive 4-pillar research reports
+- **Multi-Chain Support**: Ethereum, BSC, Polygon, Arbitrum, Base, Solana
+- **Usage Metering**: Built-in API key authentication and usage tracking
+
+## Installation
+
+```bash
+# From npm (when published)
+npm install -g @aicryptorisk/mcp-server
+
+# Or from source
+cd mcp-server
+npm install
+```
+
+## Configuration
+
+### For Claude Desktop
+
+Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on Mac or `%APPDATA%\Claude\claude_desktop_config.json` on Windows):
+
+```json
+{
+  "mcpServers": {
+    "aicryptorisk": {
+      "command": "node",
+      "args": ["/path/to/mcp-server/index.js"],
+      "env": {
+        "AICRYPTORISK_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+### For Claude Code
+
+Add to your project's `.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "aicryptorisk": {
+      "command": "node",
+      "args": ["./mcp-server/index.js"],
+      "env": {
+        "AICRYPTORISK_API_KEY": "your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### `analyze_crypto_risk`
+
+Analyze a token for scam indicators and risk factors.
+
+**Input:**
+- `contract_address` (required): Token contract address
+- `chain` (optional): Blockchain network (default: ethereum)
+- `coin_name` (optional): Name for better context
+
+**Returns:**
+- Risk score (0-100)
+- Risk level (Low/Medium/High/Critical)
+- Red flags and warnings
+- Recommendations
+
+### `request_deep_research`
+
+Request comprehensive 4-pillar analysis (delivered via email).
+
+**Input:**
+- `contract_address` (required): Token contract address
+- `chain` (required): Blockchain network
+- `coin_name` (required): Token name
+- `symbol` (optional): Token symbol
+- `email` (required): Email for report delivery
+
+### `get_supported_chains`
+
+Get list of supported blockchain networks.
+
+## Pricing Tiers
+
+| Tier | Daily Limit | Price |
+|------|-------------|-------|
+| Free | 10 scans | $0 |
+| Pro | 100 scans | $19/mo |
+| Enterprise | Unlimited | Contact us |
+
+Get your API key at: https://aicryptorisk.com/api-keys
+
+## Example Usage
+
+Once configured, you can ask Claude:
+
+> "Analyze this token for scam risk: 0x1234...abcd on ethereum"
+
+> "Research this new memecoin PEPE2 at 0xabc... on BSC and send the report to my@email.com"
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Run locally (dev mode, no auth required)
+npm start
+
+# With auth (production)
+SUPABASE_URL=your-url \
+SUPABASE_SERVICE_ROLE_KEY=your-key \
+AICRYPTORISK_API_KEY=test-key \
+npm start
+```
+
+## Database Setup
+
+Run `schema.sql` in your Supabase SQL editor to create the required tables for API key management and usage tracking.
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { createClient } from "@supabase/supabase-js";
+import crypto from "crypto";
+
+// Configuration from environment
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_SERVICE_ROLE_KEY = process.env.SUPABASE_SERVICE_ROLE_KEY;
+const API_KEY = process.env.AICRYPTORISK_API_KEY;
+const API_BASE_URL = process.env.API_BASE_URL || "https://aicryptorisk.com";
+
+// Initialize Supabase client for auth and usage tracking
+const supabase = SUPABASE_URL && SUPABASE_SERVICE_ROLE_KEY
+  ? createClient(SUPABASE_URL, SUPABASE_SERVICE_ROLE_KEY)
+  : null;
+
+// Supported chains
+const SUPPORTED_CHAINS = {
+  ethereum: "1",
+  bsc: "56",
+  polygon: "137",
+  arbitrum: "42161",
+  base: "8453",
+  solana: "solana",
+};
+
+/**
+ * Validate API key and check usage limits
+ */
+async function validateApiKey(apiKey) {
+  if (!apiKey) {
+    return { valid: false, error: "API key required. Get one at https://aicryptorisk.com/api-keys" };
+  }
+
+  if (!supabase) {
+    // Local development mode - accept any key
+    console.error("[MCP] Warning: Supabase not configured, skipping auth");
+    return { valid: true, userId: "dev-mode", tier: "unlimited" };
+  }
+
+  try {
+    // Check API key in database
+    const { data: keyData, error } = await supabase
+      .from("api_keys")
+      .select("id, user_id, tier, calls_today, daily_limit, is_active")
+      .eq("key_hash", hashApiKey(apiKey))
+      .single();
+
+    if (error || !keyData) {
+      return { valid: false, error: "Invalid API key" };
+    }
+
+    if (!keyData.is_active) {
+      return { valid: false, error: "API key is disabled" };
+    }
+
+    if (keyData.daily_limit && keyData.calls_today >= keyData.daily_limit) {
+      return {
+        valid: false,
+        error: `Daily limit reached (${keyData.daily_limit} calls). Upgrade at https://aicryptorisk.com/pricing`
+      };
+    }
+
+    return {
+      valid: true,
+      userId: keyData.user_id,
+      tier: keyData.tier,
+      keyId: keyData.id
+    };
+  } catch (err) {
+    console.error("[MCP] Auth error:", err.message);
+    return { valid: false, error: "Authentication service unavailable" };
+  }
+}
+
+/**
+ * Hash API key for secure storage lookup (SHA-256)
+ */
+function hashApiKey(key) {
+  return crypto.createHash("sha256").update(key).digest("hex");
+}
+
+/**
+ * Track API usage for billing
+ */
+async function trackUsage(keyId, tool, success) {
+  if (!supabase || !keyId) return;
+
+  try {
+    // Increment daily counter
+    await supabase.rpc("increment_api_calls", { key_id: keyId });
+
+    // Log detailed usage
+    await supabase.from("api_usage_log").insert({
+      api_key_id: keyId,
+      tool_name: tool,
+      success,
+      timestamp: new Date().toISOString(),
+    });
+  } catch (err) {
+    console.error("[MCP] Usage tracking error:", err.message);
+  }
+}
+
+/**
+ * Analyze a crypto token for risk indicators
+ */
+async function analyzeToken(contractAddress, chain, coinName) {
+  const chainId = SUPPORTED_CHAINS[chain.toLowerCase()] || chain;
+
+  try {
+    // Call our MCP-specific API endpoint (uses API key auth)
+    const response = await fetch(`${API_BASE_URL}/api/scam-likely/mcp`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY,
+      },
+      body: JSON.stringify({
+        contractAddress,
+        chainId,
+        coinName: coinName || undefined,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`API error: ${response.status} - ${error}`);
+    }
+
+    return await response.json();
+  } catch (err) {
+    throw new Error(`Failed to analyze token: ${err.message}`);
+  }
+}
+
+/**
+ * Request deep research on a token (async, results sent via email)
+ */
+async function requestDeepResearch(contractAddress, chain, coinName, symbol, email) {
+  try {
+    const response = await fetch(`${API_BASE_URL}/api/scam-likely/research`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        contractAddress,
+        chain,
+        coinName,
+        symbol,
+        email,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Research API error: ${response.status} - ${error}`);
+    }
+
+    return await response.json();
+  } catch (err) {
+    throw new Error(`Failed to request research: ${err.message}`);
+  }
+}
+
+// Create MCP server
+const server = new Server(
+  {
+    name: "aicryptorisk",
+    version: "1.0.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      {
+        name: "analyze_crypto_risk",
+        description: `Analyze a cryptocurrency token for scam indicators and risk factors.
+
+Returns a comprehensive risk analysis including:
+- Overall risk score (0-100, higher = more risky)
+- Risk level (Low/Medium/High/Critical)
+- On-chain risk indicators (honeypot, ownership, liquidity)
+- Specific red flags and warnings
+- Actionable recommendations
+
+Supports Ethereum, BSC, Polygon, Arbitrum, Base, and Solana.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            contract_address: {
+              type: "string",
+              description: "The token contract address to analyze",
+            },
+            chain: {
+              type: "string",
+              enum: ["ethereum", "bsc", "polygon", "arbitrum", "base", "solana"],
+              description: "The blockchain network (default: ethereum)",
+            },
+            coin_name: {
+              type: "string",
+              description: "Optional: Name of the coin for better context",
+            },
+          },
+          required: ["contract_address"],
+        },
+      },
+      {
+        name: "request_deep_research",
+        description: `Request comprehensive 4-pillar research on a cryptocurrency token.
+
+This triggers an in-depth analysis covering:
+1. On-Chain Analysis - Contract security, liquidity, holder distribution
+2. Social Media Intelligence - Community sentiment, influencer activity
+3. Institutional Interest - VC backing, exchange listings, partnerships
+4. Off-Chain Intelligence - Team background, legal status, news
+
+Results are delivered via email within 5-10 minutes.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            contract_address: {
+              type: "string",
+              description: "The token contract address to research",
+            },
+            chain: {
+              type: "string",
+              enum: ["ethereum", "bsc", "polygon", "arbitrum", "base", "solana"],
+              description: "The blockchain network",
+            },
+            coin_name: {
+              type: "string",
+              description: "Name of the coin",
+            },
+            symbol: {
+              type: "string",
+              description: "Token symbol (e.g., ETH, BTC)",
+            },
+            email: {
+              type: "string",
+              description: "Email address to receive the research report",
+            },
+          },
+          required: ["contract_address", "chain", "coin_name", "email"],
+        },
+      },
+      {
+        name: "get_supported_chains",
+        description: "Get list of supported blockchain networks for token analysis",
+        inputSchema: {
+          type: "object",
+          properties: {},
+        },
+      },
+    ],
+  };
+});
+
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  // Validate API key
+  const auth = await validateApiKey(API_KEY);
+  if (!auth.valid) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: auth.error }, null, 2),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  try {
+    let result;
+
+    switch (name) {
+      case "analyze_crypto_risk": {
+        const { contract_address, chain = "ethereum", coin_name } = args;
+
+        if (!contract_address) {
+          throw new Error("contract_address is required");
+        }
+
+        result = await analyzeToken(contract_address, chain, coin_name);
+        await trackUsage(auth.keyId, "analyze_crypto_risk", true);
+        break;
+      }
+
+      case "request_deep_research": {
+        const { contract_address, chain, coin_name, symbol, email } = args;
+
+        if (!contract_address || !chain || !coin_name || !email) {
+          throw new Error("contract_address, chain, coin_name, and email are required");
+        }
+
+        result = await requestDeepResearch(contract_address, chain, coin_name, symbol, email);
+        await trackUsage(auth.keyId, "request_deep_research", true);
+        break;
+      }
+
+      case "get_supported_chains": {
+        result = {
+          chains: Object.keys(SUPPORTED_CHAINS),
+          details: {
+            ethereum: { chainId: "1", name: "Ethereum Mainnet" },
+            bsc: { chainId: "56", name: "BNB Smart Chain" },
+            polygon: { chainId: "137", name: "Polygon" },
+            arbitrum: { chainId: "42161", name: "Arbitrum One" },
+            base: { chainId: "8453", name: "Base" },
+            solana: { chainId: "solana", name: "Solana" },
+          },
+        };
+        break;
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    await trackUsage(auth.keyId, name, false);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: error.message }, null, 2),
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start the server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[MCP] AI Crypto Risk server running");
+}
+
+main().catch((error) => {
+  console.error("[MCP] Fatal error:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@aicryptorisk/mcp-server",
+  "version": "1.0.0",
+  "description": "MCP Server for AI Crypto Risk Analysis - Analyze tokens for scam indicators",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "aicryptorisk-mcp": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "setup": "node setup.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@supabase/supabase-js": "^2.58.0"
+  },
+  "keywords": [
+    "mcp",
+    "crypto",
+    "risk",
+    "scam",
+    "analysis",
+    "ai",
+    "claude"
+  ],
+  "author": "AICryptoRisk",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/djangamane/montecrypto"
+  },
+  "homepage": "https://aicryptorisk.com"
+}

package/schema.sql

@@ -0,0 +1,89 @@
+-- API Keys table for MCP server authentication
+-- Run this in your Supabase SQL editor
+
+-- API Keys table
+CREATE TABLE IF NOT EXISTS api_keys (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  user_id UUID NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  key_hash TEXT NOT NULL UNIQUE,
+  key_prefix TEXT NOT NULL, -- First 8 chars for display (e.g., "acr_1a2b...")
+  name TEXT NOT NULL DEFAULT 'Default',
+  tier TEXT NOT NULL DEFAULT 'free', -- free, pro, enterprise
+  daily_limit INTEGER DEFAULT 10, -- null = unlimited
+  calls_today INTEGER DEFAULT 0,
+  calls_total INTEGER DEFAULT 0,
+  is_active BOOLEAN DEFAULT true,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  last_used_at TIMESTAMPTZ,
+  last_reset_at DATE DEFAULT CURRENT_DATE
+);
+
+-- Usage log for billing and analytics
+CREATE TABLE IF NOT EXISTS api_usage_log (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  api_key_id UUID REFERENCES api_keys(id) ON DELETE SET NULL,
+  tool_name TEXT NOT NULL,
+  success BOOLEAN NOT NULL,
+  timestamp TIMESTAMPTZ DEFAULT NOW(),
+  metadata JSONB DEFAULT '{}'
+);
+
+-- Index for fast lookups
+CREATE INDEX IF NOT EXISTS idx_api_keys_hash ON api_keys(key_hash);
+CREATE INDEX IF NOT EXISTS idx_api_keys_user ON api_keys(user_id);
+CREATE INDEX IF NOT EXISTS idx_usage_log_key ON api_usage_log(api_key_id);
+CREATE INDEX IF NOT EXISTS idx_usage_log_timestamp ON api_usage_log(timestamp);
+
+-- Function to increment API calls (atomic)
+CREATE OR REPLACE FUNCTION increment_api_calls(key_id UUID)
+RETURNS void AS $$
+BEGIN
+  UPDATE api_keys
+  SET
+    calls_today = CASE
+      WHEN last_reset_at < CURRENT_DATE THEN 1
+      ELSE calls_today + 1
+    END,
+    calls_total = calls_total + 1,
+    last_used_at = NOW(),
+    last_reset_at = CURRENT_DATE
+  WHERE id = key_id;
+END;
+$$ LANGUAGE plpgsql;
+
+-- RLS Policies
+ALTER TABLE api_keys ENABLE ROW LEVEL SECURITY;
+ALTER TABLE api_usage_log ENABLE ROW LEVEL SECURITY;
+
+-- Users can only see their own API keys
+CREATE POLICY "Users can view own api_keys" ON api_keys
+  FOR SELECT USING (auth.uid() = user_id);
+
+CREATE POLICY "Users can insert own api_keys" ON api_keys
+  FOR INSERT WITH CHECK (auth.uid() = user_id);
+
+CREATE POLICY "Users can update own api_keys" ON api_keys
+  FOR UPDATE USING (auth.uid() = user_id);
+
+CREATE POLICY "Users can delete own api_keys" ON api_keys
+  FOR DELETE USING (auth.uid() = user_id);
+
+-- Users can view their own usage
+CREATE POLICY "Users can view own usage" ON api_usage_log
+  FOR SELECT USING (
+    api_key_id IN (SELECT id FROM api_keys WHERE user_id = auth.uid())
+  );
+
+-- Service role can do everything (for the MCP server)
+CREATE POLICY "Service role full access api_keys" ON api_keys
+  FOR ALL USING (auth.role() = 'service_role');
+
+CREATE POLICY "Service role full access usage" ON api_usage_log
+  FOR ALL USING (auth.role() = 'service_role');
+
+-- Tier configurations (for reference)
+COMMENT ON TABLE api_keys IS 'Tier limits:
+  - free: 10 calls/day
+  - pro: 100 calls/day
+  - enterprise: unlimited (null daily_limit)
+';

package/setup.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+
+/**
+ * MCP Server Setup Helper
+ * Helps users configure Claude Desktop to use the AI Crypto Risk MCP server
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import readline from "readline";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    rl.question(question, resolve);
+  });
+}
+
+// Detect platform and config path
+function getClaudeConfigPath() {
+  const platform = process.platform;
+  const home = process.env.HOME || process.env.USERPROFILE;
+
+  if (platform === "darwin") {
+    return path.join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else if (platform === "win32") {
+    return path.join(process.env.APPDATA, "Claude", "claude_desktop_config.json");
+  } else {
+    return path.join(home, ".config", "claude", "claude_desktop_config.json");
+  }
+}
+
+async function main() {
+  console.log("\n🔐 AI Crypto Risk MCP Server Setup\n");
+  console.log("This will configure Claude Desktop to use the crypto risk analysis tools.\n");
+
+  // Get API key
+  const apiKey = await prompt("Enter your API key (get one at https://aicryptorisk.com/api-keys): ");
+
+  if (!apiKey || !apiKey.startsWith("acr_")) {
+    console.log("\n❌ Invalid API key. Keys should start with 'acr_'");
+    rl.close();
+    process.exit(1);
+  }
+
+  const configPath = getClaudeConfigPath();
+  const serverPath = path.resolve(__dirname, "index.js");
+
+  // Read existing config or create new
+  let config = { mcpServers: {} };
+  try {
+    if (fs.existsSync(configPath)) {
+      config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+      config.mcpServers = config.mcpServers || {};
+    }
+  } catch (err) {
+    console.log("Creating new Claude config...");
+  }
+
+  // Add our server
+  config.mcpServers.aicryptorisk = {
+    command: "node",
+    args: [serverPath],
+    env: {
+      AICRYPTORISK_API_KEY: apiKey,
+    },
+  };
+
+  // Ensure directory exists
+  const configDir = path.dirname(configPath);
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  // Write config
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  console.log(`\n✅ Configuration saved to: ${configPath}`);
+  console.log("\n📋 Next steps:");
+  console.log("   1. Restart Claude Desktop");
+  console.log("   2. You can now ask Claude to analyze crypto tokens!");
+  console.log("\n💡 Try: \"Analyze this token for scam risk: 0x...\"");
+
+  rl.close();
+}
+
+main().catch((err) => {
+  console.error("Setup failed:", err.message);
+  rl.close();
+  process.exit(1);
+});