@edubase/mcp 1.0.23

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 EduBase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,169 @@
+<img src="https://static.edubase.net/media/brand/title/color.png" alt="EduBase logo" height="150" />
+
+# EduBase MCP server
+
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/EduBase/MCP/main.svg)](https://results.pre-commit.ci/latest/github/EduBase/MCP/main)
+[![smithery badge](https://smithery.ai/badge/@EduBase/MCP)](https://smithery.ai/server/@EduBase/MCP)
+
+This repository contains the **implementation of the Model Context Protocol** (MCP) server **for the EduBase platform**. It allows MCP clients (for example Claude Desktop) and LLMs to interact with your EduBase account and perform tasks on your behalf. It supports stdio, SSE and streamable HTTP transport protocols.
+
+![EduBase MCP demo GIF: Claude uploads math questions](https://shared.edubase.net/mcp/EduBaseMCPdemomath.gif)
+
+<a href="https://glama.ai/mcp/servers/@EduBase/MCP">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/@EduBase/MCP/badge" alt="EduBase Server MCP server" />
+</a>
+
+## What is EduBase?
+
+EduBase is an innovative, modular, online educational platform that makes learning more enjoyable, simpler and interactive, suitable for educational institutions or enterprises.
+
+### Why choose EduBase?
+
+EduBase revolutionizes digital learning with its unique combination of features:
+
+* **Advanced Quiz System** with parametrization allowing infinite variations of the same question, real-time cheating detection, beautiful LaTeX typesetting, advanced STEM-support and automatic grading
+* **Unified Learning Environment** that centralizes all your educational content — videos, exams, documents, and SCORM modules — in one intuitive system
+* **Enterprise-Grade Security** with features like SSO integration, fine-grained access controls, comprehensive auditing, and GDPR compliance
+* **Integration** with your existing systems through LTI, comprehensive API, and custom integration options
+* **AI-Assisted Tools**, such as EduBase Assistant, that can instantly transform your existing content into interactive quizzes and assessments, or translate your materials from one language to another
+
+From higher education institutions to corporate training departments, EduBase scales to meet your specific needs while maintaining an intuitive user experience across all devices.
+
+### Demo video
+
+Collaboratively creating and uploading questions, scheduling exams and analyzing user results with Claude:
+
+<a href="https://www.youtube.com/watch?v=jvGP-5NzRPs">
+  <img src="https://img.youtube.com/vi/jvGP-5NzRPs/maxresdefault.jpg" alt="Demonstrating EduBase's MCP server to collaboratively create and upload questions, schedule exams and analyze results." width="600"/>
+</a>
+
+### Obtaining your API credentials
+
+Once logged in, on your Dashboard, search for the Integrations menu, click "add integration" and choose the type "EduBase API".
+
+**If you don't see this option**, enter the `MCPGITHUB` activation code or feel free to contact us to request access at [info@edubase.net](mailto:info@edubase.net).
+
+<img src="https://shared.edubase.net/mcp/EduBase_Integration_page_with_API_credentials.png" alt="EduBase API credentials page" width="500" />
+
+## Tools
+
+Each documented API endpoint is available as a separate tool, named `edubase_<method>_<endpoint>`. For example, the tool for the `GET /user:me` endpoint is named `edubase_get_user_me`. See our [developer documentation](https://developer.edubase.net) for more information.
+
+## Configuration
+
+The MCP server can be configured using environment variables. The following variables are available:
+
+| Variable | Description | Required | Default value |
+|---|---|---|---|
+| `EDUBASE_API_URL` | The base URL of the EduBase API, most probably `https://subdomain.edubase.net/api`. | **Yes** | `https://www.edubase.net/api` |
+| `EDUBASE_API_APP` | The App ID of your integration app on EduBase, the `app` on the EduBase API. Find this in the integration details window on EduBase. | Not if HTTP transport is used with authentication, otherwise **Yes** | - |
+| `EDUBASE_API_KEY` | The Secret key of your integration app on EduBase, the `secret` on the EduBase API. Find this along the App ID in the integration details window on EduBase. | Not if HTTP transport is used with authentication, otherwise **Yes** | - |
+| `EDUBASE_SSE_MODE` | Start MCP server in HTTP mode with SSE transport. Value must be `true`. | No | `false` |
+| `EDUBASE_STREAMABLE_HTTP_MODE` | Start MCP server in HTTP mode with streamable HTTP transport. Value must be `true`. | No | `false` |
+| `EDUBASE_HTTP_PORT` | HTTP server will listen on this port if SSE or streamable HTTP transport mode is used. | No | 3000 |
+
+## Use as a remote MCP server
+
+You can use the **EduBase MCP server as a remote MCP server** for your MCP client. To do this, you need to host the MCP server where clients can access it, and then configure the client to connect to the server. Either start it with SSE or streamable HTTP transport mode and always use HTTPS when accessing the server remotely over the internet!
+
+### Authentication with remote servers
+
+You can use server in two modes:
+
+* **Without client authentication**: In this mode, the server will not require any authentication from the client. This is useful for testing or development purposes, or in a closed network but it is not recommended for production use. For this, you have to configure the server with the `EDUBASE_API_APP` and `EDUBASE_API_KEY` as well!
+* **With Bearer token authentication**: In this mode, the server will require a Bearer token to be sent with each request. This is the recommended way to use the server in production. You can obtain the Bearer token from your EduBase account by creating an integration app and providing the App ID and Secret key in the `{app}:{secret}` format, base64 encoded as a token. The server will then use this token to authenticate the client and authorize access to the API endpoints.
+
+## Usage with Claude Desktop
+
+For a step-by-step walkthrough, see our blog post on how to [connect EduBase with Claude: The Complete MCP Integration Guide](https://edubase.blog/claude-mcp-integration-guide/).
+
+### Installing manually
+
+Add the following to your `claude_desktop_config.json`:
+
+#### Using Node.js
+
+Before running the MCP server, make sure you have **Node.js installed**. You can download it from [nodejs.org](https://nodejs.org/) or use a package manager like `brew`. Download EduBase MCP server release or clone the repository and run `npm run build` to build the server. Do not forget to adjust `/path/to/dist` to the actual directory and **configure the environmental variables**!
+
+```json
+{
+  "mcpServers": {
+    "edubase": {
+      "command": "node",
+      "args": [
+        "/path/to/dist/index.js"
+      ],
+      "env": {
+        "EDUBASE_API_URL": "https://domain.edubase.net/api",
+        "EDUBASE_API_APP": "your_integration_app_id",
+        "EDUBASE_API_KEY": "your_integration_secret_key"
+      }
+    }
+  }
+}
+```
+
+#### Using Docker
+
+Before running the MCP server, make sure you have **Docker installed and is running**. You can download it from [docker.com](https://www.docker.com/) or use a package manager. Do not forget to **configure the environmental variables**!
+
+```json
+{
+  "mcpServers": {
+    "edubase": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "-e",
+        "EDUBASE_API_URL",
+        "-e",
+        "EDUBASE_API_APP",
+        "-e",
+        "EDUBASE_API_KEY",
+        "edubase/mcp"
+      ],
+      "env": {
+        "EDUBASE_API_URL": "https://domain.edubase.net/api",
+        "EDUBASE_API_APP": "your_integration_app_id",
+        "EDUBASE_API_KEY": "your_integration_secret_key"
+      }
+    }
+  }
+}
+```
+
+### Installing via remote MCP server
+
+You can use the provided EduBase MCP server (if available) as a remote server. We recommend Base64 encoding your `EDUBASE_API_APP` and `EDUBASE_API_KEY` and using it in as a Bearer token in the `Authorization` header (`Authorization: Bearer ${BASE64_ENCODED_TOKEN}`).
+
+```json
+{
+  "mcpServers": {
+    "edubase": {
+      "command": "npx",
+      "args": [
+        "mcp-remote",
+        "https://domain.edubase.net/mcp",
+        "--header",
+        "Authorization: Bearer ${EDUBASE_API_APP}:${EDUBASE_API_KEY}"
+      ]
+    }
+  }
+}
+```
+
+### Installing via Smithery
+
+To install EduBase MCP server for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@EduBase/MCP):
+
+```bash
+npx -y @smithery/cli install @EduBase/MCP --client claude
+```
+
+## Contact
+
+Website: [www.edubase.net](www.edubase.net)  
+Developer Documentation: [developer.edubase.net](developer.edubase.net)  
+Email: [info@edubase.net](mailto:info@edubase.net)

package/dist/helpers.js

@@ -0,0 +1,4 @@
+/* Get request client IP address */
+export function getClientIp(req) {
+    return (req.get('x-forwarded-for')?.split(',')[0] || req.get('x-real-ip') || req.ip || req.socket.remoteAddress || null);
+}

package/dist/index.js

@@ -0,0 +1,430 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { randomUUID } from "node:crypto";
+import queryString from "query-string";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { InMemoryEventStore } from '@modelcontextprotocol/sdk/examples/shared/inMemoryEventStore.js';
+import express from "express";
+import bodyParser from "body-parser";
+import { getClientIp } from "./helpers.js";
+/* Enable SSE or Streamable HTTP mode */
+const SSE = ((process.env.EDUBASE_SSE_MODE || 'false') == 'true');
+const STREAMABLE_HTTP = ((process.env.EDUBASE_STREAMABLE_HTTP_MODE || 'false') == 'true');
+/* Check required EduBase environment variables */
+const EDUBASE_API_URL = process.env.EDUBASE_API_URL || 'https://www.edubase.net/api';
+if (!SSE && !STREAMABLE_HTTP && EDUBASE_API_URL.length == 0) {
+    console.error('Error: EDUBASE_API_URL environment variable is required with this transport mode');
+    process.exit(1);
+}
+const EDUBASE_API_APP = process.env.EDUBASE_API_APP || '';
+if (!SSE && !STREAMABLE_HTTP && EDUBASE_API_APP.length == 0) {
+    console.error('Error: EDUBASE_API_APP environment variable is required with this transport mode');
+    process.exit(1);
+}
+const EDUBASE_API_KEY = process.env.EDUBASE_API_KEY || '';
+if (!SSE && !STREAMABLE_HTTP && EDUBASE_API_KEY.length == 0) {
+    console.error('Error: EDUBASE_API_KEY environment variable is required with this transport mode');
+    process.exit(1);
+}
+/* Supported tools and prompts */
+import { EDUBASE_API_TOOLS, EDUBASE_API_TOOLS_OUTPUT_SCHEMA } from "./tools.js";
+import { EDUBASE_API_PROMPTS, EDUBASE_API_PROMPTS_HANDLERS } from "./prompts.js";
+/* Create MCP server */
+const server = new Server({
+    name: '@edubase/mcp',
+    version: '1.0.23',
+}, {
+    capabilities: {
+        prompts: {},
+        tools: {},
+    },
+});
+/* EduBase API rate limits (via environment variables or configured defaults) */
+const EDUBASE_API_MAXRATE_DEFAULT = {
+    second: 10,
+    minute: 1000
+};
+const EDUBASE_API_MAXRATE_ENV = {
+    second: parseInt(process.env.EDUBASE_API_MAXRATE || ''),
+    minute: parseInt(process.env.EDUBASE_API_MAXRATE60 || '')
+};
+const EDUBASE_API_MAXRATE = {
+    second: Number.isInteger(EDUBASE_API_MAXRATE_ENV.second) ? EDUBASE_API_MAXRATE_ENV.second : EDUBASE_API_MAXRATE_DEFAULT.second,
+    minute: Number.isInteger(EDUBASE_API_MAXRATE_ENV.minute) ? EDUBASE_API_MAXRATE_ENV.minute : EDUBASE_API_MAXRATE_DEFAULT.minute,
+};
+let requestRate = {
+    second: 0,
+    minute: 0,
+    since: {
+        second: Date.now(),
+        minute: Date.now()
+    }
+};
+function checkRateLimit() {
+    const now = Date.now();
+    if (now - requestRate.since.second > 1000) {
+        /* New second, reset rate */
+        requestRate.second = 0;
+        requestRate.since.second = now;
+    }
+    if (now - requestRate.since.minute > 60000) {
+        /* New minute, reset rate */
+        requestRate.minute = 0;
+        requestRate.since.minute = now;
+    }
+    if (requestRate.second >= EDUBASE_API_MAXRATE.second || requestRate.minute >= EDUBASE_API_MAXRATE.minute) {
+        throw new Error('Rate limit exceeded');
+    }
+    requestRate.second++;
+    requestRate.minute++;
+}
+async function sendEduBaseApiRequest(method, endpoint, data, authentication) {
+    /* Check method and endpoint */
+    method = method.toUpperCase();
+    if (!['GET', 'POST', 'DELETE'].includes(method)) {
+        throw new Error('Invalid method: "' + method + '"');
+    }
+    if (endpoint.length == 0) {
+        throw new Error('Invalid endpoint');
+    }
+    /* Check rate limit */
+    checkRateLimit();
+    /* Prepare authentication (prefer EDUBASE_API_APP and EDUBASE_API_KEY environment variables) */
+    if (!authentication) {
+        authentication = { app: EDUBASE_API_APP, secret: EDUBASE_API_KEY };
+    }
+    else {
+        if (!authentication.hasOwnProperty('app') || authentication.app.length == 0 || EDUBASE_API_APP.length > 0) {
+            authentication.app = EDUBASE_API_APP;
+        }
+        if (!authentication.hasOwnProperty('secret') || authentication.secret.length == 0 || EDUBASE_API_KEY.length > 0) {
+            authentication.secret = EDUBASE_API_KEY;
+        }
+    }
+    /* Send request with input data */
+    let headers = {
+        'Content-Type': 'application/json',
+        'Accept-Encoding': 'gzip',
+        'EduBase-API-Client': 'MCP',
+        'EduBase-API-Transport': (STREAMABLE_HTTP) ? 'Streamable HTTP' : ((SSE) ? 'SSE' : 'Stdio'),
+        'EduBase-API-App': authentication.app,
+        'EduBase-API-Secret': authentication.secret
+    };
+    const response = await fetch(endpoint + (method == 'GET' ? '?' + queryString.stringify(data) : ''), {
+        method: method,
+        body: (method != 'GET' ? JSON.stringify(data) : undefined),
+        headers: headers
+    });
+    if (!response.ok) {
+        throw new Error(`EduBase API error: ${response.status} ${response.statusText}` + (response.headers.has('EduBase-API-Error') ? ` (${response.headers.get('EduBase-API-Error')})` : ''));
+    }
+    /* Parse response and return as object */
+    let clonedResponse = response.clone();
+    try {
+        /* First try to decode as JSON */
+        return await response.json();
+    }
+    catch (error) {
+        /* Response might be empty string with a 200 status code */
+        return await clonedResponse.text();
+    }
+}
+server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+    prompts: Object.values(EDUBASE_API_PROMPTS),
+}));
+server.setRequestHandler(GetPromptRequestSchema, (request) => {
+    try {
+        /* Decompose request and check arguments */
+        const { name, arguments: args } = request.params;
+        const promptHandler = EDUBASE_API_PROMPTS_HANDLERS[name];
+        if (!promptHandler) {
+            throw new Error('Prompt not found');
+        }
+        /* Return prompt response */
+        return promptHandler;
+    }
+    catch (error) {
+        /* Request failed */
+        return {};
+    }
+});
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: EDUBASE_API_TOOLS,
+}));
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+        /* Decompose request and check arguments */
+        const { name, arguments: args } = request.params;
+        if (!name.match(/^edubase_(get|post|delete)/)) {
+            throw new Error('Invalid tool configuration');
+        }
+        if (!args) {
+            throw new Error('No arguments provided');
+        }
+        const meta = request.params._meta || {};
+        /* Prepare authentication */
+        let authentication = null;
+        if (meta && meta.override && meta.override.EDUBASE_API_APP && meta.override.EDUBASE_API_KEY) {
+            /* Use authentication from custom configuration */
+            authentication = {
+                app: meta.override.EDUBASE_API_APP,
+                secret: meta.override.EDUBASE_API_KEY
+            };
+        }
+        else if (meta && meta.headers && meta.headers['edubase-api-app'] && meta.headers['edubase-api-secret']) {
+            /* Use authentication from request headers */
+            authentication = {
+                app: meta.headers['edubase-api-app'],
+                secret: meta.headers['edubase-api-secret']
+            };
+        }
+        else if (meta && meta.headers && meta.headers['authorization'] && meta.headers['authorization'].startsWith('Bearer ')) {
+            /* Use authentication from Bearer token */
+            try {
+                /* Decode Bearer token */
+                const [app, secret] = atob(meta.headers['authorization'].split(' ')[1]).split(':');
+                if (app && app.length > 0 && secret && secret.length > 0) {
+                    authentication = { app, secret };
+                }
+            }
+            catch (error) {
+                /* Probably not encoded as base64 */
+                const [app, secret] = meta.headers['authorization'].split(' ')[1].split(':');
+                if (app && app.length > 0 && secret && secret.length > 0) {
+                    authentication = { app, secret };
+                }
+            }
+        }
+        /* Prepare and send API request */
+        const [, method, ...endpoint] = name.split('_');
+        const response = await sendEduBaseApiRequest(method, (meta?.override?.EDUBASE_API_URL || EDUBASE_API_URL) + '/' + endpoint.join(':'), args, authentication);
+        /* Return response */
+        const outputSchemaKey = name;
+        if (typeof EDUBASE_API_TOOLS_OUTPUT_SCHEMA[outputSchemaKey] == 'object' && Object.keys(EDUBASE_API_TOOLS_OUTPUT_SCHEMA[outputSchemaKey]).length == 0 && typeof response == 'string' && response.length == 0) {
+            /* Endpoint without response */
+            return {
+                content: [{ type: 'text', text: 'Success.' }],
+                isError: false,
+            };
+        }
+        else if (typeof response != 'object') {
+            /* Response should be an object at this point */
+            throw new Error('Invalid response');
+        }
+        else {
+            /* Return response with optional schema */
+            return {
+                content: [{ type: 'text', text: "Response: " + JSON.stringify(response) + (Object.keys(EDUBASE_API_TOOLS_OUTPUT_SCHEMA[outputSchemaKey]).length > 0 ? "\nResponse schema: " + JSON.stringify(EDUBASE_API_TOOLS_OUTPUT_SCHEMA[outputSchemaKey]) : '') }],
+                isError: false,
+            };
+        }
+    }
+    catch (error) {
+        /* Request failed */
+        return {
+            content: [{
+                    type: 'text',
+                    text: `${error instanceof Error ? error.message : String(error)}`,
+                }],
+            isError: true,
+        };
+    }
+});
+/* Start MCP server */
+if (STREAMABLE_HTTP) {
+    /* Using HTTP with Streamable HTTP transport */
+    const app = express();
+    app.disable('x-powered-by');
+    app.use(bodyParser.json());
+    const transports = {};
+    app.post('/mcp', async (req, res) => {
+        /* Handle POST requests */
+        const sessionId = req.headers['mcp-session-id'];
+        let transport;
+        if (sessionId && transports[sessionId]) {
+            /* Use existing session */
+            transport = transports[sessionId];
+        }
+        else if (!sessionId && isInitializeRequest(req.body)) {
+            /* New session */
+            const eventStore = new InMemoryEventStore();
+            transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+                eventStore,
+                onsessioninitialized: (sessionId) => {
+                    transports[sessionId] = transport;
+                }
+            });
+            transport.onclose = () => {
+                if (transport.sessionId) {
+                    delete transports[transport.sessionId];
+                }
+            };
+            await server.connect(transport);
+        }
+        else {
+            console.error("No session found for request");
+            res.status(400).send();
+            return;
+        }
+        try {
+            let override = { EDUBASE_API_URL: null, EDUBASE_API_APP: null, EDUBASE_API_KEY: null };
+            if (req.query?.config && typeof req.query.config == 'string') {
+                /* Apply Smithery configuration */
+                const smitheryConfig = JSON.parse(Buffer.from(req.query.config, 'base64').toString());
+                if (smitheryConfig.edubaseApiUrl && typeof smitheryConfig.edubaseApiUrl == 'string' && smitheryConfig.edubaseApiUrl.length > 0) {
+                    override.EDUBASE_API_URL = smitheryConfig.edubaseApiUrl;
+                }
+                if (smitheryConfig.edubaseApiApp && typeof smitheryConfig.edubaseApiApp == 'string' && smitheryConfig.edubaseApiApp.length > 0) {
+                    override.EDUBASE_API_APP = smitheryConfig.edubaseApiApp;
+                }
+                if (smitheryConfig.edubaseApiKey && typeof smitheryConfig.edubaseApiKey == 'string' && smitheryConfig.edubaseApiKey.length > 0) {
+                    override.EDUBASE_API_KEY = smitheryConfig.edubaseApiKey;
+                }
+            }
+            const params = req.body?.params || {};
+            params._meta = {
+                ip: getClientIp(req),
+                headers: req.headers,
+                override: override,
+            };
+            await transport.handleRequest(req, res, { ...req.body, params });
+        }
+        catch (error) {
+            console.error("Error handling POST request for session (" + sessionId + "): " + error);
+            res.status(500).send();
+        }
+    });
+    app.get('/mcp', async (req, res) => {
+        /* Handle GET requests */
+        const sessionId = req.headers['mcp-session-id'];
+        if (!sessionId || !transports[sessionId]) {
+            res.status(400).send('Invalid session ID');
+            return;
+        }
+        try {
+            const transport = transports[sessionId];
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error("Error handling GET request for session (" + sessionId + "): " + error);
+            res.status(500).send();
+        }
+    });
+    app.delete('/mcp', async (req, res) => {
+        /* Handle DELETE requests */
+        const sessionId = req.headers['mcp-session-id'];
+        if (!sessionId || !transports[sessionId]) {
+            res.status(400).send('Invalid session ID');
+            return;
+        }
+        try {
+            const transport = transports[sessionId];
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error("Error handling DELETE request for session (" + sessionId + "): " + error);
+            res.status(500).send();
+        }
+    });
+    app.get('/health', async (_, res) => {
+        /* Health check endpoint */
+        res.status(200).send();
+    });
+    const EDUBASE_HTTP_PORT = parseInt(process.env.EDUBASE_HTTP_PORT || process.env.PORT || '3000');
+    app.listen(EDUBASE_HTTP_PORT, () => {
+        console.error("EduBase MCP server is now listening on HTTP port " + EDUBASE_HTTP_PORT + " with Streamable HTTP transport");
+    });
+    process.on('SIGTERM', () => {
+        /* Graceful shutdown */
+        console.error("Received SIGTERM, shutting down EduBase MCP server...");
+        server.close();
+    });
+}
+else if (SSE) {
+    /* Using HTTP with SSE transport */
+    const app = express();
+    app.use(bodyParser.json());
+    app.disable('x-powered-by');
+    const transports = {};
+    app.get('/sse', async (_, res) => {
+        /* Handle SSE sessions */
+        const transport = new SSEServerTransport('/messages', res);
+        transports[transport.sessionId] = transport;
+        res.on('close', () => {
+            delete transports[transport.sessionId];
+        });
+        try {
+            await server.connect(transport);
+        }
+        catch (error) {
+            console.error("Error connecting transport to MCP server for session (" + transport.sessionId + "): " + error);
+        }
+    });
+    app.post('/messages', async (req, res) => {
+        /* Handle MCP messages */
+        const sessionId = req.query.sessionId;
+        const transport = transports[sessionId] ?? Object.values(transports)[0];
+        if (transport) {
+            try {
+                let override = { EDUBASE_API_URL: null, EDUBASE_API_APP: null, EDUBASE_API_KEY: null };
+                if (req.query?.config && typeof req.query.config == 'string') {
+                    /* Apply Smithery configuration */
+                    const smitheryConfig = JSON.parse(Buffer.from(req.query.config, 'base64').toString());
+                    if (smitheryConfig.edubaseApiUrl && typeof smitheryConfig.edubaseApiUrl == 'string' && smitheryConfig.edubaseApiUrl.length > 0) {
+                        override.EDUBASE_API_URL = smitheryConfig.edubaseApiUrl;
+                    }
+                    if (smitheryConfig.edubaseApiApp && typeof smitheryConfig.edubaseApiApp == 'string' && smitheryConfig.edubaseApiApp.length > 0) {
+                        override.EDUBASE_API_APP = smitheryConfig.edubaseApiApp;
+                    }
+                    if (smitheryConfig.edubaseApiKey && typeof smitheryConfig.edubaseApiKey == 'string' && smitheryConfig.edubaseApiKey.length > 0) {
+                        override.EDUBASE_API_KEY = smitheryConfig.edubaseApiKey;
+                    }
+                }
+                const params = req.body?.params || {};
+                params._meta = {
+                    ip: getClientIp(req),
+                    headers: req.headers,
+                    override: override,
+                };
+                await transport.handlePostMessage(req, res, { ...req.body, params });
+            }
+            catch (error) {
+                console.error("Error handling message for session (" + sessionId + "): " + error);
+                res.status(500).send();
+            }
+        }
+        else {
+            console.error("No transport found for session (" + sessionId + ")");
+            res.status(400).send();
+        }
+    });
+    app.get('/health', async (_, res) => {
+        /* Health check endpoint */
+        res.status(200).send();
+    });
+    const EDUBASE_HTTP_PORT = parseInt(process.env.EDUBASE_HTTP_PORT || process.env.PORT || '3000');
+    app.listen(EDUBASE_HTTP_PORT, () => {
+        console.error("EduBase MCP server is now listening on HTTP port " + EDUBASE_HTTP_PORT + " with SSE transport");
+    });
+    process.on('SIGTERM', () => {
+        /* Graceful shutdown */
+        console.error("Received SIGTERM, shutting down EduBase MCP server...");
+        server.close();
+    });
+}
+else {
+    /* Using stdio transport */
+    async function runMcpServer() {
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        console.error("EduBase MCP server is now listening on standard input/output");
+    }
+    runMcpServer().catch((error) => {
+        console.error("Cannot start EduBase MCP server: ", error);
+        process.exit(1);
+    });
+}

package/dist/prompts.js

@@ -0,0 +1,4 @@
+/* Prompt definitions */
+export const EDUBASE_API_PROMPTS = {};
+/* Prompt handler definitions */
+export const EDUBASE_API_PROMPTS_HANDLERS = {};