crewai create crew job_posting_agent

job_posting_agent/
├── .env                           # API keys
├── .gitignore
├── pyproject.toml                 # Dependencies
├── README.md
├── knowledge/
│   └── user_preference.txt
└── src/job_posting_agent/
    ├── __init__.py
    ├── main.py                    # Main execution
    ├── crew.py                    # Crew definition
    ├── config/
    │   ├── agents.yaml           # Agent configurations
    │   └── tasks.yaml            # Task definitions
    └── tools/
        ├── __init__.py
        └── custom_tool.py        # Custom tools

# .env (already has OPENAI_API_KEY from crewai create)
OPENAI_API_KEY=your_openai_key_here
AGENTOPS_API_KEY=your_agentops_key_here
SERPER_API_KEY=your_serper_key_here

researcher:
  role: "Research Analyst"
  goal: "Analyze the company website and provided description to extract insights on culture, values, and specific needs."
  backstory: "Expert in analyzing company cultures and identifying key values and needs from various sources, including websites and brief descriptions."
  verbose: true

writer:
  role: "Job Description Writer"
  goal: "Use insights from the Research Analyst to create a detailed, engaging, and enticing job posting."
  backstory: "Skilled in crafting compelling job descriptions that resonate with the company's values and attract the right candidates."
  verbose: true

editor:
  role: "Review and Editing Specialist"
  goal: "Review the job posting for clarity, engagement, grammatical accuracy, and alignment with company values and refine it to ensure perfection."
  backstory: "A meticulous editor with an eye for detail, ensuring every piece of content is clear, engaging, and grammatically perfect."
  verbose: true

research_company_culture:
  description: >
    Analyze the provided company website and description: "{company_description}" 
    at domain {company_domain}. Focus on understanding the company's culture, 
    values, and mission. Identify unique selling points and specific projects 
    or achievements highlighted on the site. Compile a report summarizing these 
    insights, specifically how they can be leveraged in a job posting to attract 
    the right candidates.
  expected_output: >
    A comprehensive report detailing the company's culture, values, and mission, 
    along with specific selling points relevant to the job role. Suggestions on 
    incorporating these insights into the job posting should be included.
  agent: researcher

research_role_requirements:
  description: >
    Based on the hiring manager's needs: "{hiring_needs}", identify the key skills, 
    experiences, and qualities the ideal candidate should possess for the role. 
    Consider the company's current projects, its competitive landscape, and industry 
    trends. Prepare a list of recommended job requirements and qualifications that 
    align with the company's needs and values.
  expected_output: >
    A list of recommended skills, experiences, and qualities for the ideal candidate, 
    aligned with the company's culture, ongoing projects, and the specific role's requirements.
  agent: researcher

draft_job_posting:
  description: >
    Draft a job posting for the role described by the hiring manager: "{hiring_needs}". 
    Use the insights on "{company_description}" to start with a compelling introduction, 
    followed by a detailed role description, responsibilities, and required skills and 
    qualifications. Ensure the tone aligns with the company's culture and incorporate 
    any unique benefits or opportunities offered by the company. 
    Specific benefits: "{specific_benefits}"
  expected_output: >
    A detailed, engaging job posting that includes an introduction, role description, 
    responsibilities, requirements, and unique company benefits. The tone should 
    resonate with the company's culture and values, aimed at attracting the right candidates.
  agent: writer
  context:
    - research_company_culture
    - research_role_requirements

review_and_edit_job_posting:
  description: >
    Review the draft job posting for the role: "{hiring_needs}". Check for clarity, 
    engagement, grammatical accuracy, and alignment with the company's culture and 
    values. Edit and refine the content, ensuring it speaks directly to the desired 
    candidates and accurately reflects the role's unique benefits and opportunities. 
    Provide feedback for any necessary revisions.
  expected_output: >
    A polished, error-free job posting that is clear, engaging, and perfectly 
    aligned with the company's culture and values. Feedback on potential improvements 
    and final approval for publishing. Formatted in markdown.
  agent: editor
  context:
    - draft_job_posting
  output_file: "job_posting.md"

from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import SerperDevTool, WebsiteSearchTool
import agentops

# Initialize AgentOps
agentops.init()

@CrewBase
class JobPostingAgentCrew():
    """JobPostingAgent crew"""
    
    def __init__(self) -> None:
        # Initialize tools
        self.serper_tool = SerperDevTool()
        self.website_tool = WebsiteSearchTool()

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config['researcher'],
            tools=[self.serper_tool, self.website_tool]
        )

    @agent
    def writer(self) -> Agent:
        return Agent(
            config=self.agents_config['writer'],
            tools=[self.serper_tool, self.website_tool]
        )

    @agent
    def editor(self) -> Agent:
        return Agent(
            config=self.agents_config['editor']
        )

    @task
    def research_company_culture(self) -> Task:
        return Task(
            config=self.tasks_config['research_company_culture']
        )

    @task
    def research_role_requirements(self) -> Task:
        return Task(
            config=self.tasks_config['research_role_requirements']
        )

    @task
    def draft_job_posting(self) -> Task:
        return Task(
            config=self.tasks_config['draft_job_posting']
        )

    @task
    def review_and_edit_job_posting(self) -> Task:
        return Task(
            config=self.tasks_config['review_and_edit_job_posting']
        )

    @crew
    def crew(self) -> Crew:
        """Creates the JobPostingAgent crew"""
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True
        )

#!/usr/bin/env python
import sys
import warnings
from job_posting_agent.crew import JobPostingAgentCrew
import agentops

warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")

def run():
    """
    Run the crew with AgentOps tracking.
    """
    # Start AgentOps session
    session = agentops.start_session(tags=["crewai", "job-posting"])
    
    try:
        # Define the inputs for the crew
        inputs = {
            'company_description': 'A fast-paced tech startup focused on AI-driven solutions for e-commerce.',
            'company_domain': 'https://agentops.ai',
            'hiring_needs': 'Senior Software Engineer with experience in Python, AI, and cloud platforms.',
            'specific_benefits': 'Competitive salary, stock options, remote work flexibility, and great team culture.'
        }
        
        # Initialize and run the crew
        crew = JobPostingAgentCrew().crew()
        result = crew.kickoff(inputs=inputs)
        
        print("\n" + "="*50)
        print("Job Posting Creation Completed!")
        print("Result:")
        print(result)
        print("\nCheck 'job_posting.md' for the generated job posting.")
        
        # End session successfully
        agentops.end_session("Success")
        return result
        
    except Exception as e:
        print(f"An error occurred: {e}")
        agentops.end_session("Failed", end_state_reason=str(e))
        raise

def train():
    """
    Train the crew for a given number of iterations.
    """
    inputs = {
        'company_description': 'A fast-paced tech startup focused on AI-driven solutions for e-commerce.',
        'company_domain': 'https://agentops.ai', 
        'hiring_needs': 'Senior Software Engineer with experience in Python, AI, and cloud platforms.',
        'specific_benefits': 'Competitive salary, stock options, remote work flexibility, and great team culture.'
    }
    try:
        JobPostingAgentCrew().crew().train(n_iterations=int(sys.argv[1]), filename=sys.argv[2], inputs=inputs)
    except Exception as e:
        raise Exception(f"An error occurred while training the crew: {e}")

def replay():
    """
    Replay the crew execution from a specific task.
    """
    try:
        JobPostingAgentCrew().crew().replay(task_id=sys.argv[1])
    except Exception as e:
        raise Exception(f"An error occurred while replaying the crew: {e}")

def test():
    """
    Test the crew execution and returns the results.
    """
    inputs = {
        'company_description': 'A fast-paced tech startup focused on AI-driven solutions for e-commerce.',
        'company_domain': 'https://agentops.ai',
        'hiring_needs': 'Senior Software Engineer with experience in Python, AI, and cloud platforms.',
        'specific_benefits': 'Competitive salary, stock options, remote work flexibility, and great team culture.'
    }
    try:
        JobPostingAgentCrew().crew().test(n_iterations=int(sys.argv[1]), openai_model_name=sys.argv[2], inputs=inputs)
    except Exception as e:
        raise Exception(f"An error occurred while testing the crew: {e}")

cd job_posting_agent
crewai run