Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

perplexity-migration-deep-dive

/perplexity-migration-deep-dive

Prowadzi dużą migrację i przebudowę architektury do lub z Perplexity wzorcem strangler fig, także przy dużych aktualizacjach wersji.

Repozytorium
agent ↗
Licencja
MIT
Ostatnia zmiana repozytorium
14.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
3
Przestarzałość

Brak sygnałów. Repozytorium zmienione 14.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Prowadzi dużą migrację i przebudowę architektury do lub z Perplexity wzorcem strangler fig, także przy dużych aktualizacjach wersji.

Wyzwalacze z opisu

migrate perplexityperplexity migrationswitch to perplexityperplexity replatformperplexity upgrade major
Oryginalny opis (EN)

Execute Perplexity major re-architecture and migration strategies with strangler fig pattern. Use when migrating to or from Perplexity, performing major version upgrades, or re-platforming existing integrations to Perplexity. Trigger with phrases like "migrate perplexity", "perplexity migration", "switch to perplexity", "perplexity replatform", "perplexity upgrade major".

Jak działa

  1. Overview
  2. Prerequisites
  3. Migration Types
  4. Pre-Migration Assessment
  5. Migration Strategy: Strangler Fig Pattern
  6. Implementation Plan
  7. Rollback Plan
  8. Post-Migration Validation
  9. Instructions
  10. Output
Sekcje z nagłówków SKILL.md, w oryginale · 231 linii, 732 słów
Podgląd SKILL.md
---
name: perplexity-migration-deep-dive
description: |
  Execute Perplexity major re-architecture and migration strategies with strangler fig pattern.
  Use when migrating to or from Perplexity, performing major version upgrades,
  or re-platforming existing integrations to Perplexity.
  Trigger with phrases like "migrate perplexity", "perplexity migration",
  "switch to perplexity", "perplexity replatform", "perplexity upgrade major".
allowed-tools: Read, Write, Edit, Bash(npm:*), Bash(node:*), Bash(kubectl:*)
version: 1.0.0
license: MIT
author: Jeremy Longshore <jeremy@intentsolutions.io>
---

# Perplexity Migration Deep Dive

## Overview
Comprehensive guide for migrating to or from Perplexity, or major version upgrades.

## Prerequisites
- Current system documentation
- Perplexity SDK installed
- Feature flag infrastructure
- Rollback strategy tested

## Migration Types

| Type | Complexity | Duration | Risk |
|------|-----------|----------|------|
| Fresh install | Low | Days | Low |
| From competitor | Medium | Weeks | Medium |
| Major version | Medium | Weeks | Medium |
| Full replatform | High | Months | High |

## Pre-Migration Assessment

### Step 1: Current State Analysis
```bash
# Document current implementation
find . -name "*.ts" -o -name "*.py" | xargs grep -l "perplexity" > perplexity-files.txt

# Count integration points
wc -l perplexity-files.txt

# Identify dependencies
npm list | grep perplexity
pip freeze | grep perplexity
```

### Step 2: Data Inventory
```typescript
interface MigrationInventory {
  dataTypes: string[];
  recordCounts: Record<string, number>;
  dependencies: string[];
  integrationPoints: string[];
  customizations: string[];
}

async function assessPerplexityMigration(): Promise<MigrationInventory> {
  return {
    dataTypes: await getDataTypes(),
    recordCounts: await getRecordCounts(),
    dependencies: await analyzeDependencies(),
    integrationPoints: await findIntegrationPoints(),
    customizations: await documentCustomizations(),
  };
}
```

## Migration Strategy: Strangler Fig Pattern

```
Phase 1: Parallel Run
┌─────────────┐     ┌─────────────┐
│   Old       │     │   New       │
│   System    │ ──▶ │  Perplexity   │
│   (100%)    │     │   (0%)      │
└─────────────┘     └─────────────┘

Phase 2: Gradual Shift
┌─────────────┐     ┌─────────────┐
│   Old       │     │   New       │
│   (50%)     │ ──▶ │   (50%)     │
└─────────────┘     └─────────────┘

Phase 3: Complete
┌─────────────┐     ┌─────────────┐
│   Old       │     │   New       │
│   (0%)      │ ──▶ │   (100%)    │
└─────────────┘     └─────────────┘
```

## Implementation Plan

### Phase 1: Setup (Week 1-2)
```bash
# Install Perplexity SDK
npm install @perplexity/sdk

# Configure credentials
cp .env.example .env.perplexity
# Edit with new credentials

# Verify connectivity
node -e "require('@perplexity/sdk').ping()"
```

### Phase 2: Adapter Layer (Week 3-4)
```typescript
// src/adapters/perplexity.ts
interface ServiceAdapter {
  create(data: CreateInput): Promise<Resource>;
  read(id: string): Promise<Resource>;
  update(id: string, data: UpdateInput): Promise<Resource>;
  delete(id: string): Promise<void>;
}

class PerplexityAdapter implements ServiceAdapter {
  async create(data: CreateInput): Promise<Resource> {
    const perplexityData = this.transform(data);
    return perplexityClient.create(perplexityData);
  }

  private transform(data: CreateInput): PerplexityInput {
    // Map from old format to Perplexity format
  }
}
```

### Phase 3: Data Migration (Week 5-6)
```typescript
async function migratePerplexityData(): Promise<MigrationResult> {
  const batchSize = 100;
  let processed = 0;
  let errors: MigrationError[] = [];

  for await (const batch of oldSystem.iterateBatches(batchSize)) {
    try {
      const transformed = batch.map(transform);
      await perplexityClient.batchCreate(transformed);
      processed += batch.length;
    } catch (error) {
      errors.push({ batch, error });
    }

    // Progress update
    console.log(`Migrated ${processed} records`);
  }

  return { processed, errors };
}
```

### Phase 4: Traffic Shift (Week 7-8)
```typescript
// Feature flag controlled traffic split
function getServiceAdapter(): ServiceAdapter {
  const perplexityPercentage = getFeatureFlag('perplexity_migration_percentage');

  if (Math.random() * 100 < perplexityPercentage) {
    return new PerplexityAdapter();
  }

  return new LegacyAdapter();
}
```

## Rollback Plan

```bash
# Immediate rollback
kubectl set env deployment/app PERPLEXITY_ENABLED=false
kubectl rollout restart deployment/app

# Data rollback (if needed)
./scripts/restore-from-backup.sh --date YYYY-MM-DD

# Verify rollback
curl https://app.yourcompany.com/health | jq '.services.perplexity'
```

## Post-Migration Validation

```typescript
async function validatePerplexityMigration(): Promise<ValidationReport> {
  const checks = [
    { name: 'Data count match', fn: checkDataCounts },
    { name: 'API functionality', fn: checkApiFunctionality },
    { name: 'Performance baseline', fn: checkPerformance },
    { name: 'Error rates', fn: checkErrorRates },
  ];

  const results = await Promise.all(
    checks.map(async c => ({ name: c.name, result: await c.fn() }))
  );

  return { checks: results, passed: results.every(r => r.result.success) };
}
```

## Instructions

### Step 1: Assess Current State
Document existing implementation and data inventory.

### Step 2: Build Adapter Layer
Create abstraction layer for gradual migration.

### Step 3: Migrate Data
Run batch data migration with error handling.

### Step 4: Shift Traffic
Gradually route traffic to new Perplexity integration.

## Output
- Migration assessment complete
- Adapter layer implemented
- Data migrated successfully
- Traffic fully shifted to Perplexity

## Error Handling
| Issue | Cause | Solution |
|-------|-------|----------|
| Data mismatch | Transform errors | Validate transform logic |
| Performance drop | No caching | Add caching layer |
| Rollback triggered | Errors spiked | Reduce traffic percentage |
| Validation failed | Missing data | Check batch processing |

## Examples

### Quick Migration Status
```typescript
const status = await validatePerplexityMigration();
console.log(`Migration ${status.passed ? 'PASSED' : 'FAILED'}`);
status.checks.forEach(c => console.log(`  ${c.name}: ${c.result.success}`));
```

## Resources
- [Strangler Fig Pattern](https://martinfowler.com/bliki/StranglerFigApplication.html)
- [Perplexity Migration Guide](https://docs.perplexity.com/migration)

## Flagship+ Skills
For advanced troubleshooting, see `perplexity-advanced-troubleshooting`.

Wersje

W bazie nie ma innych skilli o nazwie perplexity-migration-deep-dive.

Migawka bazy z 13.11.2026 · wersja paczki d11cc2cb316c (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100posthog-migration-deep-dive
    Prowadzi dużą przebudowę architektury i migrację do lub z PostHog wzorcem strangler fig, w tym aktualizacje wersji głównych i zmianę platformy istniejących integracji.
  • 100firecrawl-migration-deep-dive
    Prowadzi dużą przebudowę i migrację do lub z FireCrawl wzorcem strangler fig, w tym aktualizacje głównych wersji i zmianę platformy.
  • 100shopify-migration-deep-dive
    Przenosi dane e-commerce do Shopify przez operacje zbiorcze, import produktów i wzorzec strangler fig przy stopniowej zmianie platformy.
  • 100obsidian-migration-deep-dive
    Prowadzi przez duże przepisanie wtyczek Obsidian i migrację do lub z Obsidian oraz replatformowanie istniejących systemów notatek.
  • 100framework-migration-legacy-modernize
    Modernizuje systemy legacy stopniowo wzorcem strangler fig, wymieniając komponenty przy zachowaniu działania biznesu, pokrycia testami i kontraktów integracyjnych.
  • 100monoliths
    Opisuje wzorce architektury monolitycznej: modularny monolit, strategię monolith-first i migrację do mikroserwisów wzorcem Strangler Fig oraz unikanie Big Ball of Mud.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.