> ## Documentation Index
> Fetch the complete documentation index at: https://docs.alchemicalchef.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Dependency Mapping Tool

> Visualize and manage component interconnections across your enterprise architecture

The Dependency Mapping Tool is a desktop application that enables IT teams to visualize and manage interconnections across enterprise architecture components—from Active Directory and hypervisors to applications, databases, and cloud services.

## Why Map Dependencies?

Enterprise environments contain complex webs of interconnected systems. A single change to a domain controller, hypervisor, or core service can cascade through dozens of dependent systems. Without clear visibility into these relationships, teams face:

* Unplanned outages from changes to upstream dependencies
* Security blind spots where compromise paths aren't understood
* Lengthy incident response while tracing impact across systems
* Failed migrations due to undocumented dependencies

This tool provides a single source of truth for how your infrastructure components relate to each other.

## Key Features

<CardGroup cols={2}>
  <Card title="Interactive Visualization" icon="diagram-project">
    Graph-based representation using Cytoscape.js with click-to-explore functionality, adjustable depth control (1-3 levels), and multiple layout algorithms.
  </Card>

  <Card title="Environment Management" icon="server">
    Isolated configurations for dev, staging, production, or custom environments with seamless switching and per-environment data isolation.
  </Card>

  <Card title="Component Configuration" icon="cube">
    Support for nine component types spanning identity, infrastructure, applications, and external services.
  </Card>

  <Card title="Data Validation" icon="shield-check">
    Detect orphaned relationships, missing references, and circular dependencies with severity categorization.
  </Card>
</CardGroup>

## Component Types

The tool supports the following component types:

| Type                  | Description                           | Examples                                                             |
| --------------------- | ------------------------------------- | -------------------------------------------------------------------- |
| **Identity Provider** | Authentication and directory services | Active Directory, Azure AD, Okta, ADFS                               |
| **Database**          | Data stores and warehouses            | SQL Server, Oracle, PostgreSQL, MongoDB                              |
| **Backend**           | Core infrastructure and compute       | Hypervisors (VMware, Hyper-V), Kubernetes clusters, physical servers |
| **Gateway**           | Network and security appliances       | Firewalls, load balancers, VPN concentrators, reverse proxies        |
| **API**               | Internal and external API services    | REST APIs, SOAP services, GraphQL endpoints                          |
| **Queue**             | Message brokers and event systems     | RabbitMQ, Kafka, MSMQ, Azure Service Bus                             |
| **Cache**             | Caching and session layers            | Redis, Memcached, distributed caches                                 |
| **Frontend**          | User-facing applications              | Web portals, client applications, admin consoles                     |
| **External**          | Third-party and cloud services        | SaaS applications, cloud providers, partner integrations             |

## Relationship Types

Seven relationship types characterize component connections:

* **depends\_on** - Component requires another to function (e.g., application depends on database)
* **communicates\_with** - Bidirectional communication (e.g., app servers in a cluster)
* **authenticates\_via** - Authentication dependency (e.g., application authenticates via Active Directory)
* **reads\_from** - Data consumption (e.g., reporting server reads from data warehouse)
* **writes\_to** - Data production (e.g., application writes to audit database)
* **publishes** - Event publishing (e.g., service publishes to message queue)
* **subscribes** - Event subscription (e.g., processor subscribes to event stream)

<Tip>
  Edges are color-coded by relationship type for quick visual identification of dependency patterns.
</Tip>

## Use Cases

### Change Management

Before modifying infrastructure, visualize the blast radius:

1. Select the component you plan to change
2. Expand dependencies to see all affected systems
3. Identify which teams and services need to be notified
4. Plan maintenance windows based on dependency criticality

### Security Analysis

Map authentication and trust relationships:

* Trace which systems authenticate against each domain controller
* Identify single points of failure in identity infrastructure
* Document network segmentation and trust boundaries
* Support [tier model](/ad-tier-model/overview) implementation by visualizing cross-tier dependencies

### Incident Response

During outages, quickly identify root cause:

* Start from the affected service and trace upstream
* Identify shared dependencies that could cause correlated failures
* Document the incident path for post-mortems

## Prerequisites

Before installing, ensure you have:

* Node.js 18+
* Rust 1.70+
* Tauri platform-specific dependencies

## Installation

### Development

```bash theme={null}
git clone https://github.com/AlchemicalChef/DependencyMappingTool.git
cd DependencyMappingTool
npm install
npm run tauri dev
```

### Production Build

```bash theme={null}
npm run tauri build
```

<Info>
  The build output will be located in the `src-tauri/target/release` directory.
</Info>

## Getting Started

<Steps>
  <Step title="Create an Environment">
    Start by creating your first environment (e.g., "production" or "datacenter-east"). Each environment maintains isolated component configurations.
  </Step>

  <Step title="Add Components">
    Define your infrastructure components by specifying the type, version, owner, team, and any relevant tags or custom metadata.
  </Step>

  <Step title="Define Relationships">
    Connect components by creating relationships that describe how they interact with each other.
  </Step>

  <Step title="Explore the Graph">
    Use the interactive visualization to explore your architecture. Click on nodes to focus on specific components and their dependencies.
  </Step>
</Steps>

## Search and Filtering

The tool provides full-text search across:

* Component names
* Descriptions
* Tags
* Owners

You can also filter the graph view by:

* Component type
* Health status
* Relationship type

## Tech Stack

| Layer        | Technologies                                           |
| ------------ | ------------------------------------------------------ |
| **Frontend** | React 18, TypeScript, Chakra UI, Cytoscape.js, Zustand |
| **Backend**  | Rust, Tauri 2.0                                        |
| **Data**     | JSON file storage per environment                      |

## Resources

* [GitHub Repository](https://github.com/AlchemicalChef/DependencyMappingTool)
* [Report Issues](https://github.com/AlchemicalChef/DependencyMappingTool/issues)