mcp-pickaxe 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024
+
+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,221 @@
+# MCP Pickaxe Server
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![MCP](https://img.shields.io/badge/MCP-Compatible-blue)](https://modelcontextprotocol.io)
+
+An MCP (Model Context Protocol) server that connects AI assistants like Claude to the [Pickaxe](https://pickaxe.co) platform. Manage your AI agents, knowledge bases, users, and analytics directly through natural language.
+
+## Why Use This?
+
+If you're building AI agents on Pickaxe, this MCP server lets you:
+
+- **Analyze agent conversations** - Review chat history to identify knowledge gaps and improve agent performance
+- **Manage knowledge bases** - Create, update, and connect documents to your agents without leaving your AI workflow
+- **Handle user management** - Create users, manage access, send invitations, and track usage
+- **Work across multiple studios** - Seamlessly switch between different Pickaxe studios in a single session
+- **Automate workflows** - Let Claude handle repetitive Pickaxe admin tasks
+
+## Features
+
+| Category | Tools |
+|----------|-------|
+| **Studios** | List configured studios, switch between them |
+| **Chat History** | Fetch and analyze agent conversation logs |
+| **Documents** | Create, list, get, delete, connect/disconnect to agents |
+| **Users** | Create, list, get, update, delete, invite |
+| **Products** | List available products and bundles |
+| **Memory** | List memory schemas, retrieve user memories |
+
+## Prerequisites
+
+- Node.js 18+
+- A [Pickaxe](https://pickaxe.co) account with API access
+- Your Pickaxe Studio API key(s)
+
+## Installation
+
+### Option 1: Clone and Build
+
+```bash
+git clone https://github.com/YOUR_USERNAME/mcp-pickaxe.git
+cd mcp-pickaxe
+npm install
+npm run build
+```
+
+### Option 2: Install from npm (coming soon)
+
+```bash
+npm install -g mcp-pickaxe
+```
+
+## Configuration
+
+### 1. Get Your Pickaxe API Key
+
+1. Log in to [Pickaxe Studio](https://studio.pickaxe.co)
+2. Navigate to Settings > API
+3. Copy your Studio API key (starts with `studio-`)
+
+### 2. Configure Your MCP Client
+
+#### For Claude Desktop
+
+Add to your Claude Desktop config file:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "pickaxe": {
+      "command": "node",
+      "args": ["/path/to/mcp-pickaxe/dist/index.js"],
+      "env": {
+        "PICKAXE_STUDIO_MAIN": "studio-your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+#### For Claude Code
+
+Add to `~/.claude.json`:
+
+```json
+{
+  "mcpServers": {
+    "pickaxe": {
+      "command": "node",
+      "args": ["/path/to/mcp-pickaxe/dist/index.js"],
+      "env": {
+        "PICKAXE_STUDIO_MAIN": "studio-your-api-key-here"
+      }
+    }
+  }
+}
+```
+
+### Multi-Studio Configuration
+
+To work with multiple Pickaxe studios, add multiple environment variables:
+
+```json
+{
+  "env": {
+    "PICKAXE_STUDIO_PRODUCTION": "studio-xxx-xxx-xxx",
+    "PICKAXE_STUDIO_STAGING": "studio-yyy-yyy-yyy",
+    "PICKAXE_STUDIO_DEV": "studio-zzz-zzz-zzz",
+    "PICKAXE_DEFAULT_STUDIO": "PRODUCTION"
+  }
+}
+```
+
+Then specify which studio to use in your requests:
+- If you set `PICKAXE_DEFAULT_STUDIO`, that studio is used when none is specified
+- If only one studio is configured, it's used automatically
+- Otherwise, pass `studio="STAGING"` (or similar) to any tool
+
+## Usage Examples
+
+Once configured, you can interact with Pickaxe through natural language:
+
+### Analyze Agent Performance
+> "Show me the last 20 conversations from my support agent"
+
+> "What questions are users asking that my agent can't answer?"
+
+### Manage Knowledge Base
+> "Create a new document called 'FAQ' with this content: [your content]"
+
+> "Connect the FAQ document to my customer support agent"
+
+> "List all documents in my knowledge base"
+
+### User Management
+> "Show me all users and their usage stats"
+
+> "Create a new user with email user@example.com and give them access to the Pro product"
+
+> "Send invitations to these emails: [list of emails]"
+
+### Multi-Studio Operations
+> "List all users in my staging studio"
+
+> "Compare the documents between production and staging"
+
+## Available Tools
+
+### Studio Management
+- `studios_list` - List all configured studios and the current default
+
+### Chat History
+- `chat_history` - Fetch conversation history for an agent
+  - Parameters: `pickaxeId`, `skip`, `limit`, `format` ("messages" or "raw"), `studio`
+
+### Document Management
+- `doc_create` - Create document from content or URL
+- `doc_list` - List all documents (with pagination)
+- `doc_get` - Get a specific document
+- `doc_delete` - Delete a document
+- `doc_connect` - Link document to an agent
+- `doc_disconnect` - Unlink document from an agent
+
+### User Management
+- `user_list` - List all users with access and usage info
+- `user_get` - Get a specific user by email
+- `user_create` - Create a new user
+- `user_update` - Update user details, products, or usage
+- `user_delete` - Delete a user
+- `user_invite` - Send email invitations
+
+### Products
+- `products_list` - List available products/bundles
+
+### Memory
+- `memory_list` - List memory schemas
+- `memory_get_user` - Get collected memories for a user
+
+## Development
+
+```bash
+# Run in development mode (auto-reloads)
+npm run dev
+
+# Build for production
+npm run build
+
+# Run the built version
+npm start
+```
+
+## Troubleshooting
+
+### "No Pickaxe studios configured"
+Ensure you have at least one `PICKAXE_STUDIO_*` environment variable set in your MCP config.
+
+### "Studio not found"
+Check that the studio name matches exactly (case-insensitive). Run `studios_list` to see available options.
+
+### "Pickaxe API error (401)"
+Your API key is invalid or expired. Get a new one from Pickaxe Studio settings.
+
+### "Pickaxe API error (403)"
+Your API key doesn't have permission for this operation. Check your Pickaxe account permissions.
+
+## Contributing
+
+Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Links
+
+- [Pickaxe Platform](https://pickaxe.co)
+- [Pickaxe Studio](https://studio.pickaxe.co)
+- [Model Context Protocol](https://modelcontextprotocol.io)
+- [MCP Specification](https://spec.modelcontextprotocol.io)

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,594 @@
+#!/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";
+// Pickaxe API configuration
+const PICKAXE_BASE_URL = "https://api.pickaxe.co/v1";
+const DEFAULT_STUDIO = process.env.PICKAXE_DEFAULT_STUDIO;
+// Get all configured studios from environment
+function getConfiguredStudios() {
+    const studios = [];
+    for (const key of Object.keys(process.env)) {
+        if (key.startsWith("PICKAXE_STUDIO_")) {
+            const studioName = key.replace("PICKAXE_STUDIO_", "");
+            studios.push(studioName);
+        }
+    }
+    return studios;
+}
+// Get API key for a studio
+function getApiKey(studio) {
+    const studioName = studio ?? DEFAULT_STUDIO;
+    if (!studioName) {
+        const studios = getConfiguredStudios();
+        if (studios.length === 1) {
+            // Only one studio configured, use it
+            return process.env[`PICKAXE_STUDIO_${studios[0]}`];
+        }
+        throw new Error(`No studio specified and no default set. Available studios: ${studios.join(", ")}. ` +
+            `Set PICKAXE_DEFAULT_STUDIO or pass 'studio' parameter.`);
+    }
+    const apiKey = process.env[`PICKAXE_STUDIO_${studioName.toUpperCase()}`];
+    if (!apiKey) {
+        const studios = getConfiguredStudios();
+        throw new Error(`Studio "${studioName}" not found. Available studios: ${studios.join(", ")}. ` +
+            `Configure with PICKAXE_STUDIO_${studioName.toUpperCase()} environment variable.`);
+    }
+    return apiKey;
+}
+// Validate at least one studio is configured
+const configuredStudios = getConfiguredStudios();
+if (configuredStudios.length === 0) {
+    console.error("Error: No Pickaxe studios configured.");
+    console.error("Set environment variables like PICKAXE_STUDIO_RRHUB=your-api-key");
+    process.exit(1);
+}
+console.error(`Pickaxe MCP server initialized with studios: ${configuredStudios.join(", ")}`);
+if (DEFAULT_STUDIO) {
+    console.error(`Default studio: ${DEFAULT_STUDIO}`);
+}
+// API helper function
+async function pickaxeRequest(endpoint, method = "GET", body, studio) {
+    const apiKey = getApiKey(studio);
+    const url = endpoint.startsWith("http") ? endpoint : `${PICKAXE_BASE_URL}${endpoint}`;
+    const options = {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${apiKey}`,
+        },
+    };
+    if (body && method !== "GET") {
+        options.body = JSON.stringify(body);
+    }
+    const response = await fetch(url, options);
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Pickaxe API error (${response.status}): ${errorText}`);
+    }
+    return response.json();
+}
+// Studio parameter schema (added to all tools)
+const studioParam = {
+    type: "string",
+    description: `Studio name to use. Available: ${configuredStudios.join(", ")}. Default: ${DEFAULT_STUDIO || configuredStudios[0]}`,
+};
+// Define all tools
+const tools = [
+    // Studio management
+    {
+        name: "studios_list",
+        description: "List all configured Pickaxe studios and the current default.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    // Chat History
+    {
+        name: "chat_history",
+        description: "Fetch conversation history for a Pickaxe agent. Use to analyze user questions, identify KB gaps, and review agent performance.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                pickaxeId: {
+                    type: "string",
+                    description: "The Pickaxe agent ID (from the agent URL or config)",
+                },
+                skip: {
+                    type: "number",
+                    description: "Number of conversations to skip (for pagination). Default: 0",
+                },
+                limit: {
+                    type: "number",
+                    description: "Maximum conversations to return. Default: 10, Max: 100",
+                },
+                format: {
+                    type: "string",
+                    enum: ["messages", "raw"],
+                    description: "Output format. 'messages' is human-readable, 'raw' includes metadata. Default: messages",
+                },
+            },
+            required: ["pickaxeId"],
+        },
+    },
+    // Document tools
+    {
+        name: "doc_create",
+        description: "Create a new document in Pickaxe knowledge base. Can create from raw content or scrape a website URL.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                name: {
+                    type: "string",
+                    description: "Name/title of the document",
+                },
+                rawContent: {
+                    type: "string",
+                    description: "Raw text content for the document. Use this OR website, not both.",
+                },
+                website: {
+                    type: "string",
+                    description: "URL to scrape as document content. Use this OR rawContent, not both.",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "doc_connect",
+        description: "Connect/link a document to a Pickaxe agent, adding it to the agent's knowledge base.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                documentId: {
+                    type: "string",
+                    description: "The document ID to connect",
+                },
+                pickaxeId: {
+                    type: "string",
+                    description: "The Pickaxe agent ID to connect the document to",
+                },
+            },
+            required: ["documentId", "pickaxeId"],
+        },
+    },
+    {
+        name: "doc_disconnect",
+        description: "Disconnect/unlink a document from a Pickaxe agent, removing it from the agent's knowledge base.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                documentId: {
+                    type: "string",
+                    description: "The document ID to disconnect",
+                },
+                pickaxeId: {
+                    type: "string",
+                    description: "The Pickaxe agent ID to disconnect the document from",
+                },
+            },
+            required: ["documentId", "pickaxeId"],
+        },
+    },
+    {
+        name: "doc_list",
+        description: "List all documents in the Pickaxe studio with pagination.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                skip: {
+                    type: "number",
+                    description: "Number of documents to skip. Default: 0",
+                },
+                take: {
+                    type: "number",
+                    description: "Number of documents to return. Default: 10",
+                },
+            },
+        },
+    },
+    {
+        name: "doc_get",
+        description: "Retrieve a specific document by ID.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                documentId: {
+                    type: "string",
+                    description: "The document ID to retrieve",
+                },
+            },
+            required: ["documentId"],
+        },
+    },
+    {
+        name: "doc_delete",
+        description: "Delete a document from Pickaxe. This removes it from all connected agents.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                documentId: {
+                    type: "string",
+                    description: "The document ID to delete",
+                },
+            },
+            required: ["documentId"],
+        },
+    },
+    // User tools
+    {
+        name: "user_list",
+        description: "List all users in the Pickaxe studio with their product access and usage stats.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                skip: {
+                    type: "number",
+                    description: "Number of users to skip. Default: 0",
+                },
+                take: {
+                    type: "number",
+                    description: "Number of users to return. Default: 10",
+                },
+            },
+        },
+    },
+    {
+        name: "user_get",
+        description: "Get details for a specific user by email.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                email: {
+                    type: "string",
+                    description: "The user's email address",
+                },
+            },
+            required: ["email"],
+        },
+    },
+    {
+        name: "user_create",
+        description: "Create a new user with optional product access.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                email: {
+                    type: "string",
+                    description: "User's email address (required)",
+                },
+                name: {
+                    type: "string",
+                    description: "User's display name",
+                },
+                password: {
+                    type: "string",
+                    description: "User's password (optional - they can reset)",
+                },
+                products: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of product IDs to grant access to",
+                },
+                isEmailVerified: {
+                    type: "boolean",
+                    description: "Mark email as verified. Default: false",
+                },
+            },
+            required: ["email"],
+        },
+    },
+    {
+        name: "user_update",
+        description: "Update an existing user's details, products, or usage.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                email: {
+                    type: "string",
+                    description: "The user's email address",
+                },
+                name: {
+                    type: "string",
+                    description: "Updated display name",
+                },
+                products: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Updated array of product IDs",
+                },
+                currentUses: {
+                    type: "number",
+                    description: "Set current usage count",
+                },
+                extraUses: {
+                    type: "number",
+                    description: "Add extra usage allowance",
+                },
+                isEmailVerified: {
+                    type: "boolean",
+                    description: "Update email verification status",
+                },
+            },
+            required: ["email"],
+        },
+    },
+    {
+        name: "user_delete",
+        description: "Delete a user by email.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                email: {
+                    type: "string",
+                    description: "The user's email address to delete",
+                },
+            },
+            required: ["email"],
+        },
+    },
+    {
+        name: "user_invite",
+        description: "Send email invitations to new users with optional product access.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                emails: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of email addresses to invite",
+                },
+                productIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of product IDs to grant access to",
+                },
+            },
+            required: ["emails"],
+        },
+    },
+    // Product tools
+    {
+        name: "products_list",
+        description: "List all available products/bundles in the Pickaxe studio.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+            },
+        },
+    },
+    // Memory tools
+    {
+        name: "memory_list",
+        description: "List all memory schemas defined in the studio.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                skip: {
+                    type: "number",
+                    description: "Number of memories to skip. Default: 0",
+                },
+                take: {
+                    type: "number",
+                    description: "Number of memories to return. Default: 10",
+                },
+            },
+        },
+    },
+    {
+        name: "memory_get_user",
+        description: "Get all collected memories for a specific user.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                studio: studioParam,
+                email: {
+                    type: "string",
+                    description: "The user's email address",
+                },
+                memoryId: {
+                    type: "string",
+                    description: "Optional: specific memory schema ID to filter by",
+                },
+                skip: {
+                    type: "number",
+                    description: "Number of memories to skip. Default: 0",
+                },
+                take: {
+                    type: "number",
+                    description: "Number of memories to return. Default: 10",
+                },
+            },
+            required: ["email"],
+        },
+    },
+];
+// Tool execution handlers
+async function executeTool(name, args) {
+    const studio = args.studio;
+    switch (name) {
+        // Studio management
+        case "studios_list": {
+            const studios = getConfiguredStudios();
+            const result = {
+                studios,
+                default: DEFAULT_STUDIO || (studios.length === 1 ? studios[0] : null),
+                count: studios.length,
+            };
+            return JSON.stringify(result, null, 2);
+        }
+        // Chat History
+        case "chat_history": {
+            const result = await pickaxeRequest("/studio/pickaxe/history", "POST", {
+                pickaxeId: args.pickaxeId,
+                skip: args.skip ?? 0,
+                limit: args.limit ?? 10,
+                format: args.format ?? "messages",
+            }, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        // Document tools
+        case "doc_create": {
+            const body = { name: args.name };
+            if (args.rawContent)
+                body.rawContent = args.rawContent;
+            if (args.website)
+                body.website = args.website;
+            const result = await pickaxeRequest("/studio/document/create", "POST", body, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "doc_connect": {
+            const result = await pickaxeRequest("/studio/document/connect", "POST", {
+                documentId: args.documentId,
+                pickaxeId: args.pickaxeId,
+            }, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "doc_disconnect": {
+            const result = await pickaxeRequest("/studio/document/disconnect", "POST", {
+                documentId: args.documentId,
+                pickaxeId: args.pickaxeId,
+            }, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "doc_list": {
+            const skip = args.skip ?? 0;
+            const take = args.take ?? 10;
+            const result = await pickaxeRequest(`/studio/document/list?skip=${skip}&take=${take}`, "GET", undefined, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "doc_get": {
+            const result = await pickaxeRequest(`/studio/document/${args.documentId}`, "GET", undefined, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "doc_delete": {
+            const result = await pickaxeRequest(`/studio/document/${args.documentId}`, "DELETE", undefined, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        // User tools
+        case "user_list": {
+            const skip = args.skip ?? 0;
+            const take = args.take ?? 10;
+            const result = await pickaxeRequest(`/studio/user/list?skip=${skip}&take=${take}`, "GET", undefined, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "user_get": {
+            const result = await pickaxeRequest(`/studio/user/${encodeURIComponent(args.email)}`, "GET", undefined, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "user_create": {
+            const result = await pickaxeRequest("/studio/user/create", "POST", {
+                email: args.email,
+                name: args.name,
+                password: args.password,
+                products: args.products,
+                isEmailVerified: args.isEmailVerified ?? false,
+            }, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "user_update": {
+            const data = {};
+            if (args.name !== undefined)
+                data.name = args.name;
+            if (args.products !== undefined)
+                data.products = args.products;
+            if (args.currentUses !== undefined)
+                data.currentUses = args.currentUses;
+            if (args.extraUses !== undefined)
+                data.extraUses = args.extraUses;
+            if (args.isEmailVerified !== undefined)
+                data.isEmailVerified = args.isEmailVerified;
+            const result = await pickaxeRequest(`/studio/user/${encodeURIComponent(args.email)}`, "PATCH", { data }, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "user_delete": {
+            const result = await pickaxeRequest(`/studio/user/${encodeURIComponent(args.email)}`, "DELETE", undefined, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "user_invite": {
+            const result = await pickaxeRequest("/studio/user/invite", "POST", {
+                emails: args.emails,
+                productIds: args.productIds,
+            }, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        // Product tools
+        case "products_list": {
+            const result = await pickaxeRequest("/studio/product/list", "GET", undefined, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        // Memory tools
+        case "memory_list": {
+            const skip = args.skip ?? 0;
+            const take = args.take ?? 10;
+            const result = await pickaxeRequest(`/studio/memory/list?skip=${skip}&take=${take}`, "GET", undefined, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        case "memory_get_user": {
+            let url = `/studio/memory/user/${encodeURIComponent(args.email)}?`;
+            if (args.memoryId)
+                url += `memoryId=${args.memoryId}&`;
+            url += `skip=${args.skip ?? 0}&take=${args.take ?? 10}`;
+            const result = await pickaxeRequest(url, "GET", undefined, studio);
+            return JSON.stringify(result, null, 2);
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}
+// Create and run the server
+const server = new Server({
+    name: "mcp-pickaxe",
+    version: "1.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Register tool list handler
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools };
+});
+// Register tool execution handler
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        const result = await executeTool(name, args ?? {});
+        return {
+            content: [{ type: "text", text: result }],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: "text", text: `Error: ${errorMessage}` }],
+            isError: true,
+        };
+    }
+});
+// Start the server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Pickaxe MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "mcp-pickaxe",
+  "version": "1.0.0",
+  "description": "MCP server for Pickaxe API - manage AI agents, knowledge bases, users, and analytics",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mcp-pickaxe": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "pickaxe",
+    "ai-agents",
+    "claude",
+    "anthropic",
+    "knowledge-base"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aplaceforallmystuff/mcp-pickaxe.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aplaceforallmystuff/mcp-pickaxe/issues"
+  },
+  "homepage": "https://github.com/aplaceforallmystuff/mcp-pickaxe#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.0"
+  }
+}