domain-rag-mcp-server 3.2.0 → 3.3.1

package/dist/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-// ../domain-rag-system/mcp-server/src/index.ts
+// src/index.ts
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -10,7 +10,7 @@ import {
 import { QdrantClient } from "@qdrant/js-client-rest";
 import { v4 as uuidv4 } from "uuid";
 
-// ../domain-rag-system/shared/src/config.ts
+// ../shared/src/config.ts
 import { config as dotenvConfig } from "dotenv";
 import { existsSync } from "fs";
 import { join } from "path";
@@ -210,6 +210,12 @@ function buildConfig() {
     codeSearchApi: {
       enabled: getEnvBool("CODE_SEARCH_API_ENABLED", true),
       url: getEnv("CODE_SEARCH_API_URL", "http://10.3.1.94:8085")
+    },
+    datadog: {
+      enabled: getEnvBool("DATADOG_ENABLED", false),
+      apiKey: getEnv("DATADOG_API_KEY", ""),
+      appKey: getEnv("DATADOG_APP_KEY", ""),
+      site: getEnv("DATADOG_SITE", "datadoghq.eu")
     }
   };
 }
@@ -240,7 +246,7 @@ function getSourceWeightsMap() {
   };
 }
 
-// ../domain-rag-system/shared/src/embeddings/types.ts
+// ../shared/src/embeddings/types.ts
 var BaseEmbeddingProvider = class {
   /**
    * Default batch implementation - calls getEmbedding sequentially
@@ -256,7 +262,7 @@ var BaseEmbeddingProvider = class {
   }
 };
 
-// ../domain-rag-system/shared/src/embeddings/ollama.ts
+// ../shared/src/embeddings/ollama.ts
 var OllamaProvider = class extends BaseEmbeddingProvider {
   name = "ollama";
   dimensions;
@@ -320,7 +326,7 @@ var OllamaProvider = class extends BaseEmbeddingProvider {
   }
 };
 
-// ../domain-rag-system/shared/src/embeddings/openai.ts
+// ../shared/src/embeddings/openai.ts
 var OpenAIProvider = class extends BaseEmbeddingProvider {
   name = "openai";
   dimensions;
@@ -405,7 +411,7 @@ var OpenAIProvider = class extends BaseEmbeddingProvider {
   }
 };
 
-// ../domain-rag-system/shared/src/embeddings/factory.ts
+// ../shared/src/embeddings/factory.ts
 function createEmbeddingProvider() {
   const providerType = config.embeddings.provider;
   switch (providerType) {
@@ -436,7 +442,7 @@ function getEmbeddingProvider() {
   return _provider;
 }
 
-// ../domain-rag-system/shared/src/postgres/client.ts
+// ../shared/src/postgres/client.ts
 import pg from "pg";
 var { Pool } = pg;
 var pool = null;
@@ -484,7 +490,7 @@ async function checkHealth() {
   }
 }
 
-// ../domain-rag-system/shared/src/postgres/search.ts
+// ../shared/src/postgres/search.ts
 async function searchAll(searchQuery, options = {}) {
   const { limit = 30, sources } = options;
   const includeJira = !sources || sources.includes("jira");
@@ -737,7 +743,36 @@ async function getStats() {
   };
 }
 
-// ../domain-rag-system/mcp-server/src/index.ts
+// ../shared/src/graph-db.ts
+async function searchGraphEntities(query_text, entityTypes, limit = 10) {
+  const params = [`%${query_text.toLowerCase()}%`];
+  let typeFilter = "";
+  if (entityTypes && entityTypes.length > 0) {
+    params.push(entityTypes);
+    typeFilter = `AND entity_type = ANY($${params.length}::text[])`;
+  }
+  params.push(limit);
+  return queryRows(
+    `SELECT * FROM graph_entities
+     WHERE (LOWER(name) LIKE $1 OR EXISTS (
+       SELECT 1 FROM unnest(aliases) a WHERE LOWER(a) LIKE $1
+     ))
+     ${typeFilter}
+     ORDER BY degree DESC
+     LIMIT $${params.length}`,
+    params
+  );
+}
+async function getGraphNeighbors(startEntityIds, maxHops = 2) {
+  if (startEntityIds.length === 0)
+    return [];
+  return queryRows(
+    `SELECT * FROM get_graph_neighbors($1::text[], $2)`,
+    [startEntityIds, maxHops]
+  );
+}
+
+// src/index.ts
 var SOURCE_WEIGHTS = getSourceWeightsMap();
 var qdrant = new QdrantClient({
   url: config.qdrant.url,
@@ -1209,6 +1244,52 @@ var tools = [
     }
   },
   // ============================================
+  // GraphRAG Tools — graph-enhanced search
+  // ============================================
+  {
+    name: "graph_search",
+    description: "Graph-enhanced hybrid search. Combines Qdrant vector search with knowledge graph traversal to return connected results with relationship context. Best for complex queries that span multiple sources (Jira + Confluence + Git + People). Use when you need to understand relationships, not just find similar text.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", description: "What are you looking for?" },
+        limit: { type: "number", description: "Max results (default: 15)", default: 15 },
+        source_types: {
+          type: "array",
+          items: { type: "string", enum: ["jira", "confluence", "git_commit", "code", "decision", "domain_term"] },
+          description: "Filter by source types (optional)"
+        },
+        graph_hops: { type: "number", description: "Graph traversal depth: 1 or 2 (default: 1)", default: 1 }
+      },
+      required: ["query"]
+    }
+  },
+  {
+    name: "entity_search",
+    description: 'Find everything connected to a specific entity (person, service, Jira project, component). Uses knowledge graph to collect all related Jira issues, Confluence pages, Git commits, and people in one query. Use for "tell me everything about X" queries.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        entity: { type: "string", description: 'Entity name or ID (e.g. "PaymentGateway", "Ivan Petrov", "PROJ-123", "AUTH")' },
+        max_hops: { type: "number", description: "Relationship hops to traverse (default: 2)", default: 2 },
+        limit: { type: "number", description: "Max results (default: 20)", default: 20 }
+      },
+      required: ["entity"]
+    }
+  },
+  {
+    name: "impact_analysis",
+    description: "Analyze the impact of changing a service, module, or component. Traverses the knowledge graph to find all dependent services, teams, active issues, and documentation that would be affected. Use before making significant changes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: { type: "string", description: 'Service, module, or component name (e.g. "auth-service", "PaymentProcessor")' },
+        max_depth: { type: "number", description: "Traversal depth (default: 3)", default: 3 }
+      },
+      required: ["target"]
+    }
+  },
+  // ============================================
   // Server Code Search Tools (LOW PRIORITY - use last)
   // Direct grep on server filesystem repositories
   // WARNING: Returns large responses that consume context window.
@@ -1257,7 +1338,42 @@ var tools = [
       type: "object",
       properties: {}
     }
-  }
+  },
+  // ============================================
+  // Datadog Log Search Tool
+  // ============================================
+  ...config.datadog.enabled ? [{
+    name: "search_datadog_logs",
+    description: 'Search application logs in Datadog. Use this to investigate errors, debug issues, check service health, or find specific log entries. Supports Datadog query syntax (e.g. "service:api status:error", "@http.status_code:500").',
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: 'Datadog log search query. Examples: "error", "service:my-api status:error", "@http.url:/api/users", "timeout OR connection refused"'
+        },
+        service: {
+          type: "string",
+          description: "Filter by service name (optional, appended to query as service:<value>)"
+        },
+        env: {
+          type: "string",
+          description: 'Filter by environment (optional, e.g. "production", "staging")'
+        },
+        time_range: {
+          type: "string",
+          description: 'Time range to search (default: "1h"). Supported: "15m", "1h", "6h", "24h", "3d", "7d"',
+          default: "1h"
+        },
+        limit: {
+          type: "number",
+          description: "Maximum log entries to return (default: 30, max: 100)",
+          default: 30
+        }
+      },
+      required: ["query"]
+    }
+  }] : []
 ];
 async function handleSearchServerCode(args) {
   if (!config.codeSearchApi.enabled) {
@@ -1813,6 +1929,360 @@ async function handleGetStats() {
   }
   return response;
 }
+async function handleGraphSearch(args) {
+  const { query: query2, limit = 15, source_types, graph_hops = 1 } = args;
+  const embedding = await getEmbedding(query2);
+  const filterMust = [];
+  if (source_types && source_types.length > 0) {
+    filterMust.push({ key: "source_type", match: { any: source_types } });
+  }
+  const [chunkResults, entityResults] = await Promise.all([
+    qdrant.search(config.qdrant.collectionName, {
+      vector: embedding,
+      limit: limit * 3,
+      filter: filterMust.length > 0 ? { must: filterMust } : void 0,
+      with_payload: true,
+      score_threshold: 0.25
+    }),
+    qdrant.search("graph_entities", {
+      vector: embedding,
+      limit: 20,
+      with_payload: true,
+      score_threshold: 0.3
+    }).catch(() => [])
+    // graceful fallback if collection doesn't exist yet
+  ]);
+  const topEntityIds = entityResults.slice(0, 10).map((r) => r.payload.entity_id).filter(Boolean);
+  let expandedEntityIds = new Set(topEntityIds);
+  if (topEntityIds.length > 0 && pgAvailable) {
+    try {
+      const neighbors = await getGraphNeighbors(topEntityIds, graph_hops);
+      for (const n of neighbors)
+        expandedEntityIds.add(n.entity_id);
+    } catch {
+    }
+  }
+  const topEntitySet = new Set(topEntityIds.slice(0, 5));
+  const seen = /* @__PURE__ */ new Map();
+  for (const r of chunkResults) {
+    const payload = r.payload;
+    const sourceType = payload.source_type || "";
+    const sourceId = payload.source_id || "";
+    const chunkEntityIds = payload.entity_ids || [];
+    const weight = SOURCE_WEIGHTS[sourceType] || 1;
+    const connectedCount = chunkEntityIds.filter((e) => topEntitySet.has(e) || expandedEntityIds.has(e)).length;
+    const graphBoost = 1 + 0.3 * Math.min(connectedCount / 3, 1);
+    const finalScore = (r.score || 0) * graphBoost * weight;
+    const key = `${sourceType}:${sourceId}`;
+    const existing = seen.get(key);
+    if (!existing || finalScore > existing.score) {
+      seen.set(key, { score: finalScore, payload });
+    }
+  }
+  const ranked = [...seen.values()].sort((a, b) => b.score - a.score).slice(0, limit);
+  if (ranked.length === 0) {
+    return `No results found for graph search: "${query2}"`;
+  }
+  let response = `## Graph Search: "${query2}"
+
+`;
+  response += `Found ${ranked.length} results (vector + graph-enhanced):
+
+`;
+  if (expandedEntityIds.size > 0) {
+    response += `Graph context: ${expandedEntityIds.size} connected entities found
+
+`;
+  }
+  for (const { score, payload } of ranked) {
+    const sourceType = payload.source_type || "";
+    const sourceId = payload.source_id || "";
+    const content = payload.content || "";
+    const url = payload.source_url;
+    const communityId = payload.community_id;
+    response += `### [${sourceType.toUpperCase()}] ${sourceId}
+`;
+    response += `Score: ${(score * 100).toFixed(1)}%`;
+    if (communityId)
+      response += ` | Community: ${communityId}`;
+    response += "\n";
+    if (url)
+      response += `URL: ${url}
+`;
+    response += `
+${content.substring(0, 1e3)}${content.length > 1e3 ? "..." : ""}
+
+---
+
+`;
+  }
+  return response;
+}
+async function handleEntitySearch(args) {
+  const { entity, max_hops = 2, limit = 20 } = args;
+  if (!pgAvailable) {
+    return handleGraphSearch({ query: entity, limit });
+  }
+  let matchedEntities = [];
+  try {
+    matchedEntities = await searchGraphEntities(entity, void 0, 5);
+  } catch {
+  }
+  if (matchedEntities.length === 0) {
+    const embedding2 = await getEmbedding(entity);
+    const qdrantEntities = await qdrant.search("graph_entities", {
+      vector: embedding2,
+      limit: 5,
+      with_payload: true,
+      score_threshold: 0.4
+    }).catch(() => []);
+    matchedEntities = qdrantEntities.map((r) => {
+      const p = r.payload;
+      return {
+        entity_id: p.entity_id,
+        entity_type: p.entity_type,
+        name: p.name
+      };
+    });
+  }
+  if (matchedEntities.length === 0) {
+    return `Entity "${entity}" not found in knowledge graph. Try graph_search instead.`;
+  }
+  const primaryEntity = matchedEntities[0];
+  let response = `## Entity Search: "${entity}"
+
+`;
+  response += `**Found entity:** ${primaryEntity.name} (${primaryEntity.entity_type})
+`;
+  response += `**Entity ID:** ${primaryEntity.entity_id}
+
+`;
+  let neighbors = [];
+  try {
+    neighbors = await getGraphNeighbors([primaryEntity.entity_id], max_hops);
+  } catch {
+  }
+  if (neighbors.length > 0) {
+    response += `**Connected entities (${neighbors.length}):**
+
+`;
+    const byType = /* @__PURE__ */ new Map();
+    for (const n of neighbors.slice(0, 50)) {
+      const group = byType.get(n.entity_type) ?? [];
+      group.push(n);
+      byType.set(n.entity_type, group);
+    }
+    for (const [type, nodes] of byType) {
+      response += `**${type}** (${nodes.length}):
+`;
+      for (const n of nodes.slice(0, 10)) {
+        response += `  - ${n.name} [${n.edge_type ?? "connected"}] (hop ${n.hop})
+`;
+      }
+      response += "\n";
+    }
+  }
+  const allEntityIds = [primaryEntity.entity_id, ...neighbors.slice(0, 30).map((n) => n.entity_id)];
+  const embedding = await getEmbedding(entity);
+  const chunks = await qdrant.search(config.qdrant.collectionName, {
+    vector: embedding,
+    limit,
+    filter: {
+      must: [{ key: "entity_ids", match: { any: allEntityIds } }]
+    },
+    with_payload: true,
+    score_threshold: 0.1
+  }).catch(() => []);
+  if (chunks.length > 0) {
+    response += `**Related documents (${chunks.length}):**
+
+`;
+    for (const c of chunks.slice(0, limit)) {
+      const p = c.payload;
+      const sourceType = p.source_type || "";
+      const sourceId = p.source_id || "";
+      const content = p.content || "";
+      response += `### [${sourceType.toUpperCase()}] ${sourceId}
+`;
+      if (p.source_url)
+        response += `URL: ${p.source_url}
+`;
+      response += `
+${content.substring(0, 600)}${content.length > 600 ? "..." : ""}
+
+---
+
+`;
+    }
+  } else {
+    response += `*No indexed documents found for this entity. Run the graph indexer first.*
+`;
+  }
+  return response;
+}
+async function handleImpactAnalysis(args) {
+  const { target, max_depth = 3 } = args;
+  if (!pgAvailable) {
+    return `PostgreSQL not available. Cannot perform graph impact analysis. Use search_as_architect instead.`;
+  }
+  let entities = [];
+  try {
+    entities = await searchGraphEntities(target, void 0, 3);
+  } catch {
+  }
+  if (entities.length === 0) {
+    return `Entity "${target}" not found in knowledge graph. Try running the graph builder first (GRAPH_ENABLED=true).`;
+  }
+  const primary = entities[0];
+  let response = `## Impact Analysis: "${target}"
+
+`;
+  response += `**Analyzing:** ${primary.name} (${primary.entity_type})
+
+`;
+  let neighbors = [];
+  try {
+    neighbors = await getGraphNeighbors([primary.entity_id], max_depth);
+  } catch {
+  }
+  if (neighbors.length === 0) {
+    response += `No connected entities found. Graph may not be built yet.`;
+    return response;
+  }
+  const byType = /* @__PURE__ */ new Map();
+  for (const n of neighbors) {
+    const group = byType.get(n.entity_type) ?? [];
+    group.push(n);
+    byType.set(n.entity_type, group);
+  }
+  response += `**Total affected entities: ${neighbors.length}**
+
+`;
+  response += `| Entity Type | Count | Relationship |
+`;
+  response += `|-------------|-------|--------------|
+`;
+  for (const [type, nodes] of byType) {
+    const edgeTypes = [...new Set(nodes.map((n) => n.edge_type).filter(Boolean))].join(", ");
+    response += `| ${type} | ${nodes.length} | ${edgeTypes || "various"} |
+`;
+  }
+  response += "\n";
+  for (const [type, nodes] of byType) {
+    response += `**${type.toUpperCase()} (${nodes.length}):**
+`;
+    for (const n of nodes.slice(0, 15)) {
+      response += `  - ${n.name} via ${n.edge_type ?? "connected"} (${n.hop} hop${n.hop > 1 ? "s" : ""})
+`;
+    }
+    if (nodes.length > 15)
+      response += `  ... and ${nodes.length - 15} more
+`;
+    response += "\n";
+  }
+  return response;
+}
+function parseTimeRange(timeRange) {
+  const match = timeRange.match(/^(\d+)([mhd])$/);
+  if (!match)
+    return 60 * 60 * 1e3;
+  const [, value, unit] = match;
+  const num = parseInt(value);
+  switch (unit) {
+    case "m":
+      return num * 60 * 1e3;
+    case "h":
+      return num * 60 * 60 * 1e3;
+    case "d":
+      return num * 24 * 60 * 60 * 1e3;
+    default:
+      return 60 * 60 * 1e3;
+  }
+}
+async function handleSearchDatadogLogs(args) {
+  if (!config.datadog.enabled) {
+    return "Datadog integration is disabled. Set DATADOG_ENABLED=true with DATADOG_API_KEY and DATADOG_APP_KEY to enable.";
+  }
+  if (!config.datadog.apiKey || !config.datadog.appKey) {
+    return "Datadog API keys not configured. Set DATADOG_API_KEY and DATADOG_APP_KEY environment variables.";
+  }
+  let ddQuery = args.query;
+  if (args.service) {
+    ddQuery += ` service:${args.service}`;
+  }
+  if (args.env) {
+    ddQuery += ` env:${args.env}`;
+  }
+  const limit = Math.min(args.limit || 30, 100);
+  const timeRangeMs = parseTimeRange(args.time_range || "1h");
+  const now = /* @__PURE__ */ new Date();
+  const from = new Date(now.getTime() - timeRangeMs);
+  try {
+    const baseUrl = `https://api.${config.datadog.site}`;
+    const response = await fetch(`${baseUrl}/api/v2/logs/events/search`, {
+      method: "POST",
+      headers: {
+        "DD-API-KEY": config.datadog.apiKey,
+        "DD-APPLICATION-KEY": config.datadog.appKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        filter: {
+          query: ddQuery,
+          from: from.toISOString(),
+          to: now.toISOString()
+        },
+        sort: "-timestamp",
+        page: { limit }
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      return `Datadog API error (${response.status}): ${errorText}`;
+    }
+    const data = await response.json();
+    if (!data.data || data.data.length === 0) {
+      return `No logs found for query: \`${ddQuery}\` (time range: ${args.time_range || "1h"})`;
+    }
+    let result = `## Datadog Logs
+
+`;
+    result += `**Query:** \`${ddQuery}\`
+`;
+    result += `**Time range:** ${from.toISOString()} \u2192 ${now.toISOString()}
+`;
+    result += `**Results:** ${data.data.length}${data.meta?.page?.after ? " (more available)" : ""}
+
+`;
+    for (const log of data.data) {
+      const attrs = log.attributes;
+      const ts = attrs.timestamp ? new Date(attrs.timestamp).toISOString() : "unknown";
+      const status = (attrs.status || "info").toUpperCase();
+      const service = attrs.service || "unknown";
+      const host = attrs.host || "";
+      result += `### ${status} | ${service}${host ? ` @ ${host}` : ""}
+`;
+      result += `**Time:** ${ts}
+`;
+      if (attrs.message) {
+        const msg = attrs.message.length > 1e3 ? attrs.message.substring(0, 1e3) + "..." : attrs.message;
+        result += `\`\`\`
+${msg}
+\`\`\`
+`;
+      }
+      if (attrs.tags && attrs.tags.length > 0) {
+        result += `**Tags:** ${attrs.tags.slice(0, 10).join(", ")}
+`;
+      }
+      result += "\n---\n\n";
+    }
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return `Failed to query Datadog: ${message}`;
+  }
+}
 async function main() {
   await ensureCollection();
   await initPostgres();
@@ -1895,6 +2365,18 @@ async function main() {
         case "get_index_stats":
           result = await handleGetStats();
           break;
+        case "graph_search":
+          result = await handleGraphSearch(args);
+          break;
+        case "entity_search":
+          result = await handleEntitySearch(args);
+          break;
+        case "impact_analysis":
+          result = await handleImpactAnalysis(args);
+          break;
+        case "search_datadog_logs":
+          result = await handleSearchDatadogLogs(args);
+          break;
         default:
           throw new Error(`Unknown tool: ${name}`);
       }
@@ -1908,6 +2390,7 @@ async function main() {
   await server.connect(transport);
   const pgStatus = pgAvailable ? "connected" : "disabled";
   const codeSearchStatus = config.codeSearchApi.enabled ? config.codeSearchApi.url : "disabled";
-  console.error(`Domain RAG MCP Server v3.1 started (embedding: ${embeddingProvider.name}, qdrant: ${config.qdrant.url}, postgres: ${pgStatus}, code-search: ${codeSearchStatus})`);
+  const datadogStatus = config.datadog.enabled ? config.datadog.site : "disabled";
+  console.error(`Domain RAG MCP Server v3.1 started (embedding: ${embeddingProvider.name}, qdrant: ${config.qdrant.url}, postgres: ${pgStatus}, code-search: ${codeSearchStatus}, datadog: ${datadogStatus})`);
 }
 main().catch(console.error);

package/package.json

@@ -1,46 +1,47 @@
-{
-  "name": "domain-rag-mcp-server",
-  "version": "3.2.0",
-  "description": "MCP server for domain RAG search — connects to Qdrant + PostgreSQL + Code Search API for hybrid search across Jira, Confluence, Git commits, and server-side code repositories",
-  "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",
-    "postgresql",
-    "jira",
-    "confluence",
-    "git",
-    "semantic-search",
-    "claude",
-    "cursor"
-  ],
-  "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "@qdrant/js-client-rest": "^1.7.0",
-    "dotenv": "^16.3.1",
-    "pg": "^8.11.3",
-    "uuid": "^9.0.1"
-  },
-  "devDependencies": {
-    "@types/node": "^20.10.0",
-    "@types/pg": "^8.10.9",
-    "@types/uuid": "^9.0.7",
-    "esbuild": "^0.20.2",
-    "tsx": "^4.7.0",
-    "typescript": "^5.3.3"
-  }
-}
+{
+  "name": "domain-rag-mcp-server",
+  "version": "3.3.1",
+  "description": "MCP server for domain RAG search — connects to Qdrant + PostgreSQL + Code Search API for hybrid search across Jira, Confluence, Git commits, and server-side code repositories",
+  "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",
+    "postgresql",
+    "jira",
+    "confluence",
+    "git",
+    "semantic-search",
+    "claude",
+    "cursor"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@qdrant/js-client-rest": "^1.7.0",
+    "dotenv": "^16.3.1",
+    "pg": "^8.11.3",
+    "uuid": "^9.0.1"
+  },
+  "devDependencies": {
+    "@domain-rag/shared": "file:../shared",
+    "@types/node": "^20.10.0",
+    "@types/pg": "^8.10.9",
+    "@types/uuid": "^9.0.7",
+    "esbuild": "^0.20.2",
+    "tsx": "^4.7.0",
+    "typescript": "^5.3.3"
+  }
+}