Skip to main content
Glama

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


Built with ❤️ by VAMFI Inc.

A
license - permissive license
-
quality - not tested
C
maintenance

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/VAMFI/dag-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server