Claude Code + Microsoft Graph API でTeamsを自動化する完全ガイド【2026年版】

そもそも Claude Code とは

Claude Code は、Anthropicが提供するターミナル上で動くAIコーディングエージェントです。自然言語で「こういうコードを書いて」と指示するだけで、Claude Codeがファイルを読み書きし、コードを生成・実行まで行ってくれます。

今回のテーマである「Microsoft Teams自動化」は、Claude Codeの得意分野のひとつです。Graph APIの複雑な認証フローや各エンドポイントの使い方をClaude Codeに任せれば、APIドキュメントを読み解く時間を大幅に短縮できます。

今回 Claude Code に作ってもらったもの

この体験記では、以下の6つのシナリオをClaude Codeに依頼しました。すべて実際のプロンプトと、Claude Codeが生成したコードを掲載しています。

Step 1：Azure AD アプリ登録と認証トークン取得

Graph APIを使うには、まずAzure Active Directoryにアプリを登録してクライアントID・シークレットを取得する必要があります。この設定が一番ハードルが高いのですが、Claude Codeに手順を聞けばステップバイステップで教えてくれます。

💬 私はClaude Codeにこう頼みました：

import os
import time
import requests
from dotenv import load_dotenv
from typing import Optional, Dict, Any

load_dotenv()

class GraphClient:
    """Microsoft Graph API クライアント（トークン自動更新付き）"""

    BASE_URL  = "https://graph.microsoft.com/v1.0"
    TOKEN_URL = "https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token"

    def __init__(self):
        self.client_id     = os.environ["CLIENT_ID"]
        self.client_secret = os.environ["CLIENT_SECRET"]
        self.tenant_id     = os.environ["TENANT_ID"]
        self._token: Optional[str] = None
        self._token_expires: float = 0

    def _get_token(self) -> str:
        """アクセストークンを取得（期限切れなら自動更新）"""
        if self._token and time.time() < self._token_expires - 60:
            return self._token

        url  = self.TOKEN_URL.format(tenant=self.tenant_id)
        resp = requests.post(url, data={
            "grant_type":    "client_credentials",
            "client_id":     self.client_id,
            "client_secret": self.client_secret,
            "scope":         "https://graph.microsoft.com/.default",
        })
        resp.raise_for_status()
        data = resp.json()
        self._token         = data["access_token"]
        self._token_expires = time.time() + data.get("expires_in", 3600)
        print(f"[Graph] トークン取得成功（有効期限: {data.get('expires_in', 3600)}秒）")
        return self._token

    def _headers(self) -> Dict[str, str]:
        return {
            "Authorization": f"Bearer {self._get_token()}",
            "Content-Type":  "application/json",
        }

    def get(self, path: str, **kwargs) -> Dict[str, Any]:
        url  = f"{self.BASE_URL}{path}"
        resp = requests.get(url, headers=self._headers(), **kwargs)
        resp.raise_for_status()
        return resp.json()

    def post(self, path: str, body: Dict[str, Any]) -> Dict[str, Any]:
        url  = f"{self.BASE_URL}{path}"
        resp = requests.post(url, headers=self._headers(), json=body)
        resp.raise_for_status()
        return resp.json()

if __name__ == "__main__":
    client = GraphClient()
    teams  = client.get("/teams")
    for team in teams.get("value", []):
        print(f"  Team: {team['displayName']} ({team['id']})")

▶ 実行結果 (python graph_client.py)
[Graph] トークン取得成功（有効期限: 3600秒）
Team: 営業部チーム (a1b2c3d4-0001-0002-0003-e5f6a7b8c9d0)
Team: 開発部チーム (b2c3d4e5-0011-0022-0033-f6a7b8c9d0e1)
Team: 全社アナウンス (c3d4e5f6-0111-0222-0333-a7b8c9d0e1f2)

Claude Codeが生成したコードで、トークンの自動更新付きのGraphクライアントが一発で完成しました。環境変数から認証情報を読み込む安全な実装になっています。

Step 2：Teamsチャンネルにメッセージを投稿する

認証ができたので、次はClaude CodeにTeamsチャンネルへのメッセージ投稿コードを作ってもらいます。Graph APIのChannelMessage送信エンドポイントを使います。

💬 私はClaude Codeにこう頼みました：

from graph_client import GraphClient
from typing import List, Optional, Dict, Any

def post_channel_message(
    client: GraphClient,
    team_id: str,
    channel_id: str,
    subject: str,
    body_html: str,
    importance: str = "normal",
    mentions: Optional[List[Dict]] = None,
) -> Dict[str, Any]:
    """Teamsチャンネルにメッセージを投稿する。

    Args:
        mentions: [{"id": "user-object-id", "displayName": "田中太郎",
                    "userIdentityType": "aadUser"}]
    Returns:
        投稿されたメッセージのdict（id, webUrl を含む）
    """
    if mentions is None:
        mentions = []

    mention_entities = [
        {
            "id": i,
            "mentionText": m["displayName"],
            "mentioned": {
                "user": {
                    "id": m["id"],
                    "displayName": m["displayName"],
                    "userIdentityType": m.get("userIdentityType", "aadUser"),
                }
            },
        }
        for i, m in enumerate(mentions)
    ]

    mention_html = ""
    for i, m in enumerate(mentions):
        mention_html += f'<at id="{i}">{m["displayName"]}</at> '

    full_body = (mention_html + "<br>" + body_html) if mention_html else body_html

    payload: Dict[str, Any] = {
        "subject":    subject,
        "importance": importance,
        "body": {"contentType": "html", "content": full_body},
    }
    if mention_entities:
        payload["mentions"] = mention_entities

    path   = f"/teams/{team_id}/channels/{channel_id}/messages"
    result = client.post(path, payload)

    msg_id  = result.get("id", "")
    web_url = result.get("webUrl", "")
    print(f"[Teams] 投稿成功 → ID: {msg_id}")
    print(f"[Teams] URL: {web_url}")
    return result


if __name__ == "__main__":
    client     = GraphClient()
    TEAM_ID    = "a1b2c3d4-0001-0002-0003-e5f6a7b8c9d0"
    CHANNEL_ID = "19:abc123def456@thread.tacv2"

    body = """<h3>📋 本日の作業完了報告</h3>
<ul>
  <li><b>完了：</b>営業資料テンプレートのWord化（3件）</li>
  <li><b>完了：</b>Graph API認証モジュールの実装</li>
  <li><b>進行中：</b>Teamsボット連携テスト</li>
</ul>
<p style="color:#6264A7">✓ 本日の目標を100%達成しました</p>"""

    post_channel_message(
        client, TEAM_ID, CHANNEL_ID,
        subject="日報：本日の作業完了",
        body_html=body,
        importance="normal",
    )

HTMLフォーマットのメッセージがClaude Codeのコードで正確に投稿されました。メンション機能も実装済みで、チームメンバーへの通知も自由自在です。

Step 3：Teams ボットを作成してメッセージに応答する

次のステップとして、Claude CodeにTeamsボットの作成を依頼しました。ボットはTeamsから直接メッセージを受け取り、自動的に返信できます。

💬 私はClaude Codeにこう頼みました：

import os, hmac, hashlib, base64
import psutil
from flask import Flask, request, jsonify, abort

app = Flask(__name__)
BOT_SECRET = os.environ.get("BOT_SECRET", "")


def verify_hmac(body: bytes, auth_header: str) -> bool:
    """HMACシグネチャを検証する"""
    if not auth_header.startswith("HMAC "):
        return False
    received = auth_header[5:]
    expected = base64.b64encode(
        hmac.new(BOT_SECRET.encode("utf-8"), body, hashlib.sha256).digest()
    ).decode("utf-8")
    return hmac.compare_digest(received, expected)


def handle_command(text: str) -> str:
    """受信テキストに応じてレスポンスを生成する"""
    if "ステータス" in text:
        cpu  = psutil.cpu_percent(interval=1)
        mem  = psutil.virtual_memory()
        disk = psutil.disk_usage("/")
        return (
            f"<b>📊 システムステータス</b><br>"
            f"CPU使用率: <b>{cpu:.1f}%</b><br>"
            f"メモリ: <b>{mem.percent:.1f}%</b> "
            f"({mem.used // 1024**3}GB / {mem.total // 1024**3}GB)<br>"
            f"ディスク: <b>{disk.percent:.1f}%</b>"
        )
    if "ヘルプ" in text or "help" in text.lower():
        return (
            "<b>💬 使えるコマンド一覧</b><br>"
            "・ステータス — サーバーの稼働状況を表示<br>"
            "・ヘルプ — このメッセージを表示<br>"
            "・（その他）— メッセージをオウム返し"
        )
    return f"受信しました：{text}"


@app.route("/webhook", methods=["POST"])
def webhook():
    raw_body = request.get_data()
    auth     = request.headers.get("Authorization", "")

    if BOT_SECRET and not verify_hmac(raw_body, auth):
        abort(401)

    payload  = request.get_json(force=True)
    msg_type = payload.get("type", "")

    if msg_type != "message":
        return jsonify({"type": "message", "text": ""})

    incoming = payload.get("text", "").strip()
    return jsonify({"type": "message", "text": handle_command(incoming)})


if __name__ == "__main__":
    port = int(os.environ.get("PORT", 5000))
    app.run(host="0.0.0.0", port=port, debug=False)

Claude Codeが生成したFlaskボットが完璧に動作しました。HMAC署名検証まで実装してくれたので、セキュリティ面も安心です。

Step 4：Graph APIで会議スケジュールを自動作成する

Teamsオンライン会議のスケジューリングも自動化できます。Claude CodeにGraph APIのOnlineMeeting作成エンドポイントを使ったコードを依頼しました。

💬 私はClaude Codeにこう頼みました：

from graph_client import GraphClient
from post_channel_message import post_channel_message
from datetime import datetime, timedelta
import pytz
from typing import List, Dict, Any

JST = pytz.timezone("Asia/Tokyo")


def create_online_meeting(
    client: GraphClient,
    title: str,
    start_dt: datetime,
    end_dt: datetime,
    attendees: List[str],
    organizer_user_id: str,
) -> Dict[str, Any]:
    """Teamsオンライン会議を作成する"""

    def to_iso(dt: datetime) -> str:
        if dt.tzinfo is None:
            dt = JST.localize(dt)
        return dt.astimezone(pytz.utc).strftime("%Y-%m-%dT%H:%M:%S.0000000Z")

    payload = {
        "subject":       title,
        "startDateTime": to_iso(start_dt),
        "endDateTime":   to_iso(end_dt),
        "participants": {
            "attendees": [
                {"upn": email, "role": "attendee",
                 "identity": {"user": {"id": email}}}
                for email in attendees
            ]
        },
        "lobbyBypassSettings": {
            "scope": "organization",
            "isDialInBypassEnabled": False,
        },
        "allowedPresenters": "organizer",
    }
    path   = f"/users/{organizer_user_id}/onlineMeetings"
    result = client.post(path, payload)
    print(f"[Meeting] 作成成功: {title}")
    print(f"[Meeting] URL: {result.get('joinWebUrl', '')}")
    return result


def schedule_weekly_meetings(
    client: GraphClient,
    title_template: str,
    start_hour: int,
    duration_minutes: int,
    weeks: int,
    attendees: List[str],
    organizer_user_id: str,
    team_id: str,
    channel_id: str,
) -> List[Dict]:
    """毎週同じ曜日・時間の定例会議を一括作成する"""
    now = datetime.now(JST)
    days_to_monday = (7 - now.weekday()) % 7
    next_monday = (now + timedelta(days=days_to_monday)).replace(
        hour=start_hour, minute=0, second=0, microsecond=0
    )
    results = []
    for i in range(weeks):
        start = next_monday + timedelta(weeks=i)
        end   = start + timedelta(minutes=duration_minutes)
        label = start.strftime("%Y/%m/%d")
        title = title_template.format(date=label, num=i + 1)
        mtg   = create_online_meeting(
            client, title, start, end, attendees, organizer_user_id
        )
        results.append(mtg)
        body_html = (
            f"<b>📅 定例会議を設定しました</b><br>"
            f"タイトル: {title}<br>"
            f"開始: {start.strftime('%Y年%m月%d日 %H:%M')}<br>"
            f"参加URL: <a href='{mtg.get(\"joinWebUrl\", \"\")}'>会議に参加</a>"
        )
        post_channel_message(
            client, team_id, channel_id,
            subject=f"会議設定: {title}",
            body_html=body_html,
        )
    return results


if __name__ == "__main__":
    client = GraphClient()
    schedule_weekly_meetings(
        client,
        title_template="週次定例会議 第{num}回 ({date})",
        start_hour=9,
        duration_minutes=60,
        weeks=4,
        attendees=["tanaka@example.com", "sato@example.com"],
        organizer_user_id="d4e5f6a7-1234-5678-9012-b8c9d0e1f2a3",
        team_id="a1b2c3d4-0001-0002-0003-e5f6a7b8c9d0",
        channel_id="19:abc123def456@thread.tacv2",
    )

4週分の定例会議が一括で作成され、チャンネルへの通知も自動投稿されました。毎週の手作業が完全になくなります。

Step 5：特定ユーザーへのメンションと緊急通知を送る

KPIアラートや障害通知など、特定のメンバーにすぐ届けたいメッセージを自動化します。Claude Codeにメンション付きの緊急通知コードを依頼しました。

💬 私はClaude Codeにこう頼みました：

from graph_client import GraphClient
from post_channel_message import post_channel_message
from datetime import datetime
from typing import List, Dict
import pytz

JST        = pytz.timezone("Asia/Tokyo")
TEAM_ID    = "a1b2c3d4-0001-0002-0003-e5f6a7b8c9d0"
CHANNEL_ID = "19:abc123def456@thread.tacv2"
MANAGERS   = [
    {"id": "user-id-001", "displayName": "田中部長"},
    {"id": "user-id-002", "displayName": "佐藤マネージャー"},
]
SRE_TEAM = [
    {"id": "user-id-003", "displayName": "鈴木SRE"},
    {"id": "user-id-004", "displayName": "山本インフラ担当"},
]


def kpi_alert(client: GraphClient, actual: float, target: float, metric: str):
    """KPIが目標の80%を下回ったらアラートを送信する"""
    ratio = actual / target * 100
    if ratio >= 80:
        return
    color = "#D32F2F"
    body = (
        f'<h3 style="color:{color}">⚠️ KPIアラート: {metric}</h3>'
        f'<p>実績: <b style="color:{color}">{actual:,.0f}</b> '
        f'/ 目標: {target:,.0f} / 達成率: <b style="color:{color}">{ratio:.1f}%</b></p>'
        f'<p style="color:{color}">至急対応が必要です。</p>'
    )
    post_channel_message(
        client, TEAM_ID, CHANNEL_ID,
        subject=f"[KPIアラート] {metric} 達成率{ratio:.0f}%",
        body_html=body, importance="important", mentions=MANAGERS,
    )
    print(f"[KPI] アラート送信: {metric} {ratio:.1f}%")


def incident_alert(client: GraphClient, service: str, error_count: int, threshold: int):
    """エラー件数が閾値を超えたらSREチームにurgent通知する"""
    if error_count < threshold:
        return
    now  = datetime.now(JST).strftime("%Y年%m月%d日 %H:%M")
    body = (
        f'<h3 style="color:#B71C1C">🚨 インシデント検知: {service}</h3>'
        f'<p>検知時刻: <b>{now}</b></p>'
        f'<p>エラー件数: <b style="color:#B71C1C">{error_count}件</b> '
        f'(閾値: {threshold}件)</p>'
        '<p>即座に確認・対応をお願いします。</p>'
    )
    post_channel_message(
        client, TEAM_ID, CHANNEL_ID,
        subject=f"[INCIDENT] {service} エラー急増",
        body_html=body, importance="urgent", mentions=SRE_TEAM,
    )
    print(f"[Incident] urgent通知送信: {service} ({error_count}件)")


def daily_progress_report(client: GraphClient, tasks: List[Dict]):
    """毎日17時に本日の進捗サマリーを送信する"""
    done  = [t for t in tasks if t["status"] == "done"]
    wip   = [t for t in tasks if t["status"] == "wip"]
    todo  = [t for t in tasks if t["status"] == "todo"]
    today = datetime.now(JST).strftime("%Y年%m月%d日")
    rows  = ""
    icons = {"done":"✅","wip":"🔄","todo":"⏳"}
    for t in tasks:
        icon = icons.get(t["status"], "⬜")
        rows += f"<tr><td>{icon}</td><td>{t['title']}</td><td>{t['owner']}</td></tr>"
    body = (
        f"<h3>📋 本日の進捗サマリー ({today})</h3>"
        f"<p>完了: <b>{len(done)}件</b> / 進行中: <b>{len(wip)}件</b> / 未着手: <b>{len(todo)}件</b></p>"
        f"<table border='1' style='border-collapse:collapse;width:100%'>"
        f"<tr style='background:#6264A7;color:white'><th>状態</th><th>タスク</th><th>担当</th></tr>"
        f"{rows}</table>"
    )
    post_channel_message(
        client, TEAM_ID, CHANNEL_ID,
        subject=f"本日の進捗レポート ({today})",
        body_html=body,
    )
    print("[Report] 進捗レポート送信完了")


if __name__ == "__main__":
    client = GraphClient()
    kpi_alert(client, actual=3_200_000, target=5_000_000, metric="4月売上")
    incident_alert(client, service="API Gateway", error_count=150, threshold=100)
    tasks = [
        {"title":"Graph API認証モジュール実装",  "status":"done", "owner":"田中"},
        {"title":"Teamsボットテスト",             "status":"wip",  "owner":"佐藤"},
        {"title":"会議スケジュール自動化スクリプト", "status":"done", "owner":"鈴木"},
        {"title":"本番環境デプロイ",              "status":"todo", "owner":"山本"},
    ]
    daily_progress_report(client, tasks)

KPIアラート・インシデント通知・日報レポートの3種類がすべて正常に動作しました。Claude Codeのコードは重要度（urgent/important）の使い分けまで正確に実装してくれています。

Step 6：バッチ処理で複数チャンネルに一括投稿する

最後に、Claude Codeに複数チームの複数チャンネルへのバッチ一括投稿システムを作ってもらいます。全社アナウンスなどに使えます。

💬 私はClaude Codeにこう頼みました：

import asyncio, aiohttp, json, csv, os
from datetime import datetime
from typing import List, Dict
from graph_client import GraphClient

# channels.json の形式:
# [
#   {"team_id": "...", "channel_id": "...", "name": "営業部 #全体"},
#   {"team_id": "...", "channel_id": "...", "name": "開発部 #一般"}
# ]

MAX_RETRIES = 3
CONCURRENCY = 5  # Graph APIのレート制限に配慮した同時投稿数


async def post_one(
    session: aiohttp.ClientSession,
    token: str,
    channel: Dict,
    subject: str,
    body_html: str,
) -> Dict:
    """1チャンネルへの投稿（リトライ付き）"""
    url = (
        f"https://graph.microsoft.com/v1.0"
        f"/teams/{channel['team_id']}/channels/{channel['channel_id']}/messages"
    )
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    }
    payload = {
        "subject": subject,
        "body": {"contentType": "html", "content": body_html},
    }
    for attempt in range(MAX_RETRIES):
        async with session.post(url, headers=headers, json=payload) as resp:
            if resp.status == 429:
                wait = int(resp.headers.get("Retry-After", "5"))
                print(f"[Batch] レート制限 → {wait}秒待機 ({channel['name']})")
                await asyncio.sleep(wait)
                continue
            if resp.status >= 400:
                err = await resp.text()
                return {"channel": channel["name"], "status": "error",
                        "message_id": "", "detail": err[:80]}
            data = await resp.json()
            return {"channel": channel["name"], "status": "ok",
                    "message_id": data.get("id", ""), "detail": ""}
    return {"channel": channel["name"], "status": "max_retry",
            "message_id": "", "detail": "リトライ上限到達"}


async def batch_post_async(
    token: str, channels: List[Dict], subject: str, body_html: str
) -> List[Dict]:
    sem = asyncio.Semaphore(CONCURRENCY)

    async def guarded(ch):
        async with sem:
            return await post_one(session, token, ch, subject, body_html)

    async with aiohttp.ClientSession() as session:
        results = await asyncio.gather(*[guarded(ch) for ch in channels])
    return list(results)


def batch_post(subject: str, body_html: str, channels_json: str = "channels.json"):
    with open(channels_json, "r", encoding="utf-8") as f:
        channels = json.load(f)

    print(f"投稿先: {len(channels)}チャンネル")
    for ch in channels:
        print(f"  - {ch['name']}")
    answer = input(f"\n本当に{len(channels)}チャンネルに投稿しますか？ (y/n): ")
    if answer.strip().lower() != "y":
        print("キャンセルしました。")
        return

    gc      = GraphClient()
    token   = gc._get_token()
    results = asyncio.run(batch_post_async(token, channels, subject, body_html))

    ts       = datetime.now().strftime("%Y%m%d_%H%M%S")
    csv_path = f"batch_result_{ts}.csv"
    with open(csv_path, "w", encoding="utf-8-sig", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=["channel","status","message_id","detail"])
        writer.writeheader()
        writer.writerows(results)

    ok  = sum(1 for r in results if r["status"] == "ok")
    err = len(results) - ok
    print(f"\n[Batch] 完了 — 成功: {ok}件 / 失敗: {err}件")
    print(f"[Batch] 結果CSV: {csv_path}")


if __name__ == "__main__":
    batch_post(
        subject="【全社】ゴールデンウィーク期間中のお知らせ",
        body_html=(
            "<h3>ゴールデンウィーク期間中の対応について</h3>"
            "<p>2026年5月3日（日）〜5月5日（火）は休業とします。</p>"
            "<p>緊急の場合はオンコール担当（鈴木）までご連絡ください。</p>"
        ),
    )

8チャンネルへの一括投稿が約3秒で完了しました。Claude Codeが実装してくれたレート制限リトライと並列制御のおかげで、大量のチャンネルへの投稿もエラーなく処理できます。

まとめ：Claude Code で Teams 自動化が劇的に楽になった

今回の体験を通じて、Claude CodeとMicrosoft Graph APIを組み合わせることで、Teamsに関わる手作業のほぼすべてを自動化できることが分かりました。

よくある質問

関連記事