Parsley

Open-source, AI-powered podcast analyzer for macOS. Automatically transcribe and analyze podcasts with AI — all local except the LLM call.

Prebuilt binaries

Don't want to build from source? A signed and notarized macOS build is available at parsley-app.com. Same code as this repo — you're paying for the convenience of a ready-to-run, code-signed binary.

Feedback & issues

Bug reports and feature requests go to the parsley-feedback issue tracker.

Quick Start

npm install
npm start

Features

• Add & Manage Podcasts - Subscribe to podcasts via RSS feeds
• Local Transcription - Uses Parakeet for high-quality, local transcription (no API costs)
• Transcript Cleaning - Automatically removes filler words (um, uh, ah) while preserving content
• AI Analysis - Extracts summaries, key topics, notable quotes, and mentions using GPT-5-mini
• Smart Chunking - Handles large transcripts automatically by splitting into manageable chunks
• Cancellation Support - Cancel stuck operations and automatic recovery on restart
• Clean UI - Beautiful, dark-themed interface optimized for Mac
• Episode Management - Control how far back to fetch episodes
• Offline-First - All data stored locally in SQLite

Screenshots

Prerequisites

1. Node.js and npm

Install from nodejs.org (LTS version recommended)

2. Python 3.8+

Check if installed:

python3 --version

3. Parakeet (Nvidia NeMo Toolkit)

Install NeMo toolkit which includes Parakeet. Recommended: Use a virtual environment:

# Create virtual environment (recommended)
python3 -m venv venv
source venv/bin/activate

# Install NeMo toolkit (note the quotes for zsh)
pip install 'nemo_toolkit[all]'

Or install globally:

# For zsh users (macOS default), use quotes:
pip3 install 'nemo_toolkit[all]'

# Or with --break-system-packages flag:
pip3 install 'nemo_toolkit[all]' --break-system-packages

Note: This is a large download (~2-5GB) and may take 10-20 minutes. The Parakeet model itself (~1.3GB) will download automatically on first use.

For more details, see: NeMo ASR Documentation

4. OpenAI API Key

You'll need an OpenAI API key for AI analysis:

1. Sign up at platform.openai.com
2. Generate an API key (use regular API keys starting with sk-, not project keys)
3. Add it in the app's Settings tab (no .env file needed for end users!)

Note: The app uses GPT-5-mini for analysis. GPT-5-mini is used as a fallback for transcript cleaning.

5. Ollama (Optional, Recommended)

For faster, free transcript cleaning, install Ollama and pull a Gemma model:

# Install Ollama from https://ollama.ai
# Then pull a Gemma model:
ollama pull gemma2:2b

If Ollama is not available, the app will automatically fall back to cloud LLM for cleaning.

Installation

1. Clone or download this repository

2. Install Node.js dependencies

npm install

3. Install Parakeet (see Prerequisites above)

4. Verify Parakeet installation

python3 -c "import nemo.collections.asr; print('✓ NeMo installed successfully')"

5. Add OpenAI API Key
   • Launch the app with npm start
   • Go to the Settings tab
   • Enter your OpenAI API key
   • Click "Test API Key" to verify it works
   • Click "Save Settings"

Note for developers: You can also use a .env file for development (see .env.example), but end users should use the Settings tab.

Usage

Starting the App

npm start

Or for development mode (with DevTools):

npm run dev

Adding a Podcast

1. Find the RSS feed URL of your favorite podcast

   • Most podcast apps show the RSS feed in podcast details
   • Or search on Podcast Index

2. Paste the RSS feed URL into the "Add Podcast" field in the sidebar

3. Set the "Lookback Days" (default: 30)

   • This determines how far back to fetch episodes

4. Click "Add Podcast"

Processing Episodes

1. Select a podcast from the sidebar to view its episodes
2. Click "Process" on any episode you want to analyze
3. The app will:
   • Download the audio file
   • Transcribe it with Parakeet (this may take a few minutes)
   • Clean the transcript (remove filler words)
   • Analyze the transcript with GPT-5-mini (automatically chunks large transcripts)

Note: Podcast in-app search uses the free Podcast Index API. Set PODCAST_INDEX_API_KEY and PODCAST_INDEX_API_SECRET in your environment (see .env.example). You can still add podcasts by RSS URL without these.

• Save the results

4. Click "View Analysis" to see the summary, key topics, quotes, and more

Note: You can cancel processing at any time by clicking the "Cancel" button if an episode gets stuck.

Viewing Analysis

The analysis includes:

• Summary - 2-3 sentence overview
• Key Topics - Main themes discussed
• Notable Quotes - Important statements
• Key Takeaways - Actionable insights
• Mentions - People and companies mentioned
• Full Transcript - Complete transcription

Project Structure

parsley/
├── src/
│   ├── main.js              # Electron main process
│   ├── preload.js           # Preload script for IPC
│   ├── services/
│   │   ├── database.js      # SQLite database layer
│   │   ├── podcast.js       # RSS feed parser & downloader
│   │   ├── transcription.js # Parakeet integration
│   │   ├── cleaning.js      # Transcript cleaning (Ollama/LLM)
│   │   └── analysis.js      # OpenAI GPT-5-mini integration
│   └── renderer/
│       ├── index.html       # Main UI
│       ├── styles.css       # Styling
│       ├── app.js           # UI logic
│       └── logo.svg         # Parsley logo
├── package.json
├── .env                     # Your API keys (not in git)
└── README.md

Configuration

Change AI Model

By default, the app uses gpt-5-mini for analysis. To change it, edit src/services/analysis.js:

model: 'gpt-5-mini'  // Can use 'gpt-5' for higher quality on Tier 2+ OpenAI accounts

Note: gpt-5-mini is the default because it fits comfortably within OpenAI's Tier 1 rate limits for typical podcast lengths. gpt-5 offers marginally better analysis quality but requires a higher API tier to avoid TPM rate-limit errors on hour-long transcripts.

Transcript Cleaning Options

The app supports two methods for cleaning transcripts:

1. Ollama (Recommended) - Free, local, fast

   • Install Ollama and pull gemma2:3 or gemma2
   • The app will automatically detect and use it

2. Cloud LLM (Fallback) - Uses GPT-5-mini

   • Automatically used if Ollama is not available
   • Requires OpenAI API key

Change Parakeet Model

The default model is nvidia/parakeet-tdt_ctc-1.1b. For better accuracy (but slower), you can use larger models. Edit src/services/transcription.js:

asr_model = nemo_asr.models.EncDecRNNTBPEModel.from_pretrained('nvidia/parakeet-rnnt-1.1b')

Documentation

• BUILD.md - How to build a distributable .dmg file
• VIEW_LOGS.md - How to view and debug app logs
• LICENSE - MIT

Troubleshooting

"Parakeet is not installed" error

Make sure you've installed the NeMo toolkit with quotes (important for zsh):

pip install 'nemo_toolkit[all]'

Verify it's in your Python path:

python3 -c "import nemo.collections.asr"

If using a virtual environment, make sure it's activated:

source venv/bin/activate

"No module named 'torch'"

NeMo requires PyTorch. Install it:

pip install torch torchaudio

App crashes on startup (macOS Sequoia)

If the app crashes immediately with SIGTRAP or SIGSEGV:

1. Delete any corrupted saved states:

rm -rf ~/Library/Saved\ Application\ State/com.github.Electron.savedState/
rm -rf ~/Library/Saved\ Application\ State/com.parsley.desktop.savedState/
rm -rf ~/Library/Preferences/com.github.Electron.plist

2. Make sure you're using Electron 32+ (included in package.json)

3. Try running with: npm start

The app uses Electron 32.2.7 which is compatible with macOS Sequoia (15.x).

Audio download fails

Some podcasts may have authentication or geo-restrictions. Try a different episode or podcast.

Transcription is slow

• Parakeet transcription is CPU/GPU intensive
• First run downloads the model (~1.3GB)
• Expect 5-15 minutes for a 1-hour podcast, depending on your hardware
• Apple Silicon Macs will be faster

Analysis fails with OpenAI error

• Check your API key in .env
• Ensure you have credits in your OpenAI account and GPT-5 access
• Very long transcripts are automatically chunked - no manual intervention needed
• If you see "max_tokens" errors, the app will automatically retry with adjusted limits

Episode stuck in processing

• Click the "Cancel" button to stop processing
• Episodes stuck in processing states are automatically reset on app restart
• Check logs for detailed error messages (see VIEW_LOGS.md)

Data Storage

All data is stored locally in your user data directory:

Mac: ~/Library/Application Support/parsley/

• podcasts.db - SQLite database
• downloads/ - Downloaded audio files

Logs: ~/Library/Logs/Parsley/

• parsley-YYYY-MM-DD.log - Daily log files

See VIEW_LOGS.md for details on viewing logs.

Technical Details

Processing Pipeline

1. Download - Audio file downloaded to local storage
2. Transcribe - Parakeet converts audio to text (local, CPU/GPU)
3. Clean - Removes filler words using Ollama (local) or GPT-5-mini (cloud)
4. Analyze - GPT-5-mini extracts insights (automatically chunks large transcripts)
5. Store - Results saved to SQLite database

Chunking Strategy

For large transcripts (>8000 tokens), the app uses a simple, effective chunking approach:

1. Sentence-Based Chunking

   • Splits transcript into ~18,000 character chunks (~4500 tokens each)
   • Preserves sentence boundaries to maintain context
   • Each chunk analyzed independently for maximum detail

2. Rich Analysis Per Chunk

   • GPT-5-mini extracts comprehensive insights from each chunk:
     • Specific, detailed key topics
     • Notable quotes with full context
     • Actionable takeaways
     • People and companies mentioned
   • 4,000 token completion budget for thorough, detailed analysis
   • 5-second delays between chunks for rate limit compatibility

3. Simple Merge

   • Combines all topics, quotes, and takeaways from chunks
   • Deduplicates using Set to avoid repetition
   • Preserves up to 20 key topics, 10 quotes, 20 takeaways
   • No aggressive pruning - keeps comprehensive coverage

Key Benefits:

• Higher quality: Simple approach produces detailed, specific insights
• No artificial limits: Full quotes, comprehensive topics, rich detail
• Rate limit friendly: Sequential processing with delays
• Cost effective: GPT-5-mini provides quality analysis within Tier 1 rate limits

This straightforward approach prioritizes analysis quality over complexity, producing comprehensive insights that capture the full richness of podcast discussions.

Timeouts & Cancellation

• Overall processing timeout: 2 hours
• Transcription timeout: 30 minutes per episode
• Automatic cancellation on timeout
• Manual cancellation via UI
• Stuck episodes auto-reset on app restart

Future Enhancements

• Batch processing
• Export analysis as PDF/Markdown
• Search across all transcripts
• Custom analysis prompts
• Support for video podcasts
• Auto-process new episodes

Contributing

This is a personal project but feel free to fork and customize!

License

MIT

Credits

Built with:

• Electron
• Nvidia NeMo & Parakeet
• OpenAI GPT-5
• Ollama (optional, for local transcript cleaning)
• Inspired by Tomasz Tunguz's Parakeet Podcast Processor