Outlook AI for meetings, calendar, and email

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

# Same email works for Microsoft Teams, Zoom, Webex, and Google Meet events.

# 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 Outlook events immediately
# 5. Bot joins your next scheduled meeting automatically

# Or use Capture Live Meeting / Schedule Live Meeting in the
# Meeting Assistant UI to send the bot to one specific meeting URL.

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 - Discovery Call",
    "meetingURL": "https://teams.microsoft.com/l/meetup-join/...",
    "meetingDate": "2026-05-15T16:00:00.000Z",
    "meetingLanguage": "en-US",
    "folderId": "507f1f77bcf86cd799439011"
  }'

// Call this when your CRM creates a meeting in Outlook + Teams.
async function scheduleSpeakBot({ title, meetingURL, 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,
        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 on the CRM activity record
  // so you can pause / resume / remove the assistant later.
  return data.meetingAssistantEventId;
}

import os, requests

def schedule_speak_bot(title: str, meeting_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": meeting_url,
            "meetingDate": scheduled_at,
            "meetingLanguage": "en-US",
            "folderId": folder_id,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["data"]["meetingAssistantEventId"]

// 1. Get every message in the conversation from Microsoft Graph.
const graphRes = await fetch(
  "https://graph.microsoft.com/v1.0/me/messages?" + new URLSearchParams({
    $filter: `conversationId eq '${conversationId}'`,
    $select: "subject,from,receivedDateTime,body",
    $orderby: "receivedDateTime asc",
  }),
  { headers: { Authorization: `Bearer ${process.env.GRAPH_TOKEN}` } }
).then(r => r.json());

// 2. Strip HTML and concatenate
const threadText = graphRes.value.map(m => {
  const sender = m.from?.emailAddress?.address || "unknown";
  const when = m.receivedDateTime;
  const html = m.body?.content || "";
  // Strip HTML tags (use a real parser like JSDOM or Cheerio in production)
  const plain = html.replace(/<[^>]+>/g, "").replace(/s+/g, " ").trim();
  return `From: ${sender}nWhen: ${when}nn${plain}`;
}).join("nn---nn");

// 3. Upload thread as a Speak text media
const upload = await fetch("https://api.speakai.co/v1/media/upload", {
  method: "POST",
  headers: {
    "x-speakai-key": process.env.SPEAK_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: graphRes.value[0]?.subject || `Thread ${conversationId}`,
    text: threadText,
    mediaType: "text",
    tags: "outlook,email-thread",
  }),
}).then(r => r.json());

const mediaId = upload.data.mediaId;

// 4. Fire a Magic Prompt against the thread
await fetch("https://api.speakai.co/v1/prompt/", {
  method: "POST",
  headers: {
    "x-speakai-key": process.env.SPEAK_API_KEY,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    mediaIds: [mediaId],
    prompt: "Extract decisions, owners, and deadlines from this email thread. Return JSON.",
    isStream: false,
    isIndividualPrompt: true,
  }),
});

// Poll /v1/prompt/messages?mediaIds=$mediaId&pageSize=1 until state === "completed"

import os, re, requests

def analyze_outlook_thread(conversation_id: str) -> str:
    # 1. Fetch every message in the conversation
    graph = requests.get(
        "https://graph.microsoft.com/v1.0/me/messages",
        params={
            "$filter": f"conversationId eq '{conversation_id}'",
            "$select": "subject,from,receivedDateTime,body",
            "$orderby": "receivedDateTime asc",
        },
        headers={"Authorization": f"Bearer {os.environ['GRAPH_TOKEN']}"},
        timeout=30,
    ).json()

    def strip_html(s: str) -> str:
        return re.sub(r"<[^>]+>", "", s or "").strip()

    thread_text = "nn---nn".join(
        f"From: {m.get('from', {}).get('emailAddress', {}).get('address', 'unknown')}n"
        f"When: {m.get('receivedDateTime')}nn"
        f"{strip_html(m.get('body', {}).get('content', ''))}"
        for m in graph.get("value", [])
    )

    # 2. Upload to Speak as text media
    upload = requests.post(
        "https://api.speakai.co/v1/media/upload",
        headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
        json={
            "name": graph["value"][0].get("subject") if graph.get("value") else f"Thread {conversation_id}",
            "text": thread_text,
            "mediaType": "text",
            "tags": "outlook,email-thread",
        },
        timeout=30,
    ).json()
    media_id = upload["data"]["mediaId"]

    # 3. Run Magic Prompt
    requests.post(
        "https://api.speakai.co/v1/prompt/",
        headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
        json={
            "mediaIds": [media_id],
            "prompt": "Extract decisions, owners, and deadlines from this email thread. Return JSON.",
            "isStream": False,
            "isIndividualPrompt": True,
        },
        timeout=15,
    )
    return media_id

import express from "express";
const app = express();
app.use(express.json());

app.post("/speak/outlook-tasks", async (req, res) => {
  // Speak posts {eventType, state, mediaId} -- flat (verified 2026-05-07).
  const { eventType, state, mediaId } = req.body;
  if (eventType !== "media.analyzed" || state !== "processed") return res.sendStatus(204);
  res.sendStatus(202);

  // 1. Fire a Magic Prompt to extract action items as JSON
  const headers = { "x-speakai-key": process.env.SPEAK_API_KEY };
  await fetch("https://api.speakai.co/v1/prompt/", {
    method: "POST",
    headers: { ...headers, "Content-Type": "application/json" },
    body: JSON.stringify({
      mediaIds: [mediaId],
      prompt: 'Extract action items as JSON. Each item: {"text": "...", "owner_email": "...", "due_date": "YYYY-MM-DD"}',
      isStream: false,
      isIndividualPrompt: true,
    }),
  });

  // 2. Poll for the completed answer (typical 2-3s)
  let actionItems = [];
  for (let i = 0; i < 20; i++) {
    await new Promise(r => setTimeout(r, 1000));
    const r = await fetch(
      `https://api.speakai.co/v1/prompt/messages?mediaIds=${mediaId}&pageSize=1`,
      { headers }
    );
    const j = await r.json();
    const msg = j?.data?.history?.[0]?.messages?.[0];
    if (msg?.state === "completed") {
      try { actionItems = JSON.parse(msg.answer); } catch { actionItems = []; }
      break;
    }
  }

  // 3. Create one Outlook Task per action item via Microsoft Graph To Do
  for (const item of actionItems) {
    await fetch(
      "https://graph.microsoft.com/v1.0/me/todo/lists/tasks/tasks",
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.GRAPH_TOKEN}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify({
          title: item.text,
          body: {
            content: `From Speak meeting: https://app.speakai.co/media/${mediaId}`,
            contentType: "text",
          },
          dueDateTime: item.due_date ? {
            dateTime: `${item.due_date}T17:00:00.000`,
            timeZone: "UTC",
          } : undefined,
        }),
      }
    );
  }
});

app.listen(3000);

import asyncio, json, os, time, requests
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/speak/outlook-tasks")
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"]

    headers = {"x-speakai-key": os.environ["SPEAK_API_KEY"]}

    # 1. Fire a Magic Prompt
    requests.post(
        "https://api.speakai.co/v1/prompt/",
        headers={**headers, "Content-Type": "application/json"},
        json={
            "mediaIds": [media_id],
            "prompt": 'Extract action items as JSON. Each item: {"text": "...", "owner_email": "...", "due_date": "YYYY-MM-DD"}',
            "isStream": False,
            "isIndividualPrompt": True,
        },
        timeout=15,
    )

    # 2. Poll for completion
    action_items = []
    for _ in range(20):
        time.sleep(1)
        r = requests.get(
            "https://api.speakai.co/v1/prompt/messages",
            params={"mediaIds": media_id, "pageSize": 1},
            headers=headers, timeout=15,
        )
        history = r.json().get("data", {}).get("history", [])
        msg = history[0]["messages"][0] if history and history[0].get("messages") else None
        if msg and msg.get("state") == "completed":
            try:
                action_items = json.loads(msg.get("answer", "[]"))
            except Exception:
                action_items = []
            break

    # 3. Create one Outlook Task per action item
    for item in action_items:
        requests.post(
            "https://graph.microsoft.com/v1.0/me/todo/lists/tasks/tasks",
            headers={
                "Authorization": f"Bearer {os.environ['GRAPH_TOKEN']}",
                "Content-Type": "application/json",
            },
            json={
                "title": item.get("text", ""),
                "body": {
                    "content": f"From Speak meeting: https://app.speakai.co/media/{media_id}",
                    "contentType": "text",
                },
                "dueDateTime": ({
                    "dateTime": f"{item['due_date']}T17:00:00.000",
                    "timeZone": "UTC",
                } if item.get("due_date") else None),
            },
            timeout=15,
        )
    return {"ok": True}

# Claude Desktop / Claude Code (auto-detects your installation)
npx @speakai/mcp-server init

# Paste your Speak API key when prompted. Setup takes about 2 minutes.

# Claude.ai (web) and ChatGPT MCP connector
# Settings > Integrations > Add MCP Server
# Remote URL:    https://api.speakai.co/v1/mcp
# Auth header:   x-speakai-key: YOUR_SPEAK_API_KEY

# Verify the connection responds:
curl -s https://api.speakai.co/v1/mcp 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Accept: application/json"