# Manual: open the Outlook calendar event with the Teams meeting link.
# Click "Add attendees" and enter:
#     [email protected]
# Save the event. The bot accepts the invite and joins the Teams call automatically.

# Programmatic (Microsoft Graph) - add the bot as an attendee:
curl -X PATCH "https://graph.microsoft.com/v1.0/me/events/$EVENT_ID" 
  -H "Authorization: Bearer $GRAPH_TOKEN" 
  -H "Content-Type: application/json" 
  -d '{
    "attendees": [
      {
        "emailAddress": { "address": "[email protected]", "name": "Speak AI Notetaker" },
        "type": "required"
      }
    ]
  }'

# In Speak AI dashboard:
# 1. Go to Meeting Assistant -> Calendar
# 2. Click "Connect Microsoft 365"
# 3. Approve OAuth scopes:
#      Calendars.Read
#      OnlineMeetings.Read.All
# 4. Speak finds existing future Teams events immediately
# 5. Bot joins your next scheduled Teams meeting automatically

# Workspace admins can pre-approve via Entra ID admin consent for org-wide rollout.

curl -X POST https://api.speakai.co/v1/meeting-assistant/events/schedule 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "title": "Acme Corp - Demo Call",
    "meetingURL": "https://teams.microsoft.com/l/meetup-join/19%3ameeting_...",
    "meetingDate": "2026-05-15T16:00:00.000Z",
    "meetingLanguage": "en-US",
    "folderId": "507f1f77bcf86cd799439011"
  }'

// Call this when your CRM creates a Teams meeting (via Graph onlineMeetings).
async function scheduleSpeakBot({ title, teamsURL, scheduledAt, folderId }) {
  const r = await fetch(
    "https://api.speakai.co/v1/meeting-assistant/events/schedule",
    {
      method: "POST",
      headers: {
        "x-speakai-key": process.env.SPEAK_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        title,
        meetingURL: teamsURL,
        meetingDate: scheduledAt,
        meetingLanguage: "en-US",
        folderId,
      }),
    }
  );
  if (!r.ok) throw new Error(`Speak schedule failed: ${r.status}`);
  const { data } = await r.json();
  // Persist data.meetingAssistantEventId for pause / resume / remove later.
  return data.meetingAssistantEventId;
}

import os, requests

def schedule_speak_bot(title: str, teams_url: str, scheduled_at: str, folder_id: str | None = None):
    r = requests.post(
        "https://api.speakai.co/v1/meeting-assistant/events/schedule",
        headers={
            "x-speakai-key": os.environ["SPEAK_API_KEY"],
            "Content-Type": "application/json",
        },
        json={
            "title": title,
            "meetingURL": teams_url,
            "meetingDate": scheduled_at,
            "meetingLanguage": "en-US",
            "folderId": folder_id,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["data"]["meetingAssistantEventId"]

# In Microsoft Teams:
# 1. Open the channel that should receive Speak summaries
# 2. Click ... (More options) -> Connectors
# 3. Find "Incoming Webhook" -> Configure
# 4. Name it "Speak AI Notetaker", upload an icon (optional)
# 5. Copy the Webhook URL (https://yourtenant.webhook.office.com/webhookb2/...)
# 6. Store as TEAMS_WEBHOOK_URL env var on your handler server

# The same URL is reusable for every recording. One URL per channel.

curl -X POST https://api.speakai.co/v1/webhook 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "callbackUrl": "https://your-app.example.com/speak/teams-webhook",
    "events": ["media.analyzed"],
    "description": "Forward Speak insights to Teams channel"
  }'

// Speak posts a thin notification: { eventType, state, mediaId } (verified 2026-05-07).
import express from "express";
const app = express();
app.use(express.json());

app.post("/speak/teams-webhook", async (req, res) => {
  const { eventType, state, mediaId } = req.body;
  if (eventType !== "media.analyzed" || state !== "processed") return res.sendStatus(204);
  res.sendStatus(202);

  // 1. Fetch full insight from Speak
  const insight = await fetch(
    `https://api.speakai.co/v1/media/insight/${mediaId}`,
    { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
  ).then(r => r.json());

  const media = insight.data;
  const compound = media.sentiment?.[0]?.document?.Compound ?? 0;
  const sentiment = compound > 10 ? "Positive"
                  : compound < -10 ? "Negative" : "Neutral";

  // 2. Build an Adaptive Card (Microsoft's recommended format for Teams Incoming Webhooks)
  const card = {
    type: "message",
    attachments: [{
      contentType: "application/vnd.microsoft.card.adaptive",
      content: {
        $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
        type: "AdaptiveCard",
        version: "1.5",
        body: [
          { type: "TextBlock", size: "Large", weight: "Bolder", text: media.name },
          { type: "TextBlock", text: `Sentiment: ${sentiment} (Compound ${compound})`, wrap: true },
          { type: "TextBlock",
            text: `Duration: ${Math.round(media.duration?.inSecond / 60)} min`,
            isSubtle: true, spacing: "None" },
        ],
        actions: [{
          type: "Action.OpenUrl",
          title: "Open in Speak",
          url: `https://app.speakai.co/media/${mediaId}`,
        }],
      },
    }],
  };

  // 3. POST to the Teams Incoming Webhook
  await fetch(process.env.TEAMS_WEBHOOK_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify(card),
  });
});

app.listen(3000);

import os, requests
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/speak/teams-webhook")
async def hook(req: Request):
    body = await req.json()
    if body.get("eventType") != "media.analyzed" or body.get("state") != "processed":
        return {"ok": True}
    media_id = body["mediaId"]

    insight = requests.get(
        f"https://api.speakai.co/v1/media/insight/{media_id}",
        headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
        timeout=30,
    ).json()["data"]

    compound = (insight.get("sentiment") or [{}])[0].get("document", {}).get("Compound", 0)
    sentiment = "Positive" if compound > 10 else "Negative" if compound < -10 else "Neutral"

    card = {
        "type": "message",
        "attachments": [{
            "contentType": "application/vnd.microsoft.card.adaptive",
            "content": {
                "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
                "type": "AdaptiveCard",
                "version": "1.5",
                "body": [
                    {"type": "TextBlock", "size": "Large", "weight": "Bolder", "text": insight["name"]},
                    {"type": "TextBlock", "text": f"Sentiment: {sentiment} (Compound {compound})", "wrap": True},
                    {"type": "TextBlock",
                     "text": f"Duration: {round(insight.get('duration', {}).get('inSecond', 0) / 60)} min",
                     "isSubtle": True, "spacing": "None"},
                ],
                "actions": [{
                    "type": "Action.OpenUrl",
                    "title": "Open in Speak",
                    "url": f"https://app.speakai.co/media/{media_id}",
                }],
            },
        }],
    }

    requests.post(
        os.environ["TEAMS_WEBHOOK_URL"],
        json=card,
        timeout=15,
    )
    return {"ok": True}

// Speak webhook body shape (verified 2026-05-07): { eventType, state, mediaId }
import express from "express";
const app = express();
app.use(express.json());

app.post("/speak/teams-to-crm", async (req, res) => {
  const { eventType, state, mediaId } = req.body;
  if (eventType !== "media.analyzed" || state !== "processed") return res.sendStatus(204);
  res.sendStatus(202);

  // 1. Fetch full insight
  const { data } = await fetch(
    `https://api.speakai.co/v1/media/insight/${mediaId}`,
    { headers: { "x-speakai-key": process.env.SPEAK_API_KEY } }
  ).then(r => r.json());

  // 2. Push to HubSpot Meetings (or Salesforce Tasks, or Zoho Calls)
  const start = new Date(data.createdAt);
  const end = new Date(start.getTime() + (data.duration?.inSecond || 0) * 1000);

  await fetch("https://api.hubapi.com/crm/v3/objects/meetings", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.HUBSPOT_TOKEN}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      properties: {
        hs_timestamp: start.toISOString(),
        hs_meeting_title: data.name,
        hs_meeting_body: `Teams call summary. Open in Speak: https://app.speakai.co/media/${mediaId}`,
        hs_meeting_external_url: `https://app.speakai.co/media/${mediaId}`,
        hs_meeting_start_time: start.toISOString(),
        hs_meeting_end_time: end.toISOString(),
        hs_meeting_outcome: "COMPLETED",
      },
    }),
  });
});

app.listen(3000);

# Claude Desktop / Claude Code (erkennt Ihre Installation automatisch)
npx @speakai/mcp-server init

# Fügen Sie Ihren Speak API-Schlüssel ein, wenn Sie dazu aufgefordert werden. Die Einrichtung dauert etwa 2 Minuten.

# Claude.ai (Web) und ChatGPT MCP-Konnector
# Einstellungen > Integrationen > MCP Server hinzufügen
# Remote-URL:    https://api.speakai.co/v1/mcp
# Auth-Header:   x-speakai-key: IHREN_SPEAK_API_KEY

# Überprüfen Sie, ob die Verbindung antwortet:
curl -s https://api.speakai.co/v1/mcp 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Accept: application/json"