@tiangong-lca/mcp-server 0.0.29 → 0.0.31

package/README.md

@@ -4,6 +4,15 @@
 
 TianGong LCA Model Context Protocol (MCP) Server supports STDIO and Streamable Http protocols.
 
+## Environment
+
+GLAD dataset search tools require a GLAD API key in the server environment:
+
+```bash
+GLAD_API_KEY=your-glad-api-key
+GLAD_API_BASE_URL=https://www.globallcadataaccess.org/api/v1
+```
+
 ## Starting MCP Server
 
 ### Client STDIO Server

package/dist/src/_shared/config.js

@@ -10,3 +10,5 @@ export const supabase_publishable_key = process.env.SUPABASE_PUBLISHABLE_KEY ??
 export const x_region = process.env.X_REGION ?? 'us-east-1';
 export const redis_url = process.env.UPSTASH_REDIS_URL ?? '';
 export const redis_token = process.env.UPSTASH_REDIS_TOKEN ?? '';
+export const glad_api_base_url = process.env.GLAD_API_BASE_URL ?? 'https://www.globallcadataaccess.org/api/v1';
+export const glad_api_key = process.env.GLAD_API_KEY ?? '';

package/dist/src/_shared/init_server.js

@@ -2,6 +2,7 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { regOpenLcaPrompts } from '../prompts/lca_calculation.js';
 import { regOpenLcaResources } from '../resources/lca_calculation.js';
 import { regFlowSearchTool } from '../tools/flow_hybrid_search.js';
+import { regGladDatasetTools } from '../tools/glad_dataset_search.js';
 import { regLcaCalculationGuidanceTool } from '../tools/lca_calculation_guidance.js';
 import { regLifecycleModelSearchTool } from '../tools/life_cycle_model_hybrid_search.js';
 import { regOpenLcaLciaTool } from '../tools/openlca_ipc_lcia.js';
@@ -16,6 +17,7 @@ export function initializeServer(bearerKey) {
     regFlowSearchTool(server, bearerKey);
     regProcessSearchTool(server, bearerKey);
     regLifecycleModelSearchTool(server, bearerKey);
+    regGladDatasetTools(server);
     regOpenLcaLciaTool(server);
     regOpenLcaListSystemProcessesTool(server);
     regOpenLcaListLCIAMethodsTool(server);

package/dist/src/_shared/init_server_http.js

@@ -1,6 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { regCrudTool } from '../tools/db_crud.js';
 import { regFlowSearchTool } from '../tools/flow_hybrid_search.js';
+import { regGladDatasetTools } from '../tools/glad_dataset_search.js';
 import { regLifecycleModelSearchTool } from '../tools/life_cycle_model_hybrid_search.js';
 import { regProcessSearchTool } from '../tools/process_hybrid_search.js';
 export function initializeServer(bearerKey, supabaseSession) {
@@ -11,6 +12,7 @@ export function initializeServer(bearerKey, supabaseSession) {
     regFlowSearchTool(server, bearerKey);
     regProcessSearchTool(server, bearerKey);
     regLifecycleModelSearchTool(server, bearerKey);
+    regGladDatasetTools(server);
     regCrudTool(server, supabaseSession ?? bearerKey);
     return server;
 }

package/dist/src/tools/db_crud.js

@@ -1,11 +1,10 @@
-import { createClient, FunctionRegion } from '@supabase/supabase-js';
+import { createClient } from '@supabase/supabase-js';
 import { z } from 'zod';
 import { supabase_base_url, supabase_publishable_key } from '../_shared/config.js';
 import { resolveSupabaseAccessToken } from '../_shared/supabase_session.js';
 import { prepareLifecycleModelFile } from './life_cycle_model_file_tools.js';
 const allowedTables = ['contacts', 'flows', 'lifecyclemodels', 'processes', 'sources'];
 const tableSchema = z.enum(allowedTables);
-const UPDATE_FUNCTION_NAME = 'update_data';
 const MAX_VALIDATION_ERROR_LENGTH = 4_000;
 const tablePrimaryKey = {
     contacts: 'id',
@@ -321,35 +320,24 @@ async function handleUpdate(supabase, accessToken, input, bearerKey) {
     }
     const jsonOrderedValue = jsonOrdered;
     const preparedWrite = await prepareWritePayload(table, jsonOrderedValue, id, version, bearerKey);
-    const token = requireAccessToken(accessToken);
-    const { data: functionPayload, error } = await supabase.functions.invoke(UPDATE_FUNCTION_NAME, {
-        headers: {
-            Authorization: `Bearer ${token}`,
-        },
-        body: {
-            id: preparedWrite.resolvedId ?? id,
-            version: preparedWrite.resolvedVersion ?? version,
-            table,
-            data: preparedWrite.payload,
-        },
-        region: FunctionRegion.UsEast1,
-    });
+    requireAccessToken(accessToken);
+    const keyColumn = getPrimaryKeyColumn(table);
+    const resolvedId = preparedWrite.resolvedId ?? id;
+    const resolvedVersion = preparedWrite.resolvedVersion ?? version;
+    const { data, error } = await supabase
+        .from(table)
+        .update(preparedWrite.payload)
+        .eq(keyColumn, resolvedId)
+        .eq('version', resolvedVersion)
+        .select();
     if (error) {
-        console.error('Error invoking update_data function:', error);
+        console.error('Error updating the database:', error);
         throw error;
     }
-    const { data: updatedRows, error: functionError } = (functionPayload ??
-        {});
-    if (functionError) {
-        console.error('Supabase update_data returned an error:', functionError);
-        const message = functionError.message ?? 'Supabase update_data function rejected the request.';
-        throw new Error(message);
-    }
-    const keyColumn = getPrimaryKeyColumn(table);
-    const rows = ensureRows(updatedRows, `Update affected 0 rows for table "${table}"; verify the provided ${keyColumn} (${preparedWrite.resolvedId ?? id}) and version (${preparedWrite.resolvedVersion ?? version}) exist and are accessible.`);
+    const rows = ensureRows(data, `Update affected 0 rows for table "${table}"; verify the provided ${keyColumn} (${resolvedId}) and version (${resolvedVersion}) exist and are accessible.`);
     return JSON.stringify({
-        id: preparedWrite.resolvedId ?? id,
-        version: preparedWrite.resolvedVersion ?? version,
+        id: resolvedId,
+        version: resolvedVersion,
         data: sanitizeRowsForOutput(table, rows),
     });
 }

package/dist/src/tools/glad_dataset_search.js

@@ -0,0 +1,332 @@
+import { z } from 'zod';
+import { glad_api_base_url, glad_api_key } from '../_shared/config.js';
+const sectorSchema = z.enum([
+    'Agriculture',
+    'Chemicals',
+    'Construction',
+    'Electronics',
+    'Energy',
+    'Food',
+    'Metals',
+    'Mining',
+    'Textiles',
+    'Transport',
+    'Other',
+]);
+const formatSchema = z.enum(['ECOSPOLD1', 'ECOSPOLD2', 'ILCD', 'JSON-LD', 'OTHER', 'UNKNOWN']);
+const processTypeSchema = z.enum([
+    'UNIT',
+    'PARTIALLY_AGGREGATED',
+    'FULLY_AGGREGATED',
+    'BRIDGE',
+    'UNKNOWN',
+]);
+const modelingTypeSchema = z.enum(['ATTRIBUTIONAL', 'CONSEQUENTIAL', 'BEFORE_MODELING', 'UNKNOWN']);
+const reviewTypeSchema = z.enum(['INTERNAL', 'EXTERNAL', 'PANEL', 'UNKNOWN', 'NONE']);
+const reviewSystemSchema = z.enum([
+    'ILCD',
+    'PEF',
+    'GHG',
+    'LCA_UN',
+    'OTHER',
+    'UNKNOWN',
+    'NOT_APPLICABLE',
+]);
+const extraFilterValueSchema = z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number(), z.boolean()])),
+]);
+const gladSearchInputSchema = z.object({
+    query: z
+        .string()
+        .min(1)
+        .optional()
+        .describe('Full-text search query. GLAD searches name, description, category, and technology; multiple words are combined with AND.'),
+    page: z.number().int().min(0).default(0).describe('Zero-based GLAD result page. Default: 0.'),
+    pageSize: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(10)
+        .describe('Number of datasets to return. Capped at 100 to keep MCP responses usable.'),
+    sortBy: z.string().min(1).optional().describe('Field name to sort by, for example name.'),
+    sortOrder: z.enum(['ASC', 'DESC']).default('ASC').describe('Sort order used when sortBy is set.'),
+    sectors: z.array(sectorSchema).optional().describe('Filter by one or more GLAD sectors.'),
+    format: z.array(formatSchema).optional().describe('Filter by one or more dataset formats.'),
+    location: z
+        .array(z.string().min(1))
+        .optional()
+        .describe('Filter by one or more location codes, for example DE or ZA.'),
+    dataprovider: z
+        .array(z.string().min(1))
+        .optional()
+        .describe('Filter by one or more data provider names.'),
+    supportedNomenclatures: z
+        .array(z.string().min(1))
+        .optional()
+        .describe('Filter by supported nomenclature names, for example ecoinvent 3.5.'),
+    lciaMethods: z.array(z.string().min(1)).optional().describe('Filter by LCIA method names.'),
+    category: z
+        .array(z.string().min(1))
+        .optional()
+        .describe('Filter by category name or ISIC4 category code.'),
+    categoryPaths: z.array(z.string().min(1)).optional().describe('Filter by GLAD category paths.'),
+    unspscPaths: z.array(z.string().min(1)).optional().describe('Filter by UNSPSC path values.'),
+    co2pePaths: z.array(z.string().min(1)).optional().describe('Filter by CO2PE path values.'),
+    processType: z.array(processTypeSchema).optional().describe('Filter by GLAD process type.'),
+    modelingType: z.array(modelingTypeSchema).optional().describe('Filter by GLAD modeling type.'),
+    reviewType: z.array(reviewTypeSchema).optional().describe('Filter by GLAD review type.'),
+    reviewSystem: z.array(reviewSystemSchema).optional().describe('Filter by GLAD review system.'),
+    copyrightHolder: z.array(z.string().min(1)).optional().describe('Filter by copyright holder.'),
+    contact: z.string().min(1).optional().describe('Filter by contact value.'),
+    validFromYear: z.number().int().optional().describe('Filter by validity start year.'),
+    validUntilYear: z.number().int().optional().describe('Filter by validity end year.'),
+    copyrightProtected: z.boolean().optional().describe('Filter by copyright-protected status.'),
+    free: z.boolean().optional().describe('Filter by whether the dataset is available for free.'),
+    publiclyAccessible: z
+        .boolean()
+        .optional()
+        .describe('Filter by whether the dataset URL is publicly accessible without further login.'),
+    extraFilters: z
+        .record(z.string(), extraFilterValueSchema)
+        .optional()
+        .describe('Advanced GLAD query parameters not modeled explicitly. Use official parameter names; arrays are sent as repeated query parameters.'),
+});
+const gladGetDatasetInputSchema = z.object({
+    refId: z.string().min(1).describe('GLAD dataset refId.'),
+    dataProvider: z.string().min(1).describe('GLAD data provider name for the dataset.'),
+});
+const resultInfoSchema = z
+    .object({
+    currentPage: z.number().optional(),
+    pageSize: z.number().optional(),
+    pageCount: z.number().optional(),
+    count: z.number().optional(),
+    totalCount: z.number().optional(),
+})
+    .passthrough();
+const passthroughObjectSchema = z.object({}).passthrough();
+const gladSearchOutputSchema = z
+    .object({
+    request: z
+        .object({
+        endpoint: z.string(),
+        page: z.number(),
+        pageSize: z.number(),
+    })
+        .passthrough(),
+    resultInfo: resultInfoSchema.optional(),
+    data: z.array(passthroughObjectSchema),
+    aggregations: z.array(passthroughObjectSchema),
+})
+    .passthrough();
+const gladGetDatasetOutputSchema = z
+    .object({
+    request: z
+        .object({
+        endpoint: z.string(),
+        refId: z.string(),
+        dataProvider: z.string(),
+    })
+        .passthrough(),
+    dataSet: passthroughObjectSchema,
+})
+    .passthrough();
+const ARRAY_PARAM_MAP = {
+    'sectors[]': 'sectors',
+    'format[]': 'format',
+    'location[]': 'location',
+    'dataprovider[]': 'dataprovider',
+    'supportedNomenclatures[]': 'supportedNomenclatures',
+    'lciaMethods[]': 'lciaMethods',
+    'category[]': 'category',
+    'categoryPaths[]': 'categoryPaths',
+    'unspscPaths[]': 'unspscPaths',
+    'co2pePaths[]': 'co2pePaths',
+    'processType[]': 'processType',
+    'modelingType[]': 'modelingType',
+    'reviewType[]': 'reviewType',
+    'reviewSystem[]': 'reviewSystem',
+    'copyrightHolder[]': 'copyrightHolder',
+};
+const SCALAR_PARAM_NAMES = [
+    'query',
+    'sortBy',
+    'sortOrder',
+    'page',
+    'pageSize',
+    'contact',
+    'validFromYear',
+    'validUntilYear',
+    'copyrightProtected',
+    'free',
+    'publiclyAccessible',
+];
+function createGladUrl(pathname) {
+    const baseUrl = glad_api_base_url.replace(/\/+$/, '');
+    return new URL(`${baseUrl}${pathname}`);
+}
+function appendParam(params, key, value) {
+    if (value === undefined || value === null || value === '') {
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            appendParam(params, key, item);
+        }
+        return;
+    }
+    params.append(key, String(value));
+}
+function appendSearchParams(url, input) {
+    for (const key of SCALAR_PARAM_NAMES) {
+        appendParam(url.searchParams, key, input[key]);
+    }
+    for (const [wireName, inputKey] of Object.entries(ARRAY_PARAM_MAP)) {
+        appendParam(url.searchParams, wireName, input[inputKey]);
+    }
+    if (input.extraFilters) {
+        for (const [key, value] of Object.entries(input.extraFilters)) {
+            appendParam(url.searchParams, key, value);
+        }
+    }
+}
+function assertGladApiKey() {
+    if (!glad_api_key) {
+        throw new Error('Missing GLAD_API_KEY. Add it to the MCP server environment before using GLAD tools.');
+    }
+    return glad_api_key;
+}
+function buildGladErrorMessage(status, statusText, body) {
+    const trimmedBody = body.trim();
+    if (trimmedBody.startsWith('<!DOCTYPE html') || trimmedBody.startsWith('<html')) {
+        return `GLAD API returned an HTML page instead of JSON (HTTP ${status} ${statusText}). This usually means Cloudflare or browser verification blocked this Node.js runtime before the GLAD API processed the api-key. Verify this runtime can reach GLAD directly, or point GLAD_API_BASE_URL at an accessible GLAD-compatible API endpoint.`;
+    }
+    try {
+        const parsed = JSON.parse(trimmedBody);
+        if (typeof parsed === 'object' && parsed !== null && 'message' in parsed) {
+            return `GLAD API request failed (HTTP ${status} ${statusText}): ${String(parsed.message)}`;
+        }
+    }
+    catch {
+    }
+    const preview = trimmedBody.slice(0, 500);
+    return `GLAD API request failed (HTTP ${status} ${statusText})${preview ? `: ${preview}` : ''}`;
+}
+async function requestGladJson(url) {
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            Accept: 'application/json',
+            'User-Agent': 'TianGong-LCA-MCP/1.0',
+            'api-key': assertGladApiKey(),
+        },
+    });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new Error(buildGladErrorMessage(response.status, response.statusText, text));
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new Error(`GLAD API returned a non-JSON success response from ${url.pathname}: ${error.message}`);
+    }
+}
+async function searchGladDatasets(input) {
+    const url = createGladUrl('/search');
+    appendSearchParams(url, input);
+    const result = await requestGladJson(url);
+    return {
+        request: {
+            endpoint: `${url.origin}${url.pathname}`,
+            page: input.page,
+            pageSize: input.pageSize,
+        },
+        resultInfo: result.resultInfo,
+        data: result.data ?? [],
+        aggregations: result.aggregations ?? [],
+    };
+}
+async function getGladDataset(input) {
+    const url = createGladUrl(`/search/index/${encodeURIComponent(input.refId)}/${encodeURIComponent(input.dataProvider)}`);
+    const dataSet = await requestGladJson(url);
+    return {
+        request: {
+            endpoint: `${url.origin}${url.pathname}`,
+            refId: input.refId,
+            dataProvider: input.dataProvider,
+        },
+        dataSet,
+    };
+}
+function toSuccessResult(output) {
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(output, null, 2),
+            },
+        ],
+        structuredContent: output,
+    };
+}
+function toErrorResult(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+        isError: true,
+        content: [
+            {
+                type: 'text',
+                text: message,
+            },
+        ],
+    };
+}
+export function regGladDatasetTools(server) {
+    server.registerTool('Search_GLAD_Datasets_Tool', {
+        title: 'Search GLAD Datasets',
+        description: 'Search Global LCA Data Access (GLAD) dataset descriptors through the official GLAD /search API. Requires GLAD_API_KEY in the MCP server environment.',
+        inputSchema: gladSearchInputSchema,
+        outputSchema: gladSearchOutputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (rawInput) => {
+        try {
+            const input = gladSearchInputSchema.parse(rawInput);
+            const output = await searchGladDatasets(input);
+            return toSuccessResult(output);
+        }
+        catch (error) {
+            return toErrorResult(error);
+        }
+    });
+    server.registerTool('Get_GLAD_Dataset_Tool', {
+        title: 'Get GLAD Dataset',
+        description: 'Fetch one GLAD dataset descriptor by refId and dataProvider through the official GLAD /search/index/{refId}/{dataProvider} API. Requires GLAD_API_KEY in the MCP server environment.',
+        inputSchema: gladGetDatasetInputSchema,
+        outputSchema: gladGetDatasetOutputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (rawInput) => {
+        try {
+            const input = gladGetDatasetInputSchema.parse(rawInput);
+            const output = await getGladDataset(input);
+            return toSuccessResult(output);
+        }
+        catch (error) {
+            return toErrorResult(error);
+        }
+    });
+}

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@tiangong-lca/mcp-server",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "TianGong LCA MCP Server",
   "license": "MIT",
   "author": "Nan LI",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/linancn/tiangong-lca-mcp"
+  },
   "type": "module",
   "bin": {
     "tiangong-lca-mcp-stdio": "dist/src/index.js",
@@ -23,29 +27,30 @@
     "start:server": "npm run build && concurrently \"npx dotenv -e .env -- node dist/src/index_server.js\" \"DANGEROUSLY_OMIT_AUTH=true npx @modelcontextprotocol/inspector\"",
     "start:server-local": "npm run build && concurrently \"npx dotenv -e .env -- node dist/src/index_server_local.js\" \"DANGEROUSLY_OMIT_AUTH=true npx @modelcontextprotocol/inspector\"",
     "test": "node test/tidas_validation_test.js",
+    "prepush:gate": "npm run build && npm run lint && npm test",
     "lint": "prettier -c --write \"**/**.{js,jsx,tsx,ts,less,md,json}\"",
     "ncu": "npx npm-check-updates",
     "ncu:update": "npx npm-check-updates -u"
   },
   "dependencies": {
-    "@dagrejs/dagre": "^2.0.4",
-    "@modelcontextprotocol/sdk": "^1.27.1",
-    "@supabase/supabase-js": "^2.99.1",
-    "@tiangong-lca/tidas-sdk": "^0.1.30",
+    "@dagrejs/dagre": "^3.0.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@supabase/supabase-js": "^2.106.1",
+    "@tiangong-lca/tidas-sdk": "^0.1.40",
     "@types/express": "^5.0.6",
-    "@upstash/redis": "^1.37.0",
+    "@upstash/redis": "^1.38.0",
     "aws-jwt-verify": "^5.1.1",
-    "olca-ipc": "^2.2.1",
-    "zod": "^4.3.6"
+    "olca-ipc": "^2.6.2",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@modelcontextprotocol/inspector": "^0.21.1",
+    "@modelcontextprotocol/inspector": "^0.21.2",
     "dotenv-cli": "^11.0.0",
-    "npm-check-updates": "^19.6.3",
-    "prettier": "^3.8.1",
+    "npm-check-updates": "^22.2.1",
+    "prettier": "^3.8.3",
     "prettier-plugin-organize-imports": "^4.3.0",
     "shx": "^0.4.0",
-    "tsx": "^4.21.0",
-    "typescript": "^5.9.3"
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3"
   }
 }