Datasynx Cartography

Install once — every AI agent knows your system landscape.

100% local MCP-native Provider-agnostic Read-only

Cartography discovers your system landscape — local services, databases, SaaS tools, installed apps and their dependencies — and exposes it as a Model Context Protocol server with progressive disclosure, recursive dependency traversal and semantic search. Discovery runs deterministically (no LLM required) or via an optional Claude-driven loop. Any MCP host — Claude Code, Cursor, VS Code, Cline, Windsurf — drives the same server.

2-minute quickstart. npx -p @datasynx/agentic-ai-cartography datasynx-cartography discover → datasynx-cartography install --client claude-code. Restart the host and ask it to read cartography://graph/summary.

Quickstart

# 1. Discover your system (read-only, deterministic — no LLM required)
npx -p @datasynx/agentic-ai-cartography datasynx-cartography discover

# 2. Register the MCP server into your AI client (parse-merge, never clobber)
datasynx-cartography install --client claude-code

# 3. (optional) run the MCP server directly
npx -p @datasynx/agentic-ai-cartography cartography-mcp

One MCP server

Read-only discovery exposed as MCP resources, tools and prompts over stdio or Streamable HTTP. Start at cartography://graph/summary — a low-token index — then drill in.

Install anywhere

A single install --client <id> harness writes the correct config for 13 hosts, parse-merging into existing files without clobbering your other servers.

Install into a client

Claude Code — one-step plugin

Install from the shared Datasynx marketplace (same flow as Shadowing) — no manual config:

/plugin marketplace add datasynx/claude-plugins
/plugin install cartography@datasynx

Verify with /mcp. Every other host uses the install harness below.

Any other host — the install harness

The harness parses your host's existing config and merges in the Cartography server entry without clobbering your other servers.

datasynx-cartography list-clients                 # supported hosts
datasynx-cartography install --client <id>        # write the config
datasynx-cartography install --client <id> --dry-run   # preview the merge diff

Flag	Purpose
`--global` / `--project`	User-level (default) or project-local config.
`--dry-run`	Print the merge diff; write nothing.
`--name <server>`	Server key to register (default `cartography`).
`--http` / `--url <url>`	Register the Streamable HTTP endpoint instead of stdio.
`--db <path>` / `--session <id>`	Serve a specific catalog / discovery session.
`--deeplink`	Print a one-click Cursor/VS Code install link instead of writing.

One-click deeplinks

datasynx-cartography install --client cursor --deeplink   # cursor://… one-click
datasynx-cartography install --client vscode --deeplink   # vscode://… + `code --add-mcp`

Claude Desktop one-click bundle

npm run build:mcpb     # → dist/cartography.mcpb (validated against the mcpb v0.3 schema)

Architecture

MCP hosts ───────────►  MCP server (src/mcp) — primary interface
  Claude Code, Cursor,    │  stdio + Streamable HTTP transports
  VS Code, Cline, …       │
                          ├─ Resources   graph/summary, nodes, services, dependencies
                          ├─ Tools       query_infrastructure, get_dependencies, …
                          ├─ Prompts     audit-attack-surface, onboard-to-system, …
                          │
  install harness ───────►├─ Installer   13 hosts · parse-merge JSON/TOML/YAML
                          │
  discovery ─────────────►├─ Scanners    installed apps, ports, bookmarks (read-only)
                          ├─ Semantic    sqlite-vec vectors + lexical fallback
                          └─ CartographDB SQLite catalog (recursive-CTE graph)

The CLI and the embeddable library are thin adapters over the same core — the MCP server is the headline. Every tool is annotated readOnlyHint: true; a command allowlist rejects anything that mutates.

Resources

Read-only context with progressive disclosure — read cartography://graph/summary first.

URI	Description
`cartography://graph/summary`	Low-token aggregate index — read this first.
`cartography://nodes`	Lightweight list of all nodes.
`cartography://nodes/{id}`	Full node record plus incident edges.
`cartography://services`	Service-type nodes.
`cartography://databases`	Data-store nodes.
`cartography://dependencies/{id}`	Transitive downstream dependencies.
`cartography://sessions`	Discovery sessions in the catalog.

Tools

Tool	Read-only	Description
`get_summary`	yes	Low-token overview of the whole landscape.
`query_infrastructure`	yes	Search the topology by name/id/domain.
`search_topology`	yes	Semantic search over the topology.
`list_services`	yes	List discovered services or data stores.
`get_node`	yes	Fetch a single node with its incident edges.
`get_dependencies`	yes	Recursive dependency-graph traversal.
`run_discovery`	writes catalog	Scan the local system and update the catalog.

Prompts

Prompt	Description
`audit-attack-surface`	Review externally-reachable services and risky dependencies.
`map-service-dependencies`	Produce a dependency map for a given service.
`onboard-to-system`	Explain the system landscape to a new engineer.

Remote / HTTP

cartography-mcp --http --port 3737      # → http://127.0.0.1:3737/mcp

# Exposing beyond loopback requires an explicit Host allowlist (CVE-2025-66414):
cartography-mcp --http --host 0.0.0.0 --port 3737 --allowed-hosts cartography.internal:3737

Binding a non-loopback --host without --allowed-hosts is refused on purpose — it would leave the server open to DNS-rebinding attacks. Put it behind TLS / a reverse proxy for real deployments.

Supported clients

Run datasynx-cartography list-clients for the live list. The harness writes the exact config for each host (parse-merge, never clobber).

id	Host	Format	Notes
`claude-code`	Claude Code	json
`cursor`	Cursor	json
`vscode`	VS Code (Copilot)	json	Uses the `servers` key, not `mcpServers`.
`codex`	Codex CLI	toml	Project scope loads only in "trusted" projects.
`windsurf`	Windsurf	json
`cline`	Cline	json	Adds `alwaysAllow`/`disabled`.
`roo`	Roo Code	json	Project `.roo/mcp.json` takes precedence.
`zed`	Zed	json	Key `context_servers`; needs `"source": "custom"`.
`junie`	JetBrains / Junie	json
`gemini`	Gemini CLI	json	HTTP via `httpUrl`.
`goose`	Goose	yaml	Built-ins left untouched.
`openhands`	OpenHands	toml	`[mcp]` arrays; SHTTP preferred.
`claude-desktop`	Claude Desktop	json	One-click via the `.mcpb` bundle.

CLI

Command	Description
`discover`	Scan and map your infrastructure.
`seed`	Manually add known tools/DBs/APIs.
`install --client <id>`	Register the MCP server into a host's config.
`list-clients`	List supported hosts.
`mcp [--http]`	Run the MCP server (stdio by default).
`export [session]`	Export Mermaid / JSON / YAML / HTML.
`show / sessions / overview`	Inspect discovery sessions.
`doctor`	Check requirements (kubectl, aws, gcloud, az).

Non-MCP frameworks

Frameworks without a config file load MCP tools via their own adapters — point them at the standard stdio command. Full snippets in docs/adapters.md.

npx -y --package @datasynx/agentic-ai-cartography cartography-mcp

LangGraph CrewAI AutoGen / MAF Pydantic AI OpenAI Agents SDK Smolagents Vercel AI SDK

Datasynx Agentic Suite

Cartography is one of three composable, local-first, MCP-native tools. They work standalone, but compound when combined: Cartography maps the systems, Shadowing documents the work, CRM runs the customer relationships.

🗺️ Cartography you are here

@datasynx/agentic-ai-cartography

Maps your infrastructure into a graph of systems, services, and dependencies — exposed over MCP.

npm · GitHub

👁️ Shadowing

@datasynx/agentic-ai-shadowing

Observes daily workflows and generates anonymized SOPs via Claude. Fully local, fully anonymized.

npm · GitHub · Docs

🤝 CRM

@datasynx/agentic-crm

The CRM your AI agents actually run — local-first, MCP-native, one autonomous agent per customer.

npm · Docs

FAQ

Where does my data live?

In a local SQLite catalog. Discovery is read-only and deterministic — no cloud, no daemon. The optional Claude-driven discovery loop is the only thing that calls an LLM.

Which AI tools can use it?

Anything that speaks MCP — Claude Code, Cursor, VS Code/Copilot, Cline, Roo, Windsurf, Zed, JetBrains/Junie, Gemini CLI, Codex, Goose, OpenHands, Claude Desktop. Frameworks like LangGraph, CrewAI and the Vercel AI SDK load the tools via their own adapters.

Is it really read-only?

Yes. Every tool is annotated readOnlyHint: true and a strict command allowlist rejects anything that mutates the system. Cartography describes your landscape; it never changes it.

Do I need an API key?

No for deterministic discovery and the MCP server. An ANTHROPIC_API_KEY is only needed for the optional Claude-driven discovery loop.

Is it free?

Yes. MIT-licensed and self-hosted. No seats, no metering, no telemetry.