CrewAI — Multi-Agent Teams Made Easy

from crewai import Agent

researcher = Agent(
    role="Senior Research Analyst",
    goal="Find comprehensive, accurate data about the given topic",
    backstory="""You are a veteran research analyst with 15 years of
    experience at top consulting firms. You're known for finding
    hidden insights in data and never publishing unverified claims.
    You always cite your sources.""",
    tools=[search_tool, scrape_tool],
    llm="gpt-4o",             # ברירת מחדל: gpt-4o. אפשר claude, gemini...
    verbose=True,              # הדפסת כל צעד — מומלץ לפיתוח
    allow_delegation=True,     # יכול לבקש עזרה מסוכנים אחרים
    max_iter=5,                # מקסימום איטרציות
    memory=True                # הפעלת זיכרון
)

from crewai import Task

research_task = Task(
    description="""Research the current state of AI agents market
    in Israel. Focus on:
    1. Key companies (AI21, Tabnine, Run:ai, etc.)
    2. Investment trends in 2025-2026
    3. Most popular frameworks and tools
    4. Unique advantages of the Israeli ecosystem""",
    expected_output="""A detailed report with:
    - Executive summary (3-4 sentences)
    - List of top 10 Israeli AI agent companies with descriptions
    - Investment data with sources
    - Framework adoption trends
    - At least 5 cited sources""",
    agent=researcher,
    output_file="research_report.md"  # שמירה אוטומטית לקובץ
)

from crewai import Crew, Process

crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,     # סדרתי — כל משימה אחרי הקודמת
    verbose=True,
    memory=True,                    # זיכרון משותף
    max_rpm=10                      # הגבלת API calls לדקה
)

# הפעלת ה-crew
result = crew.kickoff()
print(result)

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, ScrapeWebsiteTool
from dotenv import load_dotenv
import os

load_dotenv()

# === כלים ===
search_tool = SerperDevTool()  # חיפוש Google (צריך SERPER_API_KEY)
scrape_tool = ScrapeWebsiteTool()  # גרידת תוכן מאתרים

# === Agent 1: Researcher ===
researcher = Agent(
    role="Senior Research Analyst",
    goal="Find accurate, comprehensive data about the given topic",
    backstory="""You are a veteran research analyst with 15 years
    of experience. You specialize in technology market research
    and are known for uncovering hidden trends. You always verify
    information from multiple sources before reporting.""",
    tools=[search_tool, scrape_tool],
    verbose=True,
    allow_delegation=False  # researcher עובד לבד
)

# === Agent 2: Writer ===
writer = Agent(
    role="Senior Content Writer",
    goal="Write engaging, well-structured articles based on research",
    backstory="""You are an award-winning content writer who has
    published in TechCrunch, Wired, and The Verge. You turn complex
    technical topics into clear, engaging content that both experts
    and beginners can understand. You write in a conversational yet
    authoritative tone.""",
    verbose=True,
    allow_delegation=False
)

# === Agent 3: Editor ===
editor = Agent(
    role="Chief Editor",
    goal="Ensure all content is polished, accurate, and publication-ready",
    backstory="""You are a meticulous editor with an eye for detail.
    You check facts, fix grammar, improve flow, and ensure consistency.
    You've edited for major tech publications and have zero tolerance
    for unverified claims or sloppy writing.""",
    verbose=True,
    allow_delegation=True  # יכול לבקש מ-researcher לאמת facts
)

# === Task 1: Research ===
research_task = Task(
    description="""Research the topic: '{topic}'.
    Find:
    1. Current state and key players
    2. Recent developments (2025-2026)
    3. Key statistics and data points
    4. Expert opinions and predictions
    Include at least 5 sources with URLs.""",
    expected_output="""A comprehensive research brief with:
    - Executive summary (100-150 words)
    - Key findings organized by sub-topic
    - Data points with citations
    - Source list with URLs""",
    agent=researcher
)

# === Task 2: Write ===
writing_task = Task(
    description="""Write a professional article based on the
    research provided. The article should be:
    - 800-1000 words
    - Include an attention-grabbing headline
    - Have clear sections with subheadings
    - Include data points from the research
    - End with actionable takeaways""",
    expected_output="""A complete article with:
    - Headline
    - Introduction (hook + thesis)
    - 3-4 body sections with subheadings
    - Conclusion with takeaways
    - 800-1000 words total""",
    agent=writer,
    context=[research_task]  # תלוי בתוצאת ה-research
)

# === Task 3: Edit ===
editing_task = Task(
    description="""Edit and polish the article. Check for:
    1. Factual accuracy — verify all claims against the research
    2. Grammar and spelling
    3. Flow and readability
    4. Consistent tone
    5. SEO optimization (title, headings, meta description)""",
    expected_output="""The final polished article, publication-ready,
    with a separate 'Editor Notes' section listing changes made.""",
    agent=editor,
    context=[research_task, writing_task],  # גישה ל-research ול-draft
    output_file="final_article.md"
)

# === Crew ===
content_crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    verbose=True
)

# === הפעלה ===
result = content_crew.kickoff(
    inputs={"topic": "AI Agents in Israeli Startups 2026"}
)

print("=" * 50)
print("Final Result:")
print(result)

# סוכן שמשתמש ב-Claude (מצוין למחקר ודיוק)
researcher = Agent(
    role="Senior Research Analyst",
    goal="Find accurate data",
    backstory="...",
    llm="anthropic/claude-sonnet-4-5-20250514"
)

# סוכן שמשתמש ב-GPT-4o (טוב לכתיבה יצירתית)
writer = Agent(
    role="Content Writer",
    goal="Write engaging articles",
    backstory="...",
    llm="gpt-4o"  # ברירת מחדל
)

# סוכן שמשתמש ב-Gemini (זול, טוב לעריכה)
editor = Agent(
    role="Editor",
    goal="Polish articles",
    backstory="...",
    llm="gemini/gemini-2.5-flash"
)

# סוכן עם מודל זול למשימות פשוטות
formatter = Agent(
    role="Formatter",
    goal="Format the final output",
    backstory="...",
    llm="gpt-4o-mini"  # $0.15/M input — חסכוני מאוד
)

crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential  # ברירת מחדל
)

# סדר הריצה: research → writing → editing
# כל task מקבל את הפלט של הקודם דרך context

crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.hierarchical,
    manager_llm="gpt-4o"  # המודל ל-manager agent
)

# ה-manager יחליט דינמית:
# - מי עובד על מה
# - באיזה סדר
# - האם צריך לחזור לשלב קודם
# - מתי הפרויקט מוכן

from crewai_tools import (
    SerperDevTool,        # חיפוש Google (דרך Serper API)
    ScrapeWebsiteTool,    # גרידת תוכן מאתרים
    FileReadTool,         # קריאת קבצים מקומיים
    DirectoryReadTool,    # קריאת תוכן תיקייה
    WebsiteSearchTool,    # חיפוש בתוך אתר ספציפי
    PDFSearchTool,        # חיפוש בתוך PDF
    YoutubeVideoSearchTool,  # חיפוש בסרטוני YouTube
)

# שימוש
search = SerperDevTool()  # צריך SERPER_API_KEY ב-.env
scraper = ScrapeWebsiteTool()
file_reader = FileReadTool(file_path="./data/report.csv")
dir_reader = DirectoryReadTool(directory="./data/")

# הקצאה לסוכנים
researcher = Agent(
    role="Researcher",
    goal="Find information",
    backstory="...",
    tools=[search, scraper]  # הסוכן יכול לחפש ולגרד
)

from crewai.tools import tool
import requests

@tool("Stock Price Checker")
def check_stock_price(symbol: str) -> str:
    """Check the current stock price for a given symbol.
    Use this when you need to look up stock prices.
    Args:
        symbol: The stock ticker symbol (e.g., AAPL, GOOGL, TSLA)
    """
    # סימולציה — בפרודקשן תחברו ל-API אמיתי
    prices = {"AAPL": 245.50, "GOOGL": 195.30, "TSLA": 420.10,
              "MSFT": 485.20, "NVDA": 890.40}
    price = prices.get(symbol.upper(), None)
    if price:
        return f"{symbol.upper()} current price: ${price:.2f}"
    return f"Symbol {symbol} not found. Available: {', '.join(prices.keys())}"

@tool("Company Info Lookup")
def lookup_company_info(company_name: str) -> str:
    """Look up detailed information about a company.
    Use this when you need company background, market cap, or sector info.
    Args:
        company_name: The name of the company to look up
    """
    # דוגמה פשוטה
    companies = {
        "AI21": {"sector": "AI/NLP", "location": "Tel Aviv",
                 "founded": 2017, "notable": "Jamba model"},
        "Tabnine": {"sector": "AI Coding", "location": "Tel Aviv",
                    "founded": 2013, "notable": "AI code completion"},
    }
    info = companies.get(company_name)
    if info:
        return f"{company_name}: {info}"
    return f"No info found for {company_name}"

# הקצאה לסוכן
analyst = Agent(
    role="Financial Analyst",
    goal="Analyze companies and stocks",
    backstory="...",
    tools=[check_stock_price, lookup_company_info]
)

from crewai.tools import BaseTool
from pydantic import BaseModel, Field
from typing import Type
import json

class MarketResearchInput(BaseModel):
    """Input schema for MarketResearchTool."""
    query: str = Field(..., description="The research query")
    market: str = Field(
        default="global",
        description="Target market: 'global', 'israel', 'us', 'eu'"
    )
    max_results: int = Field(
        default=5,
        description="Maximum number of results to return"
    )

class MarketResearchTool(BaseTool):
    name: str = "Market Research Tool"
    description: str = """Research market data including market size,
    growth rates, key players, and trends. Use this for any market
    analysis or competitive intelligence task."""
    args_schema: Type[BaseModel] = MarketResearchInput

    def _run(self, query: str, market: str = "global",
             max_results: int = 5) -> str:
        """Execute the market research."""
        # בפרודקשן — חיבור ל-API אמיתי (Statista, CB Insights, etc.)
        results = {
            "query": query,
            "market": market,
            "findings": [
                f"Market size for '{query}' in {market}: $X.XB (2026)",
                f"Growth rate: XX% CAGR (2024-2028)",
                f"Key players: Company A, Company B, Company C",
                f"Trend: Increasing adoption of AI agents",
                f"Israel-specific: Strong ecosystem with Unit 8200 alumni"
            ][:max_results]
        }
        return json.dumps(results, indent=2)

# שימוש
market_tool = MarketResearchTool()
analyst = Agent(
    role="Market Analyst",
    goal="Provide market insights",
    backstory="...",
    tools=[market_tool]
)

from crewai import Agent
from crewai_tools import MCPTool

# חיבור לשרת MCP קיים
mcp_tool = MCPTool(
    server_command="npx",
    server_args=["-y", "@modelcontextprotocol/server-filesystem",
                 "/path/to/allowed/directory"]
)

# הסוכן מקבל גישה לכל הכלים שה-MCP server חושף
file_agent = Agent(
    role="File Manager",
    goal="Manage and analyze files",
    backstory="...",
    tools=[mcp_tool]
)

researcher = Agent(
    role="Senior Researcher",
    goal="Find comprehensive data",
    backstory="...",
    allow_delegation=False  # Researcher עובד לבד — מומחה יחיד
)

writer = Agent(
    role="Content Writer",
    goal="Write excellent articles",
    backstory="...",
    allow_delegation=True  # Writer יכול לבקש עזרה
)

editor = Agent(
    role="Chief Editor",
    goal="Ensure publication-quality content",
    backstory="""You are meticulous about facts. When you encounter
    an unverified claim, you ALWAYS delegate to the researcher
    to verify it before publishing.""",
    allow_delegation=True  # Editor יכול לבקש מ-researcher לאמת
)

# כשה-editor רואה claim לא מאומת, הוא יפנה ל-researcher:
# "Hey Senior Researcher, can you verify this claim about...?"

# הגבלת עומק delegation
agent = Agent(
    role="...",
    goal="...",
    backstory="...",
    allow_delegation=True,
    max_iter=5,        # מקסימום 5 iteration cycles
    max_retry_limit=2  # מקסימום 2 retries על שגיאות
)

# Pattern מומלץ:
# 1. Researcher: allow_delegation=False (מומחה — עובד לבד)
# 2. Writer: allow_delegation=True (יכול לבקש facts מ-researcher)
# 3. Editor: allow_delegation=True (יכול לבקש מ-researcher לאמת)
# 4. Formatter: allow_delegation=False (משימה טכנית — לא צריך עזרה)

# Task 0: Planning meeting
planning_task = Task(
    description="""Before starting any work, discuss the project
    approach with your team. Consider:
    1. What information do we need?
    2. What's the best structure for the final output?
    3. What are the potential challenges?
    Produce a brief project plan.""",
    expected_output="""A project plan with:
    - Key research questions
    - Article structure
    - Risk areas to watch
    - Quality criteria""",
    agent=editor  # Editor leads the planning
)

# הוסיפו כ-task ראשון — כל ה-tasks הבאים יקבלו את ה-plan כ-context
writing_task = Task(
    description="Write the article based on research AND the project plan...",
    expected_output="...",
    agent=writer,
    context=[planning_task, research_task]
)

from crewai import Crew, Process

# הפעלת כל סוגי ה-memory
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    memory=True,           # מפעיל את כל סוגי ה-memory
    verbose=True
)

# ריצה ראשונה — ה-crew לומד
result1 = crew.kickoff(inputs={"topic": "AI Agents Market"})

# ריצה שנייה — ה-crew *זוכר* מה עשה קודם
# ויכול לבנות על הידע הקודם
result2 = crew.kickoff(inputs={"topic": "AI Agents in Healthcare"})
# ^ ה-crew יזכור entities, patterns ומידע מהריצה הראשונה

from crewai import Crew

# הגדרת memory מתקדמת
crew = Crew(
    agents=[...],
    tasks=[...],
    memory=True,
    # ברירת מחדל: שמירה מקומית בתיקיית db/
    # long-term memory נשמר ב-SQLite
    # entity memory משתמש בהטמעות (embeddings)
    embedder={
        "provider": "openai",
        "config": {
            "model": "text-embedding-3-small"
        }
    }
)

from crewai import Task

def should_fact_check(output) -> bool:
    """Run fact check only if the article mentions statistics."""
    return any(word in output.raw.lower()
               for word in ["percent", "%", "billion", "million", "study"])

# Task שרץ רק אם יש claim סטטיסטי
fact_check_task = Task(
    description="Verify all statistical claims in the article...",
    expected_output="Fact-check report with verified/unverified claims",
    agent=researcher,
    condition=should_fact_check,  # רץ רק אם הפונקציה מחזירה True
    context=[writing_task]
)

from pydantic import BaseModel, Field
from typing import List

class CompetitorAnalysis(BaseModel):
    """Structured output for competitive analysis."""
    company_name: str = Field(description="Name of the competitor")
    market_share: float = Field(description="Market share percentage")
    strengths: List[str] = Field(description="Top 3 strengths")
    weaknesses: List[str] = Field(description="Top 3 weaknesses")
    threat_level: str = Field(description="low, medium, or high")

class MarketReport(BaseModel):
    """Complete market report."""
    executive_summary: str
    market_size_usd: float
    growth_rate: float
    competitors: List[CompetitorAnalysis]
    recommendations: List[str]

# Task עם structured output
analysis_task = Task(
    description="Analyze the competitive landscape for {topic}...",
    expected_output="Structured market report",
    agent=analyst,
    output_pydantic=MarketReport  # מכריח structured output!
)

# אחרי ריצה:
result = crew.kickoff(inputs={"topic": "AI Agents"})
report = result.pydantic  # MarketReport object — type-safe!
print(f"Market size: ${report.market_size_usd:,.0f}")
for comp in report.competitors:
    print(f"  {comp.company_name}: {comp.threat_level} threat")

import time

def on_task_start(task_output):
    """Called before a task starts."""
    print(f"[{time.strftime('%H:%M:%S')}] Starting task...")

def on_task_complete(task_output):
    """Called after a task completes."""
    print(f"[{time.strftime('%H:%M:%S')}] Task completed!")
    print(f"  Output length: {len(task_output.raw)} chars")

    # שמירה ל-database, שליחת notification, וכו'
    if len(task_output.raw) < 100:
        print("  WARNING: Output seems too short!")

research_task = Task(
    description="...",
    expected_output="...",
    agent=researcher,
    callback=on_task_complete  # נקרא אחרי שה-task מסתיים
)

from crewai.flow.flow import Flow, listen, start, router
from pydantic import BaseModel

# === State שמנוהל לאורך כל ה-Flow ===
class MarketAnalysisState(BaseModel):
    topic: str = ""
    research_data: str = ""
    analysis: str = ""
    final_report: str = ""

class MarketAnalysisFlow(Flow[MarketAnalysisState]):
    """Flow that orchestrates research -> analysis -> report."""

    @start()
    def run_research_crew(self):
        """Step 1: Research crew gathers data."""
        research_crew = Crew(
            agents=[researcher],
            tasks=[research_task],
            process=Process.sequential
        )
        result = research_crew.kickoff(
            inputs={"topic": self.state.topic}
        )
        self.state.research_data = result.raw
        return result.raw

    @listen(run_research_crew)
    def run_analysis_crew(self):
        """Step 2: Analysis crew analyzes the research."""
        analysis_crew = Crew(
            agents=[analyst, statistician],
            tasks=[analysis_task, stats_task],
            process=Process.sequential
        )
        result = analysis_crew.kickoff(
            inputs={"research": self.state.research_data}
        )
        self.state.analysis = result.raw
        return result.raw

    @listen(run_analysis_crew)
    def run_report_crew(self):
        """Step 3: Report crew writes the final report."""
        report_crew = Crew(
            agents=[writer, editor],
            tasks=[writing_task, editing_task],
            process=Process.sequential
        )
        result = report_crew.kickoff(
            inputs={
                "research": self.state.research_data,
                "analysis": self.state.analysis
            }
        )
        self.state.final_report = result.raw
        return result.raw

# === הפעלה ===
flow = MarketAnalysisFlow()
final = flow.kickoff(inputs={"topic": "AI Agents Market Israel 2026"})
print(final)

from crewai.flow.flow import Flow, listen, start, router, or_

class ContentFlow(Flow[ContentState]):

    @start()
    def gather_requirements(self):
        """Step 1: Understand what content is needed."""
        # ... gather requirements logic ...
        return self.state.requirements

    @router(gather_requirements)
    def decide_content_type(self):
        """Route based on content type."""
        if "blog" in self.state.requirements.lower():
            return "blog_crew"
        elif "social" in self.state.requirements.lower():
            return "social_crew"
        else:
            return "general_crew"

    @listen("blog_crew")
    def run_blog_crew(self):
        """Specialized blog writing crew."""
        blog_crew = Crew(
            agents=[seo_researcher, blog_writer, blog_editor],
            tasks=[seo_task, blog_writing_task, blog_editing_task],
            process=Process.sequential
        )
        return blog_crew.kickoff().raw

    @listen("social_crew")
    def run_social_crew(self):
        """Specialized social media crew."""
        social_crew = Crew(
            agents=[trend_analyst, copywriter],
            tasks=[trend_task, social_copy_task],
            process=Process.sequential
        )
        return social_crew.kickoff().raw

    @listen("general_crew")
    def run_general_crew(self):
        """General content crew."""
        general_crew = Crew(
            agents=[writer, editor],
            tasks=[writing_task, editing_task],
            process=Process.sequential
        )
        return general_crew.kickoff().raw

    @listen(or_(run_blog_crew, run_social_crew, run_general_crew))
    def quality_check(self):
        """Final quality check — runs regardless of which crew was used."""
        # ... quality check logic ...
        return self.state.final_output

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

search = SerperDevTool()

# === Agents ===
seo_researcher = Agent(
    role="SEO Research Specialist",
    goal="Find high-value keywords and content gaps",
    backstory="""10 years in SEO. You understand search intent,
    keyword difficulty, and content gaps. You use data-driven
    approaches and always check search volume.""",
    tools=[search],
    llm="gpt-4o"
)

content_writer = Agent(
    role="Senior Content Writer",
    goal="Write SEO-optimized articles that rank and engage",
    backstory="""You write content that ranks on Google AND
    engages readers. You balance SEO keywords with readability.
    You've helped clients increase organic traffic by 300%.""",
    llm="anthropic/claude-sonnet-4-5-20250514"
)

social_manager = Agent(
    role="Social Media Manager",
    goal="Create engaging social posts that drive traffic to the article",
    backstory="""You manage social media for tech brands.
    You know what works on LinkedIn, X, and Instagram.
    You adapt the message for each platform's audience.""",
    llm="gpt-4o-mini"  # מודל זול — מספיק ל-social posts
)

# === Tasks ===
seo_task = Task(
    description="""Research SEO opportunity for: '{topic}'.
    Provide: primary keyword, 5 secondary keywords, search intent,
    top 3 ranking competitors, content gap analysis.""",
    expected_output="SEO brief with keywords, competitors, and gaps",
    agent=seo_researcher
)

content_task = Task(
    description="""Write a 1500-word SEO-optimized article about '{topic}'.
    Use the SEO brief from the researcher. Include:
    - H1 with primary keyword
    - H2s with secondary keywords
    - Meta description (155 chars)
    - Internal linking suggestions""",
    expected_output="Complete SEO article with meta description",
    agent=content_writer,
    context=[seo_task]
)

social_task = Task(
    description="""Create social media posts for the article:
    - LinkedIn post (professional, 200-300 words)
    - X/Twitter thread (5 tweets, each under 280 chars)
    - Instagram caption (with emoji, hashtags)""",
    expected_output="3 platform-specific social posts",
    agent=social_manager,
    context=[content_task],
    output_file="social_posts.md"
)

# === Crew ===
marketing_crew = Crew(
    agents=[seo_researcher, content_writer, social_manager],
    tasks=[seo_task, content_task, social_task],
    process=Process.sequential,
    verbose=True
)

result = marketing_crew.kickoff(
    inputs={"topic": "AI Agents for Digital Marketing 2026"}
)

pm = Agent(
    role="Product Manager",
    goal="Define clear requirements from user stories",
    backstory="You translate vague requirements into clear specs...",
    llm="gpt-4o"
)

developer = Agent(
    role="Senior Python Developer",
    goal="Write clean, tested, production-ready code",
    backstory="""15 years Python experience. You write code that
    follows PEP 8, has docstrings, and includes error handling.
    You always write tests alongside your code.""",
    llm="anthropic/claude-sonnet-4-5-20250514"  # Claude מצוין לקוד
)

qa_engineer = Agent(
    role="QA Engineer",
    goal="Find bugs and verify requirements are met",
    backstory="You have a talent for finding edge cases...",
    llm="gpt-4o"
)

docs_writer = Agent(
    role="Technical Writer",
    goal="Write clear documentation for developers",
    backstory="...",
    llm="gpt-4o-mini"  # מספיק לדוקומנטציה
)

# Tasks: spec → code → test → docs
spec_task = Task(
    description="Write technical spec for: {feature}",
    expected_output="PRD with requirements, acceptance criteria, edge cases",
    agent=pm
)

code_task = Task(
    description="Implement the feature based on the spec...",
    expected_output="Python code with docstrings and type hints",
    agent=developer,
    context=[spec_task]
)

test_task = Task(
    description="Review the code and write test cases...",
    expected_output="Test report + pytest test cases",
    agent=qa_engineer,
    context=[spec_task, code_task]
)

docs_task = Task(
    description="Write API documentation...",
    expected_output="Markdown documentation with examples",
    agent=docs_writer,
    context=[spec_task, code_task],
    output_file="api_docs.md"
)

dev_crew = Crew(
    agents=[pm, developer, qa_engineer, docs_writer],
    tasks=[spec_task, code_task, test_task, docs_task],
    process=Process.sequential
)

lead_researcher = Agent(
    role="Lead Research Specialist",
    goal="Find and qualify potential leads",
    backstory="""You specialize in B2B lead research for Israeli
    tech companies selling to US enterprise clients. You understand
    the unique challenges of selling from Israel to the US market
    — timezone differences, cultural nuances, and the competitive
    landscape.""",
    tools=[search],
    llm="gpt-4o"
)

outreach_specialist = Agent(
    role="Outreach Specialist",
    goal="Write personalized outreach messages that get responses",
    backstory="""You've written outreach for Israeli startups
    targeting Fortune 500 companies. You know that personalization
    is everything — generic templates get 2% response rates,
    your personalized messages get 15-20%.""",
    llm="anthropic/claude-sonnet-4-5-20250514"
)

followup_manager = Agent(
    role="Follow-up Manager",
    goal="Create follow-up sequences that convert",
    backstory="""You manage follow-up sequences for enterprise sales.
    You know that 80% of sales require 5+ follow-ups. You write
    sequences that add value at each step — never just 'checking in'.""",
    llm="gpt-4o-mini"
)

# Tasks
research_leads = Task(
    description="""Research potential leads for: '{product}'.
    Target: VP/Director level at US companies with 500+ employees.
    Find 5 leads with: name, title, company, pain point, linkedin URL.""",
    expected_output="5 qualified leads with details",
    agent=lead_researcher
)

write_outreach = Task(
    description="""Write personalized outreach emails for each lead.
    Each email should reference a specific pain point and how
    '{product}' solves it. Keep emails under 150 words.""",
    expected_output="5 personalized outreach emails",
    agent=outreach_specialist,
    context=[research_leads]
)

create_followups = Task(
    description="""Create a 3-email follow-up sequence for each lead.
    Follow-up 1 (day 3): value-add insight
    Follow-up 2 (day 7): social proof / case study
    Follow-up 3 (day 14): final touch with specific ask""",
    expected_output="3 follow-up emails per lead (15 total)",
    agent=followup_manager,
    context=[research_leads, write_outreach],
    output_file="outreach_sequences.md"
)

sales_crew = Crew(
    agents=[lead_researcher, outreach_specialist, followup_manager],
    tasks=[research_leads, write_outreach, create_followups],
    process=Process.sequential,
    memory=True  # זוכר leads מריצות קודמות
)

import time
import logging
from crewai import Crew, Process

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def run_crew_safe(crew, inputs, max_retries=3):
    """Run a crew with retry logic and monitoring."""
    for attempt in range(max_retries):
        try:
            start_time = time.time()
            result = crew.kickoff(inputs=inputs)
            elapsed = time.time() - start_time

            # Monitoring
            logger.info(f"Crew completed in {elapsed:.1f}s")
            logger.info(f"Output length: {len(result.raw)} chars")

            # Basic quality check
            if len(result.raw) < 50:
                logger.warning("Output seems too short — may be low quality")

            return result

        except Exception as e:
            logger.error(f"Attempt {attempt + 1} failed: {e}")
            if attempt < max_retries - 1:
                wait = 2 ** attempt  # Exponential backoff
                logger.info(f"Retrying in {wait}s...")
                time.sleep(wait)
            else:
                logger.error("All retries exhausted")
                raise

# שימוש
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    max_rpm=10,     # הגבלת rate — חשוב בפרודקשן!
    verbose=False   # False בפרודקשן — verbose רק ב-dev
)

result = run_crew_safe(
    crew,
    inputs={"topic": "AI Agents Market 2026"},
    max_retries=3
)

# 1. מיקוס מודלים — מודל יקר רק למי שצריך
researcher = Agent(llm="gpt-4o", ...)        # $2.50/M input — צריך quality
writer = Agent(llm="anthropic/claude-sonnet-4-5-20250514", ...)  # $3/M — איכות כתיבה
formatter = Agent(llm="gpt-4o-mini", ...)    # $0.15/M — מספיק ל-formatting

# 2. הגבלת iterations
agent = Agent(max_iter=3, ...)  # ברירת מחדל: 15 (!)

# 3. הגבלת RPM
crew = Crew(max_rpm=10, ...)  # מונע burst של API calls

# 4. תיאורי tasks קצרים — פחות tokens
# רע: תיאור של 500 מילים
# טוב: תיאור של 100-150 מילים ברורות

# 5. הימנעו מ-delegation מיותר
agent = Agent(allow_delegation=False, ...)  # רק כשבאמת צריך