agent-recipes 0.0.5__py3-none-any.whl

agent_recipes/templates/ai-performance-analyzer/tools.py

@@ -0,0 +1,159 @@
+"""
+AI Performance Analyzer Tools
+
+Analyze content performance metrics and generate insights.
+"""
+
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def call_llm(prompt: str, max_tokens: int = 800) -> str:
+    """Call OpenAI API."""
+    import requests
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("OPENAI_API_KEY not set")
+    response = requests.post(
+        "https://api.openai.com/v1/chat/completions",
+        headers={"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"},
+        json={"model": "gpt-4o-mini", "messages": [{"role": "user", "content": prompt}], "max_tokens": max_tokens},
+        timeout=60,
+    )
+    response.raise_for_status()
+    return response.json()["choices"][0]["message"]["content"]
+
+
+def analyze_metrics(
+    metrics: Dict[str, Any],
+    platform: str = "youtube",
+) -> Dict[str, Any]:
+    """
+    Analyze performance metrics.
+    
+    Args:
+        metrics: Metrics dictionary from platform export
+        platform: Source platform
+        
+    Returns:
+        Analysis results
+    """
+    # Extract key metrics
+    views = metrics.get("views", metrics.get("impressions", 0))
+    engagement = metrics.get("engagement", metrics.get("likes", 0) + metrics.get("comments", 0))
+    shares = metrics.get("shares", metrics.get("retweets", 0))
+    
+    # Calculate rates
+    engagement_rate = (engagement / views * 100) if views > 0 else 0
+    
+    analysis = {
+        "platform": platform,
+        "total_views": views,
+        "total_engagement": engagement,
+        "engagement_rate": round(engagement_rate, 2),
+        "shares": shares,
+        "performance_tier": _get_performance_tier(engagement_rate),
+    }
+    
+    return {"analysis": analysis}
+
+
+def _get_performance_tier(engagement_rate: float) -> str:
+    """Determine performance tier based on engagement rate."""
+    if engagement_rate >= 10:
+        return "exceptional"
+    elif engagement_rate >= 5:
+        return "excellent"
+    elif engagement_rate >= 2:
+        return "good"
+    elif engagement_rate >= 1:
+        return "average"
+    else:
+        return "needs_improvement"
+
+
+def generate_insights(
+    metrics: Dict[str, Any],
+    historical: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    """
+    Generate AI-powered insights from metrics.
+    
+    Args:
+        metrics: Current metrics
+        historical: Historical metrics for comparison
+        
+    Returns:
+        Insights and recommendations
+    """
+    metrics_summary = f"""
+Views: {metrics.get('views', 'N/A')}
+Likes: {metrics.get('likes', 'N/A')}
+Comments: {metrics.get('comments', 'N/A')}
+Shares: {metrics.get('shares', 'N/A')}
+Watch Time: {metrics.get('watch_time', 'N/A')}
+CTR: {metrics.get('ctr', 'N/A')}%
+"""
+    
+    prompt = f"""Analyze these content performance metrics and provide actionable insights:
+
+{metrics_summary}
+
+Provide:
+1. Key Performance Summary (2-3 sentences)
+2. Top 3 Strengths
+3. Top 3 Areas for Improvement
+4. 3 Specific Recommendations
+
+Be specific and actionable."""
+    
+    try:
+        insights_text = call_llm(prompt, max_tokens=600)
+        
+        return {
+            "insights": insights_text,
+            "metrics_analyzed": list(metrics.keys()),
+        }
+    except Exception as e:
+        logger.error(f"Error generating insights: {e}")
+        return {"error": str(e)}
+
+
+def compare_performance(
+    current: Dict[str, Any],
+    previous: Dict[str, Any],
+) -> Dict[str, Any]:
+    """
+    Compare current vs previous performance.
+    
+    Args:
+        current: Current period metrics
+        previous: Previous period metrics
+        
+    Returns:
+        Comparison results
+    """
+    comparison = {}
+    
+    for key in current:
+        if key in previous and isinstance(current[key], (int, float)):
+            prev_val = previous[key]
+            curr_val = current[key]
+            
+            if prev_val > 0:
+                change_pct = ((curr_val - prev_val) / prev_val) * 100
+            else:
+                change_pct = 100 if curr_val > 0 else 0
+            
+            comparison[key] = {
+                "current": curr_val,
+                "previous": prev_val,
+                "change": curr_val - prev_val,
+                "change_percent": round(change_pct, 2),
+                "trend": "up" if change_pct > 0 else "down" if change_pct < 0 else "flat",
+            }
+    
+    return {"comparison": comparison}

agent_recipes/templates/ai-podcast-cleaner/README.md

@@ -0,0 +1,117 @@
+# AI Podcast Cleaner
+
+Clean podcast audio by removing noise, normalizing volume, trimming silences, and generating transcripts with chapter markers.
+
+## Input/Output
+
+- **Input**: Audio file (wav, mp3, m4a, flac)
+- **Output**:
+  - `cleaned.mp3` - Cleaned and normalized audio
+  - `transcript.txt` - Plain text transcript
+  - `transcript.srt` - SRT caption file
+  - `chapters.json` - Chapter markers with timestamps
+  - `run.json` - Execution metadata
+
+## Requirements
+
+- **ffmpeg**: Audio processing
+- **OpenAI API Key**: For transcription (Whisper)
+
+```bash
+# macOS
+brew install ffmpeg
+
+# Linux
+apt install ffmpeg
+
+# Set API key
+export OPENAI_API_KEY=your_key_here
+```
+
+## Usage
+
+### CLI
+
+```bash
+# Basic usage
+praison run ai-podcast-cleaner recording.wav
+
+# With output directory
+praison run ai-podcast-cleaner recording.mp3 --output ./cleaned/
+
+# Aggressive cleanup preset
+praison run ai-podcast-cleaner recording.wav --preset aggressive
+
+# Skip transcription
+praison run ai-podcast-cleaner recording.wav --no-transcribe
+
+# Dry run (show plan without executing)
+praison run ai-podcast-cleaner recording.wav --dry-run
+
+# Force overwrite existing output
+praison run ai-podcast-cleaner recording.wav --force
+```
+
+### Python API
+
+```python
+from praisonaiagents import Workflow
+
+workflow = Workflow.from_template("ai-podcast-cleaner")
+result = workflow.run(
+    input="./recording.wav",
+    output="./cleaned/",
+    preset="default"
+)
+```
+
+## Presets
+
+| Preset | Description |
+|--------|-------------|
+| `default` | Balanced cleanup for most podcasts |
+| `aggressive` | Heavy noise reduction, shorter silence threshold |
+| `gentle` | Light cleanup, preserves natural pauses |
+
+## Output Files
+
+### cleaned.mp3
+- Normalized to -16 LUFS
+- Silences > 0.5s removed
+- High-quality MP3 (192kbps)
+
+### transcript.txt
+Plain text transcript of the audio content.
+
+### transcript.srt
+SRT format captions with timestamps:
+```
+1
+00:00:00,000 --> 00:00:05,000
+Welcome to the podcast.
+
+2
+00:00:05,500 --> 00:00:10,000
+Today we're discussing AI agents.
+```
+
+### chapters.json
+```json
+{
+  "chapters": [
+    {"start": 0, "end": 120, "title": "Introduction"},
+    {"start": 120, "end": 480, "title": "Main Discussion"},
+    {"start": 480, "end": 600, "title": "Conclusion"}
+  ]
+}
+```
+
+### run.json
+Execution metadata including timing, config, and output file info.
+
+## Safety Defaults
+
+- Never modifies input files
+- Output to timestamped directory by default
+- Requires `--force` to overwrite existing output
+- Logs all operations to `run.log`

agent_recipes/templates/ai-podcast-cleaner/TEMPLATE.yaml

@@ -0,0 +1,117 @@
+name: ai-podcast-cleaner
+version: "1.0.0"
+description: |
+  Clean podcast audio by removing noise, normalizing volume, 
+  trimming silences, and generating transcripts with chapter markers.
+  
+  Input: Audio file (wav, mp3, m4a, flac)
+  Output: Cleaned audio + transcript + chapters.json
+
+author: praisonai
+license: Apache-2.0
+tags: [audio, podcast, cleanup, transcript, noise-reduction, normalization]
+
+requires:
+  tools: [shell_tool]
+  packages: [praisonai-tools]
+  env: [OPENAI_API_KEY]
+  external:
+    - name: ffmpeg
+      check: "ffmpeg -version"
+      install_hint: "brew install ffmpeg (macOS) or apt install ffmpeg (Linux)"
+
+workflow: workflow.yaml
+agents: agents.yaml
+
+config:
+  input:
+    type: string
+    required: true
+    description: Input audio file path
+  output:
+    type: string
+    description: Output directory (default: ./outputs/ai-podcast-cleaner/<timestamp>/)
+  preset:
+    type: string
+    default: default
+    enum: [default, aggressive, gentle]
+    description: Cleanup preset
+  remove_silence:
+    type: boolean
+    default: true
+    description: Remove long silences
+  normalize:
+    type: boolean
+    default: true
+    description: Normalize audio levels
+  transcribe:
+    type: boolean
+    default: true
+    description: Generate transcript
+  chapters:
+    type: boolean
+    default: true
+    description: Generate chapter markers
+
+defaults:
+  preset: default
+  remove_silence: true
+  normalize: true
+  transcribe: true
+  chapters: true
+
+cli:
+  command: ai-podcast-cleaner
+  args:
+    - name: input
+      positional: true
+      required: true
+      description: Input audio file
+    - name: --output
+      short: -o
+      description: Output directory
+    - name: --preset
+      short: -p
+      default: default
+      description: Cleanup preset (default, aggressive, gentle)
+    - name: --no-silence-removal
+      flag: true
+      description: Skip silence removal
+    - name: --no-normalize
+      flag: true
+      description: Skip normalization
+    - name: --no-transcribe
+      flag: true
+      description: Skip transcription
+    - name: --dry-run
+      flag: true
+      description: Show plan without executing
+    - name: --force
+      flag: true
+      description: Overwrite existing output
+    - name: --verbose
+      short: -v
+      flag: true
+      description: Enable verbose output
+  examples:
+    - "praison run ai-podcast-cleaner recording.wav"
+    - "praison run ai-podcast-cleaner recording.mp3 --preset aggressive"
+    - "praison run ai-podcast-cleaner recording.wav --output ./cleaned/ --no-transcribe"
+    - "praison run ai-podcast-cleaner recording.wav --dry-run"
+
+outputs:
+  - name: cleaned.mp3
+    type: file
+    description: Cleaned audio file
+  - name: transcript.txt
+    type: file
+    description: Plain text transcript
+  - name: transcript.srt
+    type: file
+    description: SRT caption file
+  - name: chapters.json
+    type: file
+    description: Chapter markers with timestamps
+  - name: run.json
+    type: file
+    description: Execution metadata

agent_recipes/templates/ai-podcast-cleaner/agents.yaml

@@ -0,0 +1,59 @@
+framework: praisonai
+topic: AI Podcast Cleaner Pipeline
+
+roles:
+  audio_processor:
+    role: Audio Engineer
+    goal: Clean and enhance podcast audio
+    backstory: |
+      I am an AI audio engineer specializing in podcast production.
+      I use ffmpeg and audio processing tools to clean recordings,
+      remove noise, normalize levels, and trim silences.
+    tasks:
+      process_audio:
+        description: |
+          Process the input audio file:
+          1. Probe audio to get metadata (duration, format, sample rate)
+          2. Apply noise reduction if needed
+          3. Normalize audio levels to -16 LUFS
+          4. Remove long silences (>0.5s)
+          5. Export cleaned audio as MP3
+          
+          Input: {input}
+          Output directory: {output}
+          Preset: {preset}
+        expected_output: |
+          Cleaned audio file with:
+          - Normalized volume levels
+          - Reduced background noise
+          - Trimmed silences
+    tools:
+      - shell_tool
+
+  transcriber:
+    role: Transcription Specialist
+    goal: Generate accurate transcripts with timestamps
+    backstory: |
+      I am an AI transcription specialist using OpenAI Whisper.
+      I generate accurate transcripts with word-level timestamps
+      and can identify natural chapter breaks in content.
+    tasks:
+      transcribe_audio:
+        description: |
+          Transcribe the cleaned audio:
+          1. Use Whisper API to transcribe with word timestamps
+          2. Generate plain text transcript
+          3. Generate SRT caption file
+          4. Identify chapter breaks based on content
+          5. Create chapters.json with timestamps and titles
+          
+          Audio file: {output}/cleaned.mp3
+        expected_output: |
+          - transcript.txt: Full text transcript
+          - transcript.srt: Timestamped captions
+          - chapters.json: Chapter markers
+    tools:
+      - shell_tool
+
+dependencies:
+  - transcribe_audio depends on process_audio

agent_recipes/templates/ai-podcast-cleaner/workflow.yaml

@@ -0,0 +1,77 @@
+name: AI Podcast Cleaner Workflow
+description: |
+  End-to-end podcast audio cleaning pipeline.
+  Cleans audio, normalizes levels, removes silence, and generates transcripts.
+
+process: sequential
+
+variables:
+  input: ""
+  output: ""
+  preset: "default"
+  remove_silence: "true"
+  normalize: "true"
+  transcribe: "true"
+  chapters: "true"
+
+agents:
+  audio_processor:
+    name: AudioProcessor
+    role: Audio Engineer
+    goal: Clean and enhance podcast audio
+    instructions: |
+      You are an AI audio engineer. Process the input audio file using ffmpeg.
+      
+      Steps:
+      1. Probe the audio file to get metadata
+      2. Normalize audio to -16 LUFS using loudnorm filter
+      3. Remove silences longer than 0.5 seconds
+      4. Export as high-quality MP3
+      
+      Use these ffmpeg commands:
+      - Probe: ffprobe -v quiet -print_format json -show_format -show_streams "{input}"
+      - Normalize: ffmpeg -y -i "{input}" -af loudnorm=I=-16:TP=-1.5:LRA=11 -ar 48000 "{output}/cleaned.mp3"
+      - Remove silence: ffmpeg -y -i "{input}" -af silenceremove=start_periods=1:stop_periods=-1:stop_duration=0.5:stop_threshold=-50dB "{output}/cleaned.mp3"
+    tools: [shell_tool]
+
+  transcriber:
+    name: Transcriber
+    role: Transcription Specialist
+    goal: Generate transcripts with timestamps
+    instructions: |
+      You are a transcription specialist. Use the Whisper API to transcribe audio.
+      
+      Generate:
+      1. transcript.txt - Plain text transcript
+      2. transcript.srt - SRT caption file
+      3. chapters.json - Chapter markers based on content analysis
+    tools: [shell_tool]
+
+tasks:
+  - name: probe_audio
+    agent: audio_processor
+    description: |
+      Probe the input audio file to get metadata.
+      Run: ffprobe -v quiet -print_format json -show_format -show_streams "{input}"
+    expected_output: Audio metadata (duration, format, sample rate, channels)
+
+  - name: normalize_audio
+    agent: audio_processor
+    description: |
+      Normalize audio levels to -16 LUFS.
+      Run: ffmpeg -y -i "{input}" -af "loudnorm=I=-16:TP=-1.5:LRA=11" -ar 48000 "{output}/normalized.mp3"
+    expected_output: Normalized audio file
+
+  - name: remove_silence
+    agent: audio_processor
+    description: |
+      Remove long silences from the audio.
+      Run: ffmpeg -y -i "{output}/normalized.mp3" -af "silenceremove=start_periods=1:stop_periods=-1:stop_duration=0.5:stop_threshold=-50dB" "{output}/cleaned.mp3"
+    expected_output: Cleaned audio with silences removed
+
+  - name: transcribe
+    agent: transcriber
+    description: |
+      Transcribe the cleaned audio using Whisper API.
+      Generate transcript.txt, transcript.srt, and chapters.json.
+    expected_output: Transcript files and chapter markers

agent_recipes/templates/ai-podcast-transcriber/README.md

@@ -0,0 +1,59 @@
+# Podcast Transcriber
+
+Full podcast transcription with speaker diarization
+
+## Installation
+
+```bash
+pip install agent-recipes
+```
+
+## CLI Usage
+
+```bash
+# Basic usage
+praison recipes run ai-podcast-transcriber <input>
+
+# With output directory
+praison recipes run ai-podcast-transcriber <input> --output ./output/
+
+# Dry run (check dependencies only)
+praison recipes run ai-podcast-transcriber <input> --dry-run
+
+# Show recipe info
+praison recipes info ai-podcast-transcriber
+
+# Check dependencies
+praison recipes doctor ai-podcast-transcriber
+```
+
+## Python Usage
+
+```python
+from praisonaiagents import Agent
+from agent_recipes import load_recipe
+
+# Load and run recipe
+recipe = load_recipe("ai-podcast-transcriber")
+result = recipe.run(input="<your-input>")
+print(result)
+```
+
+## Requirements
+
+### Packages
+- openai
+
+### Environment Variables
+- OPENAI_API_KEY
+
+### External Tools
+- ffmpeg
+
+## Tags
+
+`audio`, `podcast`, `transcription`, `diarization`
+
+## License
+
+Apache-2.0

agent_recipes/templates/ai-podcast-transcriber/TEMPLATE.yaml

@@ -0,0 +1,32 @@
+name: ai-podcast-transcriber
+version: "1.0.0"
+description: Full podcast transcription with speaker diarization
+author: praison
+license: Apache-2.0
+tags:
+  - audio
+  - podcast
+  - transcription
+  - diarization
+
+requires:
+  tools:
+    - whisper_tool
+    - llm_tool
+  packages:
+    - openai
+  env:
+    - OPENAI_API_KEY
+  external:
+    - ffmpeg
+
+cli:
+  command: praison recipes run ai-podcast-transcriber
+  examples:
+    - praison recipes run ai-podcast-transcriber <input>
+    - praison recipes run ai-podcast-transcriber <input> --output ./output/
+    - praison recipes run ai-podcast-transcriber <input> --dry-run
+
+safety:
+  dry_run_default: false
+  overwrites_files: true

agent_recipes/templates/ai-post-copy-generator/recipe.yaml

@@ -0,0 +1,41 @@
+name: ai-post-copy-generator
+version: 1.0.0
+description: Generate platform-specific post copy for X, LinkedIn, YouTube descriptions
+author: PraisonAI
+tags:
+  - copy
+  - social-media
+  - content
+
+config:
+  platforms:
+    - x
+    - linkedin
+    - youtube
+  tone: professional
+  include_hashtags: true
+
+input:
+  type: object
+  properties:
+    topic:
+      type: string
+    platform:
+      type: string
+
+output:
+  type: object
+  properties:
+    copy:
+      type: string
+
+requires:
+  env:
+    - OPENAI_API_KEY
+
+workflow:
+  agents:
+    - name: copywriter
+      role: Social Media Copywriter
+      tools:
+        - generate_post_copy