agent-recipes 0.0.5__py3-none-any.whl

agent_recipes/templates/ai-context-enricher/tools.py

@@ -0,0 +1,258 @@
+"""
+AI Context Enricher Tools
+
+Tools for enriching news articles with:
+- Background context
+- Prior art references
+- Stakeholder analysis (who benefits)
+- Hype detection
+"""
+
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def call_llm(prompt: str, max_tokens: int = 500) -> str:
+    """Call OpenAI API for text generation."""
+    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,
+            "temperature": 0.7,
+        },
+        timeout=60,
+    )
+    response.raise_for_status()
+    return response.json()["choices"][0]["message"]["content"]
+
+
+def add_background(
+    article: Dict[str, Any],
+    max_length: int = 300,
+) -> Dict[str, Any]:
+    """
+    Add background context to an article.
+    
+    Args:
+        article: Article dictionary
+        max_length: Maximum length of background text
+        
+    Returns:
+        Article with background field added
+    """
+    title = article.get("title", "")
+    content = article.get("content", "")[:500]
+    
+    prompt = f"""Given this AI news article, provide brief background context that helps readers understand the significance.
+
+Title: {title}
+Content: {content}
+
+Provide 2-3 sentences of background context explaining:
+1. What problem this addresses
+2. Why it matters now
+3. Key context readers should know
+
+Background:"""
+    
+    try:
+        background = call_llm(prompt, max_tokens=200)
+        article["background"] = background.strip()
+    except Exception as e:
+        logger.warning(f"Error adding background: {e}")
+        article["background"] = ""
+    
+    return article
+
+
+def find_prior_art(
+    article: Dict[str, Any],
+) -> Dict[str, Any]:
+    """
+    Find and reference prior art related to the article.
+    
+    Args:
+        article: Article dictionary
+        
+    Returns:
+        Article with prior_art field added
+    """
+    title = article.get("title", "")
+    content = article.get("content", "")[:500]
+    
+    prompt = f"""Given this AI news article, identify relevant prior art and historical context.
+
+Title: {title}
+Content: {content}
+
+List 2-3 relevant prior developments or research that led to this:
+- Include approximate dates if known
+- Mention key papers, products, or milestones
+- Keep each item to one sentence
+
+Prior Art:"""
+    
+    try:
+        prior_art = call_llm(prompt, max_tokens=250)
+        article["prior_art"] = prior_art.strip()
+    except Exception as e:
+        logger.warning(f"Error finding prior art: {e}")
+        article["prior_art"] = ""
+    
+    return article
+
+
+def analyze_stakeholders(
+    article: Dict[str, Any],
+) -> Dict[str, Any]:
+    """
+    Analyze who benefits and who is affected by this news.
+    
+    Args:
+        article: Article dictionary
+        
+    Returns:
+        Article with stakeholders field added
+    """
+    title = article.get("title", "")
+    content = article.get("content", "")[:500]
+    
+    prompt = f"""Analyze the stakeholders for this AI news:
+
+Title: {title}
+Content: {content}
+
+Identify:
+1. Who benefits most from this development?
+2. Who might be negatively affected?
+3. What industries or groups should pay attention?
+
+Keep response concise (3-4 sentences).
+
+Stakeholder Analysis:"""
+    
+    try:
+        stakeholders = call_llm(prompt, max_tokens=200)
+        article["stakeholders"] = stakeholders.strip()
+    except Exception as e:
+        logger.warning(f"Error analyzing stakeholders: {e}")
+        article["stakeholders"] = ""
+    
+    return article
+
+
+def detect_hype(
+    article: Dict[str, Any],
+) -> Dict[str, Any]:
+    """
+    Detect hype level and provide reality check.
+    
+    Args:
+        article: Article dictionary
+        
+    Returns:
+        Article with hype_analysis field added
+    """
+    title = article.get("title", "")
+    content = article.get("content", "")[:500]
+    
+    prompt = f"""Analyze the hype level of this AI news:
+
+Title: {title}
+Content: {content}
+
+Provide:
+1. Hype Level: LOW / MEDIUM / HIGH / OVERHYPED
+2. Reality Check: One sentence on what's actually new vs marketing
+3. Confidence: How confident are you in this assessment (LOW/MEDIUM/HIGH)
+
+Format as:
+Hype Level: [level]
+Reality Check: [assessment]
+Confidence: [level]"""
+    
+    try:
+        hype_analysis = call_llm(prompt, max_tokens=150)
+        
+        # Parse the response
+        lines = hype_analysis.strip().split("\n")
+        hype_data = {
+            "raw": hype_analysis.strip(),
+            "level": "MEDIUM",
+            "reality_check": "",
+            "confidence": "MEDIUM",
+        }
+        
+        for line in lines:
+            if "Hype Level:" in line:
+                hype_data["level"] = line.split(":")[-1].strip().upper()
+            elif "Reality Check:" in line:
+                hype_data["reality_check"] = line.split(":", 1)[-1].strip()
+            elif "Confidence:" in line:
+                hype_data["confidence"] = line.split(":")[-1].strip().upper()
+        
+        article["hype_analysis"] = hype_data
+    except Exception as e:
+        logger.warning(f"Error detecting hype: {e}")
+        article["hype_analysis"] = {"level": "UNKNOWN", "reality_check": "", "confidence": "LOW"}
+    
+    return article
+
+
+def enrich_articles(
+    articles: List[Dict[str, Any]],
+    enrichment_types: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    """
+    Enrich multiple articles with context.
+    
+    Args:
+        articles: List of article dictionaries
+        enrichment_types: Types of enrichment to apply
+        
+    Returns:
+        Dictionary with enriched articles
+    """
+    enrichment_types = enrichment_types or ["background", "prior_art", "stakeholders", "hype_detection"]
+    
+    enriched = []
+    
+    for article in articles:
+        enriched_article = article.copy()
+        
+        if "background" in enrichment_types:
+            enriched_article = add_background(enriched_article)
+        
+        if "prior_art" in enrichment_types:
+            enriched_article = find_prior_art(enriched_article)
+        
+        if "stakeholders" in enrichment_types:
+            enriched_article = analyze_stakeholders(enriched_article)
+        
+        if "hype_detection" in enrichment_types:
+            enriched_article = detect_hype(enriched_article)
+        
+        enriched.append(enriched_article)
+    
+    return {
+        "enriched_articles": enriched,
+        "stats": {
+            "total_enriched": len(enriched),
+            "enrichment_types": enrichment_types,
+        }
+    }

agent_recipes/templates/ai-contract-analyzer/README.md

@@ -0,0 +1,60 @@
+# Contract Analyzer
+
+Extract key terms, dates, obligations from contracts (LEGAL DISCLAIMER)
+
+## Installation
+
+```bash
+pip install agent-recipes
+```
+
+## CLI Usage
+
+```bash
+# Basic usage
+praison recipes run ai-contract-analyzer <input>
+
+# With output directory
+praison recipes run ai-contract-analyzer <input> --output ./output/
+
+# Dry run (check dependencies only)
+praison recipes run ai-contract-analyzer <input> --dry-run
+
+# Show recipe info
+praison recipes info ai-contract-analyzer
+
+# Check dependencies
+praison recipes doctor ai-contract-analyzer
+```
+
+## Python Usage
+
+```python
+from praisonaiagents import Agent
+from agent_recipes import load_recipe
+
+# Load and run recipe
+recipe = load_recipe("ai-contract-analyzer")
+result = recipe.run(input="<your-input>")
+print(result)
+```
+
+## Requirements
+
+### Packages
+- openai
+- pdftotext
+
+### Environment Variables
+- OPENAI_API_KEY
+
+### External Tools
+- poppler
+
+## Tags
+
+`document`, `contract`, `legal`, `analysis`
+
+## License
+
+Apache-2.0

agent_recipes/templates/ai-contract-analyzer/TEMPLATE.yaml

@@ -0,0 +1,34 @@
+name: ai-contract-analyzer
+version: "1.0.0"
+description: Extract key terms, dates, obligations from contracts (LEGAL DISCLAIMER)
+author: praison
+license: Apache-2.0
+tags:
+  - document
+  - contract
+  - legal
+  - analysis
+
+requires:
+  tools:
+    - doc_tool
+    - llm_tool
+  packages:
+    - openai
+    - pdftotext
+  env:
+    - OPENAI_API_KEY
+  external:
+    - poppler
+
+cli:
+  command: praison recipes run ai-contract-analyzer
+  examples:
+    - praison recipes run ai-contract-analyzer <input>
+    - praison recipes run ai-contract-analyzer <input> --output ./output/
+    - praison recipes run ai-contract-analyzer <input> --dry-run
+
+safety:
+  dry_run_default: false
+  overwrites_files: true
+  legal_disclaimer: "This tool provides extraction only, not legal advice."

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

@@ -0,0 +1,13 @@
+# AI CSV Cleaner
+
+Clean CSV files by removing duplicates, fixing nulls, and standardizing formats.
+
+## Usage
+```bash
+praison run ai-csv-cleaner data.csv
+praison run ai-csv-cleaner data.csv --drop-duplicates --fill-nulls mean
+```
+
+## Output
+- `cleaned.csv` - Cleaned data
+- `cleaning-report.json` - Changes made

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

@@ -0,0 +1,45 @@
+name: ai-csv-cleaner
+version: "1.0.0"
+description: Clean CSV files by removing duplicates, fixing nulls, and standardizing formats.
+author: praisonai
+license: Apache-2.0
+tags: [csv, data, cleaning, etl]
+
+requires:
+  tools: [shell_tool]
+  packages: [praisonai-tools, pandas]
+  env: [OPENAI_API_KEY]
+
+config:
+  input:
+    type: string
+    required: true
+  output:
+    type: string
+  drop_duplicates:
+    type: boolean
+    default: true
+  fill_nulls:
+    type: string
+
+cli:
+  command: ai-csv-cleaner
+  args:
+    - name: input
+      positional: true
+      required: true
+    - name: --output
+      short: -o
+    - name: --drop-duplicates
+      flag: true
+    - name: --fill-nulls
+  examples:
+    - "praison run ai-csv-cleaner data.csv"
+
+outputs:
+  - name: cleaned.csv
+    type: file
+  - name: cleaning-report.json
+    type: file
+  - name: run.json
+    type: file

agent_recipes/templates/ai-cta-generator/recipe.yaml

@@ -0,0 +1,54 @@
+name: ai-cta-generator
+version: 1.0.0
+description: Generate platform-specific CTAs and titles for YouTube, X, LinkedIn, and more
+author: PraisonAI
+tags:
+  - cta
+  - titles
+  - content
+  - optimization
+
+config:
+  platforms:
+    - youtube
+    - x
+    - linkedin
+    - instagram
+    - tiktok
+  cta_types:
+    - subscribe
+    - comment
+    - share
+    - click
+    - follow
+
+input:
+  type: object
+  properties:
+    topic:
+      type: string
+    platform:
+      type: string
+    cta_type:
+      type: string
+
+output:
+  type: object
+  properties:
+    ctas:
+      type: array
+    titles:
+      type: array
+
+requires:
+  env:
+    - OPENAI_API_KEY
+
+workflow:
+  agents:
+    - name: cta_generator
+      role: CTA Specialist
+      goal: Create compelling CTAs and titles
+      tools:
+        - generate_ctas
+        - generate_titles

agent_recipes/templates/ai-cta-generator/tools.py

@@ -0,0 +1,174 @@
+"""
+AI CTA + Title Generator Tools
+
+Generate platform-specific:
+- Calls to action
+- Video/post titles
+- Thumbnail text
+"""
+
+import logging
+import os
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+def call_llm(prompt: str, max_tokens: int = 600) -> str:
+    """Call OpenAI API for text generation."""
+    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,
+            "temperature": 0.8,
+        },
+        timeout=60,
+    )
+    response.raise_for_status()
+    return response.json()["choices"][0]["message"]["content"]
+
+
+def generate_ctas(
+    topic: str,
+    platform: str = "youtube",
+    cta_type: str = "subscribe",
+    num_variants: int = 5,
+) -> Dict[str, Any]:
+    """
+    Generate platform-specific CTAs.
+    
+    Args:
+        topic: Content topic
+        platform: Target platform
+        cta_type: Type of CTA
+        num_variants: Number of variants
+        
+    Returns:
+        Dictionary with CTA variants
+    """
+    platform_context = {
+        "youtube": "YouTube video ending, asking viewers to subscribe and engage",
+        "x": "Tweet or thread, asking for retweets and follows",
+        "linkedin": "LinkedIn post, asking for comments and connections",
+        "instagram": "Instagram post/reel, asking for saves and follows",
+        "tiktok": "TikTok video, asking for follows and duets",
+    }
+    
+    cta_context = {
+        "subscribe": "Get them to subscribe/follow",
+        "comment": "Encourage comments and discussion",
+        "share": "Ask them to share with others",
+        "click": "Drive clicks to a link",
+        "follow": "Get them to follow for more content",
+    }
+    
+    prompt = f"""Generate {num_variants} CTAs for this content:
+
+Topic: {topic}
+Platform: {platform} - {platform_context.get(platform, 'social media')}
+Goal: {cta_context.get(cta_type, 'engage audience')}
+
+Requirements:
+- Natural, conversational tone
+- Platform-appropriate language
+- Create urgency without being pushy
+- Each CTA should be different in approach
+
+Format each CTA on its own line, numbered 1-{num_variants}."""
+    
+    result = call_llm(prompt, max_tokens=500)
+    
+    ctas = []
+    for line in result.split("\n"):
+        line = line.strip()
+        if line and (line[0].isdigit() or line.startswith("-")):
+            # Remove numbering
+            cta_text = line.lstrip("0123456789.-) ").strip()
+            if cta_text:
+                ctas.append({
+                    "text": cta_text,
+                    "platform": platform,
+                    "type": cta_type,
+                })
+    
+    return {
+        "ctas": ctas[:num_variants],
+        "platform": platform,
+        "cta_type": cta_type,
+    }
+
+
+def generate_titles(
+    topic: str,
+    platform: str = "youtube",
+    num_variants: int = 5,
+    include_emoji: bool = False,
+) -> Dict[str, Any]:
+    """
+    Generate platform-optimized titles.
+    
+    Args:
+        topic: Content topic
+        platform: Target platform
+        num_variants: Number of title variants
+        include_emoji: Include emojis in titles
+        
+    Returns:
+        Dictionary with title variants
+    """
+    platform_limits = {
+        "youtube": 100,
+        "x": 280,
+        "linkedin": 150,
+        "instagram": 125,
+        "tiktok": 150,
+    }
+    
+    max_chars = platform_limits.get(platform, 100)
+    
+    prompt = f"""Generate {num_variants} titles for this content:
+
+Topic: {topic}
+Platform: {platform}
+Max characters: {max_chars}
+{"Include relevant emojis" if include_emoji else "No emojis"}
+
+Title styles to include:
+- How-to / Tutorial
+- Listicle (X things...)
+- Question
+- Bold statement
+- Curiosity gap
+
+Format each title on its own line, numbered 1-{num_variants}."""
+    
+    result = call_llm(prompt, max_tokens=400)
+    
+    titles = []
+    for line in result.split("\n"):
+        line = line.strip()
+        if line and (line[0].isdigit() or line.startswith("-")):
+            title_text = line.lstrip("0123456789.-) ").strip()
+            if title_text:
+                titles.append({
+                    "text": title_text[:max_chars],
+                    "platform": platform,
+                    "char_count": len(title_text),
+                })
+    
+    return {
+        "titles": titles[:num_variants],
+        "platform": platform,
+    }