mcp-memory-gateway

Instructions

Implementation Reference

• scripts/export-databricks-bundle.js:131-222 (handler)

  The implementation of exportDatabricksBundle, which generates a Databricks-ready analytics bundle by processing feedback and proof data.

  function exportDatabricksBundle(feedbackDir = getDefaultFeedbackDir(), outputPath, options = {}) {
    const resolvedFeedbackDir = path.resolve(feedbackDir || getDefaultFeedbackDir());
    const resolvedProofDir = path.resolve(options.proofDir || DEFAULT_PROOF_DIR);
    const exportedAt = new Date().toISOString();
    const bundlePath = path.resolve(outputPath || path.join(
      resolvedFeedbackDir,
      'analytics',
      `databricks-${timestampSlug()}`
    ));
    const tablesDir = path.join(bundlePath, 'tables');
    ensureDir(tablesDir);
  
    const datasets = [
      {
        tableName: 'feedback_events',
        sourcePath: path.join(resolvedFeedbackDir, 'feedback-log.jsonl'),
        description: 'Raw RLHF feedback events from feedback-log.jsonl',
      },
      {
        tableName: 'memory_records',
        sourcePath: path.join(resolvedFeedbackDir, 'memory-log.jsonl'),
        description: 'Promoted learning and mistake memories from memory-log.jsonl',
      },
      {
        tableName: 'feedback_sequences',
        sourcePath: path.join(resolvedFeedbackDir, 'feedback-sequences.jsonl'),
        description: 'Sequence-model training rows derived from accepted feedback',
      },
      {
        tableName: 'feedback_attributions',
        sourcePath: path.join(resolvedFeedbackDir, 'attributed-feedback.jsonl'),
        description: 'Tool-call attribution rows for negative feedback events',
      },
    ];
  
    const tables = datasets.map((dataset) => {
      const rows = annotateRows(
        readJSONL(dataset.sourcePath),
        dataset.tableName,
        path.basename(dataset.sourcePath),
        exportedAt,
      );
      const fileName = `${dataset.tableName}.jsonl`;
      const relativePath = toBundleRelativePath('tables', fileName);
      writeJSONL(path.join(tablesDir, fileName), rows);
      return {
        tableName: dataset.tableName,
        relativePath,
        rowCount: rows.length,
        description: dataset.description,
      };
    });
  
    const proofRows = collectProofReports(resolvedProofDir, exportedAt);
    const proofRelativePath = toBundleRelativePath('tables', 'proof_reports.jsonl');
    writeJSONL(path.join(tablesDir, 'proof_reports.jsonl'), proofRows);
    tables.push({
      tableName: 'proof_reports',
      relativePath: proofRelativePath,
      rowCount: proofRows.length,
      description: 'Machine-readable proof artifacts discovered under proof/**/*.json',
    });
  
    const manifest = {
      format: 'databricks-analytics-bundle',
      version: 1,
      exportedAt,
      bundlePath,
      feedbackDir: resolvedFeedbackDir,
      proofDir: resolvedProofDir,
      placeholders: {
        catalog: '__CATALOG__',
        schema: '__SCHEMA__',
        bundleRoot: '__BUNDLE_ROOT__',
      },
      tables,
    };
  
    const manifestPath = path.join(bundlePath, 'manifest.json');
    const sqlTemplatePath = path.join(bundlePath, 'load_databricks.sql');
    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
    fs.writeFileSync(sqlTemplatePath, buildSqlTemplate(manifest) + '\n');
  
    return {
      bundlePath,
      manifestPath,
      sqlTemplatePath,
      tableCount: tables.length,
      totalRows: tables.reduce((sum, table) => sum + table.rowCount, 0),
      tables,
    };
  }

• adapters/mcp/server-stdio.js:390-393 (handler)

  Tool handler registration for 'export_databricks_bundle' in the MCP server adapter.

  case 'export_databricks_bundle': {
    const outputPath = args.outputPath ? resolveSafePath(args.outputPath) : undefined;
    return toTextResult(exportDatabricksBundle(undefined, outputPath));
  }