@tiangong-lca/mcp-server 0.0.7 → 0.0.9

package/dist/src/_shared/auth_middleware.js

@@ -1,16 +1,53 @@
 import { createClient } from '@supabase/supabase-js';
 import { Redis } from '@upstash/redis';
+import { authenticateCognitoToken } from './cognito_auth.js';
+import { redis_token, redis_url, supabase_anon_key, supabase_base_url } from './config.js';
 import decodeApiKey from './decode_api_key.js';
-const supabase_base_url = process.env.SUPABASE_BASE_URL ?? '';
-const supabase_anon_key = process.env.SUPABASE_ANON_KEY ?? '';
 const supabase = createClient(supabase_base_url, supabase_anon_key);
-const redis_url = process.env.UPSTASH_REDIS_URL ?? '';
-const redis_token = process.env.UPSTASH_REDIS_TOKEN ?? '';
 const redis = new Redis({
     url: redis_url,
     token: redis_token,
 });
+function getTokenType(bearerKey) {
+    const jwtPattern = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+    if (jwtPattern.test(bearerKey)) {
+        try {
+            const payload = JSON.parse(atob(bearerKey.split('.')[1]));
+            if (payload.iss && payload.iss.includes('cognito')) {
+                return 'cognito';
+            }
+        }
+        catch (error) {
+        }
+    }
+    const credentials = decodeApiKey(bearerKey);
+    if (credentials) {
+        return 'api_key';
+    }
+    return 'supabase';
+}
 export async function authenticateRequest(bearerKey) {
+    const tokenType = getTokenType(bearerKey);
+    switch (tokenType) {
+        case 'cognito':
+            return await authenticateCognitoRequest(bearerKey);
+        case 'api_key':
+            return await authenticateApiKeyRequest(bearerKey);
+        case 'supabase':
+        default:
+            return await authenticateSupabaseRequest(bearerKey);
+    }
+}
+async function authenticateCognitoRequest(bearerKey) {
+    const cognitoResult = await authenticateCognitoToken(bearerKey);
+    return {
+        isAuthenticated: cognitoResult.isAuthenticated,
+        response: cognitoResult.response,
+        userId: cognitoResult.userId,
+        email: cognitoResult.email,
+    };
+}
+async function authenticateApiKeyRequest(bearerKey) {
     const credentials = decodeApiKey(bearerKey);
     if (credentials) {
         const { email = '', password = '' } = credentials;
@@ -20,7 +57,6 @@ export async function authenticateRequest(bearerKey) {
                 email: email,
                 password: password,
             });
-            console.error(email, password, data, error);
             if (error) {
                 return {
                     isAuthenticated: false,
@@ -38,19 +74,31 @@ export async function authenticateRequest(bearerKey) {
                 return {
                     isAuthenticated: true,
                     response: data.user.id,
+                    userId: data.user.id,
+                    email: data.user.email,
                 };
             }
         }
         return {
             isAuthenticated: true,
             response: String(userIdFromRedis),
+            userId: String(userIdFromRedis),
         };
     }
+    return {
+        isAuthenticated: false,
+        response: 'Invalid API key',
+    };
+}
+async function authenticateSupabaseRequest(bearerKey) {
+    console.log(bearerKey);
     const { data: authData } = await supabase.auth.getUser(bearerKey);
     if (authData.user?.role === 'authenticated') {
         return {
             isAuthenticated: true,
             response: authData.user?.id,
+            userId: authData.user?.id,
+            email: authData.user?.email,
         };
     }
     if (!authData || !authData.user) {
@@ -70,5 +118,7 @@ export async function authenticateRequest(bearerKey) {
     return {
         isAuthenticated: true,
         response: authData.user.id,
+        userId: authData.user.id,
+        email: authData.user.email,
     };
 }

package/dist/src/_shared/cognito_auth.js

@@ -0,0 +1,33 @@
+import { CognitoJwtVerifier } from 'aws-jwt-verify';
+import { COGNITO_CLIENT_ID, COGNITO_USER_POOL_ID } from './config.js';
+const verifier = CognitoJwtVerifier.create({
+    userPoolId: COGNITO_USER_POOL_ID,
+    tokenUse: 'access',
+    clientId: COGNITO_CLIENT_ID,
+});
+export async function authenticateCognitoToken(token) {
+    try {
+        const payload = await verifier.verify(token);
+        const userId = payload.sub || payload['cognito:username'];
+        const email = payload.email || payload['cognito:email'];
+        if (!userId) {
+            return {
+                isAuthenticated: false,
+                response: 'Invalid token: missing user ID',
+            };
+        }
+        return {
+            isAuthenticated: true,
+            response: userId,
+            userId,
+            email,
+        };
+    }
+    catch (error) {
+        console.error('Cognito token verification failed:', error);
+        return {
+            isAuthenticated: false,
+            response: error instanceof Error ? error.message : 'Token verification failed',
+        };
+    }
+}

package/dist/src/_shared/config.js

@@ -1,4 +1,13 @@
-export const supabase_base_url = process.env.SUPABASE_BASE_URL ?? '';
-export const supabase_anon_key = process.env.SUPABASE_ANON_KEY ?? '';
-export const x_api_key = process.env.X_API_KEY ?? '';
-export const x_region = process.env.X_REGION ?? '';
+export const COGNITO_REGION = process.env.COGNITO_REGION ?? 'us-east-1';
+export const COGNITO_USER_POOL_ID = process.env.COGNITO_USER_POOL_ID ?? 'us-east-1_SnSYiMoND';
+export const COGNITO_CLIENT_ID = process.env.COGNITO_CLIENT_ID ?? '3p182unuqch7rahbp0trs1sprv';
+export const COGNITO_CLIENT_SECRET = process.env.COGNITO_CLIENT_SECRET;
+export const COGNITO_ISSUER = `https://cognito-idp.${COGNITO_REGION}.amazonaws.com/${COGNITO_USER_POOL_ID}`;
+export const COGNITO_JWKS_URL = `${COGNITO_ISSUER}/.well-known/jwks.json`;
+export const COGNITO_BASE_URL = 'https://us-east-1snsyimond.auth.us-east-1.amazoncognito.com';
+export const supabase_base_url = process.env.SUPABASE_BASE_URL ?? 'https://qgzvkongdjqiiamzbbts.supabase.co';
+export const supabase_anon_key = process.env.SUPABASE_ANON_KEY ??
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InFnenZrb25nZGpxaWlhbXpiYnRzIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDAzNjUyMzQsImV4cCI6MjA1NTk0MTIzNH0.PsZIcjAqexpqIg-91twpKjALyw9big6Bn4WRLLoCzTo';
+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 ?? '';

package/dist/src/_shared/init_server.js

@@ -1,6 +1,9 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { regOpenLcaPrompts } from '../prompts/lca_calculation.js';
+import { regOpenLcaResources } from '../resources/lca_calculation.js';
 import { regBomCalculationTool } from '../tools/bom_calculation.js';
 import { regFlowSearchTool } from '../tools/flow_hybrid_search.js';
+import { regLcaCalculationGuidanceTool } from '../tools/lca_calculation_guidance.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';
@@ -9,13 +12,16 @@ export function initializeServer(bearerKey) {
     const server = new McpServer({
         name: 'TianGong-MCP-Server',
         version: '1.0.0',
-    });
+    }, { capabilities: { prompts: {}, resources: {} } });
     regFlowSearchTool(server, bearerKey);
     regProcessSearchTool(server, bearerKey);
     regBomCalculationTool(server);
     regOpenLcaLciaTool(server);
     regOpenLcaListSystemProcessTool(server);
     regOpenLcaListLCIAMethodsTool(server);
+    regOpenLcaPrompts(server);
+    regOpenLcaResources(server);
+    regLcaCalculationGuidanceTool(server);
     return server;
 }
 export function getServer(bearerKey) {

package/dist/src/_shared/init_server_http.js

@@ -0,0 +1,17 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { regBomCalculationTool } from '../tools/bom_calculation.js';
+import { regFlowSearchTool } from '../tools/flow_hybrid_search.js';
+import { regProcessSearchTool } from '../tools/process_hybrid_search.js';
+export function initializeServer(bearerKey) {
+    const server = new McpServer({
+        name: 'TianGong-LCA-MCP-Server',
+        version: '1.0.0',
+    });
+    regFlowSearchTool(server, bearerKey);
+    regProcessSearchTool(server, bearerKey);
+    regBomCalculationTool(server);
+    return server;
+}
+export function getServer(bearerKey) {
+    return initializeServer(bearerKey);
+}

package/dist/src/auth_app.js

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+import { ProxyOAuthServerProvider } from '@modelcontextprotocol/sdk/server/auth/providers/proxyProvider.js';
+import { mcpAuthRouter } from '@modelcontextprotocol/sdk/server/auth/router.js';
+import express from 'express';
+import { authenticateCognitoToken } from './_shared/cognito_auth.js';
+import { COGNITO_BASE_URL, COGNITO_CLIENT_ID, COGNITO_CLIENT_SECRET } from './_shared/config.js';
+const proxyProvider = new ProxyOAuthServerProvider({
+    endpoints: {
+        authorizationUrl: `${COGNITO_BASE_URL}/oauth2/authorize`,
+        tokenUrl: `${COGNITO_BASE_URL}/oauth2/token`,
+        revocationUrl: `${COGNITO_BASE_URL}/oauth2/revoke`,
+    },
+    verifyAccessToken: async (token) => {
+        const authResult = await authenticateCognitoToken(token);
+        if (!authResult.isAuthenticated) {
+            throw new Error('Invalid token');
+        }
+        return {
+            token,
+            clientId: COGNITO_CLIENT_ID,
+            scopes: ['openid', 'email', 'profile'],
+            audience: COGNITO_CLIENT_ID,
+        };
+    },
+    getClient: async (client_id) => {
+        return {
+            client_id,
+            redirect_uris: ['https://lcamcp.tiangong.earth/oauth/callback'],
+            response_types: ['code'],
+            grant_types: ['authorization_code', 'refresh_token'],
+            token_endpoint_auth_method: 'client_secret_post',
+            code_challenge_methods_supported: ['S256'],
+            scope: 'openid email profile',
+        };
+    },
+});
+const authApp = express();
+authApp.set('trust proxy', 1);
+authApp.use(express.json());
+authApp.use(express.urlencoded({ extended: true }));
+authApp.use((req, res, next) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+    if (req.method === 'OPTIONS') {
+        res.sendStatus(200);
+        return;
+    }
+    next();
+});
+authApp.get('/callback', async (req, res) => {
+    const { code, state, error, error_description } = req.query;
+    if (error) {
+        console.error('OAuth error:', error, error_description);
+        return res.status(400).send(`OAuth Error: ${error} - ${error_description}`);
+    }
+    if (!code) {
+        console.error('Missing authorization code in callback');
+        return res.status(400).send('Missing authorization code');
+    }
+    res.send(`
+    <!DOCTYPE html>
+    <html>
+    <head>
+      <meta charset="utf-8">
+      <title>Authentication Successful - Tiangong LCA MCP</title>
+      <style>
+        body { 
+          font-family: Arial, sans-serif; 
+          margin: 40px; 
+          background-color: #f5f5f5; 
+        }
+        .container { 
+          max-width: 800px; 
+          margin: 0 auto; 
+          background: white; 
+          padding: 30px; 
+          border-radius: 8px; 
+          box-shadow: 0 2px 10px rgba(0,0,0,0.1); 
+        }
+        .header {
+          text-align: center;
+          margin-bottom: 40px;
+          color: #333;
+        }
+        .section { 
+          margin: 30px 0; 
+          padding: 20px; 
+          border: 1px solid #ddd; 
+          border-radius: 6px;
+          background-color: #fafafa;
+        }
+        .success { 
+          color: #2e7d32; 
+          background-color: #e8f5e8;
+          padding: 15px;
+          border-radius: 4px;
+          border-left: 4px solid #2e7d32;
+          margin: 15px 0;
+        }
+        .code-display { 
+          background: #f5f5f5; 
+          padding: 15px; 
+          border-radius: 4px; 
+          border-left: 4px solid #1976d2; 
+          margin: 15px 0; 
+          font-family: monospace; 
+          word-break: break-all; 
+        }
+        .link {
+          color: #1976d2;
+          text-decoration: none;
+          font-weight: bold;
+          background: #1976d2;
+          color: white;
+          padding: 12px 24px;
+          border-radius: 4px;
+          display: inline-block;
+          margin: 10px 10px 0 0;
+          transition: background-color 0.3s;
+        }
+        .link:hover {
+          background: #1565c0;
+          text-decoration: none;
+        }
+        button {
+          background: #1976d2;
+          color: white;
+          border: none;
+          padding: 12px 24px;
+          border-radius: 4px;
+          cursor: pointer;
+          font-size: 14px;
+          font-weight: bold;
+          margin: 10px 10px 0 0;
+          transition: background-color 0.3s;
+          text-decoration: none;
+          display: inline-block;
+        }
+        button:hover {
+          background: #1565c0;
+        }
+        .copy-button {
+          background: #28a745;
+          color: white;
+          border: none;
+          padding: 8px 16px;
+          border-radius: 4px;
+          cursor: pointer;
+          font-size: 12px;
+          font-weight: bold;
+          margin-left: 10px;
+          transition: background-color 0.3s;
+        }
+        .copy-button:hover {
+          background: #218838;
+        }
+        .copy-button:active {
+          background: #1e7e34;
+        }
+        .code-container {
+          position: relative;
+        }
+        .code-header {
+          display: flex;
+          align-items: center;
+          justify-content: space-between;
+          margin-bottom: 10px;
+        }
+      </style>
+    </head>
+    <body>
+      <div class="container">
+        <div class="header">
+          <h1>🎉 Authentication Successful!</h1>
+          <p>Your OAuth authorization has been completed successfully</p>
+        </div>
+        
+        <div class="success">
+          <p><strong>✅ Authorization Code Received</strong></p>
+          <p>You can now exchange this code for an access token using PKCE.</p>
+        </div>
+        
+        <div class="section">
+          <div class="code-container">
+            <div class="code-header">
+              <h3>🔑 Your Authorization Code</h3>
+              <button class="copy-button" onclick="copyAuthCode()">📋 Copy Code</button>
+            </div>
+            <div class="code-display" id="auth-code">${code}</div>
+            <p>Use this code along with your stored code verifier to exchange for an access token in the demo interface.</p>
+          </div>
+        </div>
+        
+        <div class="section">
+          <h3>🚀 Next Steps</h3>
+          <ol>
+            <li>Copy the authorization code above</li>
+            <li>Return to the OAuth demo page</li>
+            <li>Paste the code in the "Exchange Authorization Code" section</li>
+            <li>Click "Exchange for Token" to get your access token</li>
+          </ol>
+        </div>
+        
+        <div class="section">
+          <button onclick="window.close()">Close Window</button>
+        </div>
+      </div>
+      
+      <script>
+        // Copy authorization code to clipboard
+        function copyAuthCode() {
+          const codeElement = document.getElementById('auth-code');
+          const code = codeElement.textContent;
+          
+          if (navigator.clipboard && window.isSecureContext) {
+            // Use modern clipboard API
+            navigator.clipboard.writeText(code).then(() => {
+              showCopySuccess();
+            }).catch(() => {
+              fallbackCopy(code);
+            });
+          } else {
+            // Fallback for older browsers or non-secure contexts
+            fallbackCopy(code);
+          }
+        }
+        
+        function fallbackCopy(text) {
+          // Create a temporary textarea element
+          const textArea = document.createElement('textarea');
+          textArea.value = text;
+          textArea.style.position = 'fixed';
+          textArea.style.left = '-999999px';
+          textArea.style.top = '-999999px';
+          document.body.appendChild(textArea);
+          textArea.focus();
+          textArea.select();
+          
+          try {
+            document.execCommand('copy');
+            showCopySuccess();
+          } catch (err) {
+            console.error('Failed to copy text: ', err);
+            alert('Failed to copy code to clipboard. Please copy manually.');
+          }
+          
+          document.body.removeChild(textArea);
+        }
+        
+        function showCopySuccess() {
+          const button = document.querySelector('.copy-button');
+          const originalText = button.textContent;
+          button.textContent = '✅ Copied!';
+          button.style.background = '#28a745';
+          
+          setTimeout(() => {
+            button.textContent = originalText;
+            button.style.background = '#28a745';
+          }, 2000);
+        }
+        
+        // Try to communicate with parent window if in popup
+        if (window.opener) {
+          window.opener.postMessage({ 
+            type: 'oauth_success', 
+            code: '${code}',
+            state: '${state || ''}'
+          }, '*');
+        }
+      </script>
+    </body>
+    </html>
+  `);
+});
+authApp.post('/token', async (req, res) => {
+    const { grant_type, client_id, code, redirect_uri, code_verifier } = req.body;
+    if (!grant_type || grant_type !== 'authorization_code') {
+        return res
+            .status(400)
+            .json({ error: 'invalid_request', error_description: 'Invalid or missing grant_type' });
+    }
+    if (!client_id || client_id !== COGNITO_CLIENT_ID) {
+        return res
+            .status(400)
+            .json({ error: 'invalid_client', error_description: 'Invalid or missing client_id' });
+    }
+    if (!code) {
+        return res
+            .status(400)
+            .json({ error: 'invalid_request', error_description: 'Missing authorization code' });
+    }
+    if (!redirect_uri || redirect_uri !== 'https://lcamcp.tiangong.earth/oauth/callback') {
+        return res
+            .status(400)
+            .json({ error: 'invalid_request', error_description: 'Invalid redirect_uri' });
+    }
+    if (!code_verifier) {
+        return res
+            .status(400)
+            .json({ error: 'invalid_request', error_description: 'Missing code_verifier for PKCE' });
+    }
+    try {
+        const tokenParams = new URLSearchParams({
+            grant_type: 'authorization_code',
+            client_id: COGNITO_CLIENT_ID,
+            code: code,
+            redirect_uri: redirect_uri,
+            code_verifier: code_verifier,
+        });
+        const headers = {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: 'application/json',
+        };
+        if (COGNITO_CLIENT_SECRET) {
+            const credentials = Buffer.from(`${COGNITO_CLIENT_ID}:${COGNITO_CLIENT_SECRET}`).toString('base64');
+            headers['Authorization'] = `Basic ${credentials}`;
+        }
+        const tokenResponse = await fetch(`${COGNITO_BASE_URL}/oauth2/token`, {
+            method: 'POST',
+            headers,
+            body: tokenParams,
+        });
+        const responseText = await tokenResponse.text();
+        if (!tokenResponse.ok) {
+            console.error('Token exchange failed:', responseText);
+            return res.status(tokenResponse.status).json({
+                error: 'invalid_grant',
+                error_description: `Token exchange failed: ${responseText}`,
+            });
+        }
+        const tokens = JSON.parse(responseText);
+        const response = {
+            access_token: tokens.access_token,
+            token_type: tokens.token_type,
+            expires_in: tokens.expires_in,
+            ...(tokens.refresh_token && { refresh_token: tokens.refresh_token }),
+            ...(tokens.id_token && { id_token: tokens.id_token }),
+        };
+        res.json(response);
+    }
+    catch (error) {
+        console.error('Token exchange error:', error);
+        res.status(500).json({
+            error: 'server_error',
+            error_description: 'Internal server error during token exchange',
+        });
+    }
+});
+authApp.use(mcpAuthRouter({
+    provider: proxyProvider,
+    issuerUrl: new URL('https://lcamcp.tiangong.earth/oauth'),
+    baseUrl: new URL('https://lcamcp.tiangong.earth/oauth'),
+    serviceDocumentationUrl: new URL('https://docs.aws.amazon.com/cognito/'),
+}));
+export default authApp;

package/dist/src/index_server.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import express from 'express';
+import path from 'path';
+import { fileURLToPath } from 'url';
 import { authenticateRequest } from './_shared/auth_middleware.js';
-import { getServer } from './_shared/init_server.js';
+import { getServer } from './_shared/init_server_http.js';
+import authApp from './auth_app.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 const authenticateBearer = async (req, res, next) => {
     const authHeader = req.headers.authorization;
     if (!authHeader || !authHeader.startsWith('Bearer ')) {
@@ -33,7 +38,19 @@ const authenticateBearer = async (req, res, next) => {
     next();
 };
 const app = express();
+app.set('trust proxy', 1);
 app.use(express.json());
+const publicPath = path.join(__dirname, '..', 'public');
+app.use((req, res, next) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+    res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+    if (req.method === 'OPTIONS') {
+        res.sendStatus(200);
+        return;
+    }
+    next();
+});
 app.post('/mcp', authenticateBearer, async (req, res) => {
     try {
         const server = getServer(req.bearerKey);
@@ -85,10 +102,22 @@ app.delete('/mcp', async (req, res) => {
     }));
 });
 app.get('/health', async (req, res) => {
+    console.log('Health check requested');
     res.status(200).json({
-        status: 'ok'
+        status: 'ok',
+        timestamp: new Date().toISOString(),
     });
 });
+app.use('/oauth', authApp);
+app.get('/', async (req, res) => {
+    res.redirect('/oauth/index');
+});
+app.get('/oauth/index', async (req, res) => {
+    res.sendFile(path.join(publicPath, 'oauth-index.html'));
+});
+app.get('/oauth/demo', async (req, res) => {
+    res.sendFile(path.join(publicPath, 'oauth-demo.html'));
+});
 const PORT = Number(process.env.PORT ?? 9278);
 const HOST = process.env.HOST ?? '0.0.0.0';
 app.listen(PORT, HOST, () => {

package/dist/src/prompts/lca_calculation.js

@@ -0,0 +1,19 @@
+export function regOpenLcaPrompts(server) {
+    server.prompt('openlca', `The workflow for LCA calculation`, () => {
+        return {
+            messages: [
+                {
+                    role: 'assistant',
+                    content: {
+                        type: 'text',
+                        text: `I am an expert in Life Cycle Assessment (LCA) and use the MCP tool to perform LCA calculations. 
+            The workflow is as follows:
+            1. Use the OpenLCA_Impact_Assessment_Tool to list all LCIA (Life Cycle Impact Assessment) method UUIDs and their corresponding names.
+            2. Use the OpenLCA_List_System_Processes_Tool to list all system process UUIDs and their corresponding names.
+            3. Use the OpenLCA_Impact_Assessment_Tool to perform LCA calculations.`,
+                    },
+                },
+            ],
+        };
+    });
+}

package/dist/src/resources/lca_calculation.js

@@ -0,0 +1,16 @@
+export function regOpenLcaResources(server) {
+    server.resource('Guidence for LCA calculation', `resource://openlca`, (request) => {
+        return {
+            contents: [
+                {
+                    uri: 'resource://openlca',
+                    mimeType: 'text/plain',
+                    text: `The workflow to perform LCA calculations using the MCP tool is as follows:
+            1. Use the OpenLCA_Impact_Assessment_Tool to list all LCIA (Life Cycle Impact Assessment) method UUIDs and their corresponding names.
+            2. Use the OpenLCA_List_System_Processes_Tool to list all system process UUIDs and their corresponding names.
+            3. Use the OpenLCA_Impact_Assessment_Tool to perform LCA calculations.`,
+                },
+            ],
+        };
+    });
+}

package/dist/src/tools/lca_calculation_guidance.js

@@ -0,0 +1,19 @@
+async function getLcaCalculationGuidance() {
+    const prompt = `The workflow to perform LCA calculations using the MCP tool is as follows:
+            1. Use the OpenLCA_Impact_Assessment_Tool to list all LCIA (Life Cycle Impact Assessment) method UUIDs and their corresponding names.
+            2. Use the OpenLCA_List_System_Processes_Tool to list all system process UUIDs and their corresponding names.
+            3. Use the OpenLCA_Impact_Assessment_Tool to perform LCA calculations.`;
+    return prompt;
+}
+export function regLcaCalculationGuidanceTool(server) {
+    server.tool('LCA_Calculation_Guidance_Tool', 'Get the workflow, which should be followed for Life Cycle Assessment (LCA) Calculations to Obtain Life Cycle Impact Assessment (LCIA) Results', async () => {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: await getLcaCalculationGuidance(),
+                },
+            ],
+        };
+    });
+}