Google Drive AI : transcrivez, résumez et discutez avec n’importe quel fichier Drive

# Dans le tableau de bord Speak AI :
# 1. Allez à Paramètres -> Intégrations -> Google Drive
# 2. Cliquez sur « Connecter Google Drive »
# 3. Approuvez l'accès OAuth en lecture seule aux fichiers que vous sélectionnez
# 4. Speak stocke le jeton OAuth de manière sécurisée de son côté

# Ou appuyez sur le point de terminaison de connexion par programmation avec un code Google Drive OAuth :
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"
  }'

# Formats d’URL acceptés :
#   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 analyse l’ID du fichier, récupère les métadonnées via l’API Drive,
# obtient une URL de téléchargement actualisée via le jeton OAuth stocké de l’utilisateur,
# puis envoie à Speak pour la transcription et l’analyse.

// Utilise ceci dans votre CRM, planificateur ou serveur de pipeline de recherche.
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"]

# Notifications Drive Push - surveillez un dossier pour les nouveaux fichiers.
# Portée requise : drive.readonly (ou drive.file pour les fichiers sélectionnés par le sélecteur).

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"
  }'

# Le canal expire après 7 jours. Renouvelez avec un autre POST à /watch.
# Quand un changement se produit, Drive envoie une requête POST à votre adresse avec l’en-tête X-Goog-Resource-State.
# Votre gestionnaire liste ensuite les fichiers du dossier via files.list et transfère les nouveaux.

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. Lancez l’invite contre le média importé dans l’onglet 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
  }’

# Réponse (immédiate) :
# { "status": "success", "data": { "messageId": "", "state": "processing" } }

# 2. Interrogez la réponse complétée (généralement 2-3 secondes)
curl "https://api.speakai.co/v1/prompt/messages?mediaIds=14c8dd9c0a89&pageSize=1" 
  -H "x-speakai-key: $SPEAK_API_KEY"

# Quand state === "completed", le champ answer contient la réponse structurée.

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

# Collez votre clé API Speak lorsque vous y êtes invité. La configuration prend environ 2 minutes.

# Claude.ai (web) et connecteur ChatGPT MCP
# Paramètres > Intégrations > Ajouter serveur MCP
# URL distante :    https://api.speakai.co/v1/mcp
# En-tête d'authentification :   x-speakai-key: YOUR_SPEAK_API_KEY