Data Structure Protocol (DSP)

The missing memory layer for AI-assisted development

Your agent re-reads the same codebase every session.DSP fixes that.

Every time you start a new task, your AI coding agent spends the first 5–15 minutes "getting oriented" — scanning files, tracing imports, figuring out what depends on what. On large projects this becomes a constant tax on tokens and attention. Context is rebuilt from scratch, every single time.

DSP is a graph-based long-term structural memory stored in.dsp/. It gives agents a persistent, versionable map of your codebase — entities, dependencies, public APIs, and thereasonsbehind every connection — so they can pick up exactly where they left off.

DSP is not another workflow framework.It's the persistent structural memory layer that's missing from every AI coding workflow.

curl -fsSL https://raw.githubusercontent.com/k-kolomeitsev/data-structure-protocol/main/install.sh | bash

irm https://raw.githubusercontent.com/k-kolomeitsev/data-structure-protocol/main/install.ps1 | iex

$skill-installer install https://github.com/k-kolomeitsev/data-structure-protocol/tree/main/skills/data-structure-protocol

$skill-installeris a Codex skill invocation — type it inside a Codex CLI session, not in your shell.

- Agent stops re-learning your project every session— structural context persists across tasks, sessions, and even team members
- Dependency discovery in seconds, not minutes— graph traversal replaces full-repo scanning
- Impact analysis before refactors— know what breaks before you touch it
- Safer changes on brownfield codebases— hidden couplings become visible edges in the graph
- Works with Claude Code, Cursor, Codex — no lock-in— DSP is an agent skill, not a platform
- Git-native and versionable—.dsp/is plain text, diffs cleanly, reviews like code

Honest trade-off:bootstrapping DSP on a large project takes real effort (time, tokens, discipline). It pays back over the project lifetime through lower per-task token usage, faster discovery, and more predictable agent behavior.

┌──────────────────────┐ │ Codebase │ │ (files + assets) │ └──────────┬───────────┘ │ create/update graph as you work ▼ ┌──────────────────────┐ │ DSP Builder / CLI │ │ (dsp-cli.py) │ └──────────┬───────────┘ │ writes ▼ ┌──────────────────────┐ │ .dsp/ │ │ entity graph + whys │ └──────────┬───────────┘ │ reads/searches/traverses ▼ ┌──────────────────────┐ │ LLM Orchestrator │ │ (your agent + skill) │ └──────────────────────┘

As you work, DSP builds a lightweight graph of your codebase: modules, functions, dependencies, and public APIs. Each connection carries awhy— the reason it exists. Your agent reads this graph instead of re-scanning the repo, navigates structure through graph traversal, and keeps the graph updated as code evolves.

The graph lives in.dsp/— plain text files that commit, diff, and merge like any other source artifact.

Option A: Start from the boilerplate (fastest)

git clone https://github.com/k-kolomeitsev/dsp-boilerplate.git my-project cd my-project docker-compose up -d

Everything is wired:.dsp/graph with two roots (backend + frontend),@dspmarkers in all source files, DSP skills for Cursor, Claude Code, and Codex. You can start coding and the agent already knows the entire project structure.

python dsp-cli.py --root . create-object "src/app.ts" "Main application entrypoint" # → obj-a1b2c3d4 python dsp-cli.py --root . create-function "src/app.ts#start" "Starts the HTTP server" --owner obj-a1b2c3d4 # → func-7f3a9c12 python dsp-cli.py --root . add-import obj-a1b2c3d4 obj-deadbeef "HTTP routing"

python dsp-cli.py --root . search "authentication" python dsp-cli.py --root . find-by-source "src/auth/index.ts" python dsp-cli.py --root . get-children obj-a1b2c3d4 --depth 2

python dsp-cli.py --root . get-parents obj-a1b2c3d4 --depth inf python dsp-cli.py --root . get-recipients obj-a1b2c3d4

Before any refactor, runget-parentsorget-recipientsto see everything that depends on the entity you're about to change.

DSP installs as a skill for your agent. Pick your agent and scope.

Don't have a coding agent yet? Install one first:

# Project-level (current directory) irm https://raw.githubusercontent.com/k-kolomeitsev/data-structure-protocol/main/install.ps1 | iex # With specific agent powershell -ExecutionPolicy Bypass -File install.ps1 -Agent cursor powershell -ExecutionPolicy Bypass -File install.ps1 -Agent claude powershell -ExecutionPolicy Bypass -File install.ps1 -Agent codex # Global (user-level) powershell -ExecutionPolicy Bypass -File install.ps1 -Agent cursor -Global

$skill-installer install https://github.com/k-kolomeitsev/data-structure-protocol/tree/main/skills/data-structure-protocol

$skill-installeris a Codex skill invocation — type it inside a Codex CLI session, not in your shell.

Project installputs the skill in your repo (.cursor/skills/,.claude/skills/,.codex/skills/).Global installputs it in your home directory so it's available across all projects.

Modern agents already know how to plan, write tests, verify, and ship. They don't need process wrappers. What they lack ismemory.

UID markers anchor identity in source code:

Ready-made configurations for each supported agent:

Contributions are welcome. Areas where help is most valuable:

Please keep changes minimal, explicit, and consistent with the "minimal sufficient context" philosophy.

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

Memtrace gives AI coding agents structural memory — your codebase as a live knowledge graph so agents stop re-deriving code structure from scratch and start reasoning from fact.

A server for CodeFuse-CGM, a graph-integrated large language model designed for repository-level software engineering tasks.

An MCP server that indexes local code into a graph database to provide context to AI assistants.

Graph-powered code intelligence MCP server with semantic search, knowledge graph, and dependency analysis for Claude Code, Cursor, and Copilot.

Developer context continuity system that builds a temporal knowledge graph of your codebase — modules, symbols, decisions, and open problems — and serves it to AI coding agents via 12 MCP tools, so every agent session starts knowing your architecture without manual context pasting.

Cross-agent memory bridge with knowledge graph, workspace sync, and auto-memory hooks. Supports Windsurf, Cursor, Claude Code, Codex, and VS Code Copilot.

Highly efficient context management for agentic AI: MCP code search, evidence packs, graph context, and memory for large projects.

Dalexor MI is an advanced project memory system designed to provide AI coding assistants with Contextual Persistence. Unlike standard RAG (Retrieval-Augmented Generation) systems that perform surface-level keyword searches, Dalexor MI maps the logical evolution of a codebase, tracking how symbols, dependencies, and architectural decisions shift over time.

Local code-knowledge graph + bi-temporal mistakes memory for AI coding agents. Serves a ranked structural packet instead of whole files on read/grep, and surfaces fixes your repo already reverted (mined from git history). Zero cloud, Apache-2.0.