Google Drive AI: transcriu, resumeix i conversa amb qualsevol fitxer de Drive

# In Speak AI dashboard:
# 1. Go to Settings -> Integrations -> Google Drive
# 2. Click "Connect Google Drive"
# 3. Approve read-only OAuth access to files you select
# 4. Speak stores the OAuth token securely on its side

# Or hit the connect endpoint programmatically with a Drive OAuth code:
curl -X POST https://api.speakai.co/v1/integration/googledrive/connect 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{"code": "$GOOGLE_OAUTH_CODE"}'

curl -X POST https://api.speakai.co/v1/integration/googledrive/upload 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "url": "https://drive.google.com/file/d/1AbCdEfGhIjKlMnOpQrStUv/view",
    "sourceLanguage": "en-US",
    "folderId": "507f1f77bcf86cd799439011"
  }'

# Accepted URL formats:
#   https://drive.google.com/file/d/{fileId}/view
#   https://drive.google.com/file/d/{fileId}/edit
#   https://www.googleapis.com/drive/v3/files/{fileId}
#
# Speak parses the file ID, fetches metadata via Drive API,
# gets a fresh download URL via the user's stored OAuth token,
# then uploads to Speak for transcription and analysis.

// Use this in your CRM, scheduler, or research-pipeline server.
async function importDriveFileToSpeak(driveUrl, folderId) {
  const r = await fetch(
    "https://api.speakai.co/v1/integration/googledrive/upload",
    {
      method: "POST",
      headers: {
        "x-speakai-key": process.env.SPEAK_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        url: driveUrl,
        sourceLanguage: "en-US",
        folderId,
      }),
    }
  );
  if (!r.ok) throw new Error(`Drive import failed: ${r.status}`);
  const { data } = await r.json();
  // data.mediaId is the new Speak media reference.
  return data.mediaId;
}

// Example: import a research interview into Speak's "Q3 Interviews" folder
const mediaId = await importDriveFileToSpeak(
  "https://drive.google.com/file/d/1AbCdEfGhIjKlMnOpQrStUv/view",
  process.env.SPEAK_FOLDER_ID,
);

import os, requests

def import_drive_file_to_speak(drive_url: str, folder_id: str | None = None) -> str:
    r = requests.post(
        "https://api.speakai.co/v1/integration/googledrive/upload",
        headers={
            "x-speakai-key": os.environ["SPEAK_API_KEY"],
            "Content-Type": "application/json",
        },
        json={
            "url": drive_url,
            "sourceLanguage": "en-US",
            "folderId": folder_id,
        },
        timeout=30,
    )
    r.raise_for_status()
    return r.json()["data"]["mediaId"]

# Drive Push notifications - watch a folder for new files.
# Required scope: drive.readonly (or drive.file for picker-selected files).

curl -X POST "https://www.googleapis.com/drive/v3/files/$FOLDER_ID/watch" 
  -H "Authorization: Bearer $GOOGLE_OAUTH_TOKEN" 
  -H "Content-Type: application/json" 
  -d '{
    "id": "speak-drive-watch-1",
    "type": "web_hook",
    "address": "https://your-app.example.com/drive/watch"
  }'

# Channel expires after 7 days. Renew with another POST to /watch.
# When a change occurs, Drive POSTs to your address with X-Goog-Resource-State header.
# Your handler then lists files in the folder via files.list and forwards new ones.

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

// In-memory cursor (use a real DB in production)
let lastSeenIds = new Set();

app.post("/drive/watch", async (req, res) => {
  // Drive sends an X-Goog-Resource-State header on every change.
  if (req.headers["x-goog-resource-state"] === "sync") return res.sendStatus(200);
  res.sendStatus(200);

  // 1. List files in the watched folder ordered by createdTime desc
  const list = await fetch(
    "https://www.googleapis.com/drive/v3/files?" + new URLSearchParams({
      q: `'${process.env.DRIVE_FOLDER_ID}' in parents and (mimeType contains 'audio/' or mimeType contains 'video/')`,
      orderBy: "createdTime desc",
      fields: "files(id,name,mimeType,createdTime,webViewLink)",
      pageSize: "20",
    }),
    { headers: { Authorization: `Bearer ${process.env.GOOGLE_OAUTH_TOKEN}` } }
  ).then(r => r.json());

  // 2. For each new file, forward to Speak's Drive upload endpoint
  for (const file of list.files) {
    if (lastSeenIds.has(file.id)) continue;
    lastSeenIds.add(file.id);

    await fetch("https://api.speakai.co/v1/integration/googledrive/upload", {
      method: "POST",
      headers: {
        "x-speakai-key": process.env.SPEAK_API_KEY,
        "Content-Type": "application/json",
      },
      body: JSON.stringify({
        url: `https://drive.google.com/file/d/${file.id}/view`,
        sourceLanguage: "en-US",
        folderId: process.env.SPEAK_FOLDER_ID,
      }),
    });
  }
});

app.listen(3000);

import os, requests
from fastapi import FastAPI, Request

app = FastAPI()
seen_ids = set()  # use a real DB in production

@app.post("/drive/watch")
async def watch(req: Request):
    if req.headers.get("x-goog-resource-state") == "sync":
        return {"ok": True}

    list_resp = requests.get(
        "https://www.googleapis.com/drive/v3/files",
        params={
            "q": f"'{os.environ['DRIVE_FOLDER_ID']}' in parents "
                 "and (mimeType contains 'audio/' or mimeType contains 'video/')",
            "orderBy": "createdTime desc",
            "fields": "files(id,name,mimeType,createdTime,webViewLink)",
            "pageSize": "20",
        },
        headers={"Authorization": f"Bearer {os.environ['GOOGLE_OAUTH_TOKEN']}"},
        timeout=30,
    ).json()

    for f in list_resp.get("files", []):
        if f["id"] in seen_ids:
            continue
        seen_ids.add(f["id"])

        requests.post(
            "https://api.speakai.co/v1/integration/googledrive/upload",
            headers={"x-speakai-key": os.environ["SPEAK_API_KEY"]},
            json={
                "url": f"https://drive.google.com/file/d/{f['id']}/view",
                "sourceLanguage": "en-US",
                "folderId": os.environ.get("SPEAK_FOLDER_ID"),
            },
            timeout=30,
        )
    return {"ok": True}

# 1. Fire the prompt against the media imported in Tab 1
curl -X POST https://api.speakai.co/v1/prompt/ 
  -H "x-speakai-key: $SPEAK_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "mediaIds": ["14c8dd9c0a89"],
    "prompt": "List every objection raised by the customer with a timestamp.",
    "isStream": false,
    "isIndividualPrompt": true
  }'

# Response (immediate):
# { "status": "success", "data": { "messageId": "", "state": "processing" } }

# 2. Poll for the completed answer (typical 2-3 seconds)
curl "https://api.speakai.co/v1/prompt/messages?mediaIds=14c8dd9c0a89&pageSize=1" 
  -H "x-speakai-key: $SPEAK_API_KEY"

# When state === "completed", the answer field has the structured response.

async function chatWithDriveFile(mediaId, prompt) {
  const headers = { "x-speakai-key": process.env.SPEAK_API_KEY };

  // 1. Fire
  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,
    }),
  });

  // 2. Poll until completed
  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") return msg.answer;
  }
  return null;
}

# Claude Desktop / Claude Code
npx @speakai/mcp-server init

# Enganxa la teva clau de l’API de Speak quan se’t demani. La configuració triga aproximadament 2 minuts.

# Claude.ai (web) i 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