twinmind-migration-deep-dive

name	twinmind-migration-deep-dive
description	Comprehensive migration guide from other meeting AI tools to TwinMind. Use when migrating from Otter.ai, Fireflies, Rev, or other transcription services. Trigger with phrases like "migrate to twinmind", "switch from otter", "twinmind migration", "move to twinmind", "replace fireflies".
allowed-tools	Read, Write, Edit, Bash(npm:*), Grep
version	1.0.0
license	MIT
author	Jeremy Longshore <[e-mail]>

TwinMind Migration Deep Dive

Overview

Comprehensive guide for migrating from other meeting AI services to TwinMind.

Prerequisites

• TwinMind Pro/Enterprise account
• Export access on source platform
• Understanding of data formats
• Sufficient storage for migration

Supported Migration Sources

Source	Export Format	API Available	Difficulty
Otter.ai	TXT, JSON	Limited	Medium
Fireflies.ai	JSON, CSV	Yes	Easy
Rev.ai	JSON	Yes	Easy
Trint	DOCX, JSON	Yes	Medium
Descript	JSON	Yes	Medium
Zoom transcripts	VTT, TXT	Yes	Easy
Google Meet	SRT	Limited	Medium
Microsoft Teams	DOCX, VTT	Yes	Medium
Grain	JSON	Yes	Easy
Chorus.ai	JSON	Limited	Hard

Instructions

Step 1: Assess Current Data

// scripts/migration-assessment.ts
import * as fs from 'fs';
import * as path from 'path';

interface MigrationAssessment {
  source: string;
  totalTranscripts: number;
  totalDurationHours: number;
  dateRange: { earliest: Date; latest: Date };
  dataFormats: string[];
  estimatedMigrationTime: string;
  potentialIssues: string[];
}

async function assessMigration(
  source: 'otter' | 'fireflies' | 'rev' | 'zoom' | 'teams',
  dataPath: string
): Promise<MigrationAssessment> {
  const files = fs.readdirSync(dataPath);
  const issues: string[] = [];

  let totalTranscripts = 0;
  let totalDuration = 0;
  let earliest = new ();
   latest =  ();
   formats =  <>();

   ( file  files) {
     ext = path.(file).();
    formats.(ext);

     filePath = path.(dataPath, file);
     stat = fs.(filePath);

     (ext === ) {
       {
         content = .(fs.(filePath, ));
        totalTranscripts++;

        
         (content.) {
          totalDuration += content.;
        }

        
         date =  (content. || content. || stat.);
         (date < earliest) earliest = date;
         (date > latest) latest = date;
      }  (e) {
        issues.();
      }
    }
  }

  
   estimatedMinutes = .(totalTranscripts / ) + .(totalDuration /  * );

   {
    source,
    totalTranscripts,
    : totalDuration / ,
    : { earliest, latest },
    : .(formats),
    : ,
    : issues,
  };
}


 assessment =  (, );
.();
.(.(assessment, , ));

Step 2: Export Data from Source

Otter.ai Export

// scripts/exporters/otter.ts
import puppeteer from 'puppeteer';

async function exportFromOtter(credentials: { email: string; password: string }) {
  const browser = await puppeteer.launch({ headless: false });
  const page = await browser.newPage();

  // Login
  await page.goto('https://otter.ai/login');
  await page.type('input[name="email"]', credentials.email);
  await page.type('input[name="password"]', credentials.password);
  await page.click('button[type="submit"]');
  await page.waitForNavigation();

  // Navigate to conversations
  await page.goto('https://otter.ai/my-notes');
  await page.waitForSelector('.conversation-list');

  // Get all conversation IDs
  const conversationIds = await page.$$eval(
    '.conversation-item',
    items => items.( item.())
  );

  .();

  
    = [];
   ( id  conversationIds) {
     data =  page.( (convId) => {
       response =  ();
       response.();
    }, id);

    .(data);
  }

   browser.();
   ;
}

Fireflies.ai Export

// scripts/exporters/fireflies.ts
const FIREFLIES_API_URL = 'https://api.fireflies.ai/graphql';

async function exportFromFireflies(apiKey: string): Promise<any[]> {
  const query = `
    query GetAllTranscripts {
      transcripts {
        id
        title
        date
        duration
        transcript_text
        summary
        action_items {
          text
          assignee
        }
        speakers {
          name
          id
        }
        sentences {
          text
          speaker_id
          start_time
          end_time
        }
      }
    }
  `;

  const response = await fetch(FIREFLIES_API_URL, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ query }),
  });

  const data = await response.json();
  return data.data.transcripts;
}

Rev.ai Export

// scripts/exporters/rev.ts
async function exportFromRev(apiKey: string): Promise<any[]> {
  // Get all jobs
  const jobsResponse = await fetch('https://api.rev.ai/speechtotext/v1/jobs', {
    headers: { 'Authorization': `Bearer ${apiKey}` },
  });

  const jobs = await jobsResponse.json();
  const transcripts = [];

  for (const job of jobs) {
    if (job.status === 'transcribed') {
      // Get transcript
      const transcriptResponse = await fetch(
        `https://api.rev.ai/speechtotext/v1/jobs/${job.id}/transcript`,
        {
          headers: {
            'Authorization': `Bearer ${apiKey}`,
            'Accept': 'application/vnd.rev.transcript.v1.0+json',
          },
        }
      );

      const transcript = await transcriptResponse.json();
      transcripts.push({
        id: job.id,
        name: job.name,
        : job.,
        : job.,
        transcript,
      });
    }
  }

   transcripts;
}

Step 3: Transform Data to TwinMind Format

// scripts/migration/transform.ts
import { Transcript, Segment, Speaker } from '../../src/twinmind/types';

interface TransformOptions {
  preserveTimestamps: boolean;
  preserveSpeakers: boolean;
  generateNewIds: boolean;
}

// Otter.ai to TwinMind
export function transformOtterToTwinMind(otterData: any): Transcript {
  return {
    id: `tm_imported_${otterData.id}`,
    text: otterData.text || otterData.transcript_text,
    duration_seconds: otterData.duration || 0,
    language: otterData.language || 'en',
    created_at: otterData.created_at || new Date().toISOString(),
    metadata: {
      imported_from: 'otter.ai',
      original_id: otterData.id,
    },
    speakers: otterData.speakers?.map((: , : ) => ({
      : ,
      : s. || s. || ,
    })),
    : otterData.?.( ({
      : seg. || seg.,
      : seg. || seg.,
      : seg. || seg.,
      : seg.,
      : seg. || ,
    })),
  };
}


  ():  {
   {
    : ,
    : ffData.,
    : ffData.,
    : ffData.,
    : ,  
    : ffData.,
    : {
      : ,
      : ffData.,
      : ffData.,
      : ffData.,
    },
    : ffData.?.( ({
      : s.,
      : s.,
    })),
    : ffData.?.( ({
      : sent.,
      : sent.,
      : sent.,
      : sent.,
      : ,
    })),
  };
}


  ():  {
   monologues = revData.. || [];

   : [] = [];
   speakers =  <, >();

   ( monologue  monologues) {
     speakerId = monologue.;
     (!speakers.(speakerId)) {
      speakers.(speakerId, );
    }

     ( element  monologue.) {
       (element. === ) {
        segments.({
          : element.,
          : element.,
          : element.,
          : ,
          : element. || ,
        });
      }
    }
  }

   {
    : ,
    : revData.,
    : segments.( s.).(),
    : revData.,
    : ,
    : revData.,
    : {
      : ,
      : revData.,
    },
    : .(speakers.()).( ({
      : ,
      name,
    })),
    segments,
  };
}


  ():  {
   : [] = [];
   lines = vttContent.();

   : <> = {};

   ( i = ; i < lines.; i++) {
     line = lines[i].();

    
     (line.()) {
       [start, end] = line.().( (t.()));
      currentSegment. = start;
      currentSegment. = end;
    }
    
      (line && !line.() && currentSegment. !== ) {
      
       speakerMatch = line.();

       (speakerMatch) {
        currentSegment. = speakerMatch[];
        currentSegment. = speakerMatch[];
      }  {
        currentSegment. = line;
      }

       (currentSegment.) {
        segments.({
          : currentSegment.,
          : currentSegment. || currentSegment. + ,
          : currentSegment.,
          : currentSegment.,
          : ,
        }  );
        currentSegment = {};
      }
    }
  }

  
   speakerIds = [... (segments.( s.).())];

   {
    : ,
    : metadata.,
    : segments.( s.).(),
    : metadata.,
    : ,
    : metadata.,
    : {
      : ,
    },
    : speakerIds.( ({ : , : id   })),
    segments,
  };
}

 ():  {
   parts = timestamp.();
   seconds = parts.()!;
   minutes = parts.() || ;
   hours = parts.() || ;

   (
    (hours) *  +
    (minutes) *  +
    (seconds)
  );
}

Step 4: Import to TwinMind

// scripts/migration/import.ts
import { getTwinMindClient } from '../../src/twinmind/client';
import { Transcript } from '../../src/twinmind/types';

interface ImportResult {
  successful: number;
  failed: number;
  errors: Array<{ id: string; error: string }>;
}

export async function importToTwinMind(
  transcripts: Transcript[],
  options: {
    batchSize?: number;
    delayMs?: number;
    dryRun?: boolean;
  } = {}
): Promise<ImportResult> {
  const client = getTwinMindClient();
  const batchSize = options.batchSize || 10;
  const delayMs = options.delayMs || 1000;

  const result: ImportResult = {
    successful: 0,
    failed: 0,
    errors: [],
  };

  console.log();

   ( i = ; i < transcripts.; i += batchSize) {
     batch = transcripts.(i, i + batchSize);

     ( transcript  batch) {
       {
         (options.) {
          .();
          result.++;
          ;
        }

        
         existing =  client.(, {
          : {
            : transcript.?.,
          },
        });

         (existing.. > ) {
          .();
          ;
        }

        
         client.(, {
          : transcript.,
          : transcript.,
          : transcript.,
          : transcript.,
          : transcript.,
          : transcript.,
          : transcript.,
          : transcript.,
        });

        result.++;
        .();
      }  (: ) {
        result.++;
        result..({
          : transcript.,
          : error.,
        });
        .();
      }
    }

    
     (i + batchSize < transcripts.) {
        ( (r, delayMs));
    }
  }

   result;
}

Step 5: Migration Verification

// scripts/migration/verify.ts
interface VerificationResult {
  sourceCount: number;
  importedCount: number;
  matchRate: number;
  missingTranscripts: string[];
  contentMismatches: Array<{
    id: string;
    issue: string;
  }>;
}

export async function verifyMigration(
  sourceTranscripts: Transcript[],
  importedIds: string[]
): Promise<VerificationResult> {
  const client = getTwinMindClient();
  const missingTranscripts: string[] = [];
  const contentMismatches: Array<{ id: string; issue: string }> = [];

  for (const source of sourceTranscripts) {
    // Find in TwinMind
    const imported = await client.get('/transcripts', {
      params: {
        'metadata.original_id': source.metadata?.,
      },
    });

     (imported.. === ) {
      missingTranscripts.(source.);
      ;
    }

     importedTranscript = imported.[];

    
     (importedTranscript. !== source.) {
       sourceWords = source..().;
       importedWords = importedTranscript..().;

       (.(sourceWords - importedWords) > sourceWords * ) {
        contentMismatches.({
          : source.,
          : ,
        });
      }
    }

    
     (.(importedTranscript. - source.) > ) {
      contentMismatches.({
        : source.,
        : ,
      });
    }
  }

   {
    : sourceTranscripts.,
    : sourceTranscripts. - missingTranscripts.,
    : (sourceTranscripts. - missingTranscripts.) / sourceTranscripts.,
    missingTranscripts,
    contentMismatches,
  };
}

Step 6: Post-Migration Checklist

## Post-Migration Checklist

### Data Verification
- [ ] All transcripts imported (compare counts)
- [ ] Spot-check 10 random transcripts for content accuracy
- [ ] Verify speaker labels preserved
- [ ] Verify timestamps are accurate
- [ ] Check metadata (dates, durations) are correct

### Feature Verification
- [ ] Search finds imported transcripts
- [ ] Summaries can be generated for imported data
- [ ] Action items can be extracted
- [ ] Calendar integration works with imported meetings

### User Acceptance
- [ ] Key users can find their transcripts
- [ ] Historical data accessible
- [ ] Reports include migrated data

### Cleanup
- [ ] Remove temporary import files
- [ ] Update user documentation
- [ ] Archive source platform export
- [ ] Cancel source platform subscription

### Performance
- [ ] Search performance acceptable with migrated data
- [ ] No increase in error rates
- [ ] Memory usage within limits

Output

• Migration assessment tool
• Platform-specific exporters
• Data transformation functions
• TwinMind import utility
• Verification scripts
• Post-migration checklist

Platform Comparison

Feature	TwinMind	Otter.ai	Fireflies
WER	5.26%	~8%	~7%
Languages	140+	30+	60+
On-device	Yes	No	No
No audio storage	Yes	No	No
API access	Pro+	Business	Pro+
Custom models	Enterprise	No	No

Error Handling

Issue	Cause	Solution
Export rate limited	Too many requests	Add delays
Data format changed	API version	Update transformer
Import duplicate	Already migrated	Skip or overwrite
Missing speakers	Source didn't export	Set as unknown

Resources

• TwinMind Import API
• Data Export Best Practices
• Platform Comparison

Congratulations!

You have completed the TwinMind skill pack. For questions, visit TwinMind Support.