@tiangong-lca/mcp-server 0.0.3 → 0.0.5

package/README.md

@@ -1,21 +1,21 @@
-# TianGong-LCA-MCP
+# TianGong-AI-MCP
 
-[中文](./README.md) | [English](./README_EN.md)
+[中文](https://github.com/linancn/tiangong-lca-mcp/blob/main/README_CN.md) | [English](https://github.com/linancn/tiangong-lca-mcp/blob/main/README.md)
 
-TianGong LCA Model Context Protocol (MCP) Server 支持 STDIO、 SSE 和 StreamableHttp 三种协议。
+TianGong AI Model Context Protocol (MCP) Server supports STDIO, SSE and StreamableHttp protocols.
 
-## 启动 MCP 服务器
+## Starting MCP Server
 
-### 客户端 STDIO 服务器
+### Client STDIO Server
 
 ```bash
 npm install -g @tiangong-lca/mcp-server
 
 npx dotenv -e .env -- \
-npx @tiangong-lca/mcp-server
+npx -p @tiangong-lca/mcp-server tiangong-lca-mcp-stdio
 ```
 
-### 远程 SSE 服务器
+### Remote SSE Server
 
 ```bash
 npm install -g @tiangong-lca/mcp-server
@@ -28,63 +28,66 @@ npx -y supergateway \
     --ssePath /sse --messagePath /message
 ```
 
-### 使用 Docker
+### Using Docker
 
 ```bash
-# 使用 Dockerfile 构建 MCP 服务器镜像（可选）
+# Build MCP server image using Dockerfile (optional)
 docker build -t linancn/tiangong-lca-mcp-server:0.0.1 .
 
-# 拉取 MCP 服务器镜像
+# Pull MCP server image
 docker pull linancn/tiangong-lca-mcp-server:0.0.1
 
-# 使用 Docker 启动 MCP 服务器
+# Start MCP server using Docker
 docker run -d \
     --name tiangong-lca-mcp-server \
-    --publish 3001:80 \
+    --publish 9278:9278 \
     --env-file .env \
     linancn/tiangong-lca-mcp-server:0.0.1
 ```
 
-## 开发
+## Development
 
-### 环境设置
+### Environment Setup
 
 ```bash
-# 安装 Node.js
+# Install Node.js
 curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.2/install.sh | bash
 nvm install 22
 nvm use
 
-# 安装依赖
+# Install dependencies
 npm install
 
-# 更新依赖
+# Update dependencies
 npm update && npm ci
 ```
 
-### 代码格式化
+### Code Formatting
 
 ```bash
-# 使用代码检查工具格式化代码
+# Format code using the linter
 npm run lint
 ```
 
-### 本地测试
+### Local Testing
 
-#### STDIO 服务器
+#### STDIO Server
 
 ```bash
-# 使用 MCP Inspector 启动 STDIO 服务器
+# Launch the STDIO Server using MCP Inspector
 npm start
 ```
 
-#### SSE 服务器
+#### SSE Server
 
 ```bash
-# 打包当前项目
+# Build and package the project
 npm run build && npm pack
 
-# 启动 SSE 服务器，如配置了参数 --baseUrl ，应设置为有效的 IP 地址或域名
+# Optionally, install supergateway globally
+npm install -g supergateway
+
+# Launch the SSE Server (If the parameter --baseUrl is configured, it should be set to a valid IP address or domain name)
 npx dotenv -e .env -- \
 npx -y supergateway \
     --stdio "npx -y -p tiangong-lca-mcp-server-0.0.3.tgz tiangong-lca-mcp-stdio" \
@@ -92,14 +95,20 @@ npx -y supergateway \
     --ssePath /sse \
     --messagePath /message
 
-# 启动 MCP Inspector
+# Launch MCP Inspector
 npx @modelcontextprotocol/inspector
 ```
 
-### 发布
+### Publishing
 
 ```bash
 npm login
 
 npm run build && npm publish
 ```
+
+### scaffold
+
+```bash
+npx tsx src/tools/openlca_ipc_test.ts
+```

package/dist/src/_shared/init_server.js

@@ -1,7 +1,10 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { regBomCalculationTool } from '../tools/bom_calculation.js';
 import { regFlowSearchTool } from '../tools/flow_hybrid_search.js';
+import { regOpenLcaLciaTool } from '../tools/openlca_ipc_lcia.js';
+import { regOpenLcaListLCIAMethodsTool } from '../tools/openlca_ipc_lcia_methods_list.js';
+import { regOpenLcaListSystemProcessTool } from '../tools/openlca_ipc_process_list.js';
 import { regProcessSearchTool } from '../tools/process_hybrid_search.js';
-import { regBomCalculationTool } from '../tools/bom_calculation.js';
 export function initializeServer() {
     const server = new McpServer({
         name: 'TianGong-MCP-Server',
@@ -10,6 +13,9 @@ export function initializeServer() {
     regFlowSearchTool(server);
     regProcessSearchTool(server);
     regBomCalculationTool(server);
+    regOpenLcaLciaTool(server);
+    regOpenLcaListSystemProcessTool(server);
+    regOpenLcaListLCIAMethodsTool(server);
     return server;
 }
 export function getServer() {

package/dist/src/index_server.js

@@ -2,9 +2,41 @@
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import express from 'express';
 import { getServer } from './_shared/init_server.js';
+const BEARER_KEY = process.env.BEARER_KEY;
+const authenticateBearer = (req, res, next) => {
+    if (!BEARER_KEY) {
+        next();
+        return;
+    }
+    const authHeader = req.headers.authorization;
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        res.status(401).json({
+            jsonrpc: '2.0',
+            error: {
+                code: -32001,
+                message: 'Missing or invalid authorization header',
+            },
+            id: null,
+        });
+        return;
+    }
+    const token = authHeader.substring(7);
+    if (token !== BEARER_KEY) {
+        res.status(403).json({
+            jsonrpc: '2.0',
+            error: {
+                code: -32002,
+                message: 'Invalid bearer token',
+            },
+            id: null,
+        });
+        return;
+    }
+    next();
+};
 const app = express();
 app.use(express.json());
-app.post('/mcp', async (req, res) => {
+app.post('/mcp', authenticateBearer, async (req, res) => {
     try {
         const server = getServer();
         const transport = new StreamableHTTPServerTransport({

package/dist/src/tools/bom_calculation.js

@@ -15,7 +15,8 @@ async function calculation({ a, b }) {
 export function regBomCalculationTool(server) {
     server.tool('BOM_Calculation', 'Calculate sum of two numbers.', input_schema, async ({ a, b }) => {
         const result = await calculation({
-            a, b,
+            a,
+            b,
         });
         return {
             content: [

package/dist/src/tools/openlca_grpc.js

@@ -0,0 +1 @@
+export {};

package/dist/src/tools/openlca_ipc copy.js

@@ -0,0 +1 @@
+export {};

package/dist/src/tools/openlca_ipc.js

@@ -0,0 +1,57 @@
+import * as o from 'olca-ipc';
+import { z } from 'zod';
+const input_schema = {
+    systemProcess: z.string().min(1).describe('OpenLCA product system ID'),
+    impactMethod: z.string().min(1).describe('OpenLCA impact method ID'),
+    serverUrl: z.string().default('http://localhost:8080').describe('OpenLCA IPC server URL'),
+};
+async function calculateLcaImpacts({ systemProcess, impactMethod, serverUrl = 'http://localhost:8080', }) {
+    if (!systemProcess) {
+        throw new Error('No systemProcess provided');
+    }
+    if (!impactMethod) {
+        throw new Error('No impactMethod provided');
+    }
+    const client = o.IpcClient.on(serverUrl);
+    const selectedSystemProcess = await client.get(o.RefType.ProductSystem, systemProcess);
+    if (!selectedSystemProcess)
+        throw new Error('Product system not found');
+    const selectedMethod = await client.get(o.RefType.ImpactMethod, impactMethod);
+    if (!selectedMethod)
+        throw new Error('Impact method not found');
+    console.log('Calculating LCA impacts...');
+    const setup = o.CalculationSetup.of({
+        target: selectedSystemProcess,
+        impactMethod: selectedMethod,
+    });
+    const result = await client.calculate(setup);
+    const state = await result.untilReady();
+    if (state.error) {
+        throw new Error(`Calculation failed: ${state.error}`);
+    }
+    const impacts = await result.getTotalImpacts();
+    const resultsObj = impacts.map((impact) => ({
+        name: impact.impactCategory?.name,
+        value: impact.amount,
+        unit: impact.impactCategory?.refUnit,
+    }));
+    result.dispose();
+    return JSON.stringify(resultsObj);
+}
+export function regOpenLcaTool(server) {
+    server.tool('OpenLCA_Impact_Assessment_Tool', 'Calculate life cycle impact assessment using OpenLCA.', input_schema, async ({ systemProcess, impactMethod, serverUrl }) => {
+        const result = await calculateLcaImpacts({
+            systemProcess: systemProcess,
+            impactMethod: impactMethod,
+            serverUrl: serverUrl,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result,
+                },
+            ],
+        };
+    });
+}

package/dist/src/tools/openlca_ipc_lcia.js

@@ -0,0 +1,57 @@
+import * as o from 'olca-ipc';
+import { z } from 'zod';
+const input_schema = {
+    systemProcess: z.string().min(1).describe('OpenLCA product system ID'),
+    impactMethod: z.string().min(1).describe('OpenLCA impact method ID'),
+    serverUrl: z.string().default('http://localhost:8080').describe('OpenLCA IPC server URL'),
+};
+async function calculateLcaImpacts({ systemProcess, impactMethod, serverUrl = 'http://localhost:8080', }) {
+    if (!systemProcess) {
+        throw new Error('No systemProcess provided');
+    }
+    if (!impactMethod) {
+        throw new Error('No impactMethod provided');
+    }
+    const client = o.IpcClient.on(serverUrl);
+    const selectedSystemProcess = await client.get(o.RefType.ProductSystem, systemProcess);
+    if (!selectedSystemProcess)
+        throw new Error('Product system not found');
+    const selectedMethod = await client.get(o.RefType.ImpactMethod, impactMethod);
+    if (!selectedMethod)
+        throw new Error('Impact method not found');
+    console.log('Calculating LCA impacts...');
+    const setup = o.CalculationSetup.of({
+        target: selectedSystemProcess,
+        impactMethod: selectedMethod,
+    });
+    const result = await client.calculate(setup);
+    const state = await result.untilReady();
+    if (state.error) {
+        throw new Error(`Calculation failed: ${state.error}`);
+    }
+    const impacts = await result.getTotalImpacts();
+    const resultsObj = impacts.map((impact) => ({
+        name: impact.impactCategory?.name,
+        value: impact.amount,
+        unit: impact.impactCategory?.refUnit,
+    }));
+    result.dispose();
+    return JSON.stringify(resultsObj);
+}
+export function regOpenLcaLciaTool(server) {
+    server.tool('OpenLCA_Impact_Assessment_Tool', 'Calculate life cycle impact assessment using OpenLCA.', input_schema, async ({ systemProcess, impactMethod, serverUrl }) => {
+        const result = await calculateLcaImpacts({
+            systemProcess: systemProcess,
+            impactMethod: impactMethod,
+            serverUrl: serverUrl,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result,
+                },
+            ],
+        };
+    });
+}

package/dist/src/tools/openlca_ipc_lcia_methods_list.js

@@ -0,0 +1,48 @@
+import * as o from 'olca-ipc';
+import { z } from 'zod';
+const input_schema = {
+    serverUrl: z.string().default('http://localhost:8080').describe('OpenLCA IPC server URL'),
+};
+async function listLCIAMethods({ serverUrl = 'http://localhost:8080', }) {
+    const client = o.IpcClient.on(serverUrl);
+    const impactMethods = await client.getDescriptors(o.RefType.ImpactMethod);
+    if (impactMethods.length === 0) {
+        throw new Error('No LICA methods found');
+    }
+    console.log(impactMethods);
+    const resultsObj = impactMethods.map((sys) => {
+        const result = {
+            id: sys.id,
+            category: sys.category,
+            description: sys.description,
+            flowType: sys.flowType,
+            location: sys.location,
+            name: sys.name,
+            processType: sys.processType,
+            refUnit: sys.refUnit,
+            refType: sys.refType,
+        };
+        Object.keys(result).forEach((key) => {
+            if (result[key] === undefined) {
+                delete result[key];
+            }
+        });
+        return result;
+    });
+    return JSON.stringify(resultsObj);
+}
+export function regOpenLcaListLCIAMethodsTool(server) {
+    server.tool('OpenLCA_List_LCIA_Methods_Tool', 'List all LCIA methods using OpenLCA.', input_schema, async ({ serverUrl }) => {
+        const result = await listLCIAMethods({
+            serverUrl: serverUrl,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result,
+                },
+            ],
+        };
+    });
+}

package/dist/src/tools/openlca_ipc_process_list.js

@@ -0,0 +1,47 @@
+import * as o from 'olca-ipc';
+import { z } from 'zod';
+const input_schema = {
+    serverUrl: z.string().default('http://localhost:8080').describe('OpenLCA IPC server URL'),
+};
+async function listSystemProcesses({ serverUrl = 'http://localhost:8080', }) {
+    const client = o.IpcClient.on(serverUrl);
+    const systemProcesses = await client.getDescriptors(o.RefType.ProductSystem);
+    if (systemProcesses.length === 0) {
+        throw new Error('No product systems found');
+    }
+    const resultsObj = systemProcesses.map((sys) => {
+        const result = {
+            id: sys.id,
+            category: sys.category,
+            description: sys.description,
+            flowType: sys.flowType,
+            location: sys.location,
+            name: sys.name,
+            processType: sys.processType,
+            refUnit: sys.refUnit,
+            refType: sys.refType,
+        };
+        Object.keys(result).forEach((key) => {
+            if (result[key] === undefined) {
+                delete result[key];
+            }
+        });
+        return result;
+    });
+    return JSON.stringify(resultsObj);
+}
+export function regOpenLcaListSystemProcessTool(server) {
+    server.tool('OpenLCA_List_System_Processes_Tool', 'List all system processes using OpenLCA.', input_schema, async ({ serverUrl }) => {
+        const result = await listSystemProcesses({
+            serverUrl: serverUrl,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: result,
+                },
+            ],
+        };
+    });
+}

package/dist/src/tools/openlca_ipc_test.js

@@ -0,0 +1,17 @@
+import * as o from 'olca-ipc';
+async function main() {
+    const protocol = 'IPC';
+    const client = protocol === 'IPC'
+        ? o.IpcClient.on('http://localhost:8080')
+        : o.RestClient.on('http://localhost:8080');
+    const systems = await client.getDescriptors(o.RefType.ProductSystem);
+    if (systems.length === 0) {
+        console.log('error: no product systems found');
+        return;
+    }
+    console.log('可用的产品系统:');
+    systems.forEach((sys, index) => {
+        console.log(`${index}: ${sys.name} (${sys.id})`);
+    });
+}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiangong-lca/mcp-server",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "TianGong LCA MCP Server",
   "license": "MIT",
   "author": "Nan LI",
@@ -22,18 +22,20 @@
     "lint": "prettier -c --write \"**/**.{js,jsx,tsx,ts,less,md,json}\""
   },
   "dependencies": {
+    "olca-ipc": "^2.2.1",
     "@types/express": "^5.0.2",
-    "@modelcontextprotocol/sdk": "^1.11.4",
-    "@supabase/supabase-js": "^2.49.4",
-    "zod": "^3.24.4"
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@supabase/supabase-js": "^2.49.10",
+    "zod": "^3.25.51"
   },
   "devDependencies": {
-    "@modelcontextprotocol/inspector": "^0.12.0",
+    "@modelcontextprotocol/inspector": "^0.14.0",
     "dotenv-cli": "^8.0.0",
     "prettier": "^3.5.3",
     "prettier-plugin-organize-imports": "^4.1.0",
     "shx": "^0.4.0",
-    "supergateway": "^2.7.0",
+    "supergateway": "^3.1.0",
+    "tsx": "^4.19.4",
     "typescript": "^5.8.3"
   }
 }