domain-rag-mcp-server 2.1.0

package/dist/index.mjs

@@ -0,0 +1,894 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { QdrantClient } from "@qdrant/js-client-rest";
+import { v4 as uuidv4 } from "uuid";
+
+// ../shared/src/config.ts
+import { config as dotenvConfig } from "dotenv";
+import { existsSync } from "fs";
+import { join } from "path";
+function loadEnvFiles() {
+  const possibleRoots = [
+    process.cwd(),
+    join(process.cwd(), ".."),
+    join(process.cwd(), "../..")
+  ];
+  for (const root of possibleRoots) {
+    const envLocal = join(root, ".env.local");
+    const envFile = join(root, ".env");
+    if (existsSync(envLocal)) {
+      dotenvConfig({ path: envLocal });
+      break;
+    }
+    if (existsSync(envFile)) {
+      dotenvConfig({ path: envFile });
+      break;
+    }
+  }
+}
+loadEnvFiles();
+function getEnv(key, defaultValue) {
+  return process.env[key] || defaultValue;
+}
+function getEnvBool(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0)
+    return defaultValue;
+  return value.toLowerCase() === "true" || value === "1";
+}
+function getEnvNumber(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0)
+    return defaultValue;
+  const parsed = parseInt(value, 10);
+  return isNaN(parsed) ? defaultValue : parsed;
+}
+function getEnvFloat(key, defaultValue) {
+  const value = process.env[key];
+  if (value === void 0)
+    return defaultValue;
+  const parsed = parseFloat(value);
+  return isNaN(parsed) ? defaultValue : parsed;
+}
+function getEnvArray(key, defaultValue) {
+  const value = process.env[key];
+  if (!value)
+    return defaultValue;
+  return value.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function getEmbeddingDimensions(provider, model) {
+  if (provider === "openai") {
+    if (model.includes("text-embedding-3-large"))
+      return 3072;
+    if (model.includes("text-embedding-3-small"))
+      return 1536;
+    if (model.includes("text-embedding-ada"))
+      return 1536;
+    return 1536;
+  }
+  if (model.includes("nomic-embed-text"))
+    return 768;
+  if (model.includes("mxbai-embed-large"))
+    return 1024;
+  if (model.includes("all-minilm"))
+    return 384;
+  return 768;
+}
+function buildConfig() {
+  const embeddingProvider2 = getEnv("EMBEDDING_PROVIDER", "ollama");
+  const ollamaModel = getEnv("OLLAMA_MODEL", getEnv("EMBEDDINGS_MODEL", "nomic-embed-text"));
+  const openaiModel = getEnv("OPENAI_EMBEDDING_MODEL", "text-embedding-3-small");
+  const dimensions = getEmbeddingDimensions(
+    embeddingProvider2,
+    embeddingProvider2 === "openai" ? openaiModel : ollamaModel
+  );
+  return {
+    qdrant: {
+      url: getEnv("QDRANT_URL", "http://localhost:6333"),
+      apiKey: getEnv("QDRANT_API_KEY", ""),
+      collectionName: getEnv("QDRANT_COLLECTION", "domain_knowledge")
+    },
+    embeddings: {
+      provider: embeddingProvider2,
+      dimensions,
+      ollama: {
+        url: getEnv("OLLAMA_URL", getEnv("EMBEDDINGS_URL", "http://localhost:11434")),
+        model: ollamaModel
+      },
+      openai: {
+        apiKey: getEnv("OPENAI_API_KEY", ""),
+        model: openaiModel
+      }
+    },
+    sources: {
+      jira: {
+        enabled: getEnvBool("JIRA_ENABLED", true),
+        url: getEnv("JIRA_URL", ""),
+        username: getEnv("JIRA_USERNAME", ""),
+        apiToken: getEnv("JIRA_API_TOKEN", ""),
+        projects: getEnvArray("JIRA_PROJECTS", [])
+      },
+      confluence: {
+        enabled: getEnvBool("CONFLUENCE_ENABLED", true),
+        url: getEnv("CONFLUENCE_URL", ""),
+        username: getEnv("CONFLUENCE_USERNAME", ""),
+        apiToken: getEnv("CONFLUENCE_API_TOKEN", ""),
+        spaces: getEnvArray("CONFLUENCE_SPACES", [])
+      },
+      gitCommits: {
+        enabled: getEnvBool("GIT_COMMITS_ENABLED", true),
+        reposPath: getEnv("GIT_REPOS_PATH", getEnv("REPOS_PATH", ""))
+      },
+      code: {
+        enabled: getEnvBool("CODE_INDEXING_ENABLED", false),
+        // Disabled by default now
+        reposPath: getEnv("REPOS_PATH", "")
+      },
+      github: {
+        enabled: getEnvBool("GITHUB_COMMITS_ENABLED", false),
+        token: getEnv("GITHUB_TOKEN", ""),
+        orgs: getEnvArray("GITHUB_ORGS", []),
+        repos: getEnvArray("GITHUB_REPOS", [])
+      }
+    },
+    repositories: {
+      basePath: getEnv("REPOS_PATH", ""),
+      include: getEnvArray("REPOS_INCLUDE", []),
+      exclude: getEnvArray("REPOS_EXCLUDE", [
+        "node_modules",
+        ".git",
+        "dist",
+        "build",
+        "bin",
+        "obj",
+        ".vs",
+        ".idea",
+        "packages",
+        "TestResults"
+      ])
+    },
+    fileExtensions: getEnvArray("FILE_EXTENSIONS", [
+      ".cs",
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".json",
+      ".yaml",
+      ".yml",
+      ".sql"
+    ]),
+    chunking: {
+      maxChunkSize: getEnvNumber("CHUNK_MAX_SIZE", 1500),
+      chunkOverlap: getEnvNumber("CHUNK_OVERLAP", 200),
+      minChunkSize: getEnvNumber("CHUNK_MIN_SIZE", 100)
+    },
+    indexation: {
+      mode: getEnv("INDEXATION_MODE", "incremental"),
+      cron: getEnv("INDEXATION_CRON", "0 2 * * *")
+    },
+    logging: {
+      level: getEnv("LOG_LEVEL", "info")
+    },
+    sourceWeights: {
+      gitCommit: getEnvFloat("WEIGHT_GIT_COMMIT", 1.4),
+      code: getEnvFloat("WEIGHT_CODE", 1.3),
+      decision: getEnvFloat("WEIGHT_DECISION", 1.1),
+      jira: getEnvFloat("WEIGHT_JIRA", 1),
+      domainTerm: getEnvFloat("WEIGHT_DOMAIN_TERM", 1),
+      confluence: getEnvFloat("WEIGHT_CONFLUENCE", 0.8)
+    }
+  };
+}
+var config = buildConfig();
+var legacyConfig = {
+  qdrant: {
+    url: config.qdrant.url,
+    collectionName: config.qdrant.collectionName
+  },
+  embeddings: {
+    url: config.embeddings.ollama.url,
+    model: config.embeddings.ollama.model,
+    dimensions: config.embeddings.dimensions
+  },
+  repositories: config.repositories,
+  fileExtensions: config.fileExtensions,
+  chunking: config.chunking
+};
+function getSourceWeightsMap() {
+  return {
+    git_commit: config.sourceWeights.gitCommit,
+    code: config.sourceWeights.code,
+    decision: config.sourceWeights.decision,
+    jira: config.sourceWeights.jira,
+    domain_term: config.sourceWeights.domainTerm,
+    confluence: config.sourceWeights.confluence
+  };
+}
+
+// ../shared/src/embeddings/types.ts
+var BaseEmbeddingProvider = class {
+  /**
+   * Default batch implementation - calls getEmbedding sequentially
+   * Override in subclasses for native batch support
+   */
+  async getEmbeddings(texts) {
+    const embeddings = [];
+    for (const text of texts) {
+      const embedding = await this.getEmbedding(text);
+      embeddings.push(embedding);
+    }
+    return embeddings;
+  }
+};
+
+// ../shared/src/embeddings/ollama.ts
+var OllamaProvider = class extends BaseEmbeddingProvider {
+  name = "ollama";
+  dimensions;
+  url;
+  model;
+  constructor(options) {
+    super();
+    this.url = options.url;
+    this.model = options.model;
+    this.dimensions = options.dimensions;
+  }
+  async getEmbedding(text) {
+    const response = await fetch(`${this.url}/api/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: this.model,
+        prompt: text
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.embedding;
+  }
+  async checkHealth() {
+    try {
+      const response = await fetch(`${this.url}/api/tags`);
+      if (!response.ok)
+        return false;
+      const data = await response.json();
+      const hasModel = data.models?.some((m) => m.name.includes(this.model));
+      if (!hasModel) {
+        console.log(`Model ${this.model} not found. Attempting to pull...`);
+        await this.pullModel();
+      }
+      return true;
+    } catch (error) {
+      console.error("Ollama health check failed:", error);
+      return false;
+    }
+  }
+  async pullModel() {
+    const response = await fetch(`${this.url}/api/pull`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        name: this.model,
+        stream: false
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to pull model: ${response.status}`);
+    }
+    console.log(`Model ${this.model} pulled successfully`);
+  }
+};
+
+// ../shared/src/embeddings/openai.ts
+var OpenAIProvider = class extends BaseEmbeddingProvider {
+  name = "openai";
+  dimensions;
+  apiKey;
+  model;
+  baseUrl = "https://api.openai.com/v1";
+  constructor(options) {
+    super();
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+    this.dimensions = options.dimensions;
+  }
+  async getEmbedding(text) {
+    const response = await fetch(`${this.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.model,
+        input: text
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} ${errorText}`);
+    }
+    const data = await response.json();
+    return data.data[0].embedding;
+  }
+  /**
+   * OpenAI supports native batch embeddings
+   * More efficient than sequential calls
+   */
+  async getEmbeddings(texts) {
+    const batchSize = 100;
+    const allEmbeddings = [];
+    for (let i = 0; i < texts.length; i += batchSize) {
+      const batch = texts.slice(i, i + batchSize);
+      const batchEmbeddings = await this.getBatchEmbeddings(batch);
+      allEmbeddings.push(...batchEmbeddings);
+    }
+    return allEmbeddings;
+  }
+  async getBatchEmbeddings(texts) {
+    const response = await fetch(`${this.baseUrl}/embeddings`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        model: this.model,
+        input: texts
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`OpenAI API error: ${response.status} ${errorText}`);
+    }
+    const data = await response.json();
+    const sorted = data.data.sort((a, b) => a.index - b.index);
+    return sorted.map((item) => item.embedding);
+  }
+  async checkHealth() {
+    try {
+      const response = await fetch(`${this.baseUrl}/models`, {
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`
+        }
+      });
+      if (!response.ok) {
+        console.error(`OpenAI health check failed: ${response.status}`);
+        return false;
+      }
+      return true;
+    } catch (error) {
+      console.error("OpenAI health check failed:", error);
+      return false;
+    }
+  }
+};
+
+// ../shared/src/embeddings/factory.ts
+function createEmbeddingProvider() {
+  const providerType = config.embeddings.provider;
+  switch (providerType) {
+    case "ollama":
+      return new OllamaProvider({
+        url: config.embeddings.ollama.url,
+        model: config.embeddings.ollama.model,
+        dimensions: config.embeddings.dimensions
+      });
+    case "openai":
+      if (!config.embeddings.openai.apiKey) {
+        throw new Error("OPENAI_API_KEY is required when EMBEDDING_PROVIDER=openai");
+      }
+      return new OpenAIProvider({
+        apiKey: config.embeddings.openai.apiKey,
+        model: config.embeddings.openai.model,
+        dimensions: config.embeddings.dimensions
+      });
+    default:
+      throw new Error(`Unknown embedding provider: ${providerType}`);
+  }
+}
+var _provider = null;
+function getEmbeddingProvider() {
+  if (!_provider) {
+    _provider = createEmbeddingProvider();
+  }
+  return _provider;
+}
+
+// src/index.ts
+var SOURCE_WEIGHTS = getSourceWeightsMap();
+var qdrant = new QdrantClient({
+  url: config.qdrant.url,
+  ...config.qdrant.apiKey ? { apiKey: config.qdrant.apiKey } : {}
+});
+var embeddingProvider = getEmbeddingProvider();
+async function getEmbedding(text) {
+  return embeddingProvider.getEmbedding(text);
+}
+async function ensureCollection() {
+  try {
+    await qdrant.getCollection(config.qdrant.collectionName);
+  } catch {
+    await qdrant.createCollection(config.qdrant.collectionName, {
+      vectors: {
+        size: config.embeddings.dimensions,
+        distance: "Cosine"
+      }
+    });
+    await qdrant.createPayloadIndex(config.qdrant.collectionName, {
+      field_name: "source_type",
+      field_schema: "keyword"
+    });
+  }
+}
+async function searchWithWeights(options) {
+  const { query, limit = 10, sourceTypes, applyWeights = true, minScore = 0.3 } = options;
+  const embedding = await getEmbedding(query);
+  const filter = {};
+  if (sourceTypes && sourceTypes.length > 0) {
+    filter.must = [
+      { key: "source_type", match: { any: sourceTypes } }
+    ];
+  }
+  const fetchLimit = applyWeights ? limit * 2 : limit;
+  const results = await qdrant.search(config.qdrant.collectionName, {
+    vector: embedding,
+    limit: fetchLimit,
+    filter: Object.keys(filter).length > 0 ? filter : void 0,
+    with_payload: true,
+    score_threshold: minScore
+  });
+  let searchResults = results.map((r) => {
+    const payload = r.payload;
+    const sourceType = payload.source_type || "";
+    const weight = SOURCE_WEIGHTS[sourceType] || 1;
+    const weightedScore = applyWeights ? (r.score || 0) * weight : r.score || 0;
+    return {
+      content: payload.content || "",
+      source_type: sourceType,
+      source_id: payload.source_id || "",
+      source_url: payload.source_url,
+      metadata: payload.metadata || payload,
+      score: r.score || 0,
+      weighted_score: weightedScore
+    };
+  });
+  if (applyWeights) {
+    searchResults.sort((a, b) => b.weighted_score - a.weighted_score);
+  }
+  return searchResults.slice(0, limit);
+}
+function formatResults(results, title) {
+  if (results.length === 0) {
+    return `No relevant results found for ${title}.`;
+  }
+  let response = `## ${title}
+
+`;
+  response += `Found ${results.length} results (weighted by source reliability):
+
+`;
+  for (const r of results) {
+    const weight = SOURCE_WEIGHTS[r.source_type] || 1;
+    const relevance = (r.weighted_score * 100).toFixed(1);
+    response += `### [${r.source_type.toUpperCase()}] ${r.source_id}
+`;
+    response += `Relevance: ${relevance}% (weight: ${weight}x)
+`;
+    if (r.source_url) {
+      response += `URL: ${r.source_url}
+`;
+    }
+    response += `
+${r.content.substring(0, 1500)}${r.content.length > 1500 ? "..." : ""}
+
+`;
+    response += "---\n\n";
+  }
+  return response;
+}
+var tools = [
+  // Agent-based search tools
+  {
+    name: "search_as_analyst",
+    description: "Search as a Business Analyst - focuses on Jira tasks, requirements, user stories, and Confluence documentation. Use for business logic, requirements, and feature understanding.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What business requirement, task, or feature are you looking for?"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum results (default: 10)",
+          default: 10
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "search_as_architect",
+    description: "Search as a Software Architect - focuses on code, git commits, and system design. Use for understanding implementations, architecture, and technical decisions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What code, service, or architectural pattern are you looking for?"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum results (default: 10)",
+          default: 10
+        },
+        repo: {
+          type: "string",
+          description: "Filter by repository name (optional)"
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "search_as_qa",
+    description: "Search as a QA Engineer - focuses on tests, bugs, and quality-related content. Use for understanding test coverage, finding bugs, and quality patterns.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What tests, bugs, or quality aspects are you looking for?"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum results (default: 10)",
+          default: 10
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "search_as_docs",
+    description: "Search as a Documentation Specialist - focuses on Confluence documentation, guides, and explanations. Use for onboarding, tutorials, and understanding processes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What documentation or guide are you looking for?"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum results (default: 10)",
+          default: 10
+        }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "search_knowledge",
+    description: "Search across ALL knowledge sources with intelligent weighting. Code has higher weight than documentation. Use for general questions about the domain.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "What are you looking for?"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum results (default: 15)",
+          default: 15
+        }
+      },
+      required: ["query"]
+    }
+  },
+  // Legacy tools
+  {
+    name: "search_code",
+    description: "Search for code snippets only. Use search_as_architect for better results.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        limit: { type: "number", default: 5 },
+        repo: { type: "string", description: "Filter by repo" }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "search_jira",
+    description: "Search Jira issues only. Use search_as_analyst for better results.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        limit: { type: "number", default: 10 }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "search_git_commits",
+    description: "Search git commits with Jira correlation.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "Search query" },
+        limit: { type: "number", default: 10 }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "add_domain_term",
+    description: "Add a new domain term to the glossary.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        term: { type: "string", description: "The term to define" },
+        definition: { type: "string", description: "Definition" },
+        aliases: { type: "array", items: { type: "string" } }
+      },
+      required: ["term", "definition"]
+    }
+  },
+  {
+    name: "add_decision",
+    description: "Record an architectural decision.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        title: { type: "string" },
+        context: { type: "string" },
+        decision: { type: "string" },
+        reasoning: { type: "string" },
+        jira_keys: { type: "array", items: { type: "string" } }
+      },
+      required: ["title", "context", "decision"]
+    }
+  },
+  {
+    name: "get_index_stats",
+    description: "Get statistics about the RAG index.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  }
+];
+async function handleSearchAsAnalyst(args) {
+  const results = await searchWithWeights({
+    query: args.query,
+    limit: args.limit || 10,
+    sourceTypes: ["jira", "confluence"]
+  });
+  return formatResults(results, "Business Analyst Search");
+}
+async function handleSearchAsArchitect(args) {
+  let results = await searchWithWeights({
+    query: args.query,
+    limit: (args.limit || 10) * 2,
+    sourceTypes: ["code", "git_commit"]
+  });
+  if (args.repo) {
+    results = results.filter((r) => {
+      const meta = r.metadata;
+      return meta.repo?.toLowerCase().includes(args.repo.toLowerCase());
+    });
+  }
+  return formatResults(results.slice(0, args.limit || 10), "Software Architect Search");
+}
+async function handleSearchAsQA(args) {
+  const testQuery = `${args.query} test spec bug`;
+  const results = await searchWithWeights({
+    query: testQuery,
+    limit: (args.limit || 10) * 2,
+    sourceTypes: ["code", "jira"]
+  });
+  const prioritized = results.filter((r) => {
+    const isTest = r.source_id.toLowerCase().includes("test") || r.source_id.toLowerCase().includes("spec") || r.content.toLowerCase().includes("describe(") || r.content.toLowerCase().includes("[test]");
+    const isBug = r.metadata.issue_type?.toString().toLowerCase().includes("bug");
+    return isTest || isBug;
+  });
+  const others = results.filter((r) => !prioritized.includes(r));
+  const combined = [...prioritized, ...others].slice(0, args.limit || 10);
+  return formatResults(combined, "QA Engineer Search");
+}
+async function handleSearchAsDocs(args) {
+  const results = await searchWithWeights({
+    query: args.query,
+    limit: args.limit || 10,
+    sourceTypes: ["confluence"],
+    applyWeights: false
+    // No weighting for docs-only search
+  });
+  return formatResults(results, "Documentation Search");
+}
+async function handleSearchKnowledge(args) {
+  const results = await searchWithWeights({
+    query: args.query,
+    limit: args.limit || 15,
+    applyWeights: true
+  });
+  return formatResults(results, "Knowledge Base Search (Weighted)");
+}
+async function handleSearchCode(args) {
+  let results = await searchWithWeights({
+    query: args.query,
+    limit: args.limit || 5,
+    sourceTypes: ["code"]
+  });
+  if (args.repo) {
+    results = results.filter((r) => {
+      const meta = r.metadata;
+      return meta.repo?.toLowerCase().includes(args.repo.toLowerCase());
+    });
+  }
+  return formatResults(results, "Code Search");
+}
+async function handleSearchJira(args) {
+  const results = await searchWithWeights({
+    query: args.query,
+    limit: args.limit || 10,
+    sourceTypes: ["jira"]
+  });
+  return formatResults(results, "Jira Search");
+}
+async function handleSearchGitCommits(args) {
+  const results = await searchWithWeights({
+    query: args.query,
+    limit: args.limit || 10,
+    sourceTypes: ["git_commit"]
+  });
+  return formatResults(results, "Git Commits Search");
+}
+async function handleAddTerm(args) {
+  const embedding = await getEmbedding(`${args.term}: ${args.definition}`);
+  await qdrant.upsert(config.qdrant.collectionName, {
+    wait: true,
+    points: [{
+      id: uuidv4(),
+      vector: embedding,
+      payload: {
+        source_type: "domain_term",
+        source_id: `term:${args.term}`,
+        term: args.term,
+        definition: args.definition,
+        aliases: args.aliases || [],
+        content: `${args.term}: ${args.definition}`,
+        indexed_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }]
+  });
+  return `Term "${args.term}" added to glossary.`;
+}
+async function handleAddDecision(args) {
+  const text = `${args.title}. ${args.context}. ${args.decision}`;
+  const embedding = await getEmbedding(text);
+  await qdrant.upsert(config.qdrant.collectionName, {
+    wait: true,
+    points: [{
+      id: uuidv4(),
+      vector: embedding,
+      payload: {
+        source_type: "decision",
+        source_id: `decision:${Date.now()}`,
+        title: args.title,
+        context: args.context,
+        decision: args.decision,
+        reasoning: args.reasoning || null,
+        jira_keys: args.jira_keys || [],
+        content: text,
+        indexed_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }]
+  });
+  return `Decision "${args.title}" recorded.`;
+}
+async function handleGetStats() {
+  let response = "## RAG Index Statistics\n\n";
+  try {
+    const collectionInfo = await qdrant.getCollection(config.qdrant.collectionName);
+    response += `**Total documents:** ${collectionInfo.points_count}
+
+`;
+    const sourceTypes = ["code", "confluence", "jira", "git_commit", "domain_term", "decision"];
+    response += "**By source type:**\n";
+    response += "| Type | Count | Weight |\n";
+    response += "|------|-------|--------|\n";
+    for (const sourceType of sourceTypes) {
+      const count = await qdrant.count(config.qdrant.collectionName, {
+        filter: { must: [{ key: "source_type", match: { value: sourceType } }] },
+        exact: true
+      });
+      if (count.count > 0) {
+        const weight = SOURCE_WEIGHTS[sourceType] || 1;
+        response += `| ${sourceType} | ${count.count} | ${weight}x |
+`;
+      }
+    }
+  } catch {
+    response += "Collection not initialized. Run indexation first.";
+  }
+  return response;
+}
+async function main() {
+  await ensureCollection();
+  const server = new Server(
+    { name: "domain-rag-server", version: "2.1.0" },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      let result;
+      switch (name) {
+        case "search_as_analyst":
+          result = await handleSearchAsAnalyst(args);
+          break;
+        case "search_as_architect":
+          result = await handleSearchAsArchitect(args);
+          break;
+        case "search_as_qa":
+          result = await handleSearchAsQA(args);
+          break;
+        case "search_as_docs":
+          result = await handleSearchAsDocs(args);
+          break;
+        case "search_knowledge":
+          result = await handleSearchKnowledge(args);
+          break;
+        case "search_code":
+          result = await handleSearchCode(args);
+          break;
+        case "search_jira":
+          result = await handleSearchJira(args);
+          break;
+        case "search_git_commits":
+          result = await handleSearchGitCommits(args);
+          break;
+        case "add_domain_term":
+          result = await handleAddTerm(args);
+          break;
+        case "add_decision":
+          result = await handleAddDecision(args);
+          break;
+        case "get_index_stats":
+          result = await handleGetStats();
+          break;
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+      return { content: [{ type: "text", text: result }] };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`Domain RAG MCP Server v2.1 started (embedding: ${embeddingProvider.name}, qdrant: ${config.qdrant.url})`);
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "domain-rag-mcp-server",
+  "version": "2.1.0",
+  "description": "MCP server for domain RAG search — connects to Qdrant + Ollama/OpenAI for semantic search across Jira, Confluence, Git commits, and code",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "bin": {
+    "domain-rag-mcp-server": "dist/index.mjs"
+  },
+  "files": [
+    "dist/index.mjs"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "build:npm": "node build.mjs",
+    "start": "node dist/index.mjs",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": [
+    "mcp",
+    "rag",
+    "qdrant",
+    "jira",
+    "confluence",
+    "git",
+    "semantic-search",
+    "claude",
+    "cursor"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@qdrant/js-client-rest": "^1.7.0",
+    "dotenv": "^16.3.1",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@domain-rag/shared": "file:../shared",
+    "@types/node": "^20.10.0",
+    "@types/uuid": "^9.0.7",
+    "esbuild": "^0.20.2",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}