Claude Skills
Overview
Skill Use Cases
Reference

InfraNodus Skill for Claude Code & AI Agents


The InfraNodus skill (infranodus) is the main skill of the InfraNodus skills family. It teaches Claude Code, Claude Desktop, OpenClaw, Cursor, or any other LLM client how to use the InfraNodus MCP server for text network analysis and knowledge graphs: analyze any text's structure, find content gaps, generate research questions and ideas, compare texts, optimize content for SEO / GEO, retrieve answers from saved graphs with GraphRAG, and keep a structured knowledge graph memory.

It also works on whole collections of documents, not just single texts: invoked inside a folder ("graph this repo", "analyze this vault", or /infranodus), it turns a code repository, a research folder, or an Obsidian vault into a set of saved knowledge graphs with a report — and from then on answers questions about the project's themes, decisions, rationale, and gaps by querying those graphs first, before reading any files.

Graph a whole folder, an Obsidian vault, a repo — or an external knowledge base. The skill maps every document in a folder (markdown, text, PDFs, code, git history) and the [[wikilinks]] of an Obsidian vault. If your AI agent is also connected to an external knowledge base through another MCP server — Notion, Google Drive, Confluence, a CRM — the agent can pull that content through the connector and the skill uploads it to InfraNodus in exactly the same way.

You choose how deep to go: full ingestion (every statement, as written), a structure map (what links to what), a digest (the agent's own summary of how things work, with structural feedback), or an ontology (entities and typed relations) — see the build modes below.

Get Started

1
Create an Account

Sign up for a free InfraNodus account to get access to the knowledge graph tools and your API key.

Create a Free Account
2
Get InfraNodus MCP
https://mcp.infranodus.com

Add this URL as a connector via Settings > Connectors in Claude Web / Desktop and authenticate with your InfraNodus API key via OAuth.

3
Install the Skill
/plugin marketplace add infranodus/skills
/plugin install infranodus@infranodus-skills

Run these two commands in the Claude Code prompt to install the skill as a plugin (use infranodus-all@infranodus-skills to install all our skills at once). Or use npx in your terminal: 

npx skills add infranodus/skills --skill infranodus -g -a claude-code -y

npx comes bundled with Node.js. For ChatGPT and OpenClaw, see the full installation instructions.

Didn't work? You can simply download infranodus.zip from our GitHub repository and add it to your LLM client manually — see the step-by-step instructions.

What You Can Graph: Folders, Vaults, Repos & External Knowledge Bases

Run inside any folder, the skill inventories what is there (top-level folders, notes, code, PDFs, non-minable documents) and asks you what to build. It can graph:

  • A folder of documents — markdown, text, and the text layer of PDFs (a converter like pdftotext, mutool, or markitdown needs to be installed for PDFs; scanned PDFs, docx, and epub are routed to the LLM Wiki skill instead, which summarizes them with the LLM).
  • An Obsidian vault — all the notes plus the [[wikilinks]] between them as a separate link graph. Note sections are named after the pages, so the content graph and the link graph share the same node names and can be compared. See the Knowledge Graph skill page for the vault workflow in detail.
  • A code repository — documentation, docstrings, WHY: / NOTE: / TODO: comments, and the commit, PR, and issue history, each as its own graph (scope), so you can ask why something was built the way it was.
  • An external knowledge base — anything your agent can reach through another MCP server in the same session: Notion pages and databases, Google Drive documents, Confluence spaces, support tickets, a CRM. The deterministic scanner only reads local folders, so here the agent fetches the pages through that connector and uploads them as statements to a named InfraNodus graph following the skill's upload contract (one graph per source, heading-aware chunks, paced calls). Once uploaded, the same query, gap, and retrieval tools apply.

You can also narrow the scope to a specific folder, only the documents containing certain terms, or a single document — a good way to start before graphing a whole vault or repo. Filtered scans get their own graphs and never overwrite the full scan.

The Four Build Modes

After the scope, the skill always asks which build mode(s) you want. They can be combined — each is a separate scope in the same infranodus/manifest.json — and they decide both the cost and what the resulting graphs can answer:

Build mode What it builds What it's good for
Full ingestion
recommended for small and medium corpora, no LLM		 Everything the scan covers, as it is literally written: every note and document (plus the [[wikilinks]] link structure in a vault; docs, code rationale, and git / PR / issue history in a repo), one graph per scope. Many uploads, fully deterministic. "What does my knowledge base say about X?" — GraphRAG retrieval grounded in your own text, topical clusters, and the content gaps between them.
Structure map
a few uploads, no LLM — the default for a big repo		 A condensed structural map instead of the full text: in a repo the directory tree, file → imports and dependencies, exported symbols, the first docstring line per file, and package manifests; in a vault, the map of which page links to which. "How is this organised? What depends on what? Which notes are hubs and which are orphans?"
Digest + structural feedback
costs the agent's reading tokens, no server LLM		 The agent reads the target and writes a digest in its own words — one simple statement per line with [[wikilinks]] on how things work: principles, rules, procedures, hand-offs, main ideas, gaps. It is uploaded as an authored scope you can read and edit, and then optimize_knowledge_base is run on it to tell you what dominates, what is under-developed, and which clusters never connect. Reviewing and improving a project or a knowledge base: "How is this supposed to work? Is it coherent? What does it say one must do — and what is never connected to anything?"
Ontology
costs server LLM tokens, lossy by design; needs a full or structure graph first		 The InfraNodus server distils entities and typed relations ([[A]] dependsOn [[B]]) from an already-uploaded graph — the structure map for a codebase, the docs scope otherwise — into a compact onto-<project> graph. Navigating: "How do the parts fit together? How does X connect to Y?"

Digest vs ontology: both are condensations, but the digest is prose about how things work, written by the agent from the files and meant for reviewing and improving the project (it is also the layer that optimize_knowledge_base critiques); the ontology is an entity / relation map distilled by the server and meant for navigating it. A typical setup for a knowledge base is full ingestion + digest; for a large codebase, structure map + ontology.

Every build writes the manifest and appends a dated section to INFRANODUS_REPORT.md with the main topics, gaps, and ideas. When you run /infranodus again later, the skill detects the files that changed since the last build and offers to update only those: their old statements are deleted from the graph and the new ones appended in place, moved files are relabelled without re-extraction, and you can rebuild a single scope or everything when you prefer. A digest you want to correct is edited in place, line by line, not rebuilt.

What the Skill Does

The skill is a compact playbook that tells your AI agent when and how to reach for the InfraNodus MCP tools, so you don't have to know the tool names yourself. Once installed, prompts like these route to the right tools automatically:

  • "What are the main topics in this text / page / video?" — builds a knowledge graph with topical clusters and key concepts.
  • "What's missing in this text?" — detects content gaps: under-connected topic clusters that are opportunities for new ideas.
  • "Generate research questions / ideas from this" — ideation that bridges the detected gaps.
  • "Compare these two documents" — overlap, difference, or merged graphs across texts, URLs, and saved graphs.
  • "Optimize this article for search" — SEO / GEO analysis using real Google search results and related queries.
  • "Graph this repo / vault" — builds a persistent, queryable knowledge graph of your project.
  • "Remember this" — saves structured memories as knowledge graph relations you can retrieve later.

Every analysis tool accepts plain text, a URL (webpages and YouTube videos — transcribed automatically), or the name of an existing InfraNodus graph, so the same workflows apply to notes, articles, videos, and whole knowledge bases.

Install the Skill

Claude Code

Download the skill into your global skills folder:

cd ~/.claude/skills
curl -L -o infranodus.zip https://github.com/infranodus/skills/releases/latest/download/infranodus.zip
unzip infranodus.zip -d infranodus

You can then trigger it explicitly with /infranodus or just describe what you want — Claude will invoke it when relevant.

Claude Web / Desktop

Go to Customize > Skills (in older versions: Settings > Capabilities > Skills), enable Code execution and file creation, click Upload Skill, and select the infranodus.zip file.

OpenClaw

Run in the OpenClaw chat: 

install this skill to the `skills` folder: https://github.com/infranodus/skills/releases/latest/download/infranodus.zip

Or install manually:

cp infranodus.zip ~/.openclaw/skills/infranodus.zip
unzip ~/.openclaw/skills/infranodus.zip -d ~/.openclaw/skills/infranodus

See the main installation guide for step-by-step instructions per LLM client and the CLI skill page for the MCPorter-based OpenClaw setup.

Requirements & Authentication

The skill needs the InfraNodus MCP server connected to your LLM client and an InfraNodus API key (create a free InfraNodus account to get one). In Claude Code, the quickest setup is: 

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

Any other setup works too: the hosted server at https://mcp.infranodus.com/, the claude.ai InfraNodus connector, or a local / self-hosted server — see the MCP deployment guides for each client.

For bulk uploads (repo and vault graphs, see below), the skill uses the InfraNodus MCP server already connected to your session whenever one is available. Only when there is none does it fall back to its bundled upload script, which then needs the INFRANODUS_API_KEY environment variable set in your shell — API keys are read from the environment only, never from configuration files.

One server, one account: the skill always uploads through the MCP server you configured — project scope first (.mcp.json), then your Claude config (~/.claude.json, ~/.claude/settings.json). It never guesses an endpoint or falls back to another credential, so your content can't end up in an account you didn't choose. You can verify the resolved server any time by asking the agent to run the skill's --check-auth preflight.

How It Works

The skill talks to InfraNodus through two channels:

  • Queries and analysis — the agent calls the InfraNodus MCP tools available in the session directly. The server's own tool schemas remain the authoritative reference, so the skill stays thin and never goes out of date.
  • Bulk uploads — for repo, vault, and external knowledge base graphs, the agent first uses the InfraNodus MCP server already connected to the session (the claude.ai connector, the hosted server, or a local one) and uploads the statements chunk by chunk with create_knowledge_graph, following the skill's upload contract: one graph per scope, heading-aware chunks, paced calls, rate-limit backoff. When the session has no InfraNodus tools at all, the bundled upload_scopes.py script does the same through the MCP server in your own configuration, including oversized-payload splitting, so large projects never have to pass through the agent's context window.

Each uploaded graph records its provenance — endpoint, transport, account, and the date it was verified — in a local manifest, so the skill can always tell which server and account a graph lives on.

Repo & Vault Knowledge Graphs

Watch the skill in action:



This is the skill's flagship workflow. Run it inside any project folder — a codebase, a research folder, an Obsidian vault — and it builds a set of saved knowledge graphs that map what the project is about:

  1. Extract — a deterministic script mines the folder: documentation and markdown, text from PDFs, code docstrings, WHY / NOTE / TODO comments, and the project's commit, PR, and issue history.
  2. Upload — the statements are uploaded as scoped graphs (per docs, code rationale, history, etc.) to your InfraNodus account, where you can also explore them visually.
  3. Report — the skill writes an infranodus/manifest.json routing file and appends a dated section to an INFRANODUS_REPORT.md log with the main topics, gaps, and structure of what it found.

From then on, the project folder is graph-aware: when the manifest exists, questions like "why was this approach chosen?", "what are the main themes in this vault?", or "what's underdeveloped here?" are answered by querying the saved graphs first (GraphRAG retrieval), which is faster and more structural than re-reading the files each time.

Launched without a target, the skill inventories the folder and asks what to build: the full graph (recommended), a specific folder, documents matching certain terms, or a single document. It then asks which build modes to use — full ingestion, structure map, digest, ontology, or a combination — as described in the build modes above. On later runs it detects what changed and updates only those files' statements in place.

What It Uses Under the Hood

A quick orientation of how the skill maps tasks to the InfraNodus MCP tools:

Task Tools
Structural overview of a text, URL, or graph generate_knowledge_graph, generate_topical_clusters; create_knowledge_graph to persist
What's missing / ideation generate_content_gaps → generate_research_questions / generate_research_ideas; develop_text_tool for the combined pipeline
Retrieval from saved graphs retrieve_from_knowledge_base (GraphRAG), analyze_existing_graph_by_name, generate_contextual_hint, list_graphs / search / fetch
Reasoning check on a draft optimize_reasoning — diagnoses the discourse structure and suggests what to develop
Comparison overlap_between_texts, difference_between_texts, merged_graph_from_texts
SEO / GEO generate_seo_report or the individual analyze_google_search_results / analyze_related_search_queries / search_queries_vs_search_results tools
Digest feedback & ontology layer optimize_knowledge_base — what dominates, what is under-developed, which clusters never connect; generate_ontology_graph — entities and typed relations distilled from an uploaded graph
Keeping repo / vault graphs current delete_statements (remove a changed file's old statements by category) and update_statements (relabel moved files, edit digest lines in place) — both with a dry run before confirm: true
Structured memory memory_add_relations / memory_get_relations

Analysis responses include a diversity diagnosis of the discourse structure: biased (too concentrated) → focused → diversified (balanced) → dispersed (too scattered) — which the skill uses to decide whether a text needs more focus or more variety.

Companion Skills

The infranodus skill composes with the other skills in the same repository and proposes them when a graph diagnosis suggests it:

Skill When it takes over
llm-wiki Building an LLM-authored knowledge base (wiki pages, curated ontologies) from raw sources. The infranodus skill maps what exists; llm-wiki writes new knowledge on top, sharing the same manifest.
ontology-creator Semantic relations (X causes Y) as [[wikilink]] ontologies, rather than deterministic co-occurrence mining.
seo-analysis Full SEO research projects: keyword research, search intent, informational supply vs demand.
cognitive-variability, shifting-perspective, critical-perspective, rhetorical-analyst, and others Thinking lenses offered when the graph shows a biased or stuck discourse — see the full skills collection.

Skill Metadata

The skill declares its requirements in its frontmatter, which OpenClaw and other clients use for auto-configuration: 

name: infranodus
homepage: https://infranodus.com
metadata:
  openclaw:
    emoji: "🕸️"
    requires:
      env: ["INFRANODUS_API_KEY"]
    primaryEnv: INFRANODUS_API_KEY

The package also bundles references/repo-graph.md (the authoritative runbook for repo / vault graphs) and the scripts/repo2statements.py and scripts/upload_scopes.py scripts used for extraction and upload.

What's Next

Get the InfraNodus MCP