MCP Server Integration

Enable AI assistants like Claude to manage your software licenses through natural language commands.

What is MCP?

MCP (Model Context Protocol) is a standard that allows AI assistants to interact with external tools and services. The ExisOne MCP Server exposes your license management capabilities as tools that Claude can use directly.

Available Commands

Once configured, you can ask Claude things like:

• "List all my products" - View your product catalog
• "Show me all licenses" - List all license keys
• "Show licenses for ProductName" - Filter by product
• "Generate a license for user@email.com for MyProduct" - Create new keys
• "Create a 30-day license for customer@company.com" - Specify validity
• "Get details for license XXXX-XXXX-XXXX-XXXX" - View specific license info

Setup Instructions

Step 1: Get Your Access Token

1. Go to Access Tokens in your dashboard
2. Click Create Token
3. Name it "MCP Server" and select permissions: generate, verify
4. Copy the token (format: exo_at_xxx_yyy) - it's only shown once!

Step 2: Install the MCP Server

Clone the ExisOne MCP Server from GitHub and build it:

git clone https://github.com/exisllc/exisone-mcp.git
cd exisone-mcp
npm install
npm run build

Step 3: Configure Claude Desktop

Add the following to your Claude Desktop configuration file:

Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows:

{
  "mcpServers": {
    "exisone": {
      "command": "node",
      "args": ["C:\\Users\\YOURNAME\\exisone-mcp\\dist\\index.js"],
      "env": {
        "EXISONE_API_URL": "https://www.exisone.com",
        "EXISONE_ACCESS_TOKEN": "exo_at_yourpublicid_yoursecret",
        "EXISONE_TENANT_ID": "1"
      }
    }
  }
}

macOS:

{
  "mcpServers": {
    "exisone": {
      "command": "node",
      "args": ["/Users/yourname/exisone-mcp/dist/index.js"],
      "env": {
        "EXISONE_API_URL": "https://www.exisone.com",
        "EXISONE_ACCESS_TOKEN": "exo_at_yourpublicid_yoursecret",
        "EXISONE_TENANT_ID": "1"
      }
    }
  }
}

Replace the path with where you cloned the repo. Use \\ for Windows paths, / for macOS.

Step 4: Restart Claude Desktop

After saving the configuration, fully quit Claude Desktop. Closing the window is not enough - Claude continues running in the background.

• Windows: Right-click the Claude icon in the system tray → Quit, or use Task Manager to end the process
• macOS: Right-click the dock icon → Quit, or use Cmd+Q

Reopen Claude Desktop and go to Settings → Developer to verify the ExisOne server appears.

AI Prompt for Custom Integration

If you want to build your own MCP integration or extend the server, use this prompt with your AI assistant:

Prompt

You're helping me work with the ExisOne MCP Server for software license management.

CONTEXT
- ExisOne is a software licensing platform with REST API
- The MCP server exposes 4 tools: list_products, list_licenses, generate_license, get_license
- Authentication uses API tokens in format: exo_at_{publicId}_{secret}
- Tenant context is set via X-Tenant header

AVAILABLE MCP TOOLS

1. list_products
   - Description: List all products for the tenant
   - Parameters: None
   - Returns: Array of products with id, name, price, trialDays, defaultLicenseDays

2. list_licenses
   - Description: List all licenses with optional filtering
   - Parameters:
     - productId (optional): Filter by product ID
     - productName (optional): Filter by product name (case-insensitive)
     - activeOnly (optional): Only show active licenses
   - Returns: Array of licenses with activationKey, email, productName, isActive, expirationDate

3. generate_license
   - Description: Generate a new activation key
   - Parameters:
     - productName (required): Product name (must match exactly)
     - email (required): Customer email address
     - validityDays (optional): License duration (0 = perpetual, uses product default if not specified)
     - planId (optional): Plan ID for specific features
   - Returns: activationKey, isCorporate, maxSeats, isOffline

4. get_license
   - Description: Get detailed license information
   - Parameters:
     - activationKey (required): The license key to look up
   - Returns: Full license details including history

API ENDPOINTS USED BY MCP SERVER
- GET /api/product/ - List products
- GET /api/license/ - List licenses
- POST /api/activationkey/generate - Generate license
- GET /api/license/{key}/history - Get license history

CONFIGURATION
Environment variables required:
- EXISONE_API_URL: API base URL (must be HTTPS)
- EXISONE_ACCESS_TOKEN: API token (exo_at_xxx_yyy format)
- EXISONE_TENANT_ID: Tenant identifier

MCP SERVER STRUCTURE
ExisOne.Mcp/
├── src/
│   ├── index.ts          # Entry point with stdio transport
│   ├── server.ts         # MCP server setup
│   ├── config.ts         # Environment configuration
│   ├── api/
│   │   ├── client.ts     # HTTP client for ExisOne API
│   │   └── types.ts      # TypeScript interfaces
│   └── tools/
│       ├── index.ts      # Tool registry
│       ├── list-products.ts
│       ├── list-licenses.ts
│       ├── generate-license.ts
│       └── get-license.ts
└── dist/                 # Compiled JavaScript

ADDING NEW TOOLS
To add a new tool:
1. Create a new file in src/tools/ (e.g., deactivate-license.ts)
2. Define the tool schema with name, description, and inputSchema
3. Implement the handler function
4. Register in src/tools/index.ts

Example tool structure:
export const myTool = {
  name: "my_tool",
  description: "What the tool does",
  inputSchema: {
    type: "object",
    properties: {
      param1: { type: "string", description: "..." }
    },
    required: ["param1"]
  }
};

export async function handleMyTool(args, client) {
  // Implementation
  return { content: [{ type: "text", text: "Result" }] };
}

EXTENDING THE API CLIENT
Add new methods to src/api/client.ts:

async myNewMethod(params) {
  return this.request("POST", "/api/endpoint", params);
}

Please help me with the following task related to the ExisOne MCP Server:

Tools Reference

Security Notes

• Token Security: Store your access token securely. Never commit it to version control.
• HTTPS Required: The MCP server validates that the API URL uses HTTPS.
• Permission Scope: The MCP server inherits permissions from your access token. Only grant the permissions needed.
• Tenant Isolation: Each token is scoped to a specific tenant. Licenses from other tenants are not accessible.

Troubleshooting

See Also

• GitHub Repository - Source code, issues, and contributions
• Access Tokens - Create and manage API tokens
• REST API Documentation - Full API reference
• .NET SDK, Python SDK, Node.js SDK - Client libraries