# com.vithanco/vgraph-mcp (npm · @vithanco/vgraph-mcp)

Concept Maps, IBIS, Causal Loop Diagrams and Timelines as images. Runs locally via WebAssembly.

- Trust score: 61/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-26

## Components

- remote · `mcp.vithanco.com`: 23/100, [markdown](https://verifymcp.io/servers/com-vithanco-vgraph-mcp/mcp.md), [page](https://verifymcp.io/servers/com-vithanco-vgraph-mcp/mcp)
- npm · `@vithanco/vgraph-mcp`: 61/100 (this document), [markdown](https://verifymcp.io/servers/com-vithanco-vgraph-mcp/vithanco-vgraph-mcp.md), [page](https://verifymcp.io/servers/com-vithanco-vgraph-mcp/vithanco-vgraph-mcp)

## Channel facts

- Registry: `npm`
- Package: `@vithanco/vgraph-mcp`
- Version: `1.0.9`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-09-26.

- **Supply Chain Security**: 98/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 31 of 97 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 19/100
  - Repository check failed: the declared repository URL returned HTTP 404.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 5 days ago).
  - Security-disclosure policy not yet verified: we couldn't inspect the source repository.
- **Schema Quality & AI Usability**: 54/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 5177 tokens (~1035/item across 5 items; 5 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 5 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 5 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the com.vithanco/vgraph-mcp server?

com.vithanco/vgraph-mcp runs locally as an npm package, launched with npx -y @vithanco/vgraph-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add com-vithanco-vgraph-mcp -- npx -y @vithanco/vgraph-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "com-vithanco-vgraph-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@vithanco/vgraph-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "com-vithanco-vgraph-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@vithanco/vgraph-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add com-vithanco-vgraph-mcp -- npx -y @vithanco/vgraph-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "com-vithanco-vgraph-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@vithanco/vgraph-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add com-vithanco-vgraph-mcp --command npx --arg -y --arg @vithanco/vgraph-mcp
```

### Hermes

```yaml
mcp_servers:
  com-vithanco-vgraph-mcp:
    command: "npx"
    args: ["-y", "@vithanco/vgraph-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "com-vithanco-vgraph-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "@vithanco/vgraph-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add com-vithanco-vgraph-mcp -t stdio -c npx -a -y @vithanco/vgraph-mcp
```

### Other

```json
{
  "mcpServers": {
    "com-vithanco-vgraph-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@vithanco/vgraph-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-09-25 (score 61, 0)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-09-20 (score 61)

First indexed and scored.

## MCP tools (5)

### `create_cld` (~1051 tokens)

Create a CLD diagram as PNG image. A Causal Loop Diagram (CLD) is a Systems Thinking tool that maps feedback loops between variables, showing how a change in one variable causes changes in others. It reveals reinforcing dynamics (exponential growth or decline) and balancing dynamics (stabilisation toward equilibrium).

You provide VGL (Vithanco Graph Language) code using the CLD notation and the tool renders it to an PNG image.

\## Core Concepts

A CLD consists of **variables** (called Stocks) connected by **causal links** with polarity:

\- **same** (`s`): when A increases, B increases; when A decreases, B decreases. Drawn as a solid arrow.
\- **opposite** (`o`): when A increases, B decreases; when A decreases, B increases. Drawn as a dashed arrow.

A **feedback loop** is a closed chain of causal links returning to the starting variable:

\- **Reinforcing loop (R)**: even number of `opposite` edges (including zero). Drives exponential growth or decline — a snowball effect.
\- **Balancing loop (B)**: odd number of `opposite` edges. Drives the system toward equilibrium — a thermostat effect.

\## How to Build a CLD

1\. Identify the key variables (stocks) in the system — things whose value can increase or decrease.
2\. For each pair of causally related variables, determine the polarity: does an increase in A cause B to increase (same) or decrease (opposite)?
3\. Trace closed loops and classify them as reinforcing or balancing using the counting rule.
4\. Give the diagram a title that frames the system boundary.

\## VGL Syntax

\```
vgraph <id>: CLD "<title>" {
    <nodes and edges>
}
\```

\### Node Types

\- `Stock` — a variable whose value changes over time (blue circle). Examples: Population, Revenue, Stress, Trust.

\```
node <id>: Stock "<label>"
\```

\### Edges

CRITICAL: You MUST specify the edge type (`: same` or `: opposite`) on every edge. Both edge types connect Stock to Stock, so the type CANNOT be inferred — omitting it will cause an error.

\```
edge <from_id> -> <to_…

Input parameters:

- `vgl` (string, required): Valid VGL code using the CLD notation. Must start with: vgraph <id>: CLD "<title>" { ... }

### `create_concept_map` (~1586 tokens)

Create a ConceptMap diagram as PNG image. A Concept Map defines the vocabulary of a domain through falsifiable propositions. It helps people align on exact wordings and shared understanding by stating facts as simple, readable sentences.

You provide VGL (Vithanco Graph Language) code using the ConceptMap notation and the tool renders it to an PNG image.

\## How to Build a Concept Map

1\. Start with a Guiding Question (used as the graph title) — it determines what belongs on the map.
2\. List all relevant concepts.
3\. Connect every concept through relations. ALWAYS form readable propositions.
4\. NEVER leave a concept unconnected. Every concept MUST connect to at least one relation.
5\. Reuse relations when multiple concepts share the same relationship.

\## VGL Syntax

\```
vgraph <id>: ConceptMap "<Guiding Question>" {
    <nodes and edges>
}
\```

\### Node Types

\- `Concept` — a concept or term
\- `EmphasizedConcept` — a concept to highlight as especially important
\- `Relation` — a linking verb or phrase that connects concepts

\```
node <id>: Concept "<label>"
node <id>: EmphasizedConcept "<label>"
node <id>: Relation "<label>"
\```

\### Edges

\```
edge <from_id> -> <to_id>
\```

ALWAYS form the pattern: Concept -> Relation -> Concept. This creates a readable proposition.

\## Reusing Relations

When multiple concepts share the same relationship, reuse a single Relation node. No duplicate edges when reusing — create edges only where needed:

\**Multiple sources, one target:**
\```
vgraph animals: ConceptMap "What are common pets?" {
    node dog: Concept "Dog"
    node cat: Concept "Cat"
    node isa: Relation "is a"
    node mammal: Concept "Mammal"

    edge dog -> isa
    edge cat -> isa
    edge isa -> mammal  // Only ONE edge from relation to target
}
\```

Both "Dog is a Mammal" and "Cat is a Mammal" share one Relation node — only 4 nodes total.

\**One source, multiple targets:**
\```
vgraph typography: ConceptMap "What defines a font?" {
    node font: Concept "Font"…

Input parameters:

- `vgl` (string, required): Valid VGL code using the ConceptMap notation. Must start with: vgraph <id>: ConceptMap "<title>" { ... }

### `describe_notation` (~61 tokens)

Return the self-describing Markdown document for a built-in VGraph notation. The document includes the notation's purpose, when to use it, node types, edge types, history, and references.

Input parameters:

- `notation` (string, required): Name of the built-in notation

### `create_ibis` (~907 tokens)

Create a IBIS diagram as PNG image. IBIS (Issue-Based Information System) maps out any decision, discussion, or thought process using just four node types: Questions, Answers (Ideas), Pros, and Cons. Attaching Questions to any node lets you drill into any aspect at any depth.

You provide VGL (Vithanco Graph Language) code using the IBIS notation and the tool renders it to an PNG image.

\## How to Build an IBIS Diagram

1\. Start with a root Question (used as the graph title).
2\. Add Answers (Ideas) that respond to the question.
3\. Add Pro and Con arguments for each answer.
4\. Attach further Questions to any node to drill deeper.
5\. Keep going until the topic is explored to the depth you need.

\## VGL Syntax

\```
vgraph <id>: IBIS "<title>" {
    <nodes and edges>
}
\```

\### Node Types

\- `Question` — a question or issue to explore (purple, question mark icon)
\- `Answer` — an idea or proposed answer (amber, lightbulb icon)
\- `Pro` — an argument in favour of an answer (green, thumbs up icon)
\- `Con` — an argument against an answer (red, thumbs down icon)

\```
node <id>: Question "<label>"
node <id>: Answer "<label>"
node <id>: Pro "<label>"
node <id>: Con "<label>"
\```

\### Edges

Edge types are inferred from node types — just write `edge <from> -> <to>`.

Valid connections:
\- Question -> Answer (answering the question)
\- Answer -> Pro (supporting argument)
\- Answer -> Con (opposing argument)
\- Question -> Question (sub-question of a question)
\- Answer -> Question (answer raises new question)
\- Pro -> Question (pro raises new question)
\- Con -> Question (con raises new question)

\```
edge <from_id> -> <to_id>
\```

\## The Drill-Down Mechanism

The power of IBIS is that you can attach a Question to **any** node type:
\- Question a Question: "Shouldn't we rather discuss X?"
\- Question an Answer: "What would we need to implement this?"
\- Question a Pro: "Is this advantage really significant?"
\- Question a Con: "Can we mitigate this disadvantage?"

Each sub-question starts…

Input parameters:

- `vgl` (string, required): Valid VGL code using the IBIS notation. Must start with: vgraph <id>: IBIS "<title>" { ... }

### `create_timeline` (~1572 tokens)

Create a Timeline diagram as PNG image. A Timeline visualises events over time, optionally across multiple parallel tracks (groups). The default layout is left-to-right but can be changed to any direction. The base notation provides generic TimePoint and Event types — use `vnotation extends Timeline` to define domain-specific event types (e.g. Battle, Treaty, Release, Incident) with custom colours and categories.

You provide VGL (Vithanco Graph Language) code using the Timeline notation and the tool renders it to an PNG image.

\## Core Concept: alignGroup

The key mechanism is the `alignGroup` attribute. Nodes sharing the same `alignGroup` value are placed at the same position in the layout — pinned to the same column (left-to-right) or the same row (top-to-bottom). This is what creates time alignment.

\```
node t1800: TimePoint "1800" [alignGroup: "1800"]
node e1: Event "Something happened" [alignGroup: "1800"]
\```

These two nodes will appear at the same horizontal position because they share alignGroup "1800".

\## How to Build a Timeline

1\. Choose a title that describes the scope of the timeline.
2\. Decide whether you need TimePoints (axis markers) or whether alignGroup alone suffices.
3\. Add Events for things that happened, each with an `alignGroup` matching its time.
4\. Use `sequence` edges between TimePoints to form the visible time axis.
5\. Use `influence` edges between Events to show causal or contextual links.
6\. Optionally use groups to create named parallel tracks (countries, teams, systems).

\## VGL Syntax

\```
vgraph <id>: Timeline "<title>" {
    <nodes, edges, and groups>
}
\```

\### Node Types

\- `TimePoint` — an axis marker (date, phase, milestone label). Small gray box. Optional.
\- `Event` — something that happened. Steel-blue rounded box.

\```
node <id>: TimePoint "<label>" [alignGroup: "<time_value>"]
node <id>: Event "<label>" [alignGroup: "<time_value>"]
\```

ALWAYS include `alignGroup` on every node to ensure correct time alignment.

\### Edg…

Input parameters:

- `vgl` (string, required): Valid VGL code using the Timeline notation. Either `vgraph <id>: Timeline "<title>" { ... }` directly, or a `vnotation <Name> extends Timeline { ... }` block followed by `vgraph <id>: <Name> "<title>…

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/com-vithanco-vgraph-mcp/vithanco-vgraph-mcp#diagnostics

## Score history

- 2026-09-26: 61
- 2026-09-25: 61
- 2026-09-24: 61
- 2026-09-23: 61
- 2026-09-22: 61
- 2026-09-21: 61
- 2026-09-20: 61

## Common questions

### What is the com.vithanco/vgraph-mcp server?

com.vithanco/vgraph-mcp is listed in the public MCP registry as com.vithanco/vgraph-mcp. Concept Maps, IBIS, Causal Loop Diagrams and Timelines as images. Runs locally via WebAssembly. This page covers its npm package (@vithanco/vgraph-mcp).

### Is the com.vithanco/vgraph-mcp server safe to use?

com.vithanco/vgraph-mcp scores 61 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 26 September 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the com.vithanco/vgraph-mcp server expose?

com.vithanco/vgraph-mcp exposes 5 tools: create_cld, create_concept_map, describe_notation, create_ibis, create_timeline. Their descriptions and schemas cost roughly 5,177 tokens of context every time the server is loaded.

### Is the com.vithanco/vgraph-mcp server still maintained?

com.vithanco/vgraph-mcp is still listed as active in the MCP registry. We last reached this channel on 26 September 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the com.vithanco/vgraph-mcp server under?

com.vithanco/vgraph-mcp declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- npm package: https://www.npmjs.com/package/@vithanco/vgraph-mcp
- Socket report: https://socket.dev/npm/package/@vithanco/vgraph-mcp
- Website: https://vithanco.com/
- Changelog RSS feed: https://verifymcp.io/servers/com-vithanco-vgraph-mcp/vithanco-vgraph-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/com-vithanco-vgraph-mcp/vithanco-vgraph-mcp.json
- HTML version of this page: https://verifymcp.io/servers/com-vithanco-vgraph-mcp/vithanco-vgraph-mcp