Add application files

app.py

@@ -894,52 +894,34 @@ async def discover_prospects(num_prospects: int, progress=gr.Progress()):
 About {client_name}:
 {client_info}
 
-CRITICAL: Only save prospects that have verified contact details. A prospect without contacts is useless.
-
-WORKFLOW - Follow these steps:
-
-STEP 1: Search for potential prospect companies
-- Use search_web to find companies that would benefit from {client_name}'s services
-- Look for REAL, INDEPENDENT companies (not acquired/merged ones)
-- You may need to search for more companies than {num_prospects} to find ones with contacts
-
-STEP 2: For EACH potential company, FIRST find contacts:
-   a. Use find_verified_contacts tool FIRST:
-      {{"company_name": "CompanyName", "company_domain": "company.com", "target_titles": ["CEO", "Founder", "VP Sales", "CTO", "Head of Sales"], "max_contacts": 3}}
-
-      This tool searches:
-      - Company website (team/about pages)
-      - LinkedIn profiles
-      - Crunchbase and business directories
-      - Press releases and news
-      - Social media profiles
-
-   b. CHECK THE RESULT:
-      - If find_verified_contacts returns contacts (count > 0): PROCEED to save
-      - If find_verified_contacts returns NO contacts: SKIP this company, try the next one
-
-   c. ONLY IF contacts were found, save the prospect:
-      {{"prospect_id": "prospect_1", "company_id": "company_1", "company_name": "CompanyName", "company_domain": "company.com", "fit_score": 85, "metadata": {{"industry": "...", "fit_reason": "..."}}}}
-
-   d. Draft personalized email using send_email tool:
-      - Use the REAL contact info returned by find_verified_contacts
-      - to: actual verified email from the tool result
-      - subject: Reference {client_name} AND the prospect's business
-      - body: Personalized email with real facts about the company
-      - prospect_id: the prospect_id
-
-IMPORTANT RULES:
-- CONTACTS FIRST: Always find contacts BEFORE saving a prospect
-- NO CONTACTS = NO SAVE: Skip companies where no verified contacts are found
-- NEVER invent contact names or emails
-- Keep searching until you find {num_prospects} companies WITH verified contacts
-- It's better to have fewer prospects with real contacts than many with none
-
-After processing, provide summary:
-- Prospects saved (only those with verified contacts)
+USE THE discover_prospects_with_contacts TOOL - it handles everything automatically:
+- Searches for potential prospect companies
+- Finds verified contacts for each (LinkedIn, company websites, directories, etc.)
+- ONLY saves prospects that have real verified contacts
+- Keeps searching until target is met or max attempts reached
+- Skips companies without contacts automatically
+
+STEP 1: Call discover_prospects_with_contacts:
+{{"client_company": "{client_name}", "client_industry": "Brief description of {client_name}'s services and target market", "target_prospects": {num_prospects}, "target_titles": ["CEO", "Founder", "VP Sales", "CTO", "Head of Sales"]}}
+
+STEP 2: After discovery completes, for each prospect with contacts, draft personalized email:
+- Use send_email tool with the REAL contact info returned
+- to: actual verified email
+- subject: Reference {client_name} AND the prospect's business
+- body: Personalized email mentioning the contact by name and specific facts about their company
+- prospect_id: the prospect_id from discovery results
+
+IMPORTANT:
+- The discover_prospects_with_contacts tool does ALL the hard work
+- It will check multiple companies until it finds {num_prospects} with verified contacts
+- Only prospects WITH contacts are saved (no useless data)
+- NEVER invent contact names or emails - only use what the tool returns
+
+After the tool completes, provide a summary of:
+- Prospects saved (with verified contacts)
 - Total contacts found
-- Emails drafted
-- Companies skipped (no contacts found)"""
+- Companies checked vs skipped
+- Emails drafted"""
 
     prospects_found = []
     contacts_found = []
@@ -1050,8 +1032,49 @@ After processing, provide summary:
                     else:
                         output += f"   ✅ Contact saved\n"
 
+                elif tool == "discover_prospects_with_contacts":
+                    # Handle the all-in-one prospect discovery tool
+                    if isinstance(result, dict):
+                        status = result.get("status", "")
+                        discovered_prospects = result.get("prospects", [])
+                        total_contacts = result.get("contacts_count", 0)
+                        companies_checked = result.get("companies_checked", 0)
+                        companies_skipped = result.get("companies_skipped", 0)
+                        message = result.get("message", "")
+
+                        output += f"\n   📊 **Discovery Complete**\n"
+                        output += f"   {message}\n\n"
+
+                        if discovered_prospects:
+                            for p in discovered_prospects:
+                                # Add to prospects_found
+                                prospect_data = {
+                                    "name": p.get("company_name", "Unknown"),
+                                    "domain": p.get("domain", ""),
+                                    "fit_score": 75,
+                                    "summary": f"Found with {p.get('contact_count', 0)} verified contacts"
+                                }
+                                prospects_found.append(prospect_data)
+
+                                output += f"   ✅ **{p.get('company_name')}** ({p.get('domain')})\n"
+
+                                # Add contacts
+                                for c in p.get("contacts", []):
+                                    contact_data = {
+                                        "name": c.get("name", "Unknown"),
+                                        "email": c.get("email", ""),
+                                        "title": c.get("title", ""),
+                                        "company": p.get("company_name", ""),
+                                        "verified": True,
+                                        "source": c.get("source", "web_search")
+                                    }
+                                    contacts_found.append(contact_data)
+                                    output += f"      • {c.get('name')} ({c.get('title')}) - {c.get('email')}\n"
+                        else:
+                            output += f"   ⚠️ No prospects with verified contacts found.\n"
+
                 elif tool == "find_verified_contacts":
-                    # Handle verified contacts from the enhanced contact finder
+                    # Handle verified contacts from the enhanced contact finder (single company)
                     if isinstance(result, dict):
                         status = result.get("status", "")
                         found_contacts = result.get("contacts", [])
@@ -1071,7 +1094,7 @@ After processing, provide summary:
                                 contacts_found.append(contact_data)
                                 output += f"      • {contact_data['name']} ({contact_data['title']}) - {contact_data['email']}\n"
                         elif status == "no_contacts_found":
-                            output += f"   ℹ️ {message}\n"
+                            output += f"   ⏭️ {message}\n"
                         else:
                             output += f"   ⚠️ Contact search: {message}\n"
 

mcp/agents/autonomous_agent_hf.py

@@ -577,7 +577,12 @@ After completing, summarize:
                     return None
                 keys = set(params.keys())
 
-                # Check for find_verified_contacts patterns (PRIORITY - use this instead of save_contact)
+                # Check for discover_prospects_with_contacts (HIGHEST PRIORITY - all-in-one tool)
+                if "client_company" in keys and "client_industry" in keys:
+                    return "discover_prospects_with_contacts"
+                if "client_company" in keys and "target_prospects" in keys:
+                    return "discover_prospects_with_contacts"
+                # Check for find_verified_contacts patterns (single company)
                 if "company_name" in keys and "company_domain" in keys and "target_titles" in keys:
                     return "find_verified_contacts"
                 if "company_name" in keys and "company_domain" in keys and "max_contacts" in keys:
@@ -730,7 +735,178 @@ After completing, summarize:
                 "count": len(results[:max_results])
             }
 
-        # ============ VERIFIED CONTACT FINDER ============
+        # ============ OPTIMIZED PROSPECT DISCOVERY WITH CONTACTS ============
+        elif tool_name == "discover_prospects_with_contacts":
+            from services.enhanced_contact_finder import EnhancedContactFinder
+            from urllib.parse import urlparse
+
+            client_company = tool_input["client_company"]
+            client_industry = tool_input["client_industry"]
+            target_prospects = tool_input.get("target_prospects", 3)
+            target_titles = tool_input.get("target_titles", ["CEO", "Founder", "VP Sales", "CTO", "Head of Sales"])
+
+            logger.info(f"Discovering {target_prospects} prospects with contacts for {client_company}")
+            print(f"\n[PROSPECT DISCOVERY] ========================================")
+            print(f"[PROSPECT DISCOVERY] Finding {target_prospects} prospects WITH verified contacts")
+            print(f"[PROSPECT DISCOVERY] Client: {client_company}")
+            print(f"[PROSPECT DISCOVERY] ========================================")
+
+            contact_finder = EnhancedContactFinder(mcp_registry=self.mcp_registry)
+
+            saved_prospects = []
+            all_contacts = []
+            skipped_companies = []
+            companies_checked = 0
+            max_companies_to_check = target_prospects * 5  # Check up to 5x to find enough with contacts
+
+            # Search queries to find potential companies
+            search_queries = [
+                f"companies that need {client_industry} services",
+                f"businesses looking for {client_industry}",
+                f"startups {client_industry} customers",
+                f"enterprise companies {client_industry}",
+                f"growing companies need {client_industry}",
+            ]
+
+            seen_domains = set()
+
+            for query in search_queries:
+                if len(saved_prospects) >= target_prospects:
+                    break
+
+                try:
+                    print(f"\n[PROSPECT DISCOVERY] Searching: {query}")
+                    results = await self.mcp_registry.search.query(query, max_results=10)
+
+                    for result in results:
+                        if len(saved_prospects) >= target_prospects:
+                            break
+                        if companies_checked >= max_companies_to_check:
+                            break
+
+                        url = result.get('url', '')
+                        title = result.get('title', '')
+
+                        # Extract domain from URL
+                        try:
+                            parsed = urlparse(url)
+                            domain = parsed.netloc.replace('www.', '')
+                            if not domain or domain in seen_domains:
+                                continue
+                            seen_domains.add(domain)
+                        except:
+                            continue
+
+                        # Extract company name from title
+                        company_name = title.split(' - ')[0].split(' | ')[0].strip()
+                        if not company_name or len(company_name) < 3:
+                            continue
+
+                        # Skip if it's a directory/aggregator site
+                        skip_domains = ['linkedin.com', 'facebook.com', 'twitter.com', 'wikipedia.org',
+                                       'crunchbase.com', 'zoominfo.com', 'yelp.com', 'glassdoor.com']
+                        if any(skip in domain for skip in skip_domains):
+                            continue
+
+                        companies_checked += 1
+                        print(f"\n[PROSPECT DISCOVERY] Checking ({companies_checked}/{max_companies_to_check}): {company_name} ({domain})")
+
+                        # Find contacts for this company
+                        try:
+                            contacts = await contact_finder.find_real_contacts(
+                                company_name=company_name,
+                                domain=domain,
+                                target_titles=target_titles,
+                                max_contacts=3
+                            )
+
+                            if contacts and len(contacts) > 0:
+                                # Save prospect
+                                prospect_id = f"prospect_{len(saved_prospects) + 1}"
+                                company_id = domain.replace(".", "_")
+
+                                prospect_data = {
+                                    "id": prospect_id,
+                                    "company": {
+                                        "id": company_id,
+                                        "name": company_name,
+                                        "domain": domain
+                                    },
+                                    "fit_score": 75,
+                                    "status": "new",
+                                    "metadata": {"source": "automated_discovery"}
+                                }
+
+                                await self.mcp_registry.store.save_prospect(prospect_data)
+
+                                # Save contacts
+                                contact_list = []
+                                for contact in contacts:
+                                    contact_data = {
+                                        "id": contact.id,
+                                        "name": contact.name,
+                                        "email": contact.email,
+                                        "title": contact.title,
+                                        "company": company_name,
+                                        "domain": domain,
+                                        "verified": True,
+                                        "source": "web_search_and_scraping"
+                                    }
+                                    contact_list.append(contact_data)
+                                    all_contacts.append(contact_data)
+
+                                    await self.mcp_registry.store.save_contact({
+                                        "id": contact.id,
+                                        "company_id": company_id,
+                                        "email": contact.email,
+                                        "first_name": contact.name.split()[0] if contact.name else "",
+                                        "last_name": contact.name.split()[-1] if len(contact.name.split()) > 1 else "",
+                                        "title": contact.title
+                                    })
+
+                                saved_prospects.append({
+                                    "prospect_id": prospect_id,
+                                    "company_name": company_name,
+                                    "domain": domain,
+                                    "contacts": contact_list,
+                                    "contact_count": len(contact_list)
+                                })
+
+                                print(f"[PROSPECT DISCOVERY] ✅ SAVED: {company_name} with {len(contacts)} contacts")
+                            else:
+                                skipped_companies.append({"name": company_name, "domain": domain, "reason": "no_contacts"})
+                                print(f"[PROSPECT DISCOVERY] ⏭️ SKIPPED: {company_name} (no verified contacts)")
+
+                        except Exception as e:
+                            logger.debug(f"Error checking {company_name}: {str(e)}")
+                            skipped_companies.append({"name": company_name, "domain": domain, "reason": str(e)})
+                            continue
+
+                except Exception as e:
+                    logger.debug(f"Search error: {str(e)}")
+                    continue
+
+            print(f"\n[PROSPECT DISCOVERY] ========================================")
+            print(f"[PROSPECT DISCOVERY] DISCOVERY COMPLETE")
+            print(f"[PROSPECT DISCOVERY] ========================================")
+            print(f"[PROSPECT DISCOVERY] Prospects saved: {len(saved_prospects)}/{target_prospects}")
+            print(f"[PROSPECT DISCOVERY] Total contacts: {len(all_contacts)}")
+            print(f"[PROSPECT DISCOVERY] Companies checked: {companies_checked}")
+            print(f"[PROSPECT DISCOVERY] Companies skipped: {len(skipped_companies)}")
+            print(f"[PROSPECT DISCOVERY] ========================================\n")
+
+            return {
+                "status": "success" if len(saved_prospects) > 0 else "no_prospects_found",
+                "prospects": saved_prospects,
+                "prospects_count": len(saved_prospects),
+                "contacts_count": len(all_contacts),
+                "companies_checked": companies_checked,
+                "companies_skipped": len(skipped_companies),
+                "target_met": len(saved_prospects) >= target_prospects,
+                "message": f"Found {len(saved_prospects)} prospects with {len(all_contacts)} verified contacts. Checked {companies_checked} companies, skipped {len(skipped_companies)} (no contacts)."
+            }
+
+        # ============ VERIFIED CONTACT FINDER (Single Company) ============
         elif tool_name == "find_verified_contacts":
             from services.enhanced_contact_finder import EnhancedContactFinder
 
@@ -741,7 +917,6 @@ After completing, summarize:
 
             logger.info(f"Finding verified contacts for {company_name} ({company_domain})")
 
-            # Use the EnhancedContactFinder which does real web scraping and LinkedIn search
             contact_finder = EnhancedContactFinder(mcp_registry=self.mcp_registry)
 
             try:
@@ -752,7 +927,6 @@ After completing, summarize:
                     max_contacts=max_contacts
                 )
 
-                # Convert contacts to serializable format
                 contact_list = []
                 for contact in contacts:
                     contact_data = {
@@ -762,12 +936,11 @@ After completing, summarize:
                         "title": contact.title,
                         "company": company_name,
                         "domain": company_domain,
-                        "verified": True,  # These come from real web searches
+                        "verified": True,
                         "source": "web_search_and_scraping"
                     }
                     contact_list.append(contact_data)
 
-                    # Also save to store automatically
                     await self.mcp_registry.store.save_contact({
                         "id": contact.id,
                         "company_id": company_domain.replace(".", "_"),
@@ -782,14 +955,16 @@ After completing, summarize:
                         "status": "success",
                         "contacts": contact_list,
                         "count": len(contact_list),
-                        "message": f"Found {len(contact_list)} verified contacts at {company_name}"
+                        "message": f"Found {len(contact_list)} verified contacts at {company_name}",
+                        "should_save_prospect": True
                     }
                 else:
                     return {
                         "status": "no_contacts_found",
                         "contacts": [],
                         "count": 0,
-                        "message": f"No verified contacts found for {company_name}. Leadership information may not be publicly available."
+                        "message": f"No verified contacts found for {company_name}. Skip this prospect.",
+                        "should_save_prospect": False
                     }
 
             except Exception as e:
@@ -798,7 +973,8 @@ After completing, summarize:
                     "status": "error",
                     "contacts": [],
                     "count": 0,
-                    "message": f"Error searching for contacts: {str(e)}"
+                    "message": f"Error searching for contacts: {str(e)}",
+                    "should_save_prospect": False
                 }
 
         # ============ STORE MCP SERVER ============

mcp/tools/definitions.py

@@ -201,9 +201,37 @@ MCP_TOOLS: List[Dict[str, Any]] = [
             "required": ["fact_id", "company_id", "fact_type", "content"]
         }
     },
+    {
+        "name": "discover_prospects_with_contacts",
+        "description": "Find prospect companies WITH verified decision-maker contacts. This tool searches for companies, finds their contacts, and ONLY saves prospects that have real verified contacts. It keeps searching until the target number of valid prospects is found. Use this as your PRIMARY tool for prospect discovery.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "client_company": {
+                    "type": "string",
+                    "description": "Your client company name (who you're finding prospects for)"
+                },
+                "client_industry": {
+                    "type": "string",
+                    "description": "Brief description of what the client does and their target market"
+                },
+                "target_prospects": {
+                    "type": "integer",
+                    "description": "Number of prospects WITH contacts to find (default: 3)",
+                    "default": 3
+                },
+                "target_titles": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Job titles to search for (default: ['CEO', 'Founder', 'VP Sales', 'CTO'])"
+                }
+            },
+            "required": ["client_company", "client_industry"]
+        }
+    },
     {
         "name": "find_verified_contacts",
-        "description": "Find REAL verified decision-makers at a company using LinkedIn search, team page scraping, and web research. This tool searches the web to find actual executives - DO NOT make up contact names. Use this INSTEAD of save_contact to get real contacts.",
+        "description": "Find REAL verified decision-makers at a specific company. Searches LinkedIn, company websites, directories, press releases, and social media. Only returns contacts with verified email addresses found on the web.",
         "input_schema": {
             "type": "object",
             "properties": {