Skip to content
Back to search

infranodus

InfraNodus knowledge graphs and text network analysis: topics, content gaps, research questions, GraphRAG retrieval, SEO/GEO analysis, and structured memory for AI agents.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 17 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/infranodus/mcp-server-infranodus with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/infranodus/mcp-server-infranodus'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/infranodus--mcp-server-infranodus/badge.svg)](/listings/infranodus--mcp-server-infranodus)

HTML

<a href="/listings/infranodus--mcp-server-infranodus"><img src="/api/listings/infranodus--mcp-server-infranodus/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

The easiest and the fastest way to launch the InfraNodus MCP server is to either use our server URL `https://mcp.infranodus.com` for the remote / web applications or to add a manual configuration to your LLM apps if you're running them locally.

You can also install the server locally, so you have more control over it. In this case, you can also edit the source files and even create your tools based on the [InfraNodus API](https://infranodus.com/api).

Below we describe the two different ways to set up your InfraNodus MCP server.

1. Easiest Setup: InfraNodus MCP Server (via HTTP/SSE)

0. **Prerequisites**

- Create an account on [InfraNodus](https://infranodus.com) if you don't have it already and get your [InfraNodus API Key](https://infranodus.com/api-access). We offer 14-day free trials.

1. **Get the URL**

- We currently use the following URL for our MCP server deployed in our infrastructure:

https://mcp.infranodus.com

2. **Add the MCP server URL to the Client Tool Where You Want to Use InfraNodus**

- Once you add the URL above to your tool, it will automatically prompt you to authenticate using OAuth in order to be able to access the InfraNodus MCP hosted on it. - OAuth sign-in on the hosted server is only sent back to known apps (Claude, ChatGPT, Cursor, Grok, VS Code, Perplexity) or to an app on your own computer (`localhost`). If your tool is refused with "redirect_uri is not a recognised app address", connect with your InfraNodus API key as a Bearer token instead, or contact support to have the app added.

4. **Using InfraNodus Tools in Your Calls**

- To use InfraNodus, see the tools available and simply call them through the chat interface (e.g. "show me the graphs where I talk about this topic" or "get the content gaps from the document I uploaded")

- If your client is not using InfraNodus for some actions, add the instruction to use InfraNodus explicitly.

2. Manual Setup: via NPX

You can deploy the InfraNodus server manually via `npx` — a package that allows to execute local and remote Node.Js packages on your computer.

The InfraNodus MCP server is available as an npm package at [https://www.npmjs.com/package/infranodus-mcp-server](https://www.npmjs.com/package/infranodus-mcp-server) from where you can launch it remotely on your local computer with npx. It will expose its tools to the MCP client that will be using this command to launch the server

For Claude Desktop / Cursor IDE:

Just add this in your Claude's configuration file (Settings > Developer > Edit Config), inside the `"mcpServers"` object where the different servers are listed:

{
	"mcpServers": {
		"infranodus": {
			"command": "npx",
			"args": ["-y", "infranodus-mcp-server"],
			"env": {
				"INFRANODUS_API_KEY": "YOUR_INFRANODUS_API_KEY"
			}
		}
	}
}

For Claude Code

To connect the InfraNodus MCP server to your Claude code, you can use this command. Make sure to provide the correct InfraNodus API key for your account:

claude mcp add infranodus -s user \
	-- env INFRANODUS_API_KEY=YOUR_INRANODUS_KEY \
		npx -y infranodus-mcp-server

3. Manual Setup: Launching MCP as a Local Server (for inspection & development)

0. **Prerequisites**

- Node.js 18+ installed - InfraNodus API key (get yours at [https://infranodus.com/api-access](https://infranodus.com/api-access))

1. **Clone and build the server:**

   git clone https://github.com/yourusername/mcp-server-infranodus.git
   cd mcp-server-infranodus
   npm install
   npm run build:inspect
   npm run inspect

Note that `build:inspect` will generate the `dist/index.js` file which you will then use in your server setup. The standard `npm run build` command will only build a Smithery file.

2. **Set up your API key:**

Create a `.env` file in the project root:

   INFRANODUS_API_KEY=your-api-key-here

3. **Inspect the MCP:**

   npm run inspect

Claude Desktop Configuration (macOS)

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

plugin.json · Manifest · 20 lines
  1. {
  2. "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
  3. "name": "infranodus",
  4. "version": "1.10.0",
  5. "description": "InfraNodus knowledge graphs and text network analysis: topics, content gaps, research questions, GraphRAG retrieval, SEO/GEO analysis, and structured memory for AI agents.",
  6. "author": {
  7. "name": "Nodus Labs",
  8. "url": "https://infranodus.com"
  9. },
  10. "homepage": "https://infranodus.com/mcp",
  11. "repository": "https://github.com/infranodus/mcp-server-infranodus",
  12. "license": "MIT",
  13. "keywords": [
  14. "infranodus",
  15. "infranodus mcp",
  16. "infranodus graph",
  17. "knowledge graph",
  18. "text network analysis"
  19. ]
  20. }
README.md · README · 800 lines
  1. # InfraNodus MCP Server
  2. A Model Context Protocol (MCP) server that integrates InfraNodus knowledge graph and text network analysis capabilities into LLM workflows and AI assistants like Claude Desktop.
  3. [![npm version](https://img.shields.io/npm/v/infranodus-mcp-server.svg)](https://www.npmjs.com/package/infranodus-mcp-server)
  4. Available on npm: [https://www.npmjs.com/package/infranodus-mcp-server](https://www.npmjs.com/package/infranodus-mcp-server)
  5. ## Overview
  6. InfraNodus MCP Server enables LLM workflows and AI assistants to analyze text using advanced network science algorithms, generate knowledge graphs, detect content gaps, and identify key topics and concepts. It transforms unstructured text into structured insights using graph theory and network analysis.
  7. ![InfraNodus MCP Server](https://infranodus.com/images/front/infranodus-overview.jpg)
  8. ## Features
  9. ### You Can Use It To
  10. - Connect your existing InfraNodus knowledge graphs to your LLM workflows and AI chats
  11. - Identify the main topical clusters in discourse without missing the important nuances (works better than standard LLM workflows)
  12. - Identify the content gaps in any discourse (helpful for content creation and research)
  13. - Generate new knowledge graphs from any text and use them to augment your LLM responses
  14. - Save and retrieve entities and relations from memory using the knowledge graphs
  15. ### Available Tools
  16. 1. **generate_knowledge_graph**
  17. - Convert any text into a visual knowledge graph
  18. - Extract topics, concepts, and their relationships
  19. - Identify structural patterns and clusters
  20. - Apply AI-powered topic naming
  21. - Perform entity detection for cleaner graphs
  22. 2. **analyze_existing_graph_by_name**
  23. - Retrieve and analyze existing graphs from your InfraNodus account
  24. - Access previously saved analyses
  25. - Export graph data with full statistics
  26. 3. **analyze_text**
  27. - Analyze a text, URL, or YouTube transcript
  28. - Extract and analyze a graph from text or URL; provide either text or url
  29. - Get topics, clusters, statements, graph structure, and AI summary as requested
  30. 4. **analyze_text_signature**
  31. - Structural and rhythmic signature of a text, URL, or YouTube transcript
  32. - Every measure with a plain-language reading, a named text type (deep dive, refrain, chapters, sweep), and a hedged AI-likeness estimate
  33. - Use to compare writing styles, characterise an author or genre, or flag flat, uniformly paced text
  34. 5. **generate_content_gaps**
  35. - Detect missing connections in discourse
  36. - Identify underexplored topics
  37. - Generate research questions
  38. - Suggest content development opportunities
  39. 6. **generate_topical_clusters**
  40. - Generate topics and clusters of keywords from text using knowledge graph analysis
  41. - Make sure to beyond genetic insights and detect smaller topics
  42. - Use the topical clusters to establish topical authority for SEO
  43. - Returns AI-generated overviews of the topical clusters (`topicalClusterSummaries`), summarizing the discourse each cluster represents — useful for SEO-optimized content creation. Enabled by default; set `generateTopicalSummaries: false` to increase processing speed or if the summary request fails
  44. 7. **generate_contextual_hint**
  45. - Generate a topical overview of a text and provide insights for LLMs to generate better responses
  46. - Use it to get a high-level understanding of a text
  47. - Use it to augment prompts in your LLM workflows and AI assistants
  48. 8. **generate_research_questions**
  49. - Generate research questions that bridge content gaps from text, URL, or an existing InfraNodus graph
  50. - Use them as prompts in your LLM models and AI workflows
  51. - Use any AI model (included in InfraNodus API)
  52. - `optimize` chooses the clusters the questions bridge: `optimize` (default) the insight clusters picked from the structure of the graph, `gap` the widest content gap, `develop` the main topics, `latent` the under-developed ones
  53. - Returns the insight clusters used as `insightClusters`
  54. 9. **generate_research_ideas**
  55. - Generate innovative research ideas based on content gaps identified in the text
  56. - Get actionable ideas to improve the text and develop the discourse
  57. - Use any AI model (included in InfraNodus API)
  58. - `optimize` chooses the clusters the ideas bridge, as in `generate_research_questions`; the default is the insight clusters, returned as `insightClusters`
  59. 10. **optimize_text_structure**
  60. - Analyze the level of bias and coherence in text using knowledge graph analysis
  61. - If the text is too biased, develop the represented topics to balance the discourse
  62. - If the text is focused or diversified, develop the content gaps to deepen the analysis
  63. - If the text is dispersed, focus the most common gap topics to improve coherence
  64. - Choose response type: response, idea, question, or transcend
  65. 11. **optimize_reasoning**
  66. - Applies the same bias/coherence analysis to the model's own reasoning trace or chat with the user (pass it as `text`)
  67. - Detects whether the reasoning is biased, focused, diversified, or dispersed
  68. - Steers the reasoning toward optimal diversity and coherence at the same time
  69. - If too biased, develop the under-represented topics; if focused or diversified, bridge the content gaps; if dispersed, focus the most common gap topics
  70. - Returns a structural diagnosis (diversity stats, topical clusters, gaps) plus suggestions for how to continue thinking
  71. 12. **generate_responses_from_graph**
  72. - Generate responses based on an existing InfraNodus graph
  73. - Integrate them into your LLM workflows and AI assistants
  74. - Use any AI model (included in InfraNodus API)
  75. - Use any prompt
  76. 13. **develop_conceptual_bridges**
  77. - Analyze text and develop latent ideas based on concepts that connect this text to a broader discourse
  78. - Discover hidden themes and patterns that link your text to wider contexts
  79. - Use any AI model (included in InfraNodus API)
  80. - Generate insights that help develop the discourse
  81. 14. **develop_latent_topics**
  82. - Analyze text and extract underdeveloped topics with ideas on how to develop them
  83. - Identify topics that need more attention and elaboration
  84. - Use any AI model (included in InfraNodus API)
  85. - Get actionable suggestions for content expansion
  86. 15. **develop_text_tool**
  87. - Comprehensive text analysis combining content gap ideas, latent topics, and conceptual bridges
  88. - Executes multiple analyses in sequence with progress tracking
  89. - Generates research ideas based on content gaps
  90. - Identifies latent topics and conceptual bridges to develop
  91. - Finds content gaps for deeper exploration
  92. 16. **create_knowledge_graph**
  93. - Create a knowledge graph in InfraNodus from text and provide a link to it
  94. - Use it to create a knowledge graph in InfraNodus from text
  95. - Also accepts `statements` (discrete items) with parallel `categories` and `timestamps`. Categories are stored as metadata on each statement (filter, group, delete, or relabel by them) and stay out of the graph unless `categoriesAsNodes: true`, which turns each label into a `[[label]]` node — meant for large knowledge bases and Obsidian vaults where the connections between pages are the point. The parent modes of `wikilinksMode` (`obsidianStyle`, `parentAndConcepts`) always make the parent page a node
  96. 17. **generate_ontology_graph**
  97. - Use AI to generate a reasoning ontology graph (entities and the relations between them) from one of three sources: a `prompt` (a topic — e.g. "build an ontology on AI attention mechanisms"), a `text` (a long document or a structural digest of a project, chunked server-side), or a `sourceGraphName` (an existing graph — e.g. a fully ingested repo or corpus — whose statements are read back, chunked, and condensed into an ontology)
  98. - `ontologyMode: 'codebase'` frames the extraction around modules, functions, data stores, services, and the concepts they implement; `ontologyMode: 'procedural'` writes a **digest** instead — prose statements on how the project works with `[[wikilinks]]`, each typed as `[principles]`, `[rules]`, `[procedures]`, `[handoffs]`, `[main_ideas]` or `[gaps]` (saved as the statement's category), from an already-uploaded docs/structure graph; save it as `repo-<project>-digest` for `optimize_knowledge_base`; `chunkSize` (default 12000 chars) controls granularity; every chunk appends to the same graph and the response reports `chunksProcessed` / `chunksTotal`
  99. - Saved as a persistent InfraNodus graph by default and a link is returned; set `saveGraph: false` if the user asks not to save, or when you only need a one-off AI ontology overview of a topic for the current context that won't be reused later (the generated statements are returned directly without persisting)
  100. - `modelToUse` defaults to `claude-opus-5-5` for richer ontologies (also `claude-fable-5-1`, `gpt-6.1-terra`); pick `-mini`/`-lite` variants (or `gpt-4o-mini`) for faster, cheaper generation
  101. - Returns the compact graph structure (`knowledgeGraph`) and analytics (main topical clusters, content gaps, top influential nodes, top relations, statistics) by default. Set `includeGraph: false` to save context space when only the ontology statements or insights are needed. Set `includeAnalytics: false` if you just need the raw ontology without graph-derived insights — keep it on whenever you want to understand the structure, gaps, or key concepts
  102. 18. **analyze_llm_results**
  103. - Ask an LLM to describe a topic and turn its response into a knowledge graph that reveals how the model frames it — main concepts, clusters, content gaps, and the relations between them
  104. - Use it to probe model bias, surface the implicit structure of an LLM's view on a subject, or compare how different models describe the same topic
  105. - `modelToUse` defaults to `claude-opus-5-5`; pick the model you actually want to study
  106. - `modifyAnalyzedText` controls how the LLM output is parsed: `'detectEntities'` (default — mixed entities + words), `'extractEntitiesOnly'` (entity-only graph), or `'none'` (plain co-occurrence)
  107. - Saves the graph by default; set `saveGraph: false` for a one-off probe. Returns analytics by default and omits the raw graph (`includeGraph: false`) to keep responses compact — enable `includeGraph` when you also need nodes/edges
  108. 19. **overlap_between_texts**
  109. - Create knowledge graphs from two or more texts and find the overlap (similarities) between them
  110. - Use it to find similar topics and keywords across different texts
  111. 20. **merged_graph_from_texts**
  112. - 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
  113. - Use it to combine multiple sources into one graph and see clusters and content gaps across the merged content
  114. 21. **difference_between_texts**
  115. - Compare knowledge graphs from two or more texts and find what's not present in the first graph that's present in the others
  116. - Use it to find how one text can be enriched with the others
  117. 22. **analyze_google_search_results**
  118. - Generate a graph with keywords and topics for Google search results for a certain query
  119. - Use it to understand the current informational supply (what people find)
  120. 23. **analyze_youtube_results**
  121. - Generate a graph with keywords and topics from YouTube results for a query, channel, or playlist
  122. - Choose what to pull via `searchMode`: `search` (video metadata for a search term), `comments` (comments on a video), `channel` (a channel's videos — pass a username, URL, or @handle), `playlist` (a playlist's videos — pass a playlist ID or a URL with `list=`), `subtitles` / `subtitlesChannel` / `subtitlesPlaylist` (transcribed subtitles of a video / channel / playlist), or `searchVideos` (analyzes the content of the videos found — limit hard-capped to 20)
  123. - Control results with `limit` (default 100, max 2000), `sortBy` (`Popular` / `Oldest` / `Latest`), `excludeDescriptions`, `importLanguage`, and `importRegion`
  124. - Use it to understand the topics, clusters, and content gaps in the discourse around a video, channel, playlist, or search term on YouTube
  125. 24. **analyze_related_search_queries**
  126. - Generate a graph from the search queries suggested by Google for a certain query
  127. - Use it to understand the current informational demand (what people are looking for)
  128. 25. **search_queries_vs_search_results**
  129. - 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
  130. - Use it to understand what people search for but don't yet find
  131. 26. **generate_seo_report**
  132. - Analyze content for SEO optimization by comparing it with Google search results and search queries
  133. - Identify content gaps and opportunities for better search visibility
  134. - Get comprehensive analysis of what's in search results but not in your text
  135. - Discover what people search for but don't find in current results
  136. 27. **memory_add_relations** (Save to InfraNodus Memory)
  137. - Save statements to a named persistent memory graph and get back its name and URL
  138. - For "remember this", "save this to memory", or ideas, plans, and decisions worth keeping
  139. - With `graphName`: writes immediately to that graph, no opt-in, no dry run; reuse the name to append
  140. - With `scope` instead: `topic` (+ `topic`, graph `memory-<topic>`) for an outside subject, client or case, or `personal` (graph `personal-<user>`) for your own preferences and setup. These must be enabled once with `enable_memory`, and each batch is a dry run until approved, like project learnings
  141. - Mark entities with [[wikilinks]] (at least two per statement); pass categories and timestamps for later filtering
  142. 28. **memory_get_relations** (Recall from InfraNodus Memory)
  143. - Recall what was previously saved to memory about a concept or entity
  144. - For "what do I have on X", "did we decide X", "check memory"
  145. - Query one memory graph by name or search across all memory graphs
  146. - Returns the statements and relationships that mention the entity
  147. - With `scope` (`topic` + `topic`, or `personal`): reads that kept memory by entity, by `prompt` (GraphRAG), or as an overview
  148. 29. **enable_memory**
  149. - Create your topic memory (`memory-<topic>`) or personal memory (`personal-<user>`) graph so the memory tools can use it with `scope`
  150. - Called only when you explicitly ask to keep that kind of memory; idempotent
  151. 30. **retrieve_from_knowledge_base**
  152. - Retrieve context from an existing InfraNodus knowledge graph using GraphRAG
  153. - Query your knowledge base with a natural language prompt to get relevant statements
  154. - Include graph summaries for quick overviews of the knowledge structure
  155. - Optionally retrieve the full graph, statements, or extended analysis
  156. - When a search finds too few statements, widen it: `wikilinksMode` reads the saved graph in another node mode for one call ("saved" by default, "wikilinksAndConcepts", "wikilinksOnly", "plainText"), and `maxNodes` (150 by default, up to 1000) lets the prompt match less connected nodes. Both make no change to the graph; `get_node_neighborhood` takes `wikilinksMode` too
  157. - Ideal for augmenting LLM responses with domain-specific knowledge
  158. 31. **search**
  159. - Search through existing InfraNodus graphs
  160. - Also use it to search through the public graphs of a specific user
  161. - Compatible with ChatGPT Deep Research mode via Developer Mode > Connectors
  162. 32. **fetch**
  163. - Fetch a specific search result for a graph
  164. - Can be used in ChatGPT Deep Research mode via Developer Mode > Connectors
  165. 33. **get_graph_around_term**
  166. - The graph around a term across your graphs: every statement that contains the term — or all of several terms (`matchAll`, the default) or any of them — in all your graphs or the named ones, built into one graph with the terms themselves left out, so the topics, gaps and relations describe the context the terms sit in (the app's search view with the searched term hidden)
  167. - Returns which graphs the statements came from with a count each, the statistics, topical clusters, content gaps, main concepts and top relations, the compact graph (`includeGraph`, on by default) and the statements with their graph of origin (`includeStatements`, off by default); `removeTerms: false` keeps the terms in
  168. - Your own graphs only; `search` says where a term occurs, `get_node_neighborhood` walks one graph from one concept
  169. - `wikilinksMode` picks how the found statements become nodes for the call ("account" by default, "wikilinksAndConcepts", "wikilinksOnly", "plainText"); it does not change which statements are found
  170. 34. **list_graphs**
  171. - List the graphs (contexts) in your InfraNodus account, with optional filters by name, type, date, language, or favorite status
  172. - Use it to discover which graphs exist before analyzing them with `analyze_existing_graph_by_name`, searching them, or writing to them
  173. 35. **enable_project_learnings**
  174. - Create the opt-in, per-project, append-only learnings graph (`learn-<project>`) in your account — the place where the assistant saves what it learned about operating in a project
  175. - Called only when you explicitly ask to start saving learnings for a project; idempotent, so calling it again just returns the existing graph
  176. - The assistant tells you first what will be stored (project knowledge only, never anything about you), where (a private graph you can delete at any time), and that batches are shown before saving
  177. 36. **add_project_learnings**
  178. - Save learnings about a project — where things live, traps, conventions, decisions, workflows, and a self-assessment of what worked well and what should be done differently next time — as statements with a `type` category each, for later sessions on any client
  179. - Refuses (without error) when the project has not been enabled and never creates the graph itself
  180. - Dry run by default: returns what would be written, marking near-duplicates as `reinforced`; writes only with `confirm: true` — or in the same call when your client supports MCP elicitation and you approve the form
  181. - Rejects statements with secret-like content server-side (indices only, never the content)
  182. 37. **get_project_learnings**
  183. - Retrieve learnings for a project: by `prompt` (GraphRAG — most relevant statements plus an overview of what is known), by `entity` (a file path, module, or concept), or a structural overview with neither
  184. - Call with no `project` to list the projects that have learnings in your account
  185. - Transcend ideas (category `transcend`: ideas a consolidation pass brought in from outside, checked against nothing) are left out of every answer unless `transcend` is `"only"` or `"include"`
  186. - The overview lists the newest learnings; `order: "oldest"` with `uncheckedFor: <days>` lists the oldest ones that no consolidation pass (a `dream-<date>` category) checked in that time, for reviewing memory in batches
  187. - Returns `enabled: false` with an empty list when a project has no learnings graph — not an error
  188. _Also available as the `save-learnings` prompt in clients that expose MCP prompts. Set `INFRANODUS_LEARNINGS=0` to remove these three tools from the server entirely (see [Project learnings](#project-learnings))._
  189. 38. **optimize_knowledge_base**
  190. - Structural feedback on a whole code base, document vault, or body of procedural knowledge (rules, frameworks, principles) from its digest graph (`repo-<project>-digest` / `vault-<project>-digest`) — or from a digest you write and pass as text, saved with `saveAs`
  191. - Diagnoses the structure (biased / focused / diversified / dispersed) and reads it for the chosen `focus` (`codebase`, `vault`, `procedural`, `general`): what dominates, which areas are under-developed (with latent-topic ideas), which clusters never connect — missing integrations, missing bridge notes, missing hand-offs between frameworks — plus AI suggestions for what to develop next
  192. - `optimize` chooses what the suggestions work on: `optimize` (default) the insight clusters, which are returned as `insightClusters` and stepped through with `gapDepth`; `develop` all the main topics, followed by a latent-topics pass; `latent` the under-developed ones. `includeLatent: true` adds the latent pass to `optimize`
  193. - `compareWith` up to two other layers of the same project (e.g. digest vs structure map, docs vs code) and get what each has that the other lacks: rules without code, code without documentation, features described but not built
  194. - Two ways to get the digest: the assistant reads the project and writes it (the infranodus skill's **digest** build mode, or `text` + `saveAs` here), or `generate_ontology_graph` with `ontologyMode: 'procedural'` writes it server-side from an uploaded docs/structure graph
  195. - Pairs with the infranodus skill's build modes: full ingestion, digest, structure map, ontology
  196. 39. **submit_workflow_feedback**
  197. - Internal telemetry: after a workflow of InfraNodus calls, the assistant reports what it actually did with the output — how much it used, whether it contained anything new, whether it was the right tool, how many calls it took, concrete defects — as observations rather than a score; a rating is derived from them server-side
  198. - Autonomous: it never asks you anything and never surfaces in the conversation
  199. - The report contains short paraphrases of what you were working on (capped at 200 characters), the same policy as the prompts InfraNodus already logs; `MCPCAT_ANONYMOUS=1` skips the per-user log entirely
  200. - Set `INFRANODUS_FEEDBACK=0` to remove the tool (and the one-line nudge appended to workflow-ending results) from the server
  201. 39. **get_more_tools**
  202. - Added by the [mcpcat](https://mcpcat.io) analytics library: the assistant calls it when a task would benefit from a capability none of the tools above provides, describing what it needed (not offered on the `/openai` endpoint used by the ChatGPT / Codex plugin)
  203. - The server has no hidden tools, so the call only records the request as feedback for future tool development; the assistant does not need to ask you before calling it
  204. - Its logs follow the same privacy rules as the usage analytics below (`MCPCAT_ANONYMOUS=1` keeps them unlinked from your account)
  205. 40. **delete_statements**
  206. - Delete statements from a graph in your own account by a filter the server resolves — exactly one of `categories` (everything uploaded under a source label: a file path, a page name, a `[[label]]` parent), `statements` (exact text), `query` (substring or `/regex/`), `before`/`after` (ISO 8601 window), `deleteAll` (empties the graph but keeps its name, URL, and settings), or `statementIds`
  207. - Dry run by default: returns the matched count, a sample of the statements, and a per-category breakdown; nothing is removed until the same filter is sent again with `confirm: true` — or, on clients with MCP elicitation, until you accept the form in the same call. A filter that matches nothing returns `deleted: 0` without asking
  208. - The per-source replace path: `delete_statements` with the source's category, then `create_knowledge_graph` to the same graph name. `deleteAll` then `create_knowledge_graph` rebuilds a graph in place
  209. - Irreversible, own-account only (no `userName`), never creates a graph, and the assistant is instructed never to call it on its own initiative. Set `INFRANODUS_DELETE=0` to remove the tool from the server
  210. 41. **update_statements**
  211. - Edit statements of a graph in your own account **in place** — content, categories, or timestamp — keeping each statement's id, date, and position (unlike deleting and re-creating it)
  212. - Two modes: `edits` rewrites specific statements, each named by its exact current text (`match`, e.g. from `analyze_existing_graph_by_name` with `includeStatements`) or `statementId`; or one selector (the same as `delete_statements`, with `all` instead of `deleteAll`) plus `set` (`addCategories`, `removeCategories`, `categories`, `timestamp`) and/or `replace` (`{ pattern, with }`, substring or `/regex/flags`) for bulk relabelling or a find-and-replace across the graph — renaming a `[[concept]]` or a source path everywhere
  213. - Dry run by default: returns the matched count and the before → after of every change; nothing is written until the same arguments are sent again with `confirm: true` — or, on clients with MCP elicitation, until you accept the form in the same call. A request that matches nothing returns `updated: 0` without asking
  214. - New content is capped at 1000 characters; for longer text use `delete_statements` then `create_knowledge_graph`. Irreversible (the old text survives only in the dry-run output), own-account only, never creates a graph, and the assistant is instructed never to call it on its own initiative. `INFRANODUS_DELETE=0` removes it together with `delete_statements`
  215. 42. **delete_graph**
  216. - Delete one graph from your own account entirely — its statements, revisions, settings, and URL; the name becomes free again. `delete_statements` with `deleteAll` is the alternative that keeps the graph for a rebuild in place
  217. - Dry run by default: confirms the graph exists and reports its URL and whether it is a live graph; nothing is removed until the same `graphName` is sent again with `confirm: true`. Clients that support elicitation ask you directly and delete in the same call
  218. - Irreversible, own-account only (no `userName`; the graph is resolved from your API key's own graph list and the backend scopes the delete to the same user), and the assistant is instructed never to call it on its own initiative. `INFRANODUS_DELETE=0` removes it together with the other two mutation tools
  219. _More capabilites coming soon!_
  220. ### Key Capabilities
  221. - **Topic Modeling**: Automatic clustering and categorization of concepts
  222. - **Content Gap Detection**: Find missing links between concept clusters
  223. - **Entity Recognition**: Clean extraction of names, places, and organizations
  224. - **AI Enhancement**: Optional AI-powered topic naming and analysis
  225. - **Structural Analysis**: Identify influential nodes and community structures
  226. - **Network Structure Statistics**: Modularity, centrality, betweenness, and other graph metrics
  227. - **Fractal Variability**: DFA scaling exponents (alpha) of the discourse at three path levels (statements, words, and n-grams of 4 consecutive words), by step length and radial distance, plus the sentence length level (words per sentence, in order) and the influence level (betweenness, degree, and betweenness rank of the current word; read the rank series), with multifractal spectra — returned as `fractal_variability` next to `diversity_stats` whenever the graph statistics are included
  228. - **Degree Distribution**: `degree_distribution` on every graph — nodes, edges, a `[degree, count]` histogram (first 40 rows unless `fullGraph`), gini of degree, and a power-law tail exponent over the top nodes (null under 50 nodes) — descriptors of how concentrated connectivity is in the whole co-occurrence network before the node cap; never a scale-free verdict
  229. - **Knowledge Graph Memory**: Save and retrieve knowledge graph memories and analyze them to retrieve key nodes, clusters, and connectors
  230. ## Knowledge Graph Memory Use Advice
  231. InfraNodus represents any text as a network graph in order to identify the main clusters of ideas and gaps between them. This helps generate advanced insights based on the text's structure. The network is effectively a knowledge graph that can also be used to retrieve complex ontological relations between different entities and concepts. This process is automated in InfraNodus using the `search` and `fetch` tools along with the other tools that analyze the underlying network.
  232. However, you can also easily use InfraNodus as a more traditional memory server to save and retrieve relations. We use [[wikilinks]] to highlight entities in your text to make your content and graphs compatible with markup syntax and PKM tools such as Obsidian. By default, InfraNodus will generate the name of the memory graph for you based on the context of the conversation. However, you can modify this default behavior by adding a **system prompt** or **project instruction** into your LLM client.
  233. Specifically you can specify to always use a speciic knowlege graph for memories to store everything in one place:
  234. ```
  235. Save all memories in the `my-memories` graph in InfraNodus.
  236. ```
  237. Or you can ask InfraNodus to only save certain entities, e.g. for building social networks:
  238. ```
  239. When generating entities, only extract people, companies, and organizations. Ignore everything else.
  240. ```
  241. ## Installation
  242. The easiest and the fastest way to launch the InfraNodus MCP server is to either use our server URL `https://mcp.infranodus.com` for the remote / web applications or to add a manual configuration to your LLM apps if you're running them locally.
  243. You can also install the server locally, so you have more control over it. In this case, you can also edit the source files and even create your tools based on the [InfraNodus API](https://infranodus.com/api).
  244. Below we describe the two different ways to set up your InfraNodus MCP server.
  245. ### 1. Easiest Setup: InfraNodus MCP Server (via HTTP/SSE)
  246. 0. **Prerequisites**
  247. - Create an account on [InfraNodus](https://infranodus.com) if you don't have it already and get your [InfraNodus API Key](https://infranodus.com/api-access). We offer 14-day free trials.
  248. 1. **Get the URL**
  249. - We currently use the following URL for our MCP server deployed in our infrastructure:
  250. ```bash
  251. https://mcp.infranodus.com
  252. ```
  253. 2. **Add the MCP server URL to the Client Tool Where You Want to Use InfraNodus**
  254. - Once you add the URL above to your tool, it will automatically prompt you to authenticate using OAuth in order to be able to access the InfraNodus MCP hosted on it.
  255. - OAuth sign-in on the hosted server is only sent back to known apps (Claude, ChatGPT, Cursor, Grok, VS Code, Perplexity) or to an app on your own computer (`localhost`). If your tool is refused with "redirect_uri is not a recognised app address", connect with your InfraNodus API key as a Bearer token instead, or contact support to have the app added.
  256. 4. **Using InfraNodus Tools in Your Calls**
  257. - To use InfraNodus, see the tools available and simply call them through the chat interface (e.g. "show me the graphs where I talk about this topic" or "get the content gaps from the document I uploaded")
  258. - If your client is not using InfraNodus for some actions, add the instruction to use InfraNodus explicitly.
  259. ### 2. Manual Setup: via NPX
  260. You can deploy the InfraNodus server manually via `npx` — a package that allows to execute local and remote Node.Js packages on your computer.
  261. The InfraNodus MCP server is available as an npm package at [https://www.npmjs.com/package/infranodus-mcp-server](https://www.npmjs.com/package/infranodus-mcp-server) from where you can launch it remotely on your local computer with npx. It will expose its tools to the MCP client that will be using this command to launch the server
  262. #### For Claude Desktop / Cursor IDE:
  263. Just add this in your Claude's configuration file (Settings > Developer > Edit Config), inside the `"mcpServers"` object where the different servers are listed:
  264. ```json
  265. {
  266. "mcpServers": {
  267. "infranodus": {
  268. "command": "npx",
  269. "args": ["-y", "infranodus-mcp-server"],
  270. "env": {
  271. "INFRANODUS_API_KEY": "YOUR_INFRANODUS_API_KEY"
  272. }
  273. }
  274. }
  275. }
  276. ```
  277. #### For Claude Code
  278. To connect the InfraNodus MCP server to your Claude code, you can use this command. Make sure to provide the correct InfraNodus API key for your account:
  279. ```bash
  280. claude mcp add infranodus -s user \
  281. -- env INFRANODUS_API_KEY=YOUR_INRANODUS_KEY \
  282. npx -y infranodus-mcp-server
  283. ```
  284. ### 3. Manual Setup: Launching MCP as a Local Server (for inspection & development)
  285. 0. **Prerequisites**
  286. - Node.js 18+ installed
  287. - InfraNodus API key (get yours at [https://infranodus.com/api-access](https://infranodus.com/api-access))
  288. 1. **Clone and build the server:**
  289. ```bash
  290. git clone https://github.com/yourusername/mcp-server-infranodus.git
  291. cd mcp-server-infranodus
  292. npm install
  293. npm run build:inspect
  294. npm run inspect
  295. ```
  296. Note that `build:inspect` will generate the `dist/index.js` file which you will then use in your server setup. The standard `npm run build` command will only build a Smithery file.
  297. 2. **Set up your API key:**
  298. Create a `.env` file in the project root:
  299. ```
  300. INFRANODUS_API_KEY=your-api-key-here
  301. ```
  302. 3. **Inspect the MCP:**
  303. ```bash
  304. npm run inspect
  305. ```
  306. ### Claude Desktop Configuration (macOS)
  307. 1. Open your Claude Desktop configuration file:
  308. ```bash
  309. open ~/Library/Application\ Support/Claude/claude_desktop_config.json
  310. ```
  311. 2. Add the InfraNodus server configuration:
  312. a. remote launch via `npx`:
  313. ```json
  314. {
  315. "mcpServers": {
  316. "infranodus": {
  317. "command": "npx",
  318. "args": ["-y", "infranodus-mcp-server"],
  319. "env": {
  320. "INFRANODUS_API_KEY": "YOUR_INFRANODUS_API_KEY"
  321. }
  322. }
  323. }
  324. }
  325. ```
  326. b. launch this repo with `node`, specify the absolute path to the repo + `/dist/index.js`:
  327. ```json
  328. {
  329. "mcpServers": {
  330. "infranodus": {
  331. "command": "node",
  332. "args": ["/absolute/path/to/mcp-server-infranodus/dist/index.js"],
  333. "env": {
  334. "INFRANODUS_API_KEY": "your-api-key-here"
  335. }
  336. }
  337. }
  338. }
  339. ```
  340. **Note:** you can leave the `INFRANODUS_API_KEY` empty in which case you can make 70 free requests after which you will hit quota and will need to add your API key.
  341. 3. Restart Claude Desktop to load the new server.
  342. ### Claude Desktop Configuration (Windows)
  343. 1. Open your Claude Desktop configuration file:
  344. ```
  345. %APPDATA%\Claude\claude_desktop_config.json
  346. ```
  347. 2. Add the InfraNodus server configuration:
  348. a. remote launch via `npx`:
  349. ```json
  350. {
  351. "mcpServers": {
  352. "infranodus": {
  353. "command": "npx",
  354. "args": ["-y", "infranodus-mcp-server"],
  355. "env": {
  356. "INFRANODUS_API_KEY": "YOUR_INFRANODUS_API_KEY"
  357. }
  358. }
  359. }
  360. }
  361. ```
  362. b. launch this repo with `node`:
  363. ```json
  364. {
  365. "mcpServers": {
  366. "infranodus": {
  367. "command": "node",
  368. "args": ["C:\\path\\to\\mcp-server-infranodus\\dist\\index.js"],
  369. "env": {
  370. "INFRANODUS_API_KEY": "your-api-key-here"
  371. }
  372. }
  373. }
  374. }
  375. ```
  376. 3. Restart Claude Desktop.
  377. ### Cursor Configuration
  378. ### Other MCP-Compatible Applications
  379. For other applications supporting MCP, use the following command to start the server via npx:
  380. ```bash
  381. INFRANODUS_API_KEY=your-api-key npx -y infranodus-mcp-server
  382. ```
  383. or locally
  384. ```bash
  385. INFRANODUS_API_KEY=your-api-key node /path/to/mcp-server-infranodus/dist/index.js
  386. ```
  387. The server communicates via stdio, so configure your application to run this command and communicate through standard input/output.
  388. ### Legacy Setup via Smithery
  389. InfraNodus server is also available through Smithery: a repository of MCP servers that has an easy-to-follow installation process for most LLM clients. You will need a separate accout at Smithery though.
  390. - Create an account on [Smithery.Ai](https://smithery.ai/) (it's free and you can use your Google or GitHub login)
  391. - Then go to the [Smithery InfraNodus Server](https://smithery.ai/server/@infranodus/mcp-server-infranodus), click "Configure" at the top right, and add your InfraNodus API key there.
  392. - Go to [Smithery InfraNodus Server](https://smithery.ai/server/@infranodus/mcp-server-infranodus) and get the URL link from Smithery [https://server.smithery.ai/@infranodus/mcp-server-infranodus/mcp](https://server.smithery.ai/@infranodus/mcp-server-infranodus/mcp) for the server or use one of their automatic setup tools for Claude or Cursor.
  393. - You may need to get your separate Smithery API key and Smithery proile link to make this work.
  394. ##### For Cursor:
  395. ```json
  396. // e.g. Cursor will access directly the server via Smithery
  397. "mcpServers": {
  398. "mcp-server-infranodus": {
  399. "type": "http",
  400. "url": "https://server.smithery.ai/@infranodus/mcp-server-infranodus/mcp?api_key=YOUR_SMITHERY_KEY&profile=YOUR_SMITHERY_PROFILE",
  401. "headers": {}
  402. }
  403. }
  404. ```
  405. #### For Claude:
  406. ```json
  407. // Claude uses a slightly different implementation
  408. // Fot this, it launches the MCP server on your local machine
  409. "mcpServers": {
  410. "mcp-server-infranodus": {
  411. "command": "npx",
  412. "args": [
  413. "-y",
  414. "@smithery/cli@latest",
  415. "run",
  416. "@infranodus/mcp-server-infranodus",
  417. "--key",
  418. "YOUR_SMITHERY_KEY",
  419. "--profile",
  420. "YOUR_SMITHERY_PROFILE"
  421. ]
  422. }
  423. }
  424. ```
  425. **Note**, in both cases, you'll automatically get the `YOUR_SMITHERY_KEY` and `YOUR_SMITHERY_PROFILE` values from Smithery when you copy the URL with credentials. These are not your InfraNodus API keys. You can use the InfraNodus API server without the API for the first 70 calls. Then you can add it to your Smithery profile and it will automatically connect to your account using the link above.
  426. ## Usage Examples
  427. Once installed, you can ask Claude to:
  428. - "Use InfraNodus to analyze this text and show me the main topics"
  429. - "Generate a knowledge graph from this document"
  430. - "Find content gaps in this article"
  431. - "Retrieve my existing graph called 'Research Notes' from InfraNodus"
  432. - "What are the structural gaps in this text?"
  433. - "Identify the most influential concepts in this content"
  434. ## Development
  435. ### Running in Development Mode
  436. ```bash
  437. npm run dev
  438. ```
  439. ### Using the MCP Inspector
  440. Test the server with the MCP Inspector:
  441. ```bash
  442. npm run build:inspect
  443. npm run inspect
  444. ```
  445. ### Building from Source
  446. ```bash
  447. npm run build
  448. ```
  449. ### Watching for Changes
  450. ```bash
  451. npm run watch
  452. ```
  453. ### Running the Tests
  454. ```bash
  455. npm test
  456. ```
  457. Offline tests, no network: they compile the server and drive every tool handler through an intercepted `fetch`. `test/statsSurface.test.mjs` covers the network-statistics surface of all tools that return `diversity_stats` and `fractal_variability` (request flags and response shape). CI runs this on every pull request and on every push to `master`.
  458. ```bash
  459. INFRANODUS_API_KEY=... npm run test:live
  460. ```
  461. Live tests against the real API (`test/live/`): the same tools, checked for the actual data surface, including a computed multifractal spectrum on a long text. Set `INFRANODUS_API_BASE` to point at another API root, and `LIVE_SKIP_AI=1` to skip the tools that call an LLM. The saving tools create one throwaway graph and delete it afterwards. CI runs this after a merge into `master` and on demand from the Actions tab (workflow "Tests" → "Run workflow"); it needs the `INFRANODUS_API_KEY` repository secret and skips itself when the secret is absent.
  462. ## API Documentation
  463. ### generate_knowledge_graph
  464. Analyzes text and generates a knowledge graph.
  465. **Parameters:**
  466. - `text` (string): The text to analyze. Provide this, `url`, or `statements`
  467. - `statements` (string[]): Already-separated statements, with optional parallel `categories` (string[][]) and `timestamps` (ISO 8601 strings)
  468. - `categoriesAsNodes` (boolean, default false): Show category labels as `[[label]]` nodes. Only for large knowledge bases and Obsidian vaults where the connections between pages matter; otherwise the labels stay metadata
  469. - `wikilinksMode` (string): How `[[wikilinks]]` become nodes — "default", "wikilinksOnly", "obsidianStyle", "parentAndConcepts", or "plainText"
  470. - `includeStatements` (boolean): Include original statements in response
  471. - `modifyAnalyzedText` (string): How nodes are made — "none" (words), "detectEntities" (an algorithm marks names, mixed with words), "extractEntitiesOnly" (only the names an algorithm finds; for plain text without `[[wikilinks]]`), or "aiKnowledgeGraph" (an AI model writes `[[entity]]` statements about a topic or a text, and only those entities become nodes; slower, uses AI credits). Text already written as `[[entity]]` statements goes in with `wikilinksMode: "wikilinksOnly"`
  472. - `modelToUse` (string), `instructions` (string): Only with "aiKnowledgeGraph" — the AI model, and the user's own instructions (which entities, scope); they cannot change the output format
  473. ### analyze_existing_graph_by_name
  474. Retrieves and analyzes an existing graph from your InfraNodus account.
  475. **Parameters:**
  476. - `graphName` (string, required): Name of the existing graph
  477. - `includeStatements` (boolean): Include statements in response
  478. - `includeGraphSummary` (boolean): Include graph summary
  479. - `wikilinksMode` (string): Reads the saved graph in another node mode for this call — "saved" (default), "wikilinksAndConcepts", "wikilinksOnly", or "plainText". Nothing is stored
  480. ### analyze_text
  481. Analyze a text, URL, or YouTube transcript. Extract and analyze a graph from text or URL; provide either text or url.
  482. **Parameters:**
  483. - `text` (string, optional): Text to analyze. Provide either this or url.
  484. - `url` (string, optional): URL to fetch content from (e.g. webpage or YouTube transcript). Provide either this or text.
  485. - `includeStatements` (boolean): Include processed statements in response
  486. - `includeGraph` (boolean): Include full graph structure in response
  487. - `addNodesAndEdges` (boolean): Include nodes and edges in response
  488. - `multifractal` (boolean): Also compute the multifractal spectrum inside `fractal_variability` (off by default, ~0.5 s per graph; only returned together with the graph statistics)
  489. - `includeGraphSummary` (boolean): Include AI-generated graph summary for RAG prompt augmentation
  490. - `modifyAnalyzedText` (string): Entity detection — "none", "detectEntities", or "extractEntitiesOnly"
  491. ### analyze_text_signature
  492. Returns the structural and rhythmic signature of one text: how the discourse moves through its concept network, how its topics are distributed, and the sentence-length rhythm of the source. Every number comes with a one-sentence reading. Not a detector on its own.
  493. **Parameters:**
  494. - `text` / `url` / `statements`: the content, as in `analyze_text`
  495. - `multifractal` (boolean, default true): compute the multifractal spectrum of the topic path (adds ~0.5–1 s)
  496. - `maxNodes` (number): concepts kept in the graph (default 150); raise for long texts so the word path is complete
  497. - `modifyAnalyzedText` (string): entity detection, as in `analyze_text`
  498. **Response:**
  499. - `signature`: the text type the backend returns in `network_dynamics.text_type`, one of four names from two questions: does the text have a core (`has_core`, from `structure`) and does it stay where it goes (`stays_where_it_goes`, memory from the DFA exponents). Has a core and stays = deep dive; has a core and keeps moving = refrain; no single core and stays = chapters; no single core and keeps moving = sweep. Comes with `label_possible_values`, `structure_possible_values`, `basis` (memory or movement), `memory_score` and `confidence` (clear or borderline). The server does not compute it: a backend without `text_type` gives a null label.
  500. - `structure`: `modularity`, `diversity_stats` and their readings
  501. - `network_dynamics`: the numbers exactly as the API returns them, in three named groups — `fractal_variability` (DFA exponents `dfa_alpha_global`, `dfa_alpha1`, `dfa_alpha2` for the series `ngram4_graph_radial_distance`, `sentence_word_count` and `node_betweenness_rank`), `node_graph_path_amplitude` (plain statistics of the node path through the graph: mean step and mean radial distance relative to the graph radius, share of steps crossing a topic cluster, and in the full set step CV, lag-1 autocorrelation and cluster dwell CV) and `sentence_rhythm` (prose sentence count, mean words per sentence, share under 8 and over 30 words, skipped fragments, and in the full set the CV and lag-1 autocorrelation)
  502. - `readings`: one plain-language sentence per measure, keyed the same way as `network_dynamics`, with a confidence from the series length for each DFA series
  503. - `ai_likeness`: `verdict` (leaning AI / leaning human / mixed), `verdict_explanation` (why, in terms of pacing: evenly paced / variably paced / inconclusive), `score` (−1 human-like to +1 generated-like), `confidence`, the weighted `evidence` behind it, and `caveats`. It is a stylistic tendency: on a 50-page check against a commercial detector it caught uniformly paced template text but read AI-drafted pages that had been edited as human.
  504. Every number above is computed by the API and read here; they arrive inside `network_dynamics`, which the tool requests in full (`fractalExperimental`) from a compact graph. A backend that does not ship them reports them as empty rather than failing.
  505. ### generate_content_gaps
  506. Identifies content gaps and missing connections in text.
  507. **Parameters:**
  508. - `text` (string, required): The text to analyze for gaps
  509. ## Progress Notifications
  510. For long-running operations (like SEO analysis), the MCP server supports **real-time progress notifications** that provide intermediary feedback to AI agents. This allows agents to:
  511. - Track the progress of multi-step operations
  512. - Display status messages to users
  513. - Understand what's happening during lengthy analyses
  514. ### Implementation
  515. The server implements MCP progress notifications using:
  516. 1. **ToolHandlerContext**: All tool handlers can receive an optional context parameter containing the server instance and progress token
  517. 2. **ProgressReporter**: A utility class that simplifies sending progress updates with percentages and messages
  518. 3. **Wrapped Handlers**: Tool registration automatically injects the server context into handlers
  519. ### Example Usage in Tools
  520. ```typescript
  521. import { ProgressReporter } from "../utils/progress.js";
  522. import { ToolHandlerContext } from "../types/index.js";
  523. handler: async (params: ParamType, context: ToolHandlerContext = {}) => {
  524. const progress = new ProgressReporter(context);
  525. await progress.report(25, "Fetching data from API...");
  526. // Do work
  527. await progress.report(75, "Analyzing results...");
  528. // More work
  529. await progress.report(100, "Complete!");
  530. return results;
  531. };
  532. ```
  533. The `generate_seo_report` tool demonstrates this pattern with 6 major progress checkpoints that provide detailed status updates throughout the multi-step analysis process.
  534. ## Usage Analytics & Privacy
  535. To improve the product, this MCP server records which tools are used (tool names, errors, and latency). This helps us understand which features are useful and where things break. We do **not** train any models on your data — see the [InfraNodus terms and conditions](https://infranodus.com/terms-conditions).
  536. The hosted server (`mcp.infranodus.com`) also records each OAuth sign-in attempt: the time, the app's callback address, whether it succeeded, and the user ID on success. No API keys or tokens are recorded. A locally installed server records no sign-ins.
  537. If you prefer these usage stats not to be linked to your InfraNodus account, set the `MCPCAT_ANONYMOUS` environment variable:
  538. ```json
  539. {
  540. "mcpServers": {
  541. "infranodus": {
  542. "command": "npx",
  543. "args": ["-y", "infranodus-mcp-server"],
  544. "env": {
  545. "INFRANODUS_API_KEY": "YOUR_INFRANODUS_API_KEY",
  546. "MCPCAT_ANONYMOUS": "1"
  547. }
  548. }
  549. }
  550. }
  551. ```
  552. With `MCPCAT_ANONYMOUS=1` set, tool usage is still recorded but stays anonymous — it is not tied to your user account. It also disables the per-user `submit_workflow_feedback` log described under tool 37 (the report includes duration / error / retry of the call it rates).
  553. ### Project learnings
  554. The `enable_project_learnings`, `add_project_learnings`, and `get_project_learnings` tools let the assistant keep an append-only graph of what it learned about operating in a project (`learn-<project>` in your InfraNodus account). They are opt-in per project: the graph exists only after you explicitly ask to enable it, the write tool refuses when the graph is missing and never creates one, and every batch is shown to you before it is saved. If you never want these tools exposed, set `INFRANODUS_LEARNINGS=0` in the server's environment (same place as `MCPCAT_ANONYMOUS`). To stop collecting for a project, delete its `learn-<project>` graph in InfraNodus.
  555. As most tools have the `doNotSave=1` option turned on, all the graphs you create are ephemeral and won't be saved into your InfraNodus account unless you explicitly ask the MCP server to do so. We will also not keep the logs of the data you process. We also never use your data for LLM training according to the InfraNodus [https://infranodus.com/terms-conditions](terms of service).
  556. ## Troubleshooting
  557. ### Server doesn't appear in Claude
  558. 1. Verify the configuration file path is correct
  559. 2. Check that the API key is valid
  560. 3. Ensure Node.js is in your system PATH
  561. 4. Restart Claude Desktop completely
  562. ### API Key Issues
  563. - Get your API key at: [https://infranodus.com/api-access](https://infranodus.com/api-access)
  564. - Ensure the key is correctly set in the configuration
  565. - Check that the key has not expired
  566. ### Build Errors
  567. ```bash
  568. # Clean install
  569. rm -rf node_modules package-lock.json
  570. npm install
  571. npm run build
  572. ```
  573. ## Resources
  574. - [InfraNodus Website](https://infranodus.com)
  575. - [InfraNodus MCP](https://infranodus.com/mcp)
  576. - [InfraNodus API Documentation](https://infranodus.com/api-access)
  577. - [MCP Protocol Documentation](https://modelcontextprotocol.io)
  578. - [Graph Theory Concepts](https://noduslabs.com/research/)
  579. ## License
  580. MIT
  581. ## Support
  582. For issues related to:
  583. - This MCP server: Open an issue in this repository
  584. - InfraNodus API: Contact support@infranodus.com
  585. - MCP Protocol: Visit the [MCP community](https://modelcontextprotocol.io)

Version history

  • v1.10.011/17/2026

  • v1.9.911/16/2026

  • v1.9.811/15/2026

  • v1.9.511/12/2026

  • v1.9.411/11/2026

  • v1.9.211/8/2026

  • v1.9.111/7/2026

  • v1.9.011/5/2026

  • v1.8.611/1/2026

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.