TwinMind Core Workflow A: Meeting Transcription & Summary

Contents

• Overview
• Prerequisites
• Instructions
• Output
• Error Handling
• Examples
• Resources

Overview

Primary workflow for capturing meetings, generating transcripts with speaker diarization, and creating AI summaries with action items.

Prerequisites

• Completed twinmind-install-auth setup
• TwinMind Pro/Enterprise for API access
• Valid API credentials configured
• Audio source available (live or file)

Instructions

Step 1: Initialize Meeting Capture

Build a MeetingCapture class with startLiveCapture() for real-time recording and transcribeRecording() for file-based transcription. Use Ear-3 model with auto language detection and speaker diarization.

Step 2: Generate AI Summary

Create a SummaryGenerator with generateSummary() (brief/detailed/bullet-points formats), generateFollowUpEmail(), and generateMeetingNotes() methods.

Step 3: Handle Speaker Identification

Build a SpeakerManager that extracts speakers from transcript segments, calculates speaking time per speaker, and optionally matches speakers to calendar attendees.

Step 4: Orchestrate Complete Workflow

Wire everything together in processMeeting(): transcribe audio, then generate summary and identify speakers in parallel, optionally produce follow-up email and meeting notes.

See detailed implementation for complete MeetingCapture, SummaryGenerator, SpeakerManager, and orchestration code.

Output

• Complete meeting transcript with timestamps
• Speaker-labeled segments
• AI-generated summary
• Extracted action items with assignees
• Optional follow-up email draft
• Optional formatted meeting notes

Error Handling

Examples

Basic usage: Apply twinmind core workflow a to a

TwinMind Core Workflow B: Action Items & Follow-ups

Contents

• Overview
• Prerequisites
• Instructions
• Output
• Error Handling
• Examples
• Resources

Overview

Secondary workflow for extracting action items with priority/assignee inference, automating follow-up emails, and syncing tasks to project management tools (Asana, Linear, Jira).

Prerequisites

• Completed twinmind-core-workflow-a (transcription)
• Valid transcript or summary available
• Integration tokens for external services (optional)

Instructions

Step 1: Extract Action Items

Build ActionItemExtractor that calls TwinMind's /extract/action-items endpoint with options for context inclusion, speaker-based assignment, and due date inference. Auto-classify priority (high/medium/low) from keywords and categorize items (Review, Development, Communication, Meetings, Documentation).

Step 2: Automate Follow-up Emails

Create FollowUpAutomation with generateFollowUp() (AI-generated email with summary + action items), sendFollowUp() (immediate send), and scheduleFollowUp() (delayed send).

Step 3: Integrate with Task Management

Implement a TaskIntegration interface with createTask() and updateTask(). Build concrete integrations for Asana (REST API) and Linear (GraphQL) with priority mapping. Use factory pattern via getTaskIntegration().

Step 4: Orchestrate Complete Follow-up

Wire everything in runFollowUpWorkflow(): extract action items, create tasks in external system, then send or schedule follow-up email to attendees.

See detailed implementation for complete ActionItemExtractor, FollowUpAutomation, task integrations, and orchestration code.

Output

• Extracted action items with assignees and due dates
• Tasks created in project management tool
• Follow-up email sent or scheduled
• Complete audit trail

Error Handling

Examples

Basic usage: Apply t

TwinMind Cost Tuning

Overview

Optimize TwinMind costs across Free, Pro ($10/mo), and Enterprise tiers with usage monitoring and tier selection guidance. TwinMind uses the Ear-3 speech model (5.26% WER, 3.8% DER) for transcription, with GPT-4, Claude, and Gemini for AI summarization.

Prerequisites

• TwinMind account (Free, Pro $10/mo, or Enterprise)
• Chrome extension installed and authenticated
• Understanding of TwinMind workflow

Instructions

Step 1: Setup

TwinMind operates as a Chrome extension and mobile app with optional API access for Pro/Enterprise users.

// TwinMind configuration
const config = {
  apiKey: process.env.TWINMIND_API_KEY,
  model: "ear-3", // Transcription model
  aiModels: ["gpt-4", "claude", "gemini"], // Summary models
};

Step 2: Implementation

// TwinMind Cost Tuning implementation
// Core TwinMind integration
const twinmind = {
  transcriptionModel: "ear-3",
  languages: ["en", "es", "ko", "ja", "fr"],
  features: ["transcription", "summary", "action-items"],
  privacyMode: "on-device", // Audio never stored
};

// Check transcription capabilities
async function verify() {
  const health = await fetch("https://api.twinmind.com/v1/health");
  console.log("TwinMind status:", await health.json());
}

Step 3: Verification

# Verify TwinMind integration
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health | jq .

Key TwinMind Specifications

Output

• TwinMind Cost Tuning configured and verified
• TwinMind integration operational
• Meeting transcription workflow ready

Error Handling

// TwinMind configuration
const config = {
  apiKey: process.env.TWINMIND_API_KEY,
  model: "ear-3", // Transcription model
  aiModels: ["gpt-4", "claude", "gemini"], // Summary models
};

// TwinMind Data Handling implementation
// Core TwinMind integration
const twinmind = {
  transcriptionModel: "ear-3",
  languages: ["en", "es", "ko", "ja", "fr"],
  features: ["transcription", "summary", "action-items"],
  privacyMode: "on-device", // Audio never stored
};

// Check transcription capabilities
async function verify() {
  const health = await fetch("https://api.twinmind.com/v1/health");
  console.log("TwinMind status:", await health.json());
}

# Verify TwinMind integration
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health | jq .

Output

• TwinMind Data Handling configured and verified
• TwinMind integration operational
• Meeting transcription workflow ready

Error Handling

// scripts/twinmind-debug-bundle.ts
import * as fs from 'fs';
import * as os from 'os';
import * as path from 'path';

interface DebugBundle {
  timestamp: string;
  environment: EnvironmentInfo;
  apiStatus: ApiStatus;
  recentErrors: ErrorEntry[];
  configuration: ConfigSnapshot;
  networkTests: NetworkTest[];
}

interface EnvironmentInfo {
  nodeVersion: string;
  platform: string;
  arch: string;
  osRelease: string;
  timezone: string;
  memory: {
    total: number;
    free: number;
    used: number;
  };
}

interface ApiStatus {
  healthy: boolean;
  latencyMs: number;
  endpoint: string;
  responseHeaders?: Record<string, string>;
}

interface ErrorEntry {
  timestamp: string;
  type: string;
  message: string;
  stack?: string;
  context?: Record<string, any>;
}

interface ConfigSnapshot {
  apiKeyPresent: boolean;
  apiKeyPrefix: string;
  baseUrl: string;
  timeout: number;
  environment: string;
}

interface NetworkTest {
  endpoint: string;
  reachable: boolean;
  latencyMs?: number;
  error?: string;
}

export async function generateDebugBundle(): Promise<DebugBundle> {
  const bundle: DebugBundle = {
    timestamp: new Date().toISOString(),
    environment: getEnvironmentInfo(),
    apiStatus: await checkApiStatus(),
    recentErrors: collectRecentErrors(),
    configuration: getConfigSnapshot(),
    networkTests: await runNetworkTests(),
  };

  return bundle;
}

function getEnvironmentInfo(): EnvironmentInfo {
  return {
    nodeVersion: process.version,
    platform: os.platform(),
    arch: os.arch(),
    osRelease: os.release(),
    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
    memory: {
      total: os.totalmem(),
      free: os.freemem(),
      used: os.totalmem() - os.freemem(),
    },
  };
}

async function checkApiStatus(): Promise<ApiStatus> {
  const endpoint = process.env.TWINMIND_API_URL || 'https://api.twinmind.com/v1';
  const start = Date.now();

  try {
    const response = await fetch(`${endpoint}/health`, {
      headers: {
        'Authorization': `Bearer ${process.env.TWINMIND_API_KEY}`,
      },
    });

    return {
      healthy: response.ok,
      latencyMs: Date.now() - start,
      endpoint,
      responseHeaders: Object.fromEntries(response.headers.entries()),
    };
  } catch (error: any) {
    return {
      healthy: false,
      latencyMs: Date.now() 

# TwinMind API access (Pro/Enterprise)
export TWINMIND_API_KEY="your-api-key"
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health
# Expected: {"status": "ok"}

// TwinMind Deploy Integration implementation
// Core TwinMind integration
const twinmind = {
  transcriptionModel: "ear-3",
  languages: ["en", "es", "ko", "ja", "fr"],
  features: ["transcription", "summary", "action-items"],
  privacyMode: "on-device", // Audio never stored
};

// Check transcription capabilities
async function verify() {
  const health = await fetch("https://api.twinmind.com/v1/health");
  console.log("TwinMind status:", await health.json());
}

# Verify TwinMind integration
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health | jq .

// TwinMind configuration
const config = {
  apiKey: process.env.TWINMIND_API_KEY,
  model: "ear-3", // Transcription model
  aiModels: ["gpt-4", "claude", "gemini"], // Summary models
};

// TwinMind Enterprise RBAC implementation
// Enterprise tier features
const twinmind = {
  ssoProvider: "okta",
  teamSharing: true,
  customModels: ["gpt-4-turbo"],
  onPremise: true,
};

// Configure team access
async function configureTeam() {
  const team = await twinmind.createTeam({ name: "Engineering", members: ["user1", "user2"] });
  console.log("Team configured:", team.id);
}

# Verify TwinMind enterprise setup
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/team/members | jq .

"Welcome to today's project status meeting.
We have three items on the agenda.

First, the mobile app launch is scheduled for next Friday.
Sarah will handle the App Store submission.

Second, we need to review the Q1 budget.
John, please send the spreadsheet by Wednesday.

Third, the customer feedback survey shows 85% satisfaction.
We should schedule a follow-up meeting next week to discuss improvements."

[00:00] Welcome to today's project status meeting...
[00:05] We have three items on the agenda...
[00:12] First, the mobile app launch is scheduled for next Friday...
[00:18] Sarah will handle the App Store submission...

## Meeting Summary
Project status meeting covering mobile app launch, Q1 budget review,
and customer feedback analysis.

## Action Items
- [ ] Sarah: Submit app to App Store (Due: Friday)
- [ ] John: Send Q1 budget spreadsheet (Due: Wednesday)
- [ ] Team: Schedule follow-up meeting for feedback discussion

## Key Points
- Mobile app launching next Friday
- Customer satisfaction at 85%
- Budget review pending

// TwinMind stores transcripts in your Memory Vault
// Access via extension sidebar or ask AI:

"What did we discuss about the mobile app launch?"
"Who is responsible for the budget spreadsheet?"
"When is the next meeting scheduled?"

# TwinMind API access (Pro/Enterprise)
export TWINMIND_API_KEY="your-api-key"
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health
# Expected: {"status": "ok"}

// TwinMind Incident Runbook implementation
// Core TwinMind integration
const twinmind = {
  transcriptionModel: "ear-3",
  languages: ["en", "es", "ko", "ja", "fr"],
  features: ["transcription", "summary", "action-items"],
  privacyMode: "on-device", // Audio never stored
};

// Check transcription capabilities
async function verify() {
  const health = await fetch("https://api.twinmind.com/v1/health");
  console.log("TwinMind status:", await health.json());
}

# Verify TwinMind integration
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health | jq .

https://chromewebstore.google.com/detail/twinmind-chat-with-tabs-m/agpbjhhcmoanaljagpoheldgjhclepdj

// TwinMind automatically syncs with authorized calendars
// After OAuth, meetings appear in the extension sidebar

// Calendar integration provides:
// - Meeting participant names
// - Meeting agenda/description
// - Automatic transcription start/stop

https://apps.apple.com/us/app/twinmind-ai-notes-memory/id6504585781

https://play.google.com/store/apps/details?id=ai.twinmind.android

set -euo pipefail
# Set environment variable for API access
export TWINMIND_API_KEY="your-api-key"

# Or create .env file
echo 'TWINMIND_API_KEY=your-api-key' >> .env

# Verify API access
curl -H "Authorization: Bearer $TWINMIND_API_KEY" \
  https://api.twinmind.com/v1/health

// Test transcription with a short recording
// 1. Start a test meeting or voice memo
// 2. Click TwinMind extension
// 3. Click "Start Transcribing"
// 4. Speak for 10-15 seconds
// 5. Click "Stop" and verify transcript appears

set -euo pipefail
# Create project directory
mkdir twinmind-integration && cd twinmind-integration

# Initialize Node.js project
npm init -y

# Install dependencies
npm install dotenv axios zod typescript ts-node @types/node

# Initialize TypeScript
npx tsc --init

# Create environment file
cat > .env << 'EOF'
TWINMIND_API_KEY=your-api-key-here
TWINMIND_API_URL=https://api.twinmind.com/v1
TWINMIND_WEBHOOK_SECRET=your-webhook-secret
NODE_ENV=development
EOF

# Add to .gitignore
echo ".env" >> .gitignore
echo "node_modules" >> .gitignore

// src/twinmind/client.ts
import axios, { AxiosInstance } from 'axios';
import { z } from 'zod';

// Response schemas
const TranscriptSchema = z.object({
  id: z.string(),
  text: z.string(),
  duration_seconds: z.number(),
  language: z.string(),
  speakers: z.array(z.object({
    id: z.string(),
    name: z.string().optional(),
    segments: z.array(z.object({
      start: z.number(),
      end: z.number(),
      text: z.string(),
      confidence: z.number(),
    })),
  })),
  created_at: z.string(),
});

const SummarySchema = z.object({
  id: z.string(),
  transcript_id: z.string(),
  summary: z.string(),
  action_items: z.array(z.object({
    text: z.string(),
    assignee: z.string().optional(),
    due_date: z.string().optional(),
  })),
  key_points: z.array(z.string()),
});

export type Transcript = z.infer<typeof TranscriptSchema>;
export type Summary = z.infer<typeof SummarySchema>;

export class TwinMindClient {
  private client: AxiosInstance;

  constructor(apiKey: string, baseUrl?: string) {
    this.client = axios.create({
      baseURL: baseUrl || 'https://api.twinmind.com/v1',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json',
      },
      timeout: 30000,  # 30000: 30 seconds in ms
    });
  }

  async healthCheck(): Promise<boolean> {
    const response = await this.client.get('/health');
    return response.status === 200;  # HTTP 200 OK
  }

  async transcribe(audioUrl: string, options?: {
    language?: string;
    diarization?: boolean;
    model?: 'ear-3' | 'ear-2';
  }): Promise<Transcript> {
    const response = await this.client.post('/transcribe', {
      audio_url: audioUrl,
      la

// TwinMind configuration
const config = {
  apiKey: process.env.TWINMIND_API_KEY,
  model: "ear-3", // Transcription model
  aiModels: ["gpt-4", "claude", "gemini"], // Summary models
};

// TwinMind Migration Deep Dive implementation
// Enterprise tier features
const twinmind = {
  ssoProvider: "okta",
  teamSharing: true,
  customModels: ["gpt-4-turbo"],
  onPremise: true,
};

// Configure team access
async function configureTeam() {
  const team = await twinmind.createTeam({ name: "Engineering", members: ["user1", "user2"] });
  console.log("Team configured:", team.id);
}

# Verify TwinMind enterprise setup
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/team/members | jq .

// TwinMind configuration
const config = {
  apiKey: process.env.TWINMIND_API_KEY,
  model: "ear-3", // Transcription model
  aiModels: ["gpt-4", "claude", "gemini"], // Summary models
};

// TwinMind Multi-Environment Setup implementation
// Enterprise tier features
const twinmind = {
  ssoProvider: "okta",
  teamSharing: true,
  customModels: ["gpt-4-turbo"],
  onPremise: true,
};

// Configure team access
async function configureTeam() {
  const team = await twinmind.createTeam({ name: "Engineering", members: ["user1", "user2"] });
  console.log("Team configured:", team.id);
}

# Verify TwinMind enterprise setup
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/team/members | jq .

# TwinMind API access (Pro/Enterprise)
export TWINMIND_API_KEY="your-api-key"
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health
# Expected: {"status": "ok"}

// TwinMind Observability implementation
// Core TwinMind integration
const twinmind = {
  transcriptionModel: "ear-3",
  languages: ["en", "es", "ko", "ja", "fr"],
  features: ["transcription", "summary", "action-items"],
  privacyMode: "on-device", // Audio never stored
};

// Check transcription capabilities
async function verify() {
  const health = await fetch("https://api.twinmind.com/v1/health");
  console.log("TwinMind status:", await health.json());
}

# Verify TwinMind integration
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health | jq .

// TwinMind configuration
const config = {
  apiKey: process.env.TWINMIND_API_KEY,
  model: "ear-3", // Transcription model
  aiModels: ["gpt-4", "claude", "gemini"], // Summary models
};

// TwinMind Performance Tuning implementation
// Core TwinMind integration
const twinmind = {
  transcriptionModel: "ear-3",
  languages: ["en", "es", "ko", "ja", "fr"],
  features: ["transcription", "summary", "action-items"],
  privacyMode: "on-device", // Audio never stored
};

// Check transcription capabilities
async function verify() {
  const health = await fetch("https://api.twinmind.com/v1/health");
  console.log("TwinMind status:", await health.json());
}

# Verify TwinMind integration
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health | jq .

## Authentication
- [ ] Production API key generated (separate from dev/staging)
- [ ] API key stored in secrets manager (not env vars)
- [ ] API key rotation procedure documented
- [ ] Webhook secrets configured
- [ ] All OAuth tokens refreshed and valid

## Security
- [ ] HTTPS enforced on all endpoints
- [ ] Webhook signature verification enabled
- [ ] CORS configured correctly
- [ ] Rate limiting implemented
- [ ] Input validation on all endpoints
- [ ] SQL injection protection verified
- [ ] XSS protection enabled
- [ ] CSP headers configured

## Data Protection
- [ ] Transcripts encrypted at rest (AES-256)  # 256 bytes
- [ ] PII redaction enabled and tested
- [ ] Data retention policies configured
- [ ] Backup encryption verified
- [ ] Data residency requirements met

## Privacy Compliance
- [ ] GDPR compliance verified (if applicable)
- [ ] User consent flow implemented
- [ ] Data deletion API integrated
- [ ] Privacy policy updated
- [ ] Cookie consent banner (if applicable)

## Audit Trail
- [ ] Audit logging enabled for all operations
- [ ] Log retention configured
- [ ] Sensitive data excluded from logs
- [ ] Log access restricted

## Compute
- [ ] Auto-scaling configured
- [ ] Health checks enabled
- [ ] Graceful shutdown implemented
- [ ] Resource limits set (CPU, memory)
- [ ] Container security scanned

## Networking
- [ ] Load balancer configured
- [ ] TLS 1.3 enforced
- [ ] DNS records verified
- [ ] CDN configured (if applicable)
- [ ] Firewall rules reviewed

## Storage
- [ ] Database backups automated
- [ ] Storage encryption enabled
- [ ] Disaster recovery plan tested
- [ ] Data migration scripts ready

## Metrics
- [ ] Prometheus/Datadog metrics configured
- [ ] Custom TwinMind metrics added:
  - [ ] twinmind_transcriptions_total
  - [ ] twinmind_transcription_duration_seconds
  - [ ] twinmind_errors_total
  - [ ] twinmind_api_latency_seconds
- [ ] Dashboards created

## Alerting
- [ ] Alert rules configured:
  - [ ] Error rate > 5%
  - [ ] P95 latency > 5s
  - [ ] Rate limit warnings
  - [ ] API availability
- [ ] On-call rotation set up
- [ ] Escalation policy defined

## Logging
- [ ] Structured logging implemented
- [ ] Log levels configured (INFO in prod)
- [ ] Log aggregation set up
- [ ] Log-based alerts configured

## Tracing
- [ ] Distributed tracing

// src/twinmind/rate-limit.ts
interface RateLimitConfig {
  maxRetries: number;
  baseDelayMs: number;
  maxDelayMs: number;
  jitterMs: number;
}

const defaultConfig: RateLimitConfig = {
  maxRetries: 5,
  baseDelayMs: 1000,  # 1000: 1 second in ms
  maxDelayMs: 60000, // Max 1 minute  # 60000: 1 minute in ms
  jitterMs: 500,  # HTTP 500 Internal Server Error
};

export async function withRateLimit<T>(
  operation: () => Promise<T>,
  config: Partial<RateLimitConfig> = {}
): Promise<T> {
  const { maxRetries, baseDelayMs, maxDelayMs, jitterMs } = {
    ...defaultConfig,
    ...config,
  };

  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error: any) {
      if (attempt === maxRetries) throw error;

      const status = error.response?.status;
      if (status !== 429 && status !== 503) throw error; // Only retry on rate limits  # 503: HTTP 429 Too Many Requests

      // Check Retry-After header
      const retryAfter = error.response?.headers?.['retry-after'];
      let delay: number;

      if (retryAfter) {
        delay = parseInt(retryAfter) * 1000;  # 1 second in ms
      } else {
        // Exponential backoff with jitter
        const exponential = baseDelayMs * Math.pow(2, attempt);
        const jitter = Math.random() * jitterMs;
        delay = Math.min(exponential + jitter, maxDelayMs);
      }

      console.log(`Rate limited (attempt ${attempt + 1}). Waiting ${delay}ms...`);
      await new Promise(r => setTimeout(r, delay));
    }
  }

  throw new Error('Max retries exceeded');
}

// src/twinmind/queue.ts
import PQueue from 'p-queue';

// TwinMind configuration
const config = {
  apiKey: process.env.TWINMIND_API_KEY,
  model: "ear-3", // Transcription model
  aiModels: ["gpt-4", "claude", "gemini"], // Summary models
};

// TwinMind Reference Architecture implementation
// Core TwinMind integration
const twinmind = {
  transcriptionModel: "ear-3",
  languages: ["en", "es", "ko", "ja", "fr"],
  features: ["transcription", "summary", "action-items"],
  privacyMode: "on-device", // Audio never stored
};

// Check transcription capabilities
async function verify() {
  const health = await fetch("https://api.twinmind.com/v1/health");
  console.log("TwinMind status:", await health.json());
}

# Verify TwinMind integration
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health | jq .

import requests
import os

class TwinMindClient:
    def __init__(self, api_key: str = None, base_url: str = "https://api.twinmind.com/v1"):
        self.api_key = api_key or os.environ["TWINMIND_API_KEY"]
        self.base_url = base_url
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        })

    def _request(self, method: str, path: str, **kwargs):
        response = self.session.request(method, f"{self.base_url}{path}", **kwargs)
        response.raise_for_status()
        return response.json()

class TwinMindClient:
    # ... (continued from Step 1)

    def store_memory(self, content: str, context: dict = None, tags: list = None) -> dict:
        return self._request("POST", "/memories", json={
            "content": content,
            "context": context or {},
            "tags": tags or [],
            "timestamp": datetime.utcnow().isoformat()
        })

    def search_memories(self, query: str, limit: int = 10, tags: list = None) -> list:
        params = {"q": query, "limit": limit}
        if tags:
            params["tags"] = ",".join(tags)
        return self._request("GET", "/memories/search", params=params)

    def get_memory(self, memory_id: str) -> dict:
        return self._request("GET", f"/memories/{memory_id}")

    def create_meeting_context(self, meeting_id: str, transcript: str, participants: list) -> dict:
        return self._request("POST", "/contexts/meeting", json={
            "meeting_id": meeting_id,
            "transcript": transcript,
            "participants": participants,
            "extract_action_items": True,
            "extract_decisions": True
        })

    def get_meeting_insights(self, meeting_id: str) -> dict:
        return self._request("GET", f"/contexts/meeting/{meeting_id}/insights")

                

                  
                    
                  
                  twinmind-security-basics
                  View full skill →
                
                

                  
'Security best practices for TwinMind: on-device audio processing, encrypted.
                  

                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                

                  
TwinMind Security Basics
Overview
Security best practices for TwinMind: on-device audio processing, encrypted cloud backups, microphone permissions, and data privacy controls. TwinMind uses the Ear-3 speech model (5.26% WER, 3.8% DER) for transcription, with GPT-4, Claude, and Gemini for AI summarization.
Prerequisites

TwinMind account (Free, Pro $10/mo, or Enterprise)
Chrome extension installed and authenticated
Understanding of TwinMind workflow

Instructions
Step 1: Setup
TwinMind operates as a Chrome extension and mobile app with optional API access for Pro/Enterprise users.

// TwinMind configuration
const config = {
  apiKey: process.env.TWINMIND_API_KEY,
  model: "ear-3", // Transcription model
  aiModels: ["gpt-4", "claude", "gemini"], // Summary models
};

Step 2: Implementation

// TwinMind Security Basics implementation
// Core TwinMind integration
const twinmind = {
  transcriptionModel: "ear-3",
  languages: ["en", "es", "ko", "ja", "fr"],
  features: ["transcription", "summary", "action-items"],
  privacyMode: "on-device", // Audio never stored
};

// Check transcription capabilities
async function verify() {
  const health = await fetch("https://api.twinmind.com/v1/health");
  console.log("TwinMind status:", await health.json());
}

Step 3: Verification

# Verify TwinMind integration
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health | jq .

Key TwinMind Specifications

// scripts/usage-audit.ts
import { getTwinMindClient } from '../src/twinmind/client';

async function auditUsage() {
  const client = getTwinMindClient();

  // Get current plan info
  const account = await client.get('/account');
  console.log('Current Plan:', account.data.plan);
  console.log('Plan Started:', account.data.plan_started_at);

  // Get usage statistics
  const usage = await client.get('/usage', {
    params: {
      period: 'last_30_days',
    },
  });

  console.log('\n=== Usage Summary (Last 30 Days) ===');
  console.log(`Transcription Hours: ${usage.data.transcription_hours}`);
  console.log(`API Requests: ${usage.data.api_requests}`);
  console.log(`AI Tokens Used: ${usage.data.ai_tokens_used}`);
  console.log(`Storage Used: ${usage.data.storage_mb} MB`);

  // Check if hitting limits
  const limits = await client.get('/account/limits');
  console.log('\n=== Current Limits ===');
  console.log(`Rate Limit: ${limits.data.rate_limit_per_minute}/min`);
  console.log(`Concurrent Jobs: ${limits.data.concurrent_transcriptions}`);
  console.log(`Context Tokens: ${limits.data.context_tokens}`);

  // Recommendations
  console.log('\n=== Upgrade Recommendations ===');
  if (usage.data.api_requests > 0 && account.data.plan === &

// TwinMind configuration
const config = {
  apiKey: process.env.TWINMIND_API_KEY,
  model: "ear-3", // Transcription model
  aiModels: ["gpt-4", "claude", "gemini"], // Summary models
};

// TwinMind Webhooks & Events implementation
// Core TwinMind integration
const twinmind = {
  transcriptionModel: "ear-3",
  languages: ["en", "es", "ko", "ja", "fr"],
  features: ["transcription", "summary", "action-items"],
  privacyMode: "on-device", // Audio never stored
};

// Check transcription capabilities
async function verify() {
  const health = await fetch("https://api.twinmind.com/v1/health");
  console.log("TwinMind status:", await health.json());
}

# Verify TwinMind integration
curl -H "Authorization: Bearer $TWINMIND_API_KEY" https://api.twinmind.com/v1/health | jq .