aidb-architecture

Document AIDB's six-layer architecture across MCP, Service, Session, Adapter, DAP Client, and Protocol layers.

19|2|Updated Dec 1, 2025
One-click install
npx skills add https://github.com/ai-debugger-inc/aidb --skill aidb-architecture
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: aidb-architecture
Source: https://github.com/ai-debugger-inc/aidb/tree/main/.claude/skills/aidb-architecture
Command: npx skills add https://github.com/ai-debugger-inc/aidb --skill aidb-architecture

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Understanding a complex, multi-layered system like AIDB can be challenging, leading to incorrect design decisions or difficulty in tracing data flows. This Skill provides a comprehensive map of AIDB's 6-layer architecture, explaining component responsibilities, key design principles, and resource management strategies. It empowers developers to make informed architectural choices and debug cross-layer issues effectively.

Core Features & Use Cases

  • 6-Layer System Overview: Understand the entire stack from MCP to DAP Protocol.
  • Core Architectural Principles: Learn about component delegation, language-agnostic design, and human-cadence debugging.
  • Three-Tier Resource Cleanup: Master the critical strategy for managing processes, ports, and DAP connections.
  • Use Case: When designing a new feature that spans multiple AIDB layers (e.g., a new MCP tool requiring adapter interaction), use this skill to understand the correct integration points and architectural patterns, ensuring a robust and maintainable implementation.

Quick Start

Explain the 6-layer architecture of AIDB and the purpose of the Session Layer.

Frequently Asked Questions about aidb-architecture

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I understand AIDB's multi-layer architecture and data flow across components?

AIDB's architecture spans 6 layers—MCP, Service, Session, Adapter, DAP Client, and Protocol—each with distinct responsibilities. This Skill provides a structured reference explaining component roles, interactions, and data-flow patterns so you can trace requests end-to-end and make informed design decisions across layers.

What are the core design principles behind AIDB's system design?

AIDB follows component delegation, language-agnostic design, and human-cadence debugging principles. Understanding these principles helps you design new features—like MCP tools requiring adapter interaction—at the correct integration points while maintaining consistency and maintainability.

How does resource cleanup work across AIDB's layers?

AIDB implements a three-tier resource cleanup strategy managing processes, ports, and DAP connections. This Skill documents the cleanup sequence and responsibilities per layer, ensuring robust resource management when integrating features across Session, Adapter, and Protocol layers.

Can I trace cross-layer issues and architectural constraints in AIDB?

Yes. This Skill maps layer roles, interactions, and cross-layer constraints in a navigable format. When debugging issues that span multiple layers or designing features requiring multi-layer integration, you can reference the architecture to identify component boundaries and data-flow bottlenecks.

What is the purpose of the Session Layer in AIDB's architecture?

The Session Layer manages stateful interactions and coordinates between the Service and Adapter layers, maintaining context across requests. It enforces resource cleanup policies and mediates protocol-level operations, making it critical for feature designs spanning multiple layers.

Do I need to understand all 6 layers to implement a new AIDB feature?

You need to understand the layers your feature touches and their integration points. This Skill provides the architectural foundation to identify which layers are relevant, their responsibilities, and how data flows between them, reducing design errors and debugging time.