aqc-mcp 1.0.0

package/src/index.ts

@@ -0,0 +1,199 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { executeAqc } from './utils/executor.js';
+import { listTools } from './tools/index.js';
+
+const PORT = process.env.PORT ? parseInt(process.env.PORT) : 3000;
+
+async function createMcpServer() {
+  const server = new McpServer(
+    {
+      name: 'astroquery-mcp',
+      version: '1.0.0',
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  await listTools(server);
+
+  return server;
+}
+
+// Helper function to build command arguments
+function buildArgs(module: string, command: string, mainArg: string, extraArgs: (string | null | undefined)[]): string[] {
+  const args: string[] = [module, command, mainArg];
+  for (const arg of extraArgs) {
+    if (arg) args.push(arg);
+  }
+  return args;
+}
+
+async function startHttpServer() {
+  const express = (await import('express')).default;
+  const cors = (await import('cors')).default;
+
+  const app = express();
+  app.use(cors());
+  app.use(express.json());
+
+  const mcpServer = await createMcpServer();
+
+  // GET /health - Health check
+  app.get('/health', (req: any, res: any) => {
+    res.json({ status: 'ok' });
+  });
+
+  // GET / - Server info
+  app.get('/', (req: any, res: any) => {
+    res.json({
+      name: 'astroquery-mcp',
+      version: '1.0.0',
+      protocol: 'MCP',
+      transport: 'HTTP',
+      endpoints: {
+        health: '/health',
+        sse: '/sse',
+        tools: '/tools'
+      }
+    });
+  });
+
+  // GET /sse - SSE endpoint
+  app.get('/sse', async (req: any, res: any) => {
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+
+    res.write(`data: ${JSON.stringify({ type: 'connected' })}\n\n`);
+
+    req.on('close', () => {
+      res.end();
+    });
+  });
+
+  // POST /tools/list - List available tools
+  app.get('/tools/list', (req: any, res: any) => {
+    res.json({ message: 'Use MCP protocol to list tools' });
+  });
+
+  // POST /tools/call - Call a tool directly (for HTTP clients)
+  app.post('/tools/call', async (req: any, res: any) => {
+    try {
+      const { name, arguments: args } = req.body;
+
+      if (!name) {
+        return res.status(400).json({ error: 'Tool name is required' });
+      }
+
+      const cmdArgs: string[] = [];
+      switch (name) {
+        case 'simbad_query':
+          cmdArgs.push('simbad', 'object', args.object_name);
+          break;
+        case 'vizier_query':
+          cmdArgs.push('vizier', 'object', args.target, args.radius);
+          if (args.catalog) cmdArgs.push('--catalog', args.catalog);
+          break;
+        case 'alma_query':
+          cmdArgs.push('alma', 'object', args.object_name);
+          break;
+        case 'ads_query':
+          cmdArgs.push('ads', 'query');
+          if (args.latest) cmdArgs.push('--latest');
+          if (args.review) cmdArgs.push('--review');
+          if (args.query) cmdArgs.push(args.query);
+          break;
+        case 'gaia_cone_search':
+          cmdArgs.push('gaia', 'cone-search', args.target);
+          if (args.radius) cmdArgs.push('--radius', args.radius);
+          break;
+        default:
+          throw new Error(`Tool '${name}' not found`);
+      }
+
+      const result = await executeAqc(cmdArgs);
+      res.json({ content: [{ type: 'text', text: result.output || '' }] });
+    } catch (error: any) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // POST /tools/batch - Call multiple tools in parallel
+  app.post('/tools/batch', async (req: any, res: any) => {
+    try {
+      const { tools } = req.body;
+
+      if (!Array.isArray(tools)) {
+        return res.status(400).json({ error: 'Tools must be an array' });
+      }
+
+      const results = await Promise.all(
+        tools.map(async ({ name, arguments: args }: any) => {
+          try {
+            const cmdArgs: string[] = [];
+            switch (name) {
+              case 'simbad_query':
+                cmdArgs.push('simbad', 'object', args.object_name);
+                break;
+              case 'vizier_query':
+                cmdArgs.push('vizier', 'object', args.target, args.radius);
+                if (args.catalog) cmdArgs.push('--catalog', args.catalog);
+                break;
+              case 'alma_query':
+                cmdArgs.push('alma', 'object', args.object_name);
+                break;
+              case 'ads_query':
+                cmdArgs.push('ads', 'query');
+                if (args.latest) cmdArgs.push('--latest');
+                if (args.review) cmdArgs.push('--review');
+                if (args.query) cmdArgs.push(args.query);
+                break;
+              case 'gaia_cone_search':
+                cmdArgs.push('gaia', 'cone-search', args.target);
+                if (args.radius) cmdArgs.push('--radius', args.radius);
+                break;
+              default:
+                throw new Error(`Tool '${name}' not found`);
+            }
+
+            const result = await executeAqc(cmdArgs);
+            return { name, success: true, result: { content: [{ type: 'text', text: result.output || '' }] } };
+          } catch (error: any) {
+            return { name, success: false, error: error.message };
+          }
+        })
+      );
+
+      res.json(results);
+    } catch (error: any) {
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  app.listen(PORT, () => {
+    console.log(`Astroquery MCP Server running on http://localhost:${PORT}`);
+    console.log(`Health check: http://localhost:${PORT}/health`);
+    console.log(`Tools list: http://localhost:${PORT}/tools/list`);
+    console.log(`SSE endpoint: http://localhost:${PORT}/sse`);
+  });
+}
+
+async function startStdioServer() {
+  const server = await createMcpServer();
+  const transport = new StdioServerTransport();
+
+  await server.connect(transport);
+}
+
+// Start server based on transport mode
+const mode = process.env.MCP_TRANSPORT || 'stdio';
+
+if (mode === 'http') {
+  startHttpServer();
+} else {
+  startStdioServer();
+}

package/src/tools/ads.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { executeAqc } from '../utils/executor.js';
+
+let executeAdsQuery: (query?: string, lang?: string) => Promise<string>;
+
+export function registerAdsTools(server: any) {
+  executeAdsQuery = async (query?: string, lang?: string) => {
+    const args = ['ads', 'query'];
+    if (query) args.push('--query', query);
+    if (lang) args.push('--lang', lang);
+
+    const result = await executeAqc(args);
+
+    if (!result.success) {
+      throw new Error(result.error);
+    }
+
+    return result.output || '';
+  };
+
+  server.tool(
+    'ads_query',
+    'Query NASA Astrophysics Data System for papers and bibliographic information',
+    {
+      query: z.string().optional().describe('Search query (e.g., "latest papers", "highly cited reviews")'),
+      lang: z.enum(['en', 'zh']).optional().describe('Output language'),
+    },
+    async ({ query, lang }: any) => {
+      const output = await executeAdsQuery(query, lang);
+
+      return {
+        content: [{
+          type: 'text',
+          text: output
+        }]
+      };
+    }
+  );
+}
+
+export { executeAdsQuery };

package/src/tools/alma.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { executeAqc } from '../utils/executor.js';
+
+let executeAlmaQuery: (ra?: number, dec?: number, radius?: number, catalog?: string, lang?: string) => Promise<string>;
+
+export function registerAlmaTools(server: any) {
+  executeAlmaQuery = async (ra?: number, dec?: number, radius?: number, catalog?: string, lang?: string) => {
+    const args = ['alma', 'query'];
+    if (ra !== undefined) args.push('--ra', ra.toString());
+    if (dec !== undefined) args.push('--dec', dec.toString());
+    if (radius !== undefined) args.push('--radius', radius.toString());
+    if (catalog) args.push('--catalog', catalog);
+    if (lang) args.push('--lang', lang);
+
+    const result = await executeAqc(args);
+
+    if (!result.success) {
+      throw new Error(result.error);
+    }
+
+    return result.output || '';
+  };
+
+  server.tool(
+    'alma_query',
+    'Query ALMA archive for observations',
+    {
+      ra: z.number().optional().describe('Right Ascension (degrees)'),
+      dec: z.number().optional().describe('Declination (degrees)'),
+      radius: z.number().optional().describe('Search radius (degrees)'),
+      catalog: z.string().optional().describe('Specific catalog to search'),
+      lang: z.enum(['en', 'zh']).optional().describe('Output language'),
+    },
+    async ({ ra, dec, radius, catalog, lang }: any) => {
+      const output = await executeAlmaQuery(ra, dec, radius, catalog, lang);
+
+      return {
+        content: [{
+          type: 'text',
+          text: output
+        }]
+      };
+    }
+  );
+}
+
+export { executeAlmaQuery };

package/src/tools/gaia.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+import { executeAqc } from '../utils/executor.js';
+
+let executeGaiaConeSearch: (ra: number, dec: number, radius?: number, lang?: string) => Promise<string>;
+
+export function registerGaiaTools(server: any) {
+  executeGaiaConeSearch = async (ra: number, dec: number, radius?: number, lang?: string) => {
+    const args = ['gaia', 'cone-search', '--ra', ra.toString(), '--dec', dec.toString(), '--radius', (radius || 1).toString()];
+    if (lang) args.push('--lang', lang);
+
+    const result = await executeAqc(args);
+
+    if (!result.success) {
+      throw new Error(result.error);
+    }
+
+    return result.output || '';
+  };
+
+  server.tool(
+    'gaia_cone_search',
+    'Query Gaia archive via cone search',
+    {
+      ra: z.number().describe('Right Ascension (degrees)'),
+      dec: z.number().describe('Declination (degrees)'),
+      radius: z.number().optional().default(1).describe('Search radius (degrees)'),
+      lang: z.enum(['en', 'zh']).optional().describe('Output language'),
+    },
+    async ({ ra, dec, radius, lang }: any) => {
+      const output = await executeGaiaConeSearch(ra, dec, radius, lang);
+
+      return {
+        content: [{
+          type: 'text',
+          text: output
+        }]
+      };
+    }
+  );
+}
+
+export { executeGaiaConeSearch };

package/src/tools/index.ts

@@ -0,0 +1,95 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { executeAqc } from '../utils/executor.js';
+
+export async function listTools(mcpServer: McpServer) {
+  // SIMBAD - simbad object NAME
+  mcpServer.registerTool(
+    'simbad_query',
+    {
+      description: 'Query the SIMBAD astronomical database for an object',
+    },
+    async ({ object_name, lang }: any) => {
+      const args = ['simbad', 'object', object_name];
+      if (lang) args.push('--lang', lang);
+
+      const result = await executeAqc(args);
+      if (!result.success) throw new Error(result.error);
+
+      return { content: [{ type: 'text', text: result.output || '' }] };
+    }
+  );
+
+  // VizieR - vizier object TARGET RADIUS
+  mcpServer.registerTool(
+    'vizier_query',
+    {
+      description: 'Query the VizieR catalog database for an object or coordinates',
+    },
+    async ({ target, radius, catalog, lang }: any) => {
+      const args = ['vizier', 'object', target, radius];
+      if (catalog) args.push('--catalog', catalog);
+      if (lang) args.push('--lang', lang);
+
+      const result = await executeAqc(args);
+      if (!result.success) throw new Error(result.error);
+
+      return { content: [{ type: 'text', text: result.output || '' }] };
+    }
+  );
+
+  // ALMA - alma object OBJECT_NAME
+  mcpServer.registerTool(
+    'alma_query',
+    {
+      description: 'Query the ALMA archive for observations of an object',
+    },
+    async ({ object_name, lang }: any) => {
+      const args = ['alma', 'object', object_name];
+      if (lang) args.push('--lang', lang);
+
+      const result = await executeAqc(args);
+      if (!result.success) throw new Error(result.error);
+
+      return { content: [{ type: 'text', text: result.output || '' }] };
+    }
+  );
+
+  // ADS - ads query [QUERY_STRING]
+  mcpServer.registerTool(
+    'ads_query',
+    {
+      description: 'Query NASA Astrophysics Data System for papers and bibliographic information',
+    },
+    async ({ query, latest, review, lang }: any) => {
+      const args = ['ads', 'query'];
+
+      if (latest) args.push('--latest');
+      if (review) args.push('--review');
+      if (query) args.push(query);
+      if (lang) args.push('--lang', lang);
+
+      const result = await executeAqc(args);
+      if (!result.success) throw new Error(result.error);
+
+      return { content: [{ type: 'text', text: result.output || '' }] };
+    }
+  );
+
+  // Gaia - gaia cone-search TARGET --radius RADIUS
+  mcpServer.registerTool(
+    'gaia_cone_search',
+    {
+      description: 'Query Gaia archive via cone search around an object or coordinates',
+    },
+    async ({ target, radius, lang }: any) => {
+      const args = ['gaia', 'cone-search', target, '--radius', radius || '10arcsec'];
+      if (lang) args.push('--lang', lang);
+
+      const result = await executeAqc(args);
+      if (!result.success) throw new Error(result.error);
+
+      return { content: [{ type: 'text', text: result.output || '' }] };
+    }
+  );
+}

package/src/tools/simbad.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { executeAqc } from '../utils/executor.js';
+
+let executeSimbadQuery: (identifier: string, lang?: string) => Promise<string>;
+
+export function registerSimbadTools(server: any) {
+  executeSimbadQuery = async (identifier: string, lang?: string) => {
+    const args = ['simbad', 'query', '--identifier', identifier];
+    if (lang) args.push('--lang', lang);
+
+    const result = await executeAqc(args);
+
+    if (!result.success) {
+      throw new Error(result.error);
+    }
+
+    return result.output || '';
+  };
+
+  server.tool(
+    'simbad_query',
+    'Query the SIMBAD astronomical database for an object identifier',
+    {
+      identifier: z.string().describe('Object identifier (e.g., "M31", "NGC 1234")'),
+      lang: z.enum(['en', 'zh']).optional().describe('Output language'),
+    },
+    async ({ identifier, lang }: any) => {
+      const output = await executeSimbadQuery(identifier, lang);
+
+      return {
+        content: [{
+          type: 'text',
+          text: output
+        }]
+      };
+    }
+  );
+}
+
+export { executeSimbadQuery };

package/src/tools/vizier.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { executeAqc } from '../utils/executor.js';
+
+let executeVizierQuery: (catalog: string, ra?: number, dec?: number, radius?: number, lang?: string) => Promise<string>;
+
+export function registerVizierTools(server: any) {
+  executeVizierQuery = async (catalog: string, ra?: number, dec?: number, radius?: number, lang?: string) => {
+    const args = ['vizier', 'query', '--catalog', catalog];
+    if (ra !== undefined) args.push('--ra', ra.toString());
+    if (dec !== undefined) args.push('--dec', dec.toString());
+    if (radius !== undefined) args.push('--radius', radius.toString());
+    if (lang) args.push('--lang', lang);
+
+    const result = await executeAqc(args);
+
+    if (!result.success) {
+      throw new Error(result.error);
+    }
+
+    return result.output || '';
+  };
+
+  server.tool(
+    'vizier_query',
+    'Query the VizieR catalog database for a specific catalog',
+    {
+      catalog: z.string().describe('Catalog identifier (e.g., "VII/118")'),
+      ra: z.number().optional().describe('Right Ascension (degrees)'),
+      dec: z.number().optional().describe('Declination (degrees)'),
+      radius: z.number().optional().describe('Search radius (degrees)'),
+      lang: z.enum(['en', 'zh']).optional().describe('Output language'),
+    },
+    async ({ catalog, ra, dec, radius, lang }: any) => {
+      const output = await executeVizierQuery(catalog, ra, dec, radius, lang);
+
+      return {
+        content: [{
+          type: 'text',
+          text: output
+        }]
+      };
+    }
+  );
+}
+
+export { executeVizierQuery };

package/src/utils/executor.ts

@@ -0,0 +1,59 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const execAsync = promisify(exec);
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export interface AqcResult {
+  success: boolean;
+  output?: string;
+  error?: string;
+}
+
+/**
+ * Execute astroquery-cli command
+ * @param args Command arguments (e.g., ['simbad', 'object', 'M31'])
+ * @returns Execution result
+ */
+export async function executeAqc(args: string[]): Promise<AqcResult> {
+  try {
+    // Determine the CLI project root (parent of astroquery-mcp)
+    const cliRoot = join(__dirname, '..', '..', '..');
+    
+    // Build command - use poetry run from CLI root directory
+    const command = `cd ${cliRoot} && poetry run aqc ${args.join(' ')}`;
+    
+    // Pass through ADS_API_KEY if set
+    const env = { ...process.env };
+    if (process.env.ADS_API_KEY) {
+      env.ADS_API_KEY = process.env.ADS_API_KEY;
+    }
+    
+    const { stdout, stderr } = await execAsync(command, {
+      maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+      timeout: 60000, // 60s timeout
+      env,
+      shell: '/bin/bash'
+    });
+    
+    if (stderr && !stdout) {
+      return {
+        success: false,
+        error: stderr
+      };
+    }
+    
+    return {
+      success: true,
+      output: stdout || stderr
+    };
+  } catch (error: any) {
+    return {
+      success: false,
+      error: error.message || String(error)
+    };
+  }
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "lib": ["ES2022"],
+    "moduleResolution": "node",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}