initial commit - AI automation agents

.gitignore

@@ -0,0 +1,5 @@
+.env
+.venv
+__pycache__
+*.pyc
+*.pyo

Job Finder/app.py

@@ -0,0 +1,102 @@
+import gradio as gr
+import pdfplumber
+from fetcher import fetch_jobs
+from formatter import format_jobs
+from cover_letter import generate_cover_letter
+
+# store jobs globally so cover letter tab can access them
+job_store = []
+
+def read_cv(cv_file):
+    if cv_file is None:
+        return ""
+    try:
+        with pdfplumber.open(cv_file.name) as pdf:
+            text = ""
+            for page in pdf.pages:
+                text += page.extract_text() or ""
+        return text
+    except Exception as e:
+        return f"Could not read CV: {e}"
+
+def search_jobs(job_title):
+    global job_store
+    jobs = fetch_jobs(job_title)
+    job_store = jobs
+    if not jobs:
+        return "No jobs found. Try a broader search term."
+    formatted = format_jobs(jobs, job_title, "")
+    return formatted
+
+def create_cover_letter(job_number, cv_file):
+    global job_store
+    cv_text = read_cv(cv_file)
+    
+    if not cv_text:
+        return "Please upload your CV first."
+    
+    if not job_store:
+        return "Please search for jobs first."
+    
+    try:
+        index = int(job_number) - 1
+        job = job_store[index]
+    except Exception:
+        return "Invalid job number. Please enter a number from the job results."
+    
+    return generate_cover_letter(
+        job["title"],
+        job["company"],
+        job["description"],
+        cv_text
+    )
+
+with gr.Blocks(title="AI Job Finder Agent") as ui:
+    gr.Markdown("# 🤖 AI Job Finder Agent")
+    gr.Markdown("Find remote jobs and generate tailored cover letters from your CV")
+
+    with gr.Tab("🔍 Find Jobs"):
+        job_input = gr.Textbox(
+            label="What role are you looking for?",
+            placeholder="e.g. Python Developer, Designer, Data Analyst..."
+        )
+        search_btn = gr.Button("Find Jobs", variant="primary")
+        job_results = gr.Markdown()
+        status_text = gr.Textbox(label="Status", interactive=False, value="Idle")
+
+        def search_jobs_with_status(job_title):
+            if not job_title or not job_title.strip():
+                return "", "Please enter a search query."
+            return search_jobs(job_title), "Search completed"
+
+        search_btn.click(
+            fn=search_jobs_with_status,
+            inputs=[job_input],
+            outputs=[job_results, status_text]
+        )
+
+    with gr.Tab("✉️ Generate Cover Letter"):
+        gr.Markdown("Upload your CV and enter the job number from the search results")
+        cv_upload = gr.File(label="Upload CV (PDF)", file_types=[".pdf"])
+        job_number = gr.Textbox(
+            label="Job Number",
+            placeholder="e.g. 1, 2, 3..."
+        )
+        cl_btn = gr.Button("Generate Cover Letter", variant="primary")
+        cl_output = gr.Markdown()
+        cl_status = gr.Textbox(label="Status", interactive=False, value="Idle")
+
+        def create_cover_letter_with_status(job_number, cv_file):
+            if not job_number or not str(job_number).isdigit():
+                return "", "Invalid job number"
+            if not cv_file:
+                return "", "Upload CV first"
+            return create_cover_letter(job_number, cv_file), "Cover letter generated"
+
+        cl_btn.click(
+            fn=create_cover_letter_with_status,
+            inputs=[job_number, cv_upload],
+            outputs=[cl_output, cl_status]
+        )
+
+ui.launch()

Job Finder/cover_letter.py

@@ -0,0 +1,61 @@
+import os
+from groq import Groq
+from dotenv import load_dotenv
+from pathlib import Path
+
+env_file = Path(__file__).parent / ".env"
+if not env_file.exists():
+    env_file = Path(__file__).parent.parent / ".env"
+load_dotenv(env_file)
+
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+def extract_cv_info(cv_text):
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[
+            {
+                "role": "system",
+                "content": "Extract key information from this CV. Return only: full name, key skills, years of experience, and notable achievements."
+            },
+            {
+                "role": "user",
+                "content": cv_text
+            }
+        ]
+    )
+    return response.choices[0].message.content
+
+
+def generate_cover_letter(job_title, company, job_description, cv_text):
+    cv_info = extract_cv_info(cv_text)
+    
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[
+            {
+                "role": "system",
+                "content": "You are an expert career coach. Write concise compelling cover letters in 3 paragraphs. End with the applicant's full name only."
+            },
+            {
+                "role": "user",
+                "content": f"""
+Write a tailored cover letter for this job:
+
+Job Title: {job_title}
+Company: {company}
+Job Description: {job_description}
+
+Applicant Info extracted from CV:
+{cv_info}
+
+Rules:
+- 3 paragraphs max
+- Tailor specifically to the job description
+- End with applicant's full name only, no generic sign-offs
+"""
+            }
+        ]
+    )
+    return response.choices[0].message.content
+

Job Finder/fetcher.py

@@ -0,0 +1,90 @@
+import os
+import requests
+from bs4 import BeautifulSoup
+from datetime import datetime, timedelta
+from dotenv import load_dotenv
+from pathlib import Path
+
+env_file = Path(__file__).parent / ".env"
+if not env_file.exists():
+    env_file = Path(__file__).parent.parent / ".env"
+load_dotenv(env_file)
+
+ADZUNA_APP_ID = os.getenv("ADZUNA_APP_ID")
+ADZUNA_APP_KEY = os.getenv("ADZUNA_APP_KEY")
+
+DEFAULT_DATE_RANGE = 30
+
+def filter_by_date(jobs, days=DEFAULT_DATE_RANGE):
+    cutoff = datetime.now() - timedelta(days=days)
+    filtered = []
+    for job in jobs:
+        pub_date = job.get("publication_date", "")
+        if pub_date:
+            try:
+                job_date = datetime.strptime(pub_date[:10], "%Y-%m-%d")
+                if job_date >= cutoff:
+                    filtered.append(job)
+            except Exception:
+                filtered.append(job)
+        else:
+            filtered.append(job)
+    return filtered
+
+def fetch_remotive(job_title):
+    try:
+        url = f"https://remotive.com/api/remote-jobs?search={job_title}&limit=15"
+        response = requests.get(url, timeout=10)
+        jobs = response.json().get("jobs", [])
+        results = []
+        for job in jobs:
+            soup = BeautifulSoup(job.get("description", ""), "html.parser")
+            clean_description = soup.get_text()[:600]
+            results.append({
+                "title": job.get("title"),
+                "company": job.get("company_name"),
+                "location": "Remote",
+                "url": job.get("url"),
+                "description": clean_description,
+                "publication_date": job.get("publication_date", "")[:10]
+            })
+        return results
+    except Exception as e:
+        print(f"Remotive error: {e}")
+        return []
+
+def fetch_adzuna(job_title):
+    try:
+        countries = ["gb", "us", "au", "ca"]
+        results = []
+        for country in countries:
+            url = (
+                f"https://api.adzuna.com/v1/api/jobs/{country}/search/1"
+                f"?app_id={ADZUNA_APP_ID}"
+                f"&app_key={ADZUNA_APP_KEY}"
+                f"&what={job_title}"
+                f"&results_per_page=5"
+            )
+            response = requests.get(url, timeout=10)
+            jobs = response.json().get("results", [])
+            for job in jobs:
+                results.append({
+                    "title": job.get("title"),
+                    "company": job.get("company", {}).get("display_name", "Unknown"),
+                    "location": job.get("location", {}).get("display_name", country.upper()),
+                    "url": job.get("redirect_url"),
+                    "description": job.get("description", "")[:600],
+                    "publication_date": job.get("created", "")[:10]
+                })
+        return results
+    except Exception as e:
+        print(f"Adzuna error: {e}")
+        return []
+
+def fetch_jobs(job_title, days=DEFAULT_DATE_RANGE):
+    remotive_jobs = fetch_remotive(job_title)
+    adzuna_jobs = fetch_adzuna(job_title)
+    all_jobs = remotive_jobs + adzuna_jobs
+    recent_jobs = filter_by_date(all_jobs, days=days)
+    return recent_jobs
+

Job Finder/formatter.py

@@ -0,0 +1,52 @@
+import os
+from groq import Groq
+from dotenv import load_dotenv
+from pathlib import Path
+
+env_file = Path(__file__).parent / ".env"
+if not env_file.exists():
+    env_file = Path(__file__).parent.parent / ".env"
+load_dotenv(env_file)
+
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+def format_jobs(jobs, job_title, experience_level):
+    if not jobs:
+        return "No jobs found. Try different search terms."
+
+    raw = ""
+    for i, job in enumerate(jobs):
+        raw += f"""
+Job {i+1}:
+Title: {job['title']}
+Company: {job['company']}
+Location: {job['location']}
+URL: {job['url']}
+Description: {job['description']}
+---
+"""
+
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[
+            {
+                "role": "system",
+                "content": "You are a job search assistant. Format job listings clearly and helpfully."
+            },
+            {
+                "role": "user",
+                "content": f"""
+Here are raw job listings for a {experience_level} {job_title}.
+Format each one cleanly with:
+- Job title and company
+- Location
+- Key requirements from description
+- Direct apply link
+
+Raw data:
+{raw}
+"""
+            }
+        ]
+    )
+    return response.choices[0].message.content

Job Finder/requirements.txt

@@ -0,0 +1,8 @@
+groq
+gradio
+requests
+python-dotenv
+pdfplumber
+beautifulsoup4
+BeautifulSoup4
+huggingface_hub

Lead Agent/agents.py

@@ -0,0 +1,41 @@
+import os
+from crewai import Agent, LLM
+from dotenv import load_dotenv
+
+load_dotenv()
+
+llm = LLM(
+    model="groq/llama-3.3-70b-versatile",
+    api_key=os.getenv("GROQ_API_KEY")
+)
+
+researcher = Agent(
+    role="Lead Researcher",
+    goal="Find and profile businesses matching the target audience",
+    backstory="""You are an expert business researcher. 
+    You find detailed information about companies and 
+    identify what they do and who they serve.""",
+    llm=llm,
+    verbose=True
+)
+
+analyst = Agent(
+    role="Business Analyst",
+    goal="Analyze each lead and identify pain points relevant to the service being offered",
+    backstory="""You are a sharp business analyst who understands 
+    company needs. You identify gaps and opportunities where 
+    a service could genuinely help a business.""",
+    llm=llm,
+    verbose=True
+)
+
+writer = Agent(
+    role="Outreach Specialist",
+    goal="Write personalized compelling outreach messages for each lead",
+    backstory="""You are an expert copywriter specializing in 
+    cold outreach. You write messages that feel personal, 
+    reference specific details about the company, and 
+    clearly communicate value without being salesy.""",
+    llm=llm,
+    verbose=True
+)

Lead Agent/app.py

@@ -0,0 +1,42 @@
+import gradio as gr
+from crew import run_lead_gen
+
+def generate_leads(target_audience, service, sender_name):
+    if not target_audience or not service or not sender_name:
+        return "Please fill in all fields.", "Idle"
+
+    # This call is synchronous, but gradio will show progress once a long-running request starts.
+    result = run_lead_gen(target_audience, service, sender_name)
+    return result, "Completed"
+
+with gr.Blocks(title="AI Lead Gen Agent") as ui:
+    gr.Markdown("# 🤖 AI Lead Generation & Outreach Agent")
+    gr.Markdown("Find leads and generate personalized outreach messages automatically")
+
+    with gr.Row():
+        with gr.Column():
+            target_input = gr.Textbox(
+                label="Target Audience",
+                placeholder="e.g. digital marketing agencies in London"
+            )
+            service_input = gr.Textbox(
+                label="Your Service",
+                placeholder="e.g. I build AI automation tools for businesses"
+            )
+            name_input = gr.Textbox(
+                label="Your Name",
+                placeholder="e.g. Uche"
+            )
+            run_btn = gr.Button("Generate Leads", variant="primary")
+
+    status = gr.Textbox(label="Progress", interactive=False, value="Idle")
+    output = gr.Markdown()
+
+    run_btn.click(
+        fn=generate_leads,
+        inputs=[target_input, service_input, name_input],
+        outputs=[output, status],
+        show_progress=True
+    )
+
+ui.launch()

Lead Agent/crew.py

@@ -0,0 +1,48 @@
+import os
+import sys
+
+# Ensure this folder has priority for local imports (avoids root `tools.py` conflict)
+THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+if THIS_DIR not in sys.path:
+    sys.path.insert(0, THIS_DIR)
+
+from crewai import Crew, Process
+from agents import researcher, analyst, writer
+from tasks import create_tasks
+from tools import gather_leads
+
+
+def run_lead_gen(target_audience, service, sender_name):
+    # Step 0 - improve search query to favor real business sites over directory pages
+    search_query = f"{target_audience} official website contact"
+
+    # Step 1 - gather raw leads using tools
+    raw_leads = gather_leads(search_query)
+    
+    if not raw_leads:
+        return "No leads found. Try a different target audience."    
+    # format leads for tasks
+    leads_data = ""
+    for i, lead in enumerate(raw_leads):
+        leads_data += f"""
+Lead {i+1}:
+Name: {lead['name']}
+Website: {lead['website']}
+Summary: {lead['summary']}
+Details: {lead['details']}
+---
+"""
+
+    # Step 2 - create tasks with lead data
+    tasks = create_tasks(leads_data, service, sender_name, target_audience)
+
+    # Step 3 - assemble and run crew
+    crew = Crew(
+        agents=[researcher, analyst, writer],
+        tasks=tasks,
+        process=Process.sequential,
+        verbose=True
+    )
+
+    result = crew.kickoff()
+    return str(result)

Lead Agent/requirements.txt

@@ -0,0 +1,9 @@
+crewai
+crewai-tools
+groq
+gradio
+requests
+beautifulsoup4
+duckduckgo-search
+python-dotenv
+ddgs

Lead Agent/tasks.py

@@ -0,0 +1,67 @@
+from crewai import Task
+from agents import researcher, analyst, writer
+
+def create_tasks(leads_data, service, sender_name, target_audience):
+
+    research_task = Task(
+        description=f"""
+        Review this list of potential leads for '{target_audience}':
+        
+        {leads_data}
+        
+        For each lead extract and summarize:
+        - Company name
+        - What they do
+        - Who they serve
+        - Their website
+        
+        Return a clean structured list of leads.
+        """,
+        expected_output="A structured list of leads with company name, description, and website",
+        agent=researcher
+    )
+
+    analysis_task = Task(
+        description=f"""
+        Using the researched leads, analyze each company.
+        
+        The service being offered is: {service}
+        
+        For each company identify:
+        - Their likely pain points
+        - Why they would benefit from this service
+        - One specific detail that makes them a strong fit
+        
+        Be specific and realistic.
+        """,
+        expected_output="Analysis of each lead with pain points and fit assessment",
+        agent=analyst
+    )
+
+    outreach_task = Task(
+        description=f"""
+        Write a personalized outreach message for each lead.
+        
+        Sender name: {sender_name}
+        Service offered: {service}
+        
+        Each message must:
+        - Open by referencing something specific about their business
+        - Clearly explain the value of the service in one sentence
+        - End with a simple low-pressure call to action
+        - Be under 150 words
+        - Feel human and genuine, not salesy
+        
+        Format output as:
+        
+        ## [Company Name]
+        **Website:** [url]
+        **Message:**
+        [outreach message]
+        ---
+        """,
+        expected_output="Personalized outreach messages for each lead formatted cleanly",
+        agent=writer
+    )
+
+    return [research_task, analysis_task, outreach_task]

Lead Agent/tools.py

@@ -0,0 +1,53 @@
+import requests
+import time
+from bs4 import BeautifulSoup
+from ddgs import DDGS
+
+SKIP_DOMAINS = [
+    "tripadvisor", "tiktok", "facebook", "instagram",
+    "twitter", "yelp", "google", "wikipedia", "youtube",
+    "infoguidenigeria", "nairaland"
+]
+
+def search_leads(query, max_results=10):
+    try:
+        time.sleep(2)
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=max_results))
+        return results
+    except Exception as e:
+        print(f"Search error: {e}")
+        return []
+
+def scrape_website(url):
+    try:
+        response = requests.get(url, timeout=5)
+        response.raise_for_status()
+        soup = BeautifulSoup(response.text, "html.parser")
+        paragraphs = soup.find_all("p")
+        content = " ".join([p.get_text() for p in paragraphs[:15]])
+        return content[:800]
+    except Exception:
+        return ""
+
+def gather_leads(target_audience):
+    results = search_leads(target_audience)
+    leads = []
+    for r in results:
+        url = r.get("href", "")
+        title = r.get("title", "")
+        body = r.get("body", "")
+
+        # skip directories and social media
+        if url and any(domain in url.lower() for domain in SKIP_DOMAINS):
+            continue
+
+        if url:
+            extra_info = scrape_website(url)
+            leads.append({
+                "name": title,
+                "website": url,
+                "summary": body,
+                "details": extra_info
+            })
+    return leads

agent.py

@@ -0,0 +1,29 @@
+import os
+from groq import Groq
+from dotenv import load_dotenv
+from root_tools import gather_research
+
+load_dotenv()
+
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+def generate_report(topic):
+    raw_content, sources = gather_research(topic)  # unpack both now
+    
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[
+            {
+                "role": "system",
+                "content": "You are an expert research analyst. Write clear structured reports."
+            },
+            {
+                "role": "user",
+                "content": f"Using this research data, write a detailed structured report on: {topic}\n\nData:\n{raw_content}"
+            }
+        ]
+    )
+    
+    report = response.choices[0].message.content
+    sources_section = "\n\n---\n## Sources\n" + "\n".join(sources)
+    return report + sources_section

app.py

@@ -0,0 +1,20 @@
+import gradio as gr
+from agent import generate_report
+
+def run_agent(topic):
+    if not topic or not topic.strip():
+        return "", "Please enter a valid topic."
+
+    # indicate in-progress state with status message
+    output_text = generate_report(topic)
+    return output_text, "Completed"
+
+ui = gr.Interface(
+    fn=run_agent,
+    inputs=gr.Textbox(placeholder="Enter any topic...", label="Research Topic"),
+    outputs=[gr.Markdown(label="Research Report"), gr.Textbox(label="Status", interactive=False)],
+    title="AI Research & Report Agent",
+    description="Enter a topic and get a full research report instantly"
+)
+
+ui.launch()

main_app.py

@@ -0,0 +1,197 @@
+import os
+import sys
+import importlib.util
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# Add structural paths for submodules
+if BASE_DIR not in sys.path:
+    sys.path.insert(0, BASE_DIR)
+
+JOB_FINDER_DIR = os.path.join(BASE_DIR, "Job Finder")
+LEAD_AGENT_DIR = os.path.join(BASE_DIR, "Lead Agent")
+
+if JOB_FINDER_DIR not in sys.path:
+    sys.path.insert(0, JOB_FINDER_DIR)
+if LEAD_AGENT_DIR not in sys.path:
+    sys.path.insert(0, LEAD_AGENT_DIR)
+
+import gradio as gr
+from agent import generate_report
+
+# Dynamic loader helper
+
+def load_module_from_path(name, path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+# Lazy module caches: each tab can fail independently without crashing the whole app.
+job_fetcher = None
+job_formatter = None
+job_cover_letter = None
+lead_crew = None
+
+
+def ensure_job_modules_loaded():
+    global job_fetcher, job_formatter, job_cover_letter
+    if job_fetcher and job_formatter and job_cover_letter:
+        return
+
+    job_fetcher = load_module_from_path("job_fetcher", os.path.join(JOB_FINDER_DIR, "fetcher.py"))
+    job_formatter = load_module_from_path("job_formatter", os.path.join(JOB_FINDER_DIR, "formatter.py"))
+    job_cover_letter = load_module_from_path("job_cover_letter", os.path.join(JOB_FINDER_DIR, "cover_letter.py"))
+
+
+def ensure_lead_module_loaded():
+    global lead_crew
+    if lead_crew:
+        return
+
+    lead_crew = load_module_from_path("lead_crew", os.path.join(LEAD_AGENT_DIR, "crew.py"))
+
+# Job Finder state
+job_store = []
+
+def search_jobs_wrapper(job_title):
+    global job_store
+    if not job_title or not job_title.strip():
+        return "Please enter a job title."
+
+    try:
+        ensure_job_modules_loaded()
+        jobs = job_fetcher.fetch_jobs(job_title)
+    except Exception as e:
+        return f"Job Finder failed to load: {e}"
+
+    job_store = jobs
+    if not jobs:
+        return "No jobs found. Try a broader search term."
+    try:
+        return job_formatter.format_jobs(jobs, job_title, "")
+    except Exception as e:
+        return f"Job formatting failed: {e}"
+
+
+def search_jobs_with_status(job_title):
+    return search_jobs_wrapper(job_title), "Completed"
+
+
+def create_cover_letter_wrapper(job_number, cv_file):
+    global job_store
+    try:
+        ensure_job_modules_loaded()
+    except Exception as e:
+        return f"Job Finder failed to load: {e}"
+
+    if cv_file is None:
+        return "Please upload your CV first."
+
+    cv_text = ""
+    try:
+        import pdfplumber
+        with pdfplumber.open(cv_file.name) as pdf:
+            for page in pdf.pages:
+                cv_text += page.extract_text() or ""
+    except Exception as e:
+        return f"Could not read CV: {e}"
+
+    if not job_store:
+        return "Please search for jobs first."
+
+    try:
+        index = int(job_number) - 1
+        job = job_store[index]
+    except Exception:
+        return "Invalid job number. Please enter a number from the job results."
+
+    try:
+        return job_cover_letter.generate_cover_letter(
+            job["title"], job["company"], job["description"], cv_text
+        )
+    except Exception as e:
+        return f"Cover letter generation failed: {e}"
+
+
+def create_cover_letter_with_status(job_number, cv_file):
+    return create_cover_letter_wrapper(job_number, cv_file), "Completed"
+
+
+def generate_report_with_status(topic):
+    if not topic or not topic.strip():
+        return "Please enter a topic.", "Idle"
+    try:
+        return generate_report(topic), "Completed"
+    except Exception as e:
+        return f"Research agent failed: {e}", "Failed"
+
+
+def generate_leads_wrapper(target_audience, service, sender_name):
+    if not target_audience or not service or not sender_name:
+        return "Please fill in all fields.", "Idle"
+
+    try:
+        ensure_lead_module_loaded()
+        result = lead_crew.run_lead_gen(target_audience, service, sender_name)
+        return result, "Completed"
+    except Exception as e:
+        return f"Lead Agent failed: {e}", "Failed"
+
+
+with gr.Blocks(title="AI All-in-One Agents") as ui:
+    gr.Markdown("# AI All-in-One Agents\nUse the tabs to switch between Research, Job Finder, and Lead Gen agents.")
+
+    with gr.Tab("Research & Report"):
+        topic_input = gr.Textbox(label="Topic", placeholder="Enter research topic...", lines=1)
+        topic_btn = gr.Button("Generate Report")
+        topic_output = gr.Markdown()
+        topic_status = gr.Textbox(label="Status", interactive=False, value="Idle")
+        topic_btn.click(
+            fn=generate_report_with_status,
+            inputs=[topic_input],
+            outputs=[topic_output, topic_status],
+            show_progress=True,
+        )
+
+    with gr.Tab("Job Finder"):
+        job_input = gr.Textbox(label="Job title", placeholder="e.g. Python Developer")
+        job_btn = gr.Button("Find Jobs")
+        jobs_output = gr.Markdown()
+        jobs_status = gr.Textbox(label="Status", interactive=False, value="Idle")
+        job_btn.click(
+            fn=search_jobs_with_status,
+            inputs=[job_input],
+            outputs=[jobs_output, jobs_status],
+            show_progress=True,
+        )
+
+        gr.Markdown("---")
+        cv_upload = gr.File(label="Upload CV (PDF)", file_types=[".pdf"])
+        job_number = gr.Textbox(label="Job number", placeholder="e.g. 1")
+        cover_btn = gr.Button("Generate Cover Letter")
+        cover_output = gr.Markdown()
+        cover_status = gr.Textbox(label="Status", interactive=False, value="Idle")
+        cover_btn.click(
+            fn=create_cover_letter_with_status,
+            inputs=[job_number, cv_upload],
+            outputs=[cover_output, cover_status],
+            show_progress=True,
+        )
+
+    with gr.Tab("Lead Gen & Outreach"):
+        target_input = gr.Textbox(label="Target Audience", placeholder="e.g. digital marketing agencies")
+        service_input = gr.Textbox(label="Your Service", placeholder="e.g. AI automation consulting")
+        name_input = gr.Textbox(label="Your Name", placeholder="e.g. Uche")
+        lead_btn = gr.Button("Generate Leads")
+        lead_output = gr.Markdown()
+        status_output = gr.Textbox(label="Status", interactive=False, value="Idle")
+
+        lead_btn.click(
+            fn=generate_leads_wrapper,
+            inputs=[target_input, service_input, name_input],
+            outputs=[lead_output, status_output],
+            show_progress=True,
+        )
+
+ui.launch()

requirements.txt

@@ -0,0 +1,12 @@
+groq
+gradio
+requests
+beautifulsoup4
+BeautifulSoup4
+duckduckgo-search
+ddgs
+python-dotenv
+pdfplumber
+huggingface_hub
+crewai
+crewai-tools

root_tools.py

@@ -0,0 +1,51 @@
+import os
+import requests
+from bs4 import BeautifulSoup
+from ddgs import DDGS
+
+
+def search_web(query, max_results=5):
+    try:
+        with DDGS() as ddgs:
+            return list(ddgs.text(query, max_results=max_results))
+    except Exception:
+        return []
+
+
+def scrape_page(url, timeout=8):
+    try:
+        r = requests.get(url, timeout=timeout, headers={"User-Agent": "Mozilla/5.0"})
+        r.raise_for_status()
+        content_type = (r.headers.get("Content-Type") or "").lower()
+        # Ignore binary/non-HTML responses (PDFs commonly produce gibberish text in reports).
+        if "pdf" in content_type or ("html" not in content_type and "text" not in content_type):
+            return ""
+        soup = BeautifulSoup(r.text, "html.parser")
+        for script in soup(["script", "style"]):
+            script.decompose()
+        text = "\n".join(line.strip() for line in soup.stripped_strings)
+        return text[:3500]
+    except Exception:
+        return ""
+
+
+def gather_research(topic):
+    results = search_web(topic + " research report -filetype:pdf")
+    all_content = ""
+    sources = []
+
+    for result in results[:5]:
+        url = result.get("href", "")
+        title = result.get("title", url)
+        if not url:
+            continue
+
+        content = scrape_page(url)
+        if content:
+            all_content += content + "\n"
+            sources.append(f"- [{title}]({url})")
+
+    if not all_content:
+        all_content = f"General background context on {topic}."
+
+    return all_content, sources

tools.py

@@ -0,0 +1,43 @@
+from ddgs import DDGS
+import requests
+from bs4 import BeautifulSoup
+import time
+
+def search_web(query):
+    try:
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=5))
+        return results
+    except Exception as e:
+        print(f"Search error: {e}")
+        return []
+
+def scrape_page(url):
+    try:
+        response = requests.get(url, timeout=5)
+        soup = BeautifulSoup(response.text, "html.parser")
+        paragraphs = soup.find_all("p")
+        content = " ".join([p.get_text() for p in paragraphs[:20]])
+        return content
+    except:
+        return ""
+
+def gather_research(topic):
+    time.sleep(2)
+    results = search_web(topic)
+    
+    if not results:
+        return "No search results found. Try again in a few minutes.", []
+    
+    all_content = ""
+    sources = []
+
+    for r in results:
+        url = r.get("href", "")  # back to href - confirmed correct
+        title = r.get("title", url)
+
+        if url:
+            all_content += scrape_page(url) + "\n"
+            sources.append(f"- [{title}]({url})")
+        
+    return all_content, sources