DAG - Documentation Augmented Generation

MCP Server for Version-Aware Library Documentation and API Retrieval

DAG is a Model Context Protocol (MCP) server that provides intelligent, version-aware access to npm library documentation through semantic search, API validation, and version comparison tools.

Features

• Semantic Search: Vector-based search across library documentation and source code
• API Validation: Real-time validation of API usage against indexed signatures
• Version Comparison: Diff analysis showing added/removed APIs between versions
• Hybrid Search: Combines vector similarity with keyword matching for accuracy
• Multi-Ecosystem: Designed for extensibility to Python, Ruby, Java, etc.

Architecture

┌──────────────────────────────────────────────────────────────┐
│                      MCP Server (Stdio)                      │
├──────────────────────────────────────────────────────────────┤
│  Resources                   │  Tools                        │
│  • library-docs/{lib}/{ver}  │  • search_library            │
│  • api-signature/{lib}/{fn}  │  • validate_api              │
│  • library-versions/{lib}    │  • compare_versions          │
├──────────────────────────────────────────────────────────────┤
│              Indexing Pipeline (Orchestrator)                │
│     NPM → Parse AST → Chunk → Embed → Qdrant Store         │
├──────────────────────────────────────────────────────────────┤
│  Services Layer                                              │
│  • NPM Crawler     • AST Parser    • Chunker                │
│  • Embedder        • Qdrant        • Orchestrator           │
└──────────────────────────────────────────────────────────────┘

Packages

This monorepo contains three packages:

1. @vamfi/dag-shared

Core types and interfaces used across the system.

Coverage: 98.01% | Tests: 6/6 passing

2. @vamfi/dag-indexer

Indexing pipeline for npm packages.

Components:

• NPM Crawler (downloads tarballs, extracts source)
• AST Parser (tree-sitter for TypeScript/JavaScript)
• Semantic Chunker (splits code by functions/classes)
• Embedder (Voyage AI embeddings)
• Qdrant Service (vector database operations)
• IndexingOrchestrator (end-to-end pipeline)

Coverage: 98.57% | Tests: 48/48 passing

3. @vamfi/dag-mcp-server

MCP server implementation.

Components:

• MCP Server (stdio transport)
• Resource Provider (3 resource types)
• Tool Provider (3 tools)
• Health monitoring

Coverage: 58.65% | Tests: 28/28 passing

Installation

Prerequisites

• Node.js ≥ 18.0.0
• npm ≥ 9.0.0
• Qdrant Cloud account (or local Qdrant instance)

Setup

1. Clone the repository:

   git clone https://github.com/VAMFI/DAG.git
   cd DAG
   

2. Install dependencies:

   npm install
   

3. Build all packages:

   npm run build
   

4. Run tests:

   npm test
   

Configuration

Create a .env file in the project root:

# Qdrant Configuration
QDRANT_URL=https://your-cluster.qdrant.tech
QDRANT_API_KEY=your_api_key_here

# MCP Server Configuration
MCP_SERVER_NAME=dag-mcp-server
MCP_SERVER_VERSION=0.1.0

Usage

Indexing a Library

import { IndexingOrchestrator } from '@vamfi/dag-indexer';
import {
  NPMCrawlerService,
  ASTParserService,
  ChunkerService,
  EmbedderService,
  QdrantService
} from '@vamfi/dag-indexer';

// Initialize services
const crawler = new NPMCrawlerService();
const parser = new ASTParserService();
const chunker = new ChunkerService();
const embedder = new EmbedderService({
  qdrantUrl: process.env.QDRANT_URL,
  apiKey: process.env.QDRANT_API_KEY
});
const qdrant = new QdrantService({
  url: process.env.QDRANT_URL,
  apiKey: process.env.QDRANT_API_KEY
});

// Create orchestrator
const orchestrator = new IndexingOrchestrator(
  crawler,
  parser,
  chunker,
  embedder,
  qdrant
);

// Index a package
const result = await orchestrator.indexPackage('express', '4.18.2');

console.log(`Indexed ${result.chunksIndexed} chunks in ${result.duration}ms`);

Running the MCP Server

# Start the server
npm start --workspace=@vamfi/dag-mcp-server

# Or use the CLI directly
./packages/mcp-server/dist/index.js

Using Resources

Resources provide structured access to documentation:

dag://library-docs/express/4.18.2
dag://api-signature/express/Router
dag://library-versions/express

Using Tools

Tools enable intelligent interaction with documentation:

1. Search Library:

{
  "tool": "search_library",
  "arguments": {
    "query": "how to create middleware",
    "library": "express",
    "version": "4.18.2",
    "limit": 5
  }
}

2. Validate API:

{
  "tool": "validate_api",
  "arguments": {
    "library": "express",
    "apiCall": "app.use(express.json())",
    "version": "4.18.2"
  }
}

3. Compare Versions:

{
  "tool": "compare_versions",
  "arguments": {
    "library": "express",
    "version1": "4.17.0",
    "version2": "4.18.2"
  }
}

MCP Client Integration

Claude Desktop

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "dag": {
      "command": "node",
      "args": ["/path/to/DAG/packages/mcp-server/dist/index.js"],
      "env": {
        "QDRANT_URL": "https://your-cluster.qdrant.tech",
        "QDRANT_API_KEY": "your_api_key"
      }
    }
  }
}

Continue.dev

Add to .continue/config.json:

{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "node",
          "args": ["/path/to/DAG/packages/mcp-server/dist/index.js"]
        },
        "env": {
          "QDRANT_URL": "https://your-cluster.qdrant.tech",
          "QDRANT_API_KEY": "your_api_key"
        }
      }
    ]
  }
}

Quality Gates

All quality gates have been passed:

Quality Gate 1: Orchestrator Integration ✓

• Requirement: Full pipeline integration with comprehensive testing
• Result: 48/48 tests passing, 98.57% coverage
• Status: PASSED

Quality Gate 2: Tool Performance ✓

• Requirement: Search latency < 2 seconds
• Result: < 100ms average latency
• Status: PASSED

Quality Gate 3: Complete MVP ✓

• Requirement: All components integrated, documented, and tested
• Result: 82/82 tests passing across all packages
• Status: PASSED

Performance

• Indexing: ~100-500ms per package (depending on size)
• Search: < 100ms average latency
• API Validation: < 50ms average
• Version Comparison: < 200ms average

Roadmap

• [ ] Python ecosystem support (PyPI)
• [ ] Ruby ecosystem support (RubyGems)
• [ ] Java ecosystem support (Maven)
• [ ] Real-time package updates
• [ ] Enhanced caching layer
• [ ] Multi-tenant support
• [ ] GraphQL API

Contributing

Contributions are welcome! Please follow these guidelines:

1. Fork the repository
2. Create a feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes with conventional commits
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

License

MIT © VAMFI Inc.

Support

• GitHub Issues: https://github.com/VAMFI/DAG/issues
• Documentation: https://vamfi.org/docs/dag
• Email: support@vamfi.org

---

Built with ❤️ by VAMFI Inc.