agent-recipes 0.0.5__py3-none-any.whl

agent_recipes/templates/ai-news-deduper/recipe.yaml

@@ -0,0 +1,47 @@
+name: ai-news-deduper
+version: 1.0.0
+description: Deduplicate news articles and cluster them by topic using semantic similarity
+author: PraisonAI
+tags:
+  - news
+  - deduplication
+  - clustering
+  - nlp
+
+config:
+  similarity_threshold: 0.85
+  min_cluster_size: 2
+  clustering_method: semantic
+  output_format: json
+
+input:
+  type: object
+  properties:
+    articles:
+      type: array
+      description: List of articles to deduplicate and cluster
+
+output:
+  type: object
+  properties:
+    deduplicated_articles:
+      type: array
+    clusters:
+      type: array
+    stats:
+      type: object
+
+requires:
+  env:
+    - OPENAI_API_KEY
+  packages:
+    - numpy
+
+workflow:
+  agents:
+    - name: deduper
+      role: Content Deduplicator
+      goal: Remove duplicate articles and group similar content
+      tools:
+        - deduplicate_articles
+        - cluster_by_topic

agent_recipes/templates/ai-news-deduper/tools.py

@@ -0,0 +1,235 @@
+"""
+AI News Deduper Tools
+
+Tools for deduplicating and clustering news articles:
+- Semantic similarity detection
+- Topic clustering
+- Duplicate removal
+"""
+
+import hashlib
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def get_text_hash(text: str) -> str:
+    """Generate a hash for text content."""
+    return hashlib.md5(text.lower().strip().encode()).hexdigest()
+
+
+def get_embedding(text: str) -> List[float]:
+    """Get embedding for text using OpenAI API."""
+    api_key = os.environ.get("OPENAI_API_KEY")
+    if not api_key:
+        raise ValueError("OPENAI_API_KEY not set")
+    
+    import requests
+    
+    response = requests.post(
+        "https://api.openai.com/v1/embeddings",
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        json={
+            "model": "text-embedding-3-small",
+            "input": text[:8000],
+        },
+        timeout=30,
+    )
+    response.raise_for_status()
+    return response.json()["data"][0]["embedding"]
+
+
+def cosine_similarity(a: List[float], b: List[float]) -> float:
+    """Calculate cosine similarity between two vectors."""
+    import math
+    dot_product = sum(x * y for x, y in zip(a, b))
+    norm_a = math.sqrt(sum(x * x for x in a))
+    norm_b = math.sqrt(sum(x * x for x in b))
+    if norm_a == 0 or norm_b == 0:
+        return 0.0
+    return dot_product / (norm_a * norm_b)
+
+
+def deduplicate_articles(
+    articles: List[Dict[str, Any]],
+    similarity_threshold: float = 0.85,
+    use_semantic: bool = True,
+) -> Dict[str, Any]:
+    """
+    Deduplicate articles based on title and content similarity.
+    
+    Args:
+        articles: List of article dictionaries
+        similarity_threshold: Threshold for considering articles as duplicates
+        use_semantic: Use semantic similarity (requires API) or hash-based
+        
+    Returns:
+        Dictionary with deduplicated articles and stats
+    """
+    if not articles:
+        return {"deduplicated": [], "removed": 0, "stats": {}}
+    
+    seen_hashes = set()
+    deduplicated = []
+    removed_count = 0
+    
+    if use_semantic:
+        # Get embeddings for all articles
+        embeddings = []
+        for article in articles:
+            text = f"{article.get('title', '')} {article.get('content', '')[:500]}"
+            try:
+                embedding = get_embedding(text)
+                embeddings.append(embedding)
+            except Exception as e:
+                logger.warning(f"Error getting embedding: {e}")
+                embeddings.append(None)
+        
+        # Check for duplicates using cosine similarity
+        for i, article in enumerate(articles):
+            is_duplicate = False
+            
+            if embeddings[i] is not None:
+                for j in range(len(deduplicated)):
+                    if embeddings[j] is not None:
+                        sim = cosine_similarity(embeddings[i], embeddings[j])
+                        if sim >= similarity_threshold:
+                            is_duplicate = True
+                            break
+            
+            if not is_duplicate:
+                deduplicated.append(article)
+            else:
+                removed_count += 1
+    else:
+        # Hash-based deduplication
+        for article in articles:
+            title_hash = get_text_hash(article.get("title", ""))
+            if title_hash not in seen_hashes:
+                seen_hashes.add(title_hash)
+                deduplicated.append(article)
+            else:
+                removed_count += 1
+    
+    return {
+        "deduplicated": deduplicated,
+        "removed": removed_count,
+        "stats": {
+            "original_count": len(articles),
+            "final_count": len(deduplicated),
+            "duplicate_rate": removed_count / len(articles) if articles else 0,
+        }
+    }
+
+
+def cluster_by_topic(
+    articles: List[Dict[str, Any]],
+    min_cluster_size: int = 2,
+    num_clusters: Optional[int] = None,
+) -> Dict[str, Any]:
+    """
+    Cluster articles by topic using semantic similarity.
+    
+    Args:
+        articles: List of article dictionaries
+        min_cluster_size: Minimum articles per cluster
+        num_clusters: Number of clusters (auto-detected if None)
+        
+    Returns:
+        Dictionary with clusters and unclustered articles
+    """
+    if len(articles) < 2:
+        return {"clusters": [], "unclustered": articles}
+    
+    # Get embeddings
+    embeddings = []
+    valid_articles = []
+    
+    for article in articles:
+        text = f"{article.get('title', '')} {article.get('content', '')[:500]}"
+        try:
+            embedding = get_embedding(text)
+            embeddings.append(embedding)
+            valid_articles.append(article)
+        except Exception as e:
+            logger.warning(f"Error getting embedding: {e}")
+    
+    if len(embeddings) < 2:
+        return {"clusters": [], "unclustered": articles}
+    
+    # Simple clustering: group articles with high similarity
+    clusters = []
+    used = set()
+    
+    for i in range(len(valid_articles)):
+        if i in used:
+            continue
+        
+        cluster = [valid_articles[i]]
+        used.add(i)
+        
+        for j in range(i + 1, len(valid_articles)):
+            if j in used:
+                continue
+            
+            sim = cosine_similarity(embeddings[i], embeddings[j])
+            if sim >= 0.7:  # Cluster threshold
+                cluster.append(valid_articles[j])
+                used.add(j)
+        
+        if len(cluster) >= min_cluster_size:
+            # Generate cluster topic from titles
+            titles = [a.get("title", "") for a in cluster]
+            clusters.append({
+                "topic": _extract_common_topic(titles),
+                "articles": cluster,
+                "size": len(cluster),
+            })
+    
+    # Collect unclustered articles
+    unclustered = [a for i, a in enumerate(valid_articles) if i not in used]
+    
+    return {
+        "clusters": clusters,
+        "unclustered": unclustered,
+        "stats": {
+            "num_clusters": len(clusters),
+            "clustered_articles": sum(c["size"] for c in clusters),
+            "unclustered_articles": len(unclustered),
+        }
+    }
+
+
+def _extract_common_topic(titles: List[str]) -> str:
+    """Extract common topic from a list of titles."""
+    if not titles:
+        return "Unknown Topic"
+    
+    # Simple approach: find common words
+    word_counts = {}
+    stop_words = {"the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+                  "have", "has", "had", "do", "does", "did", "will", "would", "could",
+                  "should", "may", "might", "must", "shall", "can", "to", "of", "in",
+                  "for", "on", "with", "at", "by", "from", "as", "into", "through",
+                  "and", "or", "but", "if", "then", "else", "when", "where", "why",
+                  "how", "all", "each", "every", "both", "few", "more", "most", "other",
+                  "some", "such", "no", "nor", "not", "only", "own", "same", "so",
+                  "than", "too", "very", "just", "also", "now", "new", "first", "last"}
+    
+    for title in titles:
+        words = title.lower().split()
+        for word in words:
+            word = word.strip(".,!?:;\"'()[]{}").lower()
+            if len(word) > 2 and word not in stop_words:
+                word_counts[word] = word_counts.get(word, 0) + 1
+    
+    # Get top words
+    sorted_words = sorted(word_counts.items(), key=lambda x: x[1], reverse=True)
+    top_words = [w[0].title() for w in sorted_words[:3]]
+    
+    return " ".join(top_words) if top_words else "Mixed Topics"

agent_recipes/templates/ai-newsletter-generator/README.md

@@ -0,0 +1,59 @@
+# Newsletter Generator
+
+Generate email newsletters from content
+
+## Installation
+
+```bash
+pip install agent-recipes
+```
+
+## CLI Usage
+
+```bash
+# Basic usage
+praison recipes run ai-newsletter-generator <input>
+
+# With output directory
+praison recipes run ai-newsletter-generator <input> --output ./output/
+
+# Dry run (check dependencies only)
+praison recipes run ai-newsletter-generator <input> --dry-run
+
+# Show recipe info
+praison recipes info ai-newsletter-generator
+
+# Check dependencies
+praison recipes doctor ai-newsletter-generator
+```
+
+## Python Usage
+
+```python
+from praisonaiagents import Agent
+from agent_recipes import load_recipe
+
+# Load and run recipe
+recipe = load_recipe("ai-newsletter-generator")
+result = recipe.run(input="<your-input>")
+print(result)
+```
+
+## Requirements
+
+### Packages
+- openai
+
+### Environment Variables
+- OPENAI_API_KEY
+
+### External Tools
+- None
+
+## Tags
+
+`web`, `newsletter`, `email`
+
+## License
+
+Apache-2.0

agent_recipes/templates/ai-newsletter-generator/TEMPLATE.yaml

@@ -0,0 +1,28 @@
+name: ai-newsletter-generator
+version: "1.0.0"
+description: Generate email newsletters from content
+author: praison
+license: Apache-2.0
+tags:
+  - web
+  - newsletter
+  - email
+
+requires:
+  tools:
+    - llm_tool
+  packages:
+    - openai
+  env:
+    - OPENAI_API_KEY
+
+cli:
+  command: praison recipes run ai-newsletter-generator
+  examples:
+    - praison recipes run ai-newsletter-generator <input>
+    - praison recipes run ai-newsletter-generator <input> --output ./output/
+    - praison recipes run ai-newsletter-generator <input> --dry-run
+
+safety:
+  dry_run_default: false
+  overwrites_files: true

agent_recipes/templates/ai-note-summarizer/README.md

@@ -0,0 +1,59 @@
+# Note Summarizer
+
+Summarize notes and documents
+
+## Installation
+
+```bash
+pip install agent-recipes
+```
+
+## CLI Usage
+
+```bash
+# Basic usage
+praison recipes run ai-note-summarizer <input>
+
+# With output directory
+praison recipes run ai-note-summarizer <input> --output ./output/
+
+# Dry run (check dependencies only)
+praison recipes run ai-note-summarizer <input> --dry-run
+
+# Show recipe info
+praison recipes info ai-note-summarizer
+
+# Check dependencies
+praison recipes doctor ai-note-summarizer
+```
+
+## Python Usage
+
+```python
+from praisonaiagents import Agent
+from agent_recipes import load_recipe
+
+# Load and run recipe
+recipe = load_recipe("ai-note-summarizer")
+result = recipe.run(input="<your-input>")
+print(result)
+```
+
+## Requirements
+
+### Packages
+- openai
+
+### Environment Variables
+- OPENAI_API_KEY
+
+### External Tools
+- None
+
+## Tags
+
+`productivity`, `notes`, `summary`
+
+## License
+
+Apache-2.0

agent_recipes/templates/ai-note-summarizer/TEMPLATE.yaml

@@ -0,0 +1,28 @@
+name: ai-note-summarizer
+version: "1.0.0"
+description: Summarize notes and documents
+author: praison
+license: Apache-2.0
+tags:
+  - productivity
+  - notes
+  - summary
+
+requires:
+  tools:
+    - llm_tool
+  packages:
+    - openai
+  env:
+    - OPENAI_API_KEY
+
+cli:
+  command: praison recipes run ai-note-summarizer
+  examples:
+    - praison recipes run ai-note-summarizer <input>
+    - praison recipes run ai-note-summarizer <input> --output ./output/
+    - praison recipes run ai-note-summarizer <input> --dry-run
+
+safety:
+  dry_run_default: false
+  overwrites_files: true

agent_recipes/templates/ai-pdf-summarizer/README.md

@@ -0,0 +1,12 @@
+# AI PDF Summarizer
+
+Summarize PDF documents with key points extraction.
+
+## Usage
+```bash
+praison run ai-pdf-summarizer document.pdf
+```
+
+## Output
+- `summary.md` - Document summary
+- `key-points.json` - Extracted key points

agent_recipes/templates/ai-pdf-summarizer/TEMPLATE.yaml

@@ -0,0 +1,40 @@
+name: ai-pdf-summarizer
+version: "1.0.0"
+description: Summarize PDF documents with key points extraction.
+author: praisonai
+license: Apache-2.0
+tags: [pdf, summary, extraction, analysis]
+
+requires:
+  tools: [shell_tool]
+  packages: [praisonai-tools]
+  env: [OPENAI_API_KEY]
+  external:
+    - name: pdftotext
+      check: "pdftotext -v"
+
+config:
+  input:
+    type: string
+    required: true
+  output:
+    type: string
+
+cli:
+  command: ai-pdf-summarizer
+  args:
+    - name: input
+      positional: true
+      required: true
+    - name: --output
+      short: -o
+  examples:
+    - "praison run ai-pdf-summarizer document.pdf"
+
+outputs:
+  - name: summary.md
+    type: file
+  - name: key-points.json
+    type: file
+  - name: run.json
+    type: file

agent_recipes/templates/ai-pdf-to-markdown/README.md

@@ -0,0 +1,19 @@
+# AI PDF to Markdown
+
+Convert PDF documents to clean Markdown format with extracted images.
+
+## Input/Output
+- **Input**: PDF file
+- **Output**: `document.md`, `images/`, `metadata.json`, `run.json`
+
+## Requirements
+- poppler-utils (pdftotext, pdfimages)
+- OpenAI API Key (for AI cleanup)
+
+## Usage
+```bash
+praison run ai-pdf-to-markdown document.pdf
+praison run ai-pdf-to-markdown document.pdf --output ./docs/
+praison run ai-pdf-to-markdown document.pdf --ocr  # For scanned PDFs
+praison run ai-pdf-to-markdown document.pdf --no-images
+```

agent_recipes/templates/ai-pdf-to-markdown/TEMPLATE.yaml

@@ -0,0 +1,63 @@
+name: ai-pdf-to-markdown
+version: "1.0.0"
+description: |
+  Convert PDF documents to clean Markdown format with extracted images.
+  Uses AI to clean up OCR artifacts and structure content properly.
+
+author: praisonai
+license: Apache-2.0
+tags: [pdf, markdown, conversion, document, ocr]
+
+requires:
+  tools: [shell_tool]
+  packages: [praisonai-tools]
+  env: [OPENAI_API_KEY]
+  external:
+    - name: pdftotext
+      check: "pdftotext -v"
+      install_hint: "brew install poppler (macOS) or apt install poppler-utils (Linux)"
+
+config:
+  input:
+    type: string
+    required: true
+    description: Input PDF file path
+  output:
+    type: string
+    description: Output directory
+  extract_images:
+    type: boolean
+    default: true
+  use_ocr:
+    type: boolean
+    default: false
+
+cli:
+  command: ai-pdf-to-markdown
+  args:
+    - name: input
+      positional: true
+      required: true
+    - name: --output
+      short: -o
+    - name: --no-images
+      flag: true
+    - name: --ocr
+      flag: true
+    - name: --dry-run
+      flag: true
+    - name: --force
+      flag: true
+  examples:
+    - "praison run ai-pdf-to-markdown document.pdf"
+    - "praison run ai-pdf-to-markdown document.pdf --output ./docs/"
+
+outputs:
+  - name: document.md
+    type: file
+  - name: images/
+    type: directory
+  - name: metadata.json
+    type: file
+  - name: run.json
+    type: file

agent_recipes/templates/ai-performance-analyzer/recipe.yaml

@@ -0,0 +1,45 @@
+name: ai-performance-analyzer
+version: 1.0.0
+description: Analyze content performance metrics from platform JSON exports
+author: PraisonAI
+tags:
+  - analytics
+  - performance
+  - metrics
+  - insights
+
+config:
+  metrics:
+    - views
+    - engagement
+    - retention
+    - growth
+  comparison_period: 30
+
+input:
+  type: object
+  properties:
+    metrics_json:
+      type: object
+    platform:
+      type: string
+
+output:
+  type: object
+  properties:
+    analysis:
+      type: object
+    recommendations:
+      type: array
+
+requires:
+  env:
+    - OPENAI_API_KEY
+
+workflow:
+  agents:
+    - name: analyzer
+      role: Performance Analyst
+      tools:
+        - analyze_metrics
+        - generate_insights