infranodus-mcp-server 1.2.4 → 1.4.0

package/README.md

@@ -34,68 +34,75 @@ InfraNodus MCP Server enables LLM workflows and AI assistants to analyze text us
    - Access previously saved analyses
    - Export graph data with full statistics
 
-3. **generate_content_gaps**
+3. **analyze_text**
+
+   - Analyze a text, URL, or YouTube transcript
+   - Extract and analyze a graph from text or URL; provide either text or url
+   - Get topics, clusters, statements, graph structure, and AI summary as requested
+
+4. **generate_content_gaps**
 
    - Detect missing connections in discourse
    - Identify underexplored topics
    - Generate research questions
    - Suggest content development opportunities
 
-4. **generate_topical_clusters**
+5. **generate_topical_clusters**
 
    - Generate topics and clusters of keywords from text using knowledge graph analysis
    - Make sure to beyond genetic insights and detect smaller topics
    - Use the topical clusters to establish topical authority for SEO
 
-5. **generate_contextual_hint**
+6. **generate_contextual_hint**
 
    - Generate a topical overview of a text and provide insights for LLMs to generate better responses
    - Use it to get a high-level understanding of a text
    - Use it to augment prompts in your LLM workflows and AI assistants
 
-6. **generate_research_questions**
+7. **generate_research_questions**
 
-   - Generate research questions that bridge content gaps
+   - Generate research questions that bridge content gaps from text, URL, or an existing InfraNodus graph
    - Use them as prompts in your LLM models and AI workflows
    - Use any AI model (included in InfraNodus API)
    - Content gaps are identified based on topical clustering
 
-7. **generate_research_ideas**
+8. **generate_research_ideas**
 
    - Generate innovative research ideas based on content gaps identified in the text
    - Get actionable ideas to improve the text and develop the discourse
    - Use any AI model (included in InfraNodus API)
    - Ideas are generated from gaps between topical clusters
 
-8. **research_questions_from_graph**
+9. **optimize_text_structure**
 
-   - Generate research questions based on an existing InfraNodus graph
-   - Use them as prompts in your LLM models
-   - Use any AI model (included in InfraNodus API)
-   - Content gaps are identified based on topical clustering
+   - Analyze the level of bias and coherence in text using knowledge graph analysis
+   - If the text is too biased, develop the represented topics to balance the discourse
+   - If the text is focused or diversified, develop the content gaps to deepen the analysis
+   - If the text is dispersed, focus the most common gap topics to improve coherence
+   - Choose response type: response, idea, question, or transcend
 
-9. **generate_responses_from_graph**
+10. **generate_responses_from_graph**
 
-   - Generate responses based on an existing InfraNodus graph
-   - Integrate them into your LLM workflows and AI assistants
-   - Use any AI model (included in InfraNodus API)
-   - Use any prompt
+    - Generate responses based on an existing InfraNodus graph
+    - Integrate them into your LLM workflows and AI assistants
+    - Use any AI model (included in InfraNodus API)
+    - Use any prompt
 
-10. **develop_conceptual_bridges**
+11. **develop_conceptual_bridges**
 
     - Analyze text and develop latent ideas based on concepts that connect this text to a broader discourse
     - Discover hidden themes and patterns that link your text to wider contexts
     - Use any AI model (included in InfraNodus API)
     - Generate insights that help develop the discourse
 
-11. **develop_latent_topics**
+12. **develop_latent_topics**
 
     - Analyze text and extract underdeveloped topics with ideas on how to develop them
     - Identify topics that need more attention and elaboration
     - Use any AI model (included in InfraNodus API)
     - Get actionable suggestions for content expansion
 
-12. **develop_text_tool**
+13. **develop_text_tool**
 
     - Comprehensive text analysis combining content gap ideas, latent topics, and conceptual bridges
     - Executes multiple analyses in sequence with progress tracking
@@ -103,44 +110,49 @@ InfraNodus MCP Server enables LLM workflows and AI assistants to analyze text us
     - Identifies latent topics and conceptual bridges to develop
     - Finds content gaps for deeper exploration
 
-13. **create_knowledge_graph**
+14. **create_knowledge_graph**
 
     - Create a knowledge graph in InfraNodus from text and provide a link to it
     - Use it to create a knowledge graph in InfraNodus from text
 
-14. **overlap_between_texts**
+15. **overlap_between_texts**
 
     - Create knowledge graphs from two or more texts and find the overlap (similarities) between them
     - Use it to find similar topics and keywords across different texts
 
-15. **difference_between_texts**
+16. **merged_graph_from_texts**
+
+    - Build a graph of all the texts and URLs provided, providing topical clusters and gaps present in the merged graph generated from all the texts
+    - Use it to combine multiple sources into one graph and see clusters and content gaps across the merged content
+
+17. **difference_between_texts**
 
     - Compare knowledge graphs from two or more texts and find what's not present in the first graph that's present in the others
     - Use it to find how one text can be enriched with the others
 
-16. **analyze_google_search_results**
+18. **analyze_google_search_results**
 
     - Generate a graph with keywords and topics for Google search results for a certain query
     - Use it to understand the current informational supply (what people find)
 
-17. **analyze_related_search_queries**
+19. **analyze_related_search_queries**
 
     - Generate a graph from the search queries suggested by Google for a certain query
     - Use it to understand the current informational demand (what people are looking for)
 
-18. **search_queries_vs_search_results**
+20. **search_queries_vs_search_results**
 
     - Generate a graph of keyword combinations and topics people tend to search for that do not readily appear in the search results for the same queries
     - Use it to understand what people search for but don't yet find
 
-19. **generate_seo_report**
+21. **generate_seo_report**
 
     - Analyze content for SEO optimization by comparing it with Google search results and search queries
     - Identify content gaps and opportunities for better search visibility
     - Get comprehensive analysis of what's in search results but not in your text
     - Discover what people search for but don't find in current results
 
-20. **memory_add_relations**
+22. **memory_add_relations**
 
     - Add relations to the InfraNodus memory from text
     - Automatically detect entities or use [[wikilinks]] syntax to mark them
@@ -148,7 +160,7 @@ InfraNodus MCP Server enables LLM workflows and AI assistants to analyze text us
     - Support automatic entity extraction or manual entity marking
     - Provide links to created memory graphs for easy access
 
-21. **memory_get_relations**
+23. **memory_get_relations**
 
     - Retrieve relations from InfraNodus memory for specific entities
     - Search for entity relations using [[wikilinks]] syntax
@@ -156,7 +168,7 @@ InfraNodus MCP Server enables LLM workflows and AI assistants to analyze text us
     - Extract statements and relationships from stored knowledge graphs
     - Support both entity-specific searches and full context retrieval
 
-22. **retrieve_from_knowledge_base**
+24. **retrieve_from_knowledge_base**
 
     - Retrieve context from an existing InfraNodus knowledge graph using GraphRAG
     - Query your knowledge base with a natural language prompt to get relevant statements
@@ -164,13 +176,13 @@ InfraNodus MCP Server enables LLM workflows and AI assistants to analyze text us
     - Optionally retrieve the full graph, statements, or extended analysis
     - Ideal for augmenting LLM responses with domain-specific knowledge
 
-23. **search**
+25. **search**
 
     - Search through existing InfraNodus graphs
     - Also use it to search through the public graphs of a specific user
     - Compatible with ChatGPT Deep Research mode via Developer Mode > Connectors
 
-24. **fetch**
+26. **fetch**
 
     - Fetch a specific search result for a graph
     - Can be used in ChatGPT Deep Research mode via Developer Mode > Connectors
@@ -523,6 +535,20 @@ Retrieves and analyzes an existing graph from your InfraNodus account.
 - `includeStatements` (boolean): Include statements in response
 - `includeGraphSummary` (boolean): Include graph summary
 
+### analyze_text
+
+Analyze a text, URL, or YouTube transcript. Extract and analyze a graph from text or URL; provide either text or url.
+
+**Parameters:**
+
+- `text` (string, optional): Text to analyze. Provide either this or url.
+- `url` (string, optional): URL to fetch content from (e.g. webpage or YouTube transcript). Provide either this or text.
+- `includeStatements` (boolean): Include processed statements in response
+- `includeGraph` (boolean): Include full graph structure in response
+- `addNodesAndEdges` (boolean): Include nodes and edges in response
+- `includeGraphSummary` (boolean): Include AI-generated graph summary for RAG prompt augmentation
+- `modifyAnalyzedText` (string): Entity detection — "none", "detectEntities", or "extractEntitiesOnly"
+
 ### generate_content_gaps
 
 Identifies content gaps and missing connections in text.

package/dist/http-server.js

@@ -5,16 +5,36 @@
 import express from "express";
 import cors from "cors";
 import helmet from "helmet";
+import crypto from "crypto";
 import * as dotenv from "dotenv";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import createServer from "./index.js";
 import { exchangeApiKeyForToken, verifyAccessToken, revokeSession, getSessionCount, registerClient, getClient, createAuthorizationCode, exchangeAuthorizationCode, validateApiKey, } from "./auth/oauth-provider.js";
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
 // Load environment variables
 dotenv.config();
 // Configuration
 const PORT = parseInt(process.env.PORT || "3000", 10);
 const CORS_ORIGIN = process.env.CORS_ORIGIN || "*";
 const INFRANODUS_API_BASE = process.env.INFRANODUS_API_BASE || "https://infranodus.com/api/v1";
+// Allow HTTP only for localhost/127.0.0.1 (local dev); otherwise require HTTPS
+function isRedirectUriAllowed(redirectUri) {
+    if (redirectUri.startsWith("https://"))
+        return true;
+    if (!redirectUri.startsWith("http://"))
+        return false;
+    try {
+        const u = new URL(redirectUri);
+        const host = u.hostname.toLowerCase();
+        return host === "localhost" || host === "127.0.0.1";
+    }
+    catch {
+        return false;
+    }
+}
 // Store auth info on request (using a symbol to avoid conflicts with MCP SDK)
 const AUTH_KEY = Symbol("auth");
 // Create Express app
@@ -40,16 +60,21 @@ app.use((req, res, next) => {
     })}`);
     next();
 });
-// Store transports per session for MCP
+// Store transports per session for MCP (Streamable HTTP)
 const transports = new Map();
+// Store SSE transports per session for legacy MCP clients
+const sseTransports = new Map();
 /**
- * Auth middleware - validates Bearer token and attaches auth info to request
+ * Auth middleware - validates Bearer token and attaches auth info to request.
+ * Supports both JWT access tokens (from OAuth flow) and raw InfraNodus API keys.
  */
-function authMiddleware(req, res, next) {
+async function authMiddleware(req, res, next) {
     console.log(`[AUTH] Checking auth for ${req.method} ${req.path}`);
     const authHeader = req.headers.authorization;
     if (!authHeader || !authHeader.startsWith("Bearer ")) {
         console.log(`[AUTH] Missing or invalid Authorization header`);
+        const baseUrl = `${req.protocol}://${req.get("host")}`;
+        res.setHeader("WWW-Authenticate", `Bearer resource_metadata="${baseUrl}/.well-known/oauth-protected-resource"`);
         const error = {
             error: "unauthorized",
             error_description: "Missing or invalid Authorization header",
@@ -59,19 +84,41 @@ function authMiddleware(req, res, next) {
     }
     const token = authHeader.slice(7); // Remove "Bearer " prefix
     console.log(`[AUTH] Token present, verifying...`);
+    // Try JWT verification first (fast path for OAuth-authenticated clients)
     const authInfo = verifyAccessToken(token);
-    if (!authInfo) {
-        console.log(`[AUTH] Token verification failed`);
-        const error = {
-            error: "invalid_token",
-            error_description: "Access token is invalid or expired",
-        };
-        res.status(401).json(error);
+    if (authInfo) {
+        console.log(`[AUTH] Authenticated via JWT as ${authInfo.userName} (${authInfo.userId})`);
+        req[AUTH_KEY] = authInfo;
+        next();
         return;
     }
-    console.log(`[AUTH] Authenticated as ${authInfo.userName} (${authInfo.userId})`);
-    req[AUTH_KEY] = authInfo;
-    next();
+    // JWT failed — try treating the token as a raw InfraNodus API key
+    console.log(`[AUTH] JWT verification failed, trying as raw API key...`);
+    try {
+        const userInfo = await validateApiKey(token);
+        if (userInfo) {
+            console.log(`[AUTH] Authenticated via raw API key as ${userInfo.userName} (${userInfo.userId})`);
+            req[AUTH_KEY] = {
+                userId: userInfo.userId,
+                userName: userInfo.userName,
+                apiKey: token,
+                sessionId: crypto.randomUUID(),
+            };
+            next();
+            return;
+        }
+    }
+    catch (err) {
+        console.log(`[AUTH] Raw API key validation error: ${err}`);
+    }
+    console.log(`[AUTH] All authentication methods failed`);
+    const baseUrl = `${req.protocol}://${req.get("host")}`;
+    res.setHeader("WWW-Authenticate", `Bearer resource_metadata="${baseUrl}/.well-known/oauth-protected-resource"`);
+    const error = {
+        error: "invalid_token",
+        error_description: "Access token is invalid or expired",
+    };
+    res.status(401).json(error);
 }
 /**
  * Helper to get auth info from request
@@ -142,12 +189,11 @@ app.get("/oauth/authorize", (req, res) => {
         });
         return;
     }
-    // Accept any HTTPS redirect_uri (stateless validation)
-    // The real security is in the API key validation
-    if (!redirect_uri.startsWith("https://")) {
+    // Accept HTTPS or http://localhost / http://127.0.0.1 (for local dev)
+    if (!isRedirectUriAllowed(redirect_uri)) {
         res.status(400).json({
             error: "invalid_request",
-            error_description: "redirect_uri must use HTTPS",
+            error_description: "redirect_uri must use HTTPS or http://localhost or http://127.0.0.1",
         });
         return;
     }
@@ -205,8 +251,8 @@ app.post("/oauth/authorize", express.urlencoded({ extended: true }), async (req,
         res.status(400).json({ error: "invalid_client" });
         return;
     }
-    // Validate redirect_uri (stateless - accept any HTTPS URL)
-    if (!redirect_uri || !redirect_uri.startsWith("https://")) {
+    // Validate redirect_uri (HTTPS or localhost/127.0.0.1 for local dev)
+    if (!redirect_uri || !isRedirectUriAllowed(redirect_uri)) {
         res.status(400).json({
             error: "invalid_request",
             error_description: "Invalid redirect_uri",
@@ -365,6 +411,19 @@ app.get("/.well-known/openid-configuration", (req, res) => {
         scopes_supported: ["mcp", "read", "write"],
     });
 });
+/**
+ * GET /.well-known/oauth-protected-resource - OAuth2 Protected Resource Metadata (RFC 9728)
+ * MCP clients fetch this to discover the authorization server for this resource.
+ */
+app.get("/.well-known/oauth-protected-resource", (req, res) => {
+    const baseUrl = `${req.protocol}://${req.get("host")}`;
+    res.json({
+        resource: baseUrl,
+        authorization_servers: [baseUrl],
+        scopes_supported: ["mcp", "read", "write"],
+        bearer_methods_supported: ["header"],
+    });
+});
 // ============================================================================
 // MCP Endpoints
 // ============================================================================
@@ -481,14 +540,23 @@ app.post("/mcp", authMiddleware, async (req, res) => {
     }
 });
 /**
- * GET /mcp - SSE endpoint for server-to-client notifications
+ * GET /mcp - Auto-detect transport:
+ *   SSE client (no mcp-session-id, Accept: text/event-stream) → SSE transport
+ *   Streamable HTTP client (has mcp-session-id) → existing Streamable HTTP
  */
 app.get("/mcp", authMiddleware, async (req, res) => {
     try {
-        await handleMcpRequest(req, res);
+        const wantsSSE = !req.headers["mcp-session-id"] &&
+            req.headers.accept?.includes("text/event-stream");
+        if (wantsSSE) {
+            await handleSseConnection(req, res);
+        }
+        else {
+            await handleMcpRequest(req, res);
+        }
     }
     catch (error) {
-        console.error("MCP GET error:", error);
+        console.error("MCP GET /mcp error:", error);
         if (!res.headersSent) {
             res.status(500).json({ error: "Internal server error" });
         }
@@ -509,6 +577,97 @@ app.delete("/mcp", authMiddleware, async (req, res) => {
     }
 });
 // ============================================================================
+// Legacy SSE Transport Endpoints (for clients like Make.com)
+// ============================================================================
+/**
+ * Shared helper: establish an SSE connection for the authenticated user.
+ * Creates an SSEServerTransport, wires up an MCP server, and starts streaming.
+ */
+async function handleSseConnection(req, res) {
+    const auth = getAuth(req);
+    if (!auth) {
+        res.status(401).json({ error: "unauthorized" });
+        return;
+    }
+    console.log(`[SSE] New SSE connection from ${auth.userName} (${auth.userId})`);
+    const transport = new SSEServerTransport("/message", res);
+    const sessionId = transport.sessionId;
+    sseTransports.set(sessionId, transport);
+    const config = {
+        apiKey: auth.apiKey,
+        apiBase: INFRANODUS_API_BASE,
+    };
+    const server = createServer({ config });
+    transport.onclose = () => {
+        console.log(`[SSE] Transport closed for session ${sessionId}`);
+        sseTransports.delete(sessionId);
+    };
+    await server.connect(transport);
+    console.log(`[SSE] Server connected, session ${sessionId}`);
+}
+/**
+ * GET /sse - Establish SSE stream (legacy MCP transport)
+ * The client connects here first to get an SSE stream, then POSTs messages to /message
+ */
+app.get("/sse", authMiddleware, async (req, res) => {
+    try {
+        await handleSseConnection(req, res);
+    }
+    catch (error) {
+        console.error("SSE GET /sse error:", error);
+        if (!res.headersSent) {
+            res.status(500).json({ error: "Internal server error" });
+        }
+    }
+});
+/**
+ * POST /message - Receive messages from SSE clients (legacy MCP transport)
+ */
+app.post("/message", authMiddleware, async (req, res) => {
+    const sessionId = req.query.sessionId;
+    if (!sessionId) {
+        res.status(400).json({ error: "Missing sessionId query parameter" });
+        return;
+    }
+    const transport = sseTransports.get(sessionId);
+    if (!transport) {
+        res.status(404).json({
+            error: "Session not found. The SSE connection may have been closed.",
+        });
+        return;
+    }
+    console.log(`[SSE] POST /message for session ${sessionId}`);
+    try {
+        await transport.handlePostMessage(req, res, req.body);
+    }
+    catch (error) {
+        console.error(`[SSE] Error handling message:`, error);
+        if (!res.headersSent) {
+            res.status(500).json({ error: "Internal server error" });
+        }
+    }
+});
+// ============================================================================
+// LLM Documentation Endpoints (llms.txt standard)
+// ============================================================================
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+function serveLlmsFile(filename, res) {
+    const filePath = path.resolve(__dirname, "../", filename);
+    try {
+        const content = fs.readFileSync(filePath, "utf-8");
+        res.type("text/markdown; charset=utf-8").send(content);
+    }
+    catch {
+        res.status(404).send(`${filename} not found`);
+    }
+}
+app.get("/llms.txt", (_req, res) => {
+    serveLlmsFile("llms.txt", res);
+});
+app.get("/llms-full.txt", (_req, res) => {
+    serveLlmsFile("llms-full.txt", res);
+});
+// ============================================================================
 // Health & Status Endpoints
 // ============================================================================
 /**
@@ -523,16 +682,20 @@ app.get("/health", (req, res) => {
     });
 });
 /**
- * GET / - Server info (only when no auth header - otherwise it's MCP)
+ * GET / - Server info (only when no auth header and not an MCP/SSE client)
  */
 app.get("/", (req, res, next) => {
     // If auth header is present, treat as MCP request
     if (req.headers.authorization) {
         return next();
     }
+    // If client wants SSE or MCP, let it fall through to authMiddleware (→ 401 triggers OAuth)
+    if (req.headers.accept?.includes("text/event-stream")) {
+        return next();
+    }
     res.json({
         name: "InfraNodus MCP Server",
-        version: "1.2.4",
+        version: "1.4.0",
         description: "MCP server for InfraNodus knowledge graph analysis",
         endpoints: {
             oauth: {
@@ -546,6 +709,10 @@ app.get("/", (req, res, next) => {
                 disconnect: "DELETE / or DELETE /mcp",
             },
             health: "GET /health",
+            llms: {
+                index: "GET /llms.txt",
+                full: "GET /llms-full.txt",
+            },
         },
         authentication: "Bearer token (obtain via /oauth/token with api_key)",
     });
@@ -566,11 +733,20 @@ app.post("/", authMiddleware, async (req, res) => {
     }
 });
 /**
- * GET / with auth - SSE endpoint for MCP at root
+ * GET / with auth - Auto-detect transport:
+ *   SSE client (no mcp-session-id, Accept: text/event-stream) → SSE transport
+ *   Streamable HTTP client (has mcp-session-id) → existing Streamable HTTP
  */
 app.get("/", authMiddleware, async (req, res) => {
     try {
-        await handleMcpRequest(req, res);
+        const wantsSSE = !req.headers["mcp-session-id"] &&
+            req.headers.accept?.includes("text/event-stream");
+        if (wantsSSE) {
+            await handleSseConnection(req, res);
+        }
+        else {
+            await handleMcpRequest(req, res);
+        }
     }
     catch (error) {
         console.error("MCP GET / error:", error);
@@ -599,10 +775,12 @@ app.delete("/", authMiddleware, async (req, res) => {
 // Handle graceful shutdown
 process.on("SIGINT", () => {
     console.log("\nShutting down HTTP server...");
-    // Close all transports
     for (const transport of transports.values()) {
         transport.close();
     }
+    for (const transport of sseTransports.values()) {
+        transport.close();
+    }
     process.exit(0);
 });
 process.on("SIGTERM", () => {
@@ -610,6 +788,9 @@ process.on("SIGTERM", () => {
     for (const transport of transports.values()) {
         transport.close();
     }
+    for (const transport of sseTransports.values()) {
+        transport.close();
+    }
     process.exit(0);
 });
 // Start the server
@@ -618,6 +799,7 @@ app.listen(PORT, () => {
     console.log(`  - Health: http://localhost:${PORT}/health`);
     console.log(`  - OAuth token: POST http://localhost:${PORT}/oauth/token`);
     console.log(`  - MCP endpoint: http://localhost:${PORT}/mcp`);
+    console.log(`  - SSE endpoint: http://localhost:${PORT}/sse (legacy)`);
     console.log("");
     console.log("Environment:");
     console.log(`  - CORS_ORIGIN: ${CORS_ORIGIN}`);