python -m venv venv
source venv/bin/activate
pip install crewai[tools] duckduckgo-search openai
export OPENAI_API_KEY="sk-your-key"

# tools/search_tools.py
from crewai import Tool
from duckduckgo_search import DDGS
from typing import List, Dict
import logging

logger = logging.getLogger(__name__)


def search_web(query: str, num_results: int = 5) -> List[Dict]:
    """Search the web using DuckDuckGo."""
    try:
        with DDGS() as ddgs:
            results = list(ddgs.text(query, max_results=num_results))
            return [
                {"title": r["title"], "snippet": r["body"], "url": r["href"]}
                for r in results
            ]
    except Exception as e:
        logger.error(f"Web search failed: {e}")
        return []


def get_research_tool() -> Tool:
    """Create a web search tool for research agents."""
    def _search(query: str) -> str:
        results = search_web(query, num_results=5)
        if not results:
            return "No results found for the query."
        
        formatted = []
        for i, r in enumerate(results):
            formatted.append(
                f"[{i+1}] {r['title']}\n{r['snippet']}\nURL: {r['url']}"
            )
        return "\n\n".join(formatted)

    return Tool(
        name="Web Search",
        description="Search the web for current information on any topic",
        func=_search,
    )


def get_article_analysis_tool() -> Tool:
    """Create a URL content extraction tool."""
    def _analyze(url: str) -> str:
        import httpx
        try:
            response = httpx.get(url, follow_redirects=True, timeout=10)
            response.raise_for_status()
            from bs4 import BeautifulSoup
            soup = BeautifulSoup(response.text, "html.parser")
            
            # Remove script and style elements
            for element in soup(["script", "style", "nav", "footer"]):
                element.decompose()
            
            text = soup.get_text(separator="\n", strip=True)
            
            # Limit to meaningful content
            lines = [line.strip() for line in text.splitlines() if line.strip()]
            return "\n".join(lines)[:3000]
        except Exception as e:
            return f"Error analyzing article: {str(e)}"

    return Tool(
        name="Article Analyzer",
        description="Extract and analyze content from a URL",
        func=_analyze,
    )

# agents/researcher.py
from crewai import Agent, Tool
from tools.search_tools import get_research_tool, get_article_analysis_tool


def create_researcher() -> Agent:
    """Create a research agent with web search capabilities."""
    tools = [get_research_tool(), get_article_analysis_tool()]
    return Agent(
        role="Senior Research Analyst",
        goal="Gather comprehensive, accurate information on the given topic",
        backstory="""You are an expert researcher with a talent for finding 
        relevant information quickly. You verify multiple sources and identify 
        key insights, trends, and data points. You always cite your sources 
        and prioritize authoritative references.""",
        tools=tools,
        verbose=True,
        allow_delegation=False,
        max_iter=15,
        memory=True,
    )


# agents/writer.py
from crewai import Agent


def create_writer() -> Agent:
    """Create a content writer agent."""
    return Agent(
        role="Content Writer",
        goal="Transform research into engaging, well-structured articles",
        backstory="""You are a skilled writer who creates compelling content.
        You structure information logically, use clear language, and maintain
        reader engagement throughout. You can adapt tone for different audiences
        and always maintain factual accuracy.""",
        tools=[],
        verbose=True,
        allow_delegation=False,
        max_iter=10,
        memory=True,
    )


# agents/editor.py
from crewai import Agent


def create_editor() -> Agent:
    """Create an editor agent for quality assurance."""
    return Agent(
        role="Senior Editor",
        goal="Ensure content quality, accuracy, and readability",
        backstory="""You are a meticulous editor with exceptional attention to 
        detail. You check for grammar, clarity, flow, and factual accuracy.
        You improve content without changing the author's voice.
        You provide specific, actionable feedback.""",
        tools=[],
        verbose=True,
        allow_delegation=False,
        max_iter=10,
        memory=True,
    )


# agents/seo_specialist.py
from crewai import Agent


def create_seo_specialist() -> Agent:
    """Create an SEO optimization agent."""
    return Agent(
        role="SEO Specialist",
        goal="Optimize content for search engine visibility",
        backstory="""You are an SEO expert who understands search algorithms
        and user intent. You optimize titles, headings, meta descriptions,
        and content structure for maximum search visibility while maintaining
        readability for human audiences.""",
        tools=[],
        verbose=True,
        allow_delegation=False,
        max_iter=8,
        memory=True,
    )

# tasks/content_tasks.py
from crewai import Task


def create_research_task(agent, topic: str) -> Task:
    """Create a research task for the given topic."""
    return Task(
        description=f"""Research the topic: "{topic}"

1. Search for 5-7 authoritative sources
2. Extract key facts, statistics, and insights
3. Identify different perspectives and debates
4. Note any recent developments or trends
5. Compile a structured research summary with citations

Output format:
- Key Findings (5-7 bullet points)
- Supporting Evidence (with source URLs)
- Different Perspectives
- Recent Developments
- Conclusion""",
        expected_output="Structured research summary with citations",
        agent=agent,
    )


def create_writing_task(agent, topic: str) -> Task:
    """Create a writing task based on research."""
    return Task(
        description=f"""Write a comprehensive article on: "{topic}"

Using the research provided:
1. Create an engaging introduction with a hook
2. Structure content with clear H2/H3 headings
3. Include relevant examples and data points
4. Write 1500-2000 words
5. End with a strong conclusion and call to action

Style guidelines:
- Professional but accessible tone
- Short paragraphs (2-3 sentences)
- Use bullet points for lists
- Include transition sentences between sections""",
        expected_output="Complete 1500-2000 word article",
        agent=agent,
    )


def create_editing_task(agent) -> Task:
    """Create an editing task for quality review."""
    return Task(
        description="""Review and edit the article for:

1. Grammar and spelling errors
2. Clarity and readability
3. Logical flow and structure
4. Factual accuracy (flag any unsupported claims)
5. Tone consistency
6. Engagement level

Provide specific improvements and a cleaned-up version.""",
        expected_output="Edited article with improvements noted",
        agent=agent,
    )


def create_seo_task(agent) -> Task:
    """Create an SEO optimization task."""
    return Task(
        description="""Optimize the article for SEO:

1. Suggest primary keyword and 3-5 secondary keywords
2. Optimize title tag (under 60 characters)
3. Write meta description (under 160 characters)
4. Ensure proper heading hierarchy (H1, H2, H3)
5. Add internal linking suggestions
6. Optimize image alt text suggestions
7. Check keyword density (1-2%)

Provide the optimized version with SEO changes highlighted.""",
        expected_output="SEO-optimized article with metadata",
        agent=agent,
    )

# crew.py
from crewai import Crew, Process
from agents.researcher import create_researcher
from agents.writer import create_writer
from agents.editor import create_editor
from agents.seo_specialist import create_seo_specialist
from tasks.content_tasks import (
    create_research_task,
    create_writing_task,
    create_editing_task,
    create_seo_task,
)
import logging

logger = logging.getLogger(__name__)


class ContentCrew:
    """
    Multi-agent crew for content creation.
    
    Coordinates researcher, writer, editor, and SEO specialist
    to produce publication-ready articles.
    """
    
    def __init__(self, topic: str):
        self.topic = topic
        self.researcher = create_researcher()
        self.writer = create_writer()
        self.editor = create_editor()
        self.seo_specialist = create_seo_specialist()

    def run(self) -> dict:
        """Execute the content creation pipeline."""
        logger.info(f"Starting content creation for: {self.topic}")
        
        research_task = create_research_task(self.researcher, self.topic)
        writing_task = create_writing_task(self.writer, self.topic)
        editing_task = create_editing_task(self.editor)
        seo_task = create_seo_task(self.seo_specialist)

        crew = Crew(
            agents=[
                self.researcher,
                self.writer,
                self.editor,
                self.seo_specialist,
            ],
            tasks=[
                research_task,
                writing_task,
                editing_task,
                seo_task,
            ],
            process=Process.sequential,
            verbose=True,
            memory=True,
        )

        result = crew.kickoff()
        
        return {
            "topic": self.topic,
            "output": result,
            "usage_metrics": crew.usage_metrics,
        }

crew = ContentCrew(topic="AI in Healthcare 2024")
result = crew.run()
# Produces: Research-backed, well-written, edited, SEO-optimized article

# Customize agents for specific domains
researcher = create_researcher()
researcher.goal = "Focus on market data and competitor analysis"

writer = create_writer()
writer.backstory = "Write in formal consulting style with executive summaries"

# Example: Cost-controlled multi-agent system
crew = Crew(
    agents=[...],
    tasks=[...],
    max_rpm=10,  # Limit API calls per minute
    token_budget=10000,  # Limit total tokens
)