Use Speak AI with Slack

# In Speak AI dashboard:
# 1. Go to Settings -> Integrations -> Slack
# 2. Click "Connect Slack"
# 3. Choose your Slack workspace + channels you want to enable
# 4. Approve scopes (chat:write, channels:read, users:read, files:write)
# 5. Speak stores an accountId you reference from the API

# Or hit Speak's connect endpoint programmatically:
curl -X POST https://api.speakai.co/v1/integration/slack/connect 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{"code": "$SLACK_OAUTH_CODE", "redirectUri": "https://yourapp/slack-redirect"}'

curl https://api.speakai.co/v1/integration/slack/$ACCOUNT_ID/channels 
  -H "x-speakai-key: $SPEAK_API_KEY"

# Response:
# {
#   "status": "success",
#   "data": {
#     "channels": [
#       { "id": "C0123ABCD", "name": "deals-pipeline" },
#       { "id": "C0123EFGH", "name": "support-oncall" },
#       ...
#     ]
#   }
# }

curl -X POST https://api.speakai.co/v1/integration/slack/send-transcription 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "mediaId": "14c8dd9c0a89",
    "channelId": "C0123ABCD",
    "channelName": "deals-pipeline",
    "accountId": "$SLACK_ACCOUNT_ID"
  }'

# Speak posts the formatted transcript card to the channel.
# AI summary, speaker labels, sentiment chip, link back to the Speak record.

// Trigger this from your CRM, scheduler, or a Speak webhook handler.
async function pushTranscriptToSlack({ mediaId, channelId, channelName, accountId }) {
  const r = await fetch(
    "https://api.speakai.co/v1/integration/slack/send-transcription",
    {
      method: "POST",
      headers: {
        "x-speakai-key": process.env.SPEAK_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({ mediaId, channelId, channelName, accountId }),
    }
  );
  if (!r.ok) throw new Error(`Slack push failed: ${r.status}`);
  return r.json();
}

import os, requests

def push_transcript_to_slack(media_id: str, channel_id: str, channel_name: str, account_id: str):
    r = requests.post(
        "https://api.speakai.co/v1/integration/slack/send-transcription",
        headers={
            "x-speakai-key": os.environ["SPEAK_API_KEY"],
            "Content-Type": "application/json",
        },
        json={
            "mediaId": media_id,
            "channelId": channel_id,
            "channelName": channel_name,
            "accountId": account_id,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()

# 1. Go to https://api.slack.com/apps
# 2. Click "Create New App" -> "From scratch"
# 3. Name it (e.g. "Speak AI Bot") and choose your workspace
# 4. Under Features, enable "Incoming Webhooks"
# 5. Click "Add New Webhook to Workspace"
# 6. Pick the channel that will receive Speak summaries
# 7. Copy the Webhook URL (https://hooks.slack.com/services/T.../B.../xxx)

# Store the URL as an env var: SLACK_WEBHOOK_URL
# Same URL is reusable for every recording analyzed by Speak.

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/slack-webhook",
    "events": ["media.analyzed"],
    "description": "Forward Speak insights to Slack"
  }'

// 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/slack-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 ? ":green_circle: Positive"
                  : compound < -10 ? ":red_circle: Negative" : ":white_circle: Neutral";

  // 2. Build a Slack Block Kit card
  const blocks = [
    {
      type: "header",
      text: { type: "plain_text", text: media.name },
    },
    {
      type: "section",
      fields: [
        { type: "mrkdwn", text: `*Sentiment*n${sentiment} (${compound})` },
        { type: "mrkdwn", text: `*Duration*n${Math.round(media.duration?.inSecond / 60)} min` },
      ],
    },
    {
      type: "actions",
      elements: [{
        type: "button",
        text: { type: "plain_text", text: "Open in Speak" },
        url: `https://app.speakai.co/media/${mediaId}`,
      }],
    },
  ];

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

app.listen(3000);

import os, requests
from fastapi import FastAPI, Request

app = FastAPI()

@app.post("/speak/slack-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_emoji = ":green_circle: Positive" if compound > 10 else ":red_circle: Negative" if compound < -10 else ":white_circle: Neutral"

    blocks = [
        {"type": "header", "text": {"type": "plain_text", "text": insight["name"]}},
        {"type": "section", "fields": [
            {"type": "mrkdwn", "text": f"*Sentiment*n{sentiment_emoji} ({compound})"},
            {"type": "mrkdwn", "text": f"*Duration*n{round(insight.get('duration', {}).get('inSecond', 0) / 60)} min"},
        ]},
        {"type": "actions", "elements": [{
            "type": "button",
            "text": {"type": "plain_text", "text": "Open in Speak"},
            "url": f"https://app.speakai.co/media/{media_id}",
        }]},
    ]

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

# In your Slack app at https://api.slack.com/apps:
# 1. Features -> Slash Commands -> Create New Command
# 2. Command:        /ask-speak
# 3. Request URL:    https://your-app.example.com/slack/ask-speak
# 4. Short description: Ask a question about a Speak recording
# 5. Usage hint:     [mediaId] [your question]
# 6. Reinstall the app to your workspace

# Slack POSTs to your URL with form-encoded body:
#   token, team_id, channel_id, user_id, command, text, response_url
#
# Verify the request with the X-Slack-Signature header
# (HMAC-SHA256 with your Slack signing secret).

import express from "express";
import crypto from "crypto";

const app = express();
app.use(express.urlencoded({ extended: false }));

function verifySlack(req) {
  const ts = req.headers["x-slack-request-timestamp"];
  const sig = req.headers["x-slack-signature"];
  const base = `v0:${ts}:${req.rawBody}`;
  const hmac = "v0=" + crypto
    .createHmac("sha256", process.env.SLACK_SIGNING_SECRET)
    .update(base).digest("hex");
  return crypto.timingSafeEqual(Buffer.from(hmac), Buffer.from(sig));
}

app.post("/slack/ask-speak", async (req, res) => {
  if (!verifySlack(req)) return res.sendStatus(401);
  res.json({ response_type: "in_channel", text: "Asking Speak..." }); // ack within 3s

  const [mediaId, ...rest] = (req.body.text || "").split(" ");
  const prompt = rest.join(" ");
  const responseUrl = req.body.response_url;

  // Fire Magic Prompt + poll until completed (typical 2-3s)
  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,
      isStream: false, isIndividualPrompt: true,
    }),
  });

  let answer = "(timed out)";
  for (let i = 0; i < 20; i++) {
    await new Promise(r => setTimeout(r, 1000));
    const r2 = await fetch(
      `https://api.speakai.co/v1/prompt/messages?mediaIds=${mediaId}&pageSize=1`,
      { headers }
    );
    const j = await r2.json();
    const msg = j?.data?.history?.[0]?.messages?.[0];
    if (msg?.state === "completed") { answer = msg.answer; break; }
  }

  // Post answer back to the same Slack thread
  await fetch(responseUrl, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ response_type: "in_channel", text: answer }),
  });
});

app.listen(3000);

# Claude Desktop / Claude Code (oppdager automatisk installasjonen din)
npx @speakai/mcp-server init

# Lim inn Speak API-nøkkelen din når du blir bedt om det. Installasjon tar cirka 2 minutter.

# Claude.ai (web) og ChatGPT MCP-kobling
# Innstillinger > Integrasjoner > Legg til MCP-server
# Fjern-URL:    https://api.speakai.co/v1/mcp
# Auth-header:   x-speakai-key: YOUR_SPEAK_API_KEY

# Verifiser at forbindelsen svarer:
curl -s https://api.speakai.co/v1/mcp 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Accept: application/json"