Copilot Studio で実現する技術文書ライフサイクル管理エージェント：8つの検出ロジックと実装戦略

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// SharePointリストからドキュメントを取得
function detectByTime() {
  const today = new Date();
  const oneYearAgo = new Date(today.setFullYear(today.getFullYear() - 1));

  const outdatedDocs = SharePoint.GetItems({
    library: "技術文書ライブラリ",
    filter: `Created <= '${oneYearAgo}' AND Modified <= '${oneYearAgo}'`,
    orderBy: "Created ASC"
  });

  return outdatedDocs;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// AI Builderでドキュメントからバージョン情報を抽出
function detectByVersion(document) {
  // ステップ1: ドキュメント全文を取得
  const content = SharePoint.GetFileContent(document.FilePath);

  // ステップ2: AIでバージョン番号を抽出
  const extractedVersions = AI.ExtractEntities({
    text: content,
    patterns: [
      /Azure Functions v(\d+)/gi,
      /API version (\d+\.\d+)/gi,
      /SDK (\d+\.\d+\.\d+)/gi,
      /バージョン (\d+(\.\d+)*)/gi
    ]
  });

  // ステップ3: 外部APIで最新バージョンを取得
  const latestVersions = ExternalAPI.GetLatestVersions({
    service: extractedVersions.serviceName
  });

  // ステップ4: 比較
  if (extractedVersions.version < latestVersions.version) {
    return {
      outdated: true,
      currentVersion: extractedVersions.version,
      latestVersion: latestVersions.version,
      versionGap: latestVersions.version - extractedVersions.version
    };
  }

  return { outdated: false };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// バージョン差異のスコアリング
function calculateVersionScore(current, latest) {
  const gap = latest - current;

  if (gap >= 3) {
    return {
      priority: "高",
      urgency: "即座に更新",
      reason: "3バージョン以上の遅れ、サポート切れリスク"
    };
  } else if (gap >= 2) {
    return {
      priority: "中",
      urgency: "1ヶ月以内に更新",
      reason: "2バージョンの遅れ、新機能の欠落"
    };
  } else if (gap >= 1) {
    return {
      priority: "低",
      urgency: "3ヶ月以内に更新",
      reason: "1バージョンの遅れ、影響は限定的"
    };
  }

  return { priority: "なし", urgency: "更新不要" };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// MCPサーバー経由で外部情報を取得
function detectByExternalComparison(document) {
  // ステップ1: ドキュメントからサービス名を抽出
  const serviceName = AI.ExtractServiceName(document.content);

  // ステップ2: 公式ドキュメントを取得（MCPサーバー経由）
  const officialDocs = MCP.FetchDocumentation({
    source: "Microsoft Learn",
    service: serviceName,
    language: "ja-jp"
  });

  // ステップ3: セマンティック類似度を計算
  const similarity = AI.CompareDocuments({
    document1: document.content,
    document2: officialDocs.content,
    method: "semantic-embedding"
  });

  // ステップ4: 差分を抽出
  const differences = AI.ExtractDifferences({
    source: document.content,
    target: officialDocs.content,
    categories: [
      "新機能",
      "廃止機能",
      "変更された手順",
      "価格変更",
      "セキュリティ推奨事項"
    ]
  });

  // ステップ5: 陳腐化スコアを計算
  const obsolescenceScore = calculateObsolescenceScore({
    similarity: similarity,
    differences: differences,
    timeSinceUpdate: document.daysSinceUpdate
  });

  return {
    outdated: obsolescenceScore > 0.6,
    score: obsolescenceScore,
    differences: differences
  };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

// SharePoint分析データからアクセス頻度を取得
function detectByAccessFrequency(document) {
  // ステップ1: 過去3ヶ月のアクセスログを取得
  const accessLogs = SharePoint.GetAnalytics({
    fileId: document.FileId,
    period: "last90days",
    metrics: ["views", "uniqueUsers", "downloads"]
  });

  // ステップ2: アクセススコアを計算
  const accessScore = (
    accessLogs.views * 1 +
    accessLogs.uniqueUsers * 5 +
    accessLogs.downloads * 10
  );

  // ステップ3: 文書の古さと組み合わせる
  const daysSinceUpdate = getDaysSince(document.Modified);
  const timeScore = daysSinceUpdate / 365; // 1年で1.0

  // ステップ4: 総合優先度を計算
  const priorityScore = accessScore * timeScore;

  return {
    priority: getPriorityLevel(priorityScore),
    accessScore: accessScore,
    timeScore: timeScore,
    recommendation: generateRecommendation(priorityScore)
  };
}

// 優先度レベルの判定
function getPriorityLevel(score) {
  if (score > 1000) return "最優先";
  if (score > 500) return "高";
  if (score > 100) return "中";
  return "低";
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 優先度判定テーブル
const priorityMatrix = {
  "高頻度（週10回以上）": {
    "1年経過": { priority: 1, action: "即座に更新" },
    "6ヶ月経過": { priority: 2, action: "1ヶ月以内に更新" },
    "3ヶ月経過": { priority: 3, action: "3ヶ月以内に確認" }
  },
  "中頻度（週1-10回）": {
    "1年経過": { priority: 2, action: "1ヶ月以内に更新" },
    "6ヶ月経過": { priority: 3, action: "3ヶ月以内に更新" },
    "3ヶ月経過": { priority: 4, action: "次回レビュー時" }
  },
  "低頻度（月1回未満）": {
    "1年経過": { priority: 3, action: "アーカイブ検討" },
    "6ヶ月経過": { priority: 4, action: "次回まとめて" },
    "3ヶ月経過": { priority: 5, action: "監視のみ" }
  }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

// ドキュメント間の参照関係を分析
function detectByDependency(document) {
  // ステップ1: このドキュメントへのリンクを検索
  const inboundLinks = SharePoint.SearchLinks({
    targetDocument: document.FilePath,
    scope: "entire-site"
  });

  // ステップ2: このドキュメントから他への参照
  const outboundLinks = extractLinksFromDocument(document.content);

  // ステップ3: 参照元ドキュメントの重要度を取得
  const referrerImportance = inboundLinks.map(link => ({
    document: link.sourceDocument,
    importance: getDocumentImportance(link.sourceDocument)
  }));

  // ステップ4: 依存度スコアを計算
  const dependencyScore = calculateDependencyScore({
    inboundCount: inboundLinks.length,
    referrerImportance: referrerImportance,
    outboundCount: outboundLinks.length
  });

  // ステップ5: 更新の影響範囲を計算
  const impactRadius = calculateImpactRadius({
    directReferrers: inboundLinks.length,
    indirectReferrers: getIndirectReferrers(inboundLinks)
  });

  return {
    priority: dependencyScore > 50 ? "高" : "中",
    dependencyScore: dependencyScore,
    impactRadius: impactRadius,
    affectedDocuments: inboundLinks.map(l => l.sourceDocument)
  };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// ドキュメントの重要度を多角的に評価
function getDocumentImportance(document) {
  const factors = {
    // 被参照数（他から参照される回数）
    inboundLinkCount: getInboundLinkCount(document) * 10,

    // 階層レベル（上位階層ほど重要）
    hierarchyLevel: (5 - document.folderDepth) * 5,

    // メタデータの重要度フラグ
    importanceTag: document.metadata.importance === "高" ? 20 : 0,

    // アクセス頻度
    accessFrequency: document.analytics.monthlyViews * 0.1,

    // ドキュメント種別
    documentType: getTypeWeight(document.type)
  };

  return Object.values(factors).reduce((sum, val) => sum + val, 0);
}

// ドキュメント種別による重み
function getTypeWeight(type) {
  const weights = {
    "基盤アーキテクチャ": 30,
    "セキュリティ基準": 25,
    "開発標準": 20,
    "運用手順": 15,
    "トラブルシューティング": 10,
    "FAQ": 5
  };
  return weights[type] || 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

// 機械学習モデルで陳腐化を予測
function detectByMachineLearning(document) {
  // ステップ1: 特徴量の抽出
  const features = extractFeatures(document);

  // ステップ2: 学習済みモデルで予測
  const prediction = ML.Predict({
    model: "document-obsolescence-classifier",
    features: features
  });

  // ステップ3: 陳腐化確率と理由を取得
  return {
    obsolescenceProbability: prediction.probability,
    confidence: prediction.confidence,
    topReasons: prediction.featureImportance,
    recommendedAction: getActionByProbability(prediction.probability)
  };
}

// 特徴量の抽出
function extractFeatures(document) {
  return {
    // 時間的特徴
    daysSinceCreation: getDaysSince(document.Created),
    daysSinceUpdate: getDaysSince(document.Modified),
    updateFrequency: document.updateHistory.length / document.ageInDays,

    // 内容的特徴
    versionMentionCount: countVersionMentions(document.content),
    externalLinkCount: countExternalLinks(document.content),
    screenshotCount: countImages(document.content),
    codeSnippetCount: countCodeBlocks(document.content),

    // メタデータ特徴
    documentType: document.type,
    serviceCategory: document.metadata.category,
    authorDepartment: document.author.department,

    // 利用状況特徴
    monthlyViews: document.analytics.monthlyViews,
    uniqueUsers: document.analytics.uniqueUsers,
    downloadCount: document.analytics.downloads,

    // 依存関係特徴
    inboundLinkCount: document.references.inbound.length,
    outboundLinkCount: document.references.outbound.length,

    // テキスト分析特徴
    sentimentScore: analyzeSentiment(document.content),
    technicalTermDensity: countTechnicalTerms(document.content) / document.wordCount,
    readabilityScore: calculateReadability(document.content)
  };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// モデルの性能評価
const modelPerformance = {
  accuracy: 0.87,        // 全体精度: 87%
  precision: 0.84,       // 適合率: 陳腐化と予測したうち84%が正解
  recall: 0.91,          // 再現率: 実際の陳腐化文書の91%を検出
  f1Score: 0.87,         // F1スコア

  confusionMatrix: {
    truePositive: 182,   // 正しく陳腐化と判定
    falsePositive: 34,   // 誤って陳腐化と判定
    trueNegative: 421,   // 正しく最新と判定
    falseNegative: 18    // 見逃した陳腐化文書
  },

  // カテゴリ別精度
  byCategory: {
    "クイックスタート": { precision: 0.92, recall: 0.89 },
    "アーキテクチャ": { precision: 0.81, recall: 0.86 },
    "トラブルシューティング": { precision: 0.79, recall: 0.94 }
  }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

// ドキュメントにフィードバック機能を埋め込む
function detectByUserFeedback(document) {
  // ステップ1: フィードバックデータを取得
  const feedback = SharePoint.GetListItems({
    list: "ドキュメントフィードバック",
    filter: `DocumentId eq '${document.FileId}'`
  });

  // ステップ2: フィードバックを分析
  const analysis = analyzeFeedback(feedback);

  // ステップ3: 陳腐化シグナルを検出
  const obsolescenceSignals = detectObsolescenceSignals(analysis);

  return {
    feedbackCount: feedback.length,
    averageRating: analysis.averageRating,
    obsolescenceScore: obsolescenceSignals.score,
    commonIssues: obsolescenceSignals.issues,
    urgency: calculateUrgency(obsolescenceSignals)
  };
}

// 陳腐化のシグナルを検出
function detectObsolescenceSignals(analysis) {
  const signals = [];

  // "情報が古い" というフィードバック
  if (analysis.negativeKeywords.includes("古い")) {
    signals.push({
      type: "outdated-content",
      severity: "高",
      count: analysis.negativeKeywords.filter(k => k === "古い").length
    });
  }

  // "動作しない" というフィードバック
  if (analysis.negativeKeywords.includes("動作しない")) {
    signals.push({
      type: "non-functional",
      severity: "最高",
      count: analysis.negativeKeywords.filter(k => k === "動作しない").length
    });
  }

  // 低評価の増加トレンド
  if (analysis.ratingTrend === "decreasing") {
    signals.push({
      type: "declining-quality",
      severity: "中",
      trendSlope: analysis.trendSlope
    });
  }

  return {
    score: calculateSignalScore(signals),
    issues: signals
  };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<!-- SharePointページに埋め込むフィードバックフォーム -->
<div class="document-feedback">
  <h3>この文書は役に立ちましたか？</h3>

  <!-- 評価（1-5）-->
  <div class="rating">
    <button onclick="submitRating(5)">⭐⭐⭐⭐⭐</button>
    <button onclick="submitRating(4)">⭐⭐⭐⭐</button>
    <button onclick="submitRating(3)">⭐⭐⭐</button>
    <button onclick="submitRating(2)">⭐⭐</button>
    <button onclick="submitRating(1)">⭐</button>
  </div>

  <!-- 問題報告 -->
  <div class="issues">
    <label><input type="checkbox" name="issue" value="outdated"> 情報が古い</label>
    <label><input type="checkbox" name="issue" value="incorrect"> 内容が正しくない</label>
    <label><input type="checkbox" name="issue" value="unclear"> 説明が不明瞭</label>
    <label><input type="checkbox" name="issue" value="missing"> 情報が不足</label>
  </div>

  <!-- 自由記述 -->
  <textarea name="comment" placeholder="具体的なフィードバックをお願いします"></textarea>

  <button onclick="submitFeedback()">送信</button>
</div>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

// 複数のロジックを統合
function detectByHybridApproach(document) {
  // 各検出パターンを実行
  const results = {
    time: detectByTime(document),
    version: detectByVersion(document),
    external: detectByExternalComparison(document),
    access: detectByAccessFrequency(document),
    dependency: detectByDependency(document),
    ml: detectByMachineLearning(document),
    feedback: detectByUserFeedback(document)
  };

  // 重み付けスコアリング
  const weights = {
    time: 0.15,
    version: 0.25,
    external: 0.20,
    access: 0.10,
    dependency: 0.10,
    ml: 0.15,
    feedback: 0.05
  };

  // 総合スコアを計算
  const totalScore = Object.keys(results).reduce((sum, key) => {
    return sum + (normalizeScore(results[key]) * weights[key]);
  }, 0);

  // 優先度を判定
  const priority = calculatePriority(totalScore, results);

  return {
    totalScore: totalScore,
    priority: priority,
    breakdown: results,
    recommendations: generateRecommendations(results)
  };
}

// 優先度の多次元判定
function calculatePriority(totalScore, results) {
  // 最優先条件（いずれか該当で最優先）
  if (
    results.version.outdated && results.version.versionGap >= 3 ||
    results.feedback.obsolescenceScore > 0.8 ||
    results.external.differences.includes("セキュリティ変更")
  ) {
    return {
      level: "最優先",
      deadline: "1週間以内",
      reason: "重大な陳腐化またはセキュリティリスク"
    };
  }

  // 高優先（総合スコア + 個別条件）
  if (totalScore > 0.7 || results.access.priority === "最優先") {
    return {
      level: "高",
      deadline: "1ヶ月以内",
      reason: "陳腐化スコアが高い、または高頻度アクセス文書"
    };
  }

  // 中優先
  if (totalScore > 0.5) {
    return {
      level: "中",
      deadline: "3ヶ月以内",
      reason: "一定の陳腐化が検出"
    };
  }

  // 低優先
  return {
    level: "低",
    deadline: "次回レビュー時",
    reason: "陳腐化の兆候は限定的"
  };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

// ドキュメント種別に応じた重みのカスタマイズ
const weightProfiles = {
  "クイックスタートガイド": {
    time: 0.20,      // UIが頻繁に変わるため時間重視
    version: 0.30,   // バージョン依存度が高い
    external: 0.25,  // 公式ドキュメントとの整合性重視
    access: 0.15,    // よく使われるため重要
    dependency: 0.05,
    ml: 0.05,
    feedback: 0.00
  },

  "アーキテクチャガイド": {
    time: 0.10,      // 基本構造は安定
    version: 0.15,
    external: 0.20,
    access: 0.10,
    dependency: 0.30, // 他文書への影響大
    ml: 0.10,
    feedback: 0.05
  },

  "トラブルシューティング": {
    time: 0.15,
    version: 0.20,
    external: 0.15,
    access: 0.10,
    dependency: 0.05,
    ml: 0.20,
    feedback: 0.15   // ユーザーフィードバック重視
  },

  "価格・プラン情報": {
    time: 0.30,      // 変更頻度が高い
    version: 0.10,
    external: 0.40,  // 公式情報との整合性が最重要
    access: 0.10,
    dependency: 0.05,
    ml: 0.05,
    feedback: 0.00
  }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// 推奨される実装順序
const implementationPhases = [
  {
    phase: 1,
    duration: "1-2ヶ月",
    patterns: ["時間ベース"],
    goal: "基本的な自動検出とアラート",
    successCriteria: "100%の対象文書を自動検出"
  },
  {
    phase: 2,
    duration: "2-3ヶ月",
    patterns: ["バージョンベース", "外部比較ベース"],
    goal: "精度の高い陳腐化判定",
    successCriteria: "誤検知率20%以下"
  },
  {
    phase: 3,
    duration: "3-4ヶ月",
    patterns: ["アクセス頻度ベース", "フィードバックベース"],
    goal: "優先順位付けとユーザー参加",
    successCriteria: "重要文書の更新漏れゼロ"
  },
  {
    phase: 4,
    duration: "6ヶ月以降",
    patterns: ["MLベース", "ハイブリッド"],
    goal: "最高精度の自動化",
    successCriteria: "精度90%以上、自動更新率50%"
  }
];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

サイト構造:
  /sites/TechDocs/
    - Documents/  # 現行文書ライブラリ
        列設定:
          - タイトル (必須)
          - サービス名 (選択肢)
          - ドキュメント種類 (選択肢)
          - バージョン (テキスト)
          - 次回レビュー日 (日付)
          - 陳腐化リスク (選択肢: 高/中/低/未評価)
          - 重要度 (選択肢: 高/中/低)
          - 最終AI評価日 (日付)
          - AI評価スコア (数値)

    - Archive/  # アーカイブライブラリ
        列設定:
          - (上記すべて)
          - アーカイブ日 (日付)
          - アーカイブ理由 (複数行テキスト)
          - 新バージョンリンク (ハイパーリンク)
          - アーカイブ承認者 (ユーザー)

    - Lists/
        - DocumentFeedback/  # フィードバック収集
        - UpdateHistory/  # 更新履歴
        - DetectionLog/  # 検出ログ