@databytesolutionid/databyte-mcp 1.0.0

package/bin/cli.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * DataByte AI MCP Server CLI
+ * 
+ * Connects to DataByte AI MCP endpoint at https://ai.databyte.co.id/mcp
+ * No external MCP package needed — user connects directly to DataByte.
+ */
+
+const https = require('https');
+
+const args = process.argv.slice(2);
+let apiKey = null;
+let baseUrl = 'https://ai.databyte.co.id/mcp';
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--api-key' && args[i + 1]) apiKey = args[++i];
+  else if (args[i] === '--url' && args[i + 1]) baseUrl = args[++i];
+  else if (args[i] === '--help') {
+    console.error(`DataByte AI MCP Server
+Usage: databyte-mcp --api-key sk-db-xxxx
+
+Options:
+  --api-key <key>   DataByte AI API key (required)
+  --url <url>       MCP endpoint URL (default: https://ai.databyte.co.id/mcp)
+  --help            Show this help
+`);
+    process.exit(0);
+  }
+}
+
+if (!apiKey) {
+  console.error('Error: --api-key is required');
+  process.exit(1);
+}
+
+const urlObj = new URL(baseUrl);
+
+function sendJsonRequest(method, params) {
+  return new Promise((resolve, reject) => {
+    const payload = JSON.stringify({
+      jsonrpc: '2.0',
+      id: Date.now(),
+      method,
+      params
+    });
+
+    const options = {
+      hostname: urlObj.hostname,
+      port: urlObj.port || 443,
+      path: urlObj.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'User-Agent': 'DataByte-MCP/1.0',
+        'Content-Length': Buffer.byteLength(payload)
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let data = '';
+      res.on('data', chunk => data += chunk);
+      res.on('end', () => {
+        try { resolve(JSON.parse(data)); }
+        catch (e) { reject(new Error('Invalid JSON response')); }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(30000, () => { req.destroy(); reject(new Error('Request timeout')); });
+    req.write(payload);
+    req.end();
+  });
+}
+
+let initialized = false;
+
+async function handleRequest(request) {
+  const { method, params, id } = request;
+  const response = { jsonrpc: '2.0', id };
+
+  try {
+    if (method === 'initialize') {
+      response.result = {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'databyte-mcp', version: '1.0.0' }
+      };
+      initialized = true;
+      send(response);
+      return;
+    }
+
+    if (method === 'ping') {
+      response.result = { status: 'ok' };
+      send(response);
+      return;
+    }
+
+    if (method === 'tools/list') {
+      response.result = {
+        tools: [
+          {
+            name: 'web_search',
+            description: 'Search the web for information.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                query: { type: 'string', description: 'The search query' }
+              },
+              required: ['query']
+            }
+          },
+          {
+            name: 'understand_image',
+            description: 'Analyze and understand images.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                image_url: { type: 'string', description: 'URL of the image' },
+                prompt: { type: 'string', description: 'Question about the image' }
+              },
+              required: ['image_url']
+            }
+          }
+        ]
+      };
+      send(response);
+      return;
+    }
+
+    if (method === 'tools/call') {
+      if (!initialized) {
+        await sendJsonRequest('initialize', {
+          protocolVersion: '2024-11-05',
+          capabilities: {},
+          clientInfo: { name: 'databyte-mcp-cli', version: '1.0.0' }
+        });
+        initialized = true;
+      }
+
+      const { name, arguments: args } = params || {};
+      const result = await sendJsonRequest('tools/call', { name, arguments: args });
+      response.result = result.result;
+      send(response);
+      return;
+    }
+
+    response.error = { code: -32601, message: `Unknown method: ${method}` };
+    send(response);
+  } catch (error) {
+    send({ ...response, error: { code: -32603, message: error.message } });
+  }
+}
+
+function send(obj) {
+  console.log(JSON.stringify(obj));
+}
+
+let buffer = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', (chunk) => {
+  buffer += chunk;
+  const lines = buffer.split('\n');
+  buffer = lines.pop();
+  for (const line of lines) {
+    if (line.trim()) {
+      try { handleRequest(JSON.parse(line)); }
+      catch (e) {}
+    }
+  }
+});
+
+process.stdin.on('end', () => {
+  if (buffer.trim()) {
+    try { handleRequest(JSON.parse(buffer)); }
+    catch (e) {}
+  }
+});

package/build.js

@@ -0,0 +1,7 @@
+const fs = require('fs');
+const path = require('path');
+const src = '/opt/databyte-ai/backend/src/mcp/databyte-mcp-server.js';
+const dest = path.join(__dirname, 'dist/index.js');
+fs.mkdirSync(path.dirname(dest), { recursive: true });
+fs.copyFileSync(src, dest);
+console.log('Built @databyte/databyte-mcp!');

package/dist/index.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+/**
+ * DataByte AI MCP Server (Stdio Bridge)
+ * 
+ * MCP server that bridges stdio protocol to DataByte AI's MCP endpoint.
+ * Provides web_search and understand_image tools.
+ * 
+ * Usage in MCP config:
+ * {
+ *   "mcpServers": {
+ *     "databyte": {
+ *       "command": "node",
+ *       "args": ["/path/to/databyte-mcp-server.js", "--api-key", "sk-db-xxxx"]
+ *     }
+ *   }
+ * }
+ * 
+ * Or for Claude Code (~/.claude/mcp.json):
+ * {
+ *   "mcpServers": {
+ *     "databyte": {
+ *       "command": "node",
+ *       "args": ["/path/to/databyte-mcp-server.js", "--api-key", "YOUR_API_KEY"]
+ *     }
+ *   }
+ * }
+ */
+
+const https = require('https');
+
+const args = process.argv.slice(2);
+let apiKey = null;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--api-key' && args[i + 1]) apiKey = args[++i];
+  else if (args[i] === '--help') {
+    console.error(`DataByte AI MCP Server
+Usage: node databyte-mcp-server.js --api-key sk-db-xxxx
+
+Options:
+  --api-key <key>   DataByte AI API key (required)
+  --help            Show this help
+`);
+    process.exit(0);
+  }
+}
+
+if (!apiKey) {
+  console.error('Error: --api-key is required');
+  process.exit(1);
+}
+
+const BASE_URL = 'ai.databyte.co.id';
+const MCP_PATH = '/mcp';
+
+function httpRequest(path, payload) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(payload);
+    const options = {
+      hostname: BASE_URL,
+      path,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'User-Agent': 'DataByte-MCP/1.0',
+        'Content-Length': Buffer.byteLength(data)
+      }
+    };
+
+    const req = https.request(options, (res) => {
+      let body = '';
+      res.on('data', chunk => body += chunk);
+      res.on('end', () => {
+        try {
+          resolve(JSON.parse(body));
+        } catch (e) {
+          reject(new Error('Invalid JSON: ' + body));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.setTimeout(30000, () => { req.destroy(); reject(new Error('Timeout')); });
+    req.write(data);
+    req.end();
+  });
+}
+
+let initialized = false;
+
+async function handleRequest(request) {
+  const { method, params, id } = request;
+  const response = { jsonrpc: '2.0', id };
+
+  try {
+    // Protocol methods - handle locally
+    if (method === 'initialize') {
+      response.result = {
+        protocolVersion: '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'databyte-mcp', version: '1.0.0' }
+      };
+      initialized = true;
+      send(response);
+      return;
+    }
+
+    if (method === 'ping') {
+      response.result = { status: 'ok' };
+      send(response);
+      return;
+    }
+
+    if (method === 'tools/list') {
+      response.result = {
+        tools: [
+          {
+            name: 'web_search',
+            description: 'Search the web for information. Use this when you need to find current or specific information from the internet.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                query: { type: 'string', description: 'The search query to look up on the web' }
+              },
+              required: ['query']
+            }
+          },
+          {
+            name: 'understand_image',
+            description: 'Analyze and understand the content of an image. Use this when you need to describe, explain, or extract information from an image.',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                image_url: { type: 'string', description: 'URL of the image to analyze' },
+                prompt: { type: 'string', description: 'What to ask about the image (optional, default: "Describe this image")' }
+              },
+              required: ['image_url']
+            }
+          }
+        ]
+      };
+      send(response);
+      return;
+    }
+
+    // Forward tool calls to DataByte AI MCP endpoint
+    if (method === 'tools/call') {
+      if (!initialized) {
+        await httpRequest(MCP_PATH, {
+          jsonrpc: '2.0', id: Date.now(), method: 'initialize',
+          params: { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'databyte-mcp-stdio', version: '1.0.0' } }
+        });
+        initialized = true;
+      }
+
+      const { name, arguments: args } = params || {};
+      const result = await httpRequest(MCP_PATH, {
+        jsonrpc: '2.0', id: Date.now(), method: 'tools/call',
+        params: { name, arguments: args }
+      });
+
+      response.result = result.result;
+      send(response);
+      return;
+    }
+
+    // Unknown method
+    response.error = { code: -32601, message: `Method not found: ${method}` };
+    send(response);
+
+  } catch (error) {
+    send({ ...response, error: { code: -32603, message: error.message } });
+  }
+}
+
+function send(obj) {
+  console.log(JSON.stringify(obj));
+}
+
+// Read lines from stdin (JSON-RPC messages)
+let buffer = '';
+process.stdin.setEncoding('utf8');
+
+process.stdin.on('data', (chunk) => {
+  buffer += chunk;
+  const lines = buffer.split('\n');
+  buffer = lines.pop();
+  
+  for (const line of lines) {
+    if (line.trim()) {
+      try {
+        handleRequest(JSON.parse(line));
+      } catch (e) {
+        // Skip malformed lines
+      }
+    }
+  }
+});
+
+process.stdin.on('end', () => {
+  if (buffer.trim()) {
+    try {
+      handleRequest(JSON.parse(buffer));
+    } catch (e) {}
+  }
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@databytesolutionid/databyte-mcp",
+  "version": "1.0.0",
+  "description": "DataByte AI MCP Server - provides web_search and understand_image tools",
+  "main": "dist/index.js",
+  "bin": {
+    "databyte-mcp": "./bin/cli.js"
+  },
+  "scripts": {
+    "build": "node build.js",
+    "prepublishOnly": "node build.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "databyte",
+    "ai",
+    "web-search",
+    "image-understanding"
+  ]
+}