app V1.0

.gitignore

@@ -0,0 +1,4 @@
+.venv
+.env
+__pycache__
+service_account_credentials.json

Dockerfile

@@ -0,0 +1,23 @@
+# Stage 1: Build React
+FROM node:18 AS build-step
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm install
+COPY frontend/ ./
+RUN npm run build
+
+# Stage 2: Python Backend
+FROM python:3.11-slim
+WORKDIR /app
+
+COPY backend/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+COPY --from=build-step /app/frontend/dist /app/frontend/dist
+
+ENV PYTHONPATH=/app
+
+EXPOSE 7860
+CMD ["uvicorn", "backend.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1 +1,102 @@
-# fello-intel
+# fello-IQ
+
+Fello IQ is an automated account intelligence platform that utilizes AI agents to identify, enrich, and analyze corporate leads based on IP addresses or domain names. It synthesizes data from multiple sources to provide intent scores, technographics, and actionable sales strategies.
+
+# System Architecture
+The project is divided into three primary modules:
+
+Backend (FastAPI): Handles API requests, serves the React frontend, generates PDF reports, and manages Google Sheets synchronization.
+
+Fello Crew (CrewAI): An autonomous agentic layer that performs account identification, deep enrichment (via Apollo and News APIs), and strategic analysis.
+
+Frontend (React): A Vite-powered dashboard for real-time interaction and visualization of intelligence streams.
+
+# Core Technologies
+- LLM: Mistral (mistral-large-latest).
+
+- Frameworks: FastAPI (Python), React (JavaScript), CrewAI.
+
+- Data Sources: Apollo.io, ip-api.com, custom scraping tools.
+
+# Prerequisites
+- Python 3.10 or higher.
+
+- Node.js 18 or higher.
+
+- Google Cloud Service Account (for Sheets sync).
+
+- Apollo.io API Key.
+
+# Environment Variables
+Create a .env file in the root directory and the backend/ directory with the following keys:
+
+```.env
+# AI and Search
+OPENAI_API_KEY=your_openai_key
+SERPER_API_KEY=your_serper_key
+APOLLO_TOKEN=your_apollo_token
+
+# Google Integration
+SPREADSHEET_ID=your_google_sheet_id
+GOOGLE_CREDENTIALS_JSON=your_minified_service_account_json
+```
+# Local Setup
+1. Backend and Crew Setup
+From the root directory, install the shared Python dependencies:
+
+```Bash
+pip install -r requirements.txt
+```
+# 2. Frontend Setup
+Navigate to the frontend directory and install dependencies:
+
+```Bash
+cd frontend
+npm install
+Running the Application Locally
+```
+You will need two terminal instances to run the full stack during development.
+
+Terminal 1: Backend API
+From the root directory:
+
+```Bash
+python -m backend.main
+```
+The API will start at http://localhost:8000.
+
+Terminal 2: Frontend Development Server
+From the frontend directory:
+
+```Bash
+npm run dev
+```
+The UI will start at http://localhost:5173.
+
+# Data Models and Tools
+Intelligence Model
+The system enforces a strict Pydantic schema for all analysis, including:
+
+- Intent Score (0.0 - 10.0).
+
+- Likely Persona.
+
+- Leadership Team.
+
+- Technographics (Tech Stack).
+
+- Recommended Sales Actions.
+
+# Integrated Tools
+- GetDomain: Resolves raw IP addresses to corporate entities.
+
+- ApolloEnrichmentTool: Fetches firmographics and technographics.
+
+- JobOpeningsTool: Monitors hiring signals as growth indicators using apollo API.
+
+- NewsTool: Tracks recent corporate events and press releases.
+
+# PDF Generation and Syncing
+- PDF Reports: Generated server-side using fpdf, sanitizing data for Latin-1 compatibility.
+
+- Google Sheets: Data is appended to "Sheet1" of the specified SPREADSHEET_ID using the Google Sheets API v4.

backend/main.py

@@ -0,0 +1,127 @@
+import sys
+import os
+import json
+import asyncio
+from fastapi import FastAPI, BackgroundTasks, Response, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from typing import Optional, List, Dict
+
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+import os
+app = FastAPI(title="Fello IQ API")
+
+# Adding the src directory to path 
+sys.path.append(os.path.join(os.path.dirname(__file__), "..", "fello_crew", "src"))
+from fello_crew.crew import FelloAccountIntelligenceCrew
+from backend.utils import FelloUtils
+frontend_path = os.path.join(os.path.dirname(__file__), "..", "frontend", "dist")
+
+if os.path.exists(frontend_path):
+    app.mount("/assets", StaticFiles(directory=os.path.join(frontend_path, "assets")), name="assets")
+
+    @app.get("/{full_path:path}")
+    async def serve_react_app(full_path: str):
+        # This allows React Router to handle deep links
+        return FileResponse(os.path.join(frontend_path, "index.html"))
+# Enable CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], 
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class AnalysisRequest(BaseModel):
+    input_data: Optional[str] = ""
+    activity_signals: str = "No recent activity recorded."
+    domain: Optional[str] = ""
+
+@app.get("/health")
+def health_check():
+    return {"status": "operational"}
+
+@app.post("/analyze")
+async def analyze_account(request: AnalysisRequest):
+    # Determine the primary identifier for the Crew 
+    # If input_data is empty, use domain as the primary signal
+    primary_signal = request.input_data if request.input_data else request.domain
+    inputs = {
+        "input_data": primary_signal,
+        "activity_signals": request.activity_signals,
+        "domain": request.domain if request.domain else "" 
+    }
+    print(inputs)
+    
+    crew_instance = FelloAccountIntelligenceCrew().crew()
+    # Using to_thread to keep the FastAPI event loop responsive 
+    result = await asyncio.to_thread(crew_instance.kickoff, inputs=inputs)
+    
+    return result.pydantic 
+
+@app.post("/analyze-stream")
+async def analyze_account_stream(request: AnalysisRequest):
+    # Use whichever identifier is strongest: IP or Domain
+    primary_signal = request.input_data if request.input_data else request.domain
+    
+    # These keys MUST match what crew.py expects in its .kickoff()
+    inputs = {
+        "input_data": primary_signal,
+        "domain": request.domain,
+        "activity_signals": request.activity_signals
+    }
+
+    async def event_generator():
+        # 1. Show the user we are starting
+        yield f"data: {json.dumps({'message': f'Initializing research for {primary_signal}...'})}\n\n"
+        
+        # 2. Run the CrewAI task
+        crew_instance = FelloAccountIntelligenceCrew().crew()
+        
+        # We run this in a thread so it doesn't block the stream
+        task = asyncio.to_thread(crew_instance.kickoff, inputs=inputs)
+        
+        yield f"data: {json.dumps({'message': 'Agents dispatched to Apollo and News sources...'})}\n\n"
+        await asyncio.sleep(1)
+        
+        try:
+            result = await task
+            # Send the final structured result back to the UI
+            yield f"data: {json.dumps({'message': 'COMPLETE', 'result': result.pydantic.dict()})}\n\n"
+        except Exception as e:
+            yield f"data: {json.dumps({'message': f'ERROR: {str(e)}'})}\n\n"
+
+    return StreamingResponse(event_generator(), media_type="text/event-stream")
+
+@app.post("/generate-report")
+async def generate_report(data: Dict):
+    """Generates the PDF bytes with endpoint-level debugging."""
+    try:
+        pdf_bytes = FelloUtils.generate_pdf_report(data)
+        return Response(
+            content=pdf_bytes,
+            media_type="application/pdf",
+            headers={
+                "Content-Disposition": f"attachment; filename=Fello_Report_{data.get('company_name', 'Account')}.pdf",
+                "Access-Control-Expose-Headers": "Content-Disposition" # Helps frontend see filename
+            }
+        )
+    except Exception as e:
+        # Return the actual error message so the frontend doesn't just get a generic 500
+        raise HTTPException(status_code=500, detail=f"PDF Server Error: {str(e)}")
+
+@app.post("/sync-sheets")
+async def sync_sheets(data: Dict, background_tasks: BackgroundTasks):
+    """
+    Separate intentional endpoint for Google Sheets sync.
+    Triggered by a specific button on the frontend.
+    """
+    # We still use background_tasks so the UI can show "Syncing..." 
+    # and immediately confirm without waiting for the Google API.
+    background_tasks.add_task(FelloUtils.sync_to_google_sheets, data)
+    return {"message": "Sync initiated successfully"}
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

backend/utils.py

@@ -0,0 +1,110 @@
+import os
+from fpdf import FPDF
+from googleapiclient.discovery import build
+from google.oauth2 import service_account
+from typing import List
+from dotenv import load_dotenv
+import json
+load_dotenv()
+
+class FelloUtils:
+    @staticmethod
+    def generate_pdf_report(data: dict) -> bytes:
+        """Generates a professional PDF report with heavy debugging."""        
+        try:
+            pdf = FPDF()
+            pdf.add_page()
+            
+            # Helper function to sanitize text for Latin-1 (FPDF default)
+            def s(text):
+                if text is None: return ""
+                # Replace common problematic unicode characters that crash FPDF
+                return str(text).encode('latin-1', 'replace').decode('latin-1')
+
+            # 1. Title
+            pdf.set_font("Arial", 'B', 20)
+            pdf.set_text_color(37, 99, 235) 
+            pdf.cell(200, 15, txt="Fello IQ Account Intelligence", ln=True, align='C')
+            pdf.ln(10)
+            
+            # 2. Company Identity
+            pdf.set_font("Arial", 'B', 14)
+            pdf.set_text_color(15, 23, 42)
+            company = s(data.get('company_name', 'N/A'))
+            domain = s(data.get('domain', 'N/A'))
+            pdf.cell(0, 10, txt=f"Account: {company} ({domain})", ln=True)
+            
+            pdf.set_font("Arial", size=10)
+            industry = s(data.get('industry', 'N/A'))
+            revenue = s(data.get('annual_revenue', 'N/A'))
+            pdf.cell(0, 7, txt=f"Industry: {industry} | Revenue: {revenue}", ln=True)
+            pdf.ln(5)
+
+            # 3. Strategic Intelligence
+            pdf.set_font("Arial", 'B', 12)
+            score = data.get('intent_score', 0)
+            stage = s(data.get('intent_stage', 'Unknown'))
+            pdf.cell(0, 10, txt=f"Intent Score: {score}/10 - {stage}", ln=True)
+            
+            pdf.set_font("Arial", 'I', 10)
+            summary = s(data.get('ai_summary', 'No summary available.'))
+            pdf.multi_cell(0, 7, txt=f"AI Summary: {summary}")
+            pdf.ln(5)
+
+            # 4. Recommended Actions
+            pdf.set_font("Arial", 'B', 12)
+            pdf.cell(0, 10, txt="Recommended Sales Actions:", ln=True)
+            
+            pdf.set_font("Arial", size=10)
+            actions = data.get('recommended_sales_actions', [])
+            if not actions:
+                pdf.cell(0, 7, txt="- No specific actions recommended.", ln=True)
+            else:
+                for action in actions:
+                    pdf.multi_cell(0, 7, txt=s(f"- {action}"))
+            
+            pdf_output = pdf.output(dest='S')
+            return pdf_output.encode('latin-1', 'replace')
+
+        except Exception as e:
+            print("!!! PDF GENERATION CRASHED !!!")
+            print(traceback.format_exc()) 
+            raise e
+
+    @staticmethod
+    def sync_to_google_sheets(data: dict):
+        """Appends research data to Google Sheets using your reference logic."""
+        SCOPES = ["https://www.googleapis.com/auth/spreadsheets"]
+        SPREADSHEET_ID = os.getenv("SPREADSHEET_ID")
+        
+        try:
+            creds_json = os.getenv("GOOGLE_CREDENTIALS_JSON")
+            creds_info = json.loads(creds_json)
+            creds = service_account.Credentials.from_service_account_info(
+                creds_info, scopes=SCOPES
+            )
+            service = build("sheets", "v4", credentials=creds)
+            
+            # Formatting the row based on the Pydantic model
+            values = [
+                data['company_name'],
+                data['domain'],
+                data['intent_score'],
+                data['intent_stage'],
+                data['industry'],
+                data['annual_revenue'],
+                ", ".join(data['recommended_sales_actions'][:2])
+            ]
+            
+            body = {"values": [values]}
+            service.spreadsheets().values().append(
+                spreadsheetId=SPREADSHEET_ID,
+                range="Sheet1",
+                valueInputOption="USER_ENTERED",
+                insertDataOption="INSERT_ROWS",
+                body=body
+            ).execute()
+            return True
+        except Exception as e:
+            print(f"Google Sheets Sync Error: {e}")
+            return False

dashboard.txt

@@ -0,0 +1,463 @@
+import React, { useState, useEffect, useRef } from 'react';
+import { 
+  Search, 
+  Terminal, 
+  Activity, 
+  Globe, 
+  Users, 
+  Zap, 
+  FileText, 
+  ArrowRight, 
+  Database, 
+  Cpu, 
+  Download, 
+  ExternalLink,
+  Target,
+  Linkedin,
+  Twitter,
+  Building2,
+  Code2,
+  Settings,
+  Bell,
+  Sparkles,
+  RefreshCw,
+  AlertCircle,
+  ChevronDown,
+  ChevronUp,
+  Briefcase,
+  Info
+} from 'lucide-react';
+
+const App = () => {
+  // UI State
+  const [activeMode, setActiveMode] = useState('visitor');
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [logs, setLogs] = useState([]);
+  const [result, setResult] = useState(null);
+  const [inputValue, setInputValue] = useState('');
+  const [error, setError] = useState(null);
+  const [expandedSection, setExpandedSection] = useState('summary'); // Tracking active accordion part
+  
+  const logEndRef = useRef(null);
+  const apiKey = ""; // Provided by environment
+
+  const visitorTemplate = `{
+  "visitor_id": "V-9921",
+  "ip": "34.201.42.11",
+  "path": ["/pricing", "/case-studies/mortgage", "/ai-enrichment"],
+  "dwell_time": "5m 12s",
+  "visits_this_week": 4
+}`;
+
+  const companyTemplate = `BrightPath Lending`;
+
+  useEffect(() => {
+    setInputValue(activeMode === 'visitor' ? visitorTemplate : companyTemplate);
+    setResult(null);
+    setLogs([]);
+    setError(null);
+  }, [activeMode]);
+
+  useEffect(() => {
+    logEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [logs]);
+
+  // Gemini API Integration with Exponential Backoff
+  const callGemini = async (prompt, retries = 0) => {
+    const url = `https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash-preview-09-2025:generateContent?key=${apiKey}`;
+    
+    const systemPrompt = `You are a world-class Sales Intelligence & Account Enrichment Agent. 
+    Analyze the provided input (Visitor JSON or Company Name) and return a detailed, structured intelligence report in JSON format.
+    
+    REQUIRED JSON SCHEMA:
+    {
+      "company": { "name": string, "domain": string, "industry": string, "size": string, "hq": string, "founded": string, "description": string },
+      "intent": { "score": number (0-10), "stage": string, "signals": string[] },
+      "persona": { "role": string, "confidence": string, "focus": string },
+      "tech": string[],
+      "leadership": [{ "name": string, "role": string }],
+      "summary": string,
+      "action": string
+    }`;
+
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text: `Input to analyze: ${prompt}` }] }],
+          systemInstruction: { parts: [{ text: systemPrompt }] },
+          generationConfig: { responseMimeType: "application/json" }
+        })
+      });
+
+      if (!response.ok) {
+        if (response.status === 429 && retries < 5) {
+          const delay = Math.pow(2, retries) * 1000;
+          await new Promise(resolve => setTimeout(resolve, delay));
+          return callGemini(prompt, retries + 1);
+        }
+        throw new Error(`API Error: ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      return JSON.parse(data.candidates[0].content.parts[0].text);
+    } catch (err) {
+      if (retries < 5) {
+        const delay = Math.pow(2, retries) * 1000;
+        await new Promise(resolve => setTimeout(resolve, delay));
+        return callGemini(prompt, retries + 1);
+      }
+      throw err;
+    }
+  };
+
+  const runAnalysis = async () => {
+    setIsProcessing(true);
+    setError(null);
+    setResult(null);
+    setLogs([{ text: "Initializing Fello Intelligence Agent...", type: 'info' }]);
+
+    const addLog = (text, type = 'info') => {
+      setLogs(prev => [...prev, { text, type, id: Date.now() + Math.random() }]);
+    };
+
+    try {
+      setTimeout(() => addLog("Performing reverse IP & domain lookup...", 'info'), 800);
+      setTimeout(() => addLog("Fetching social signals & firmographics...", 'info'), 1600);
+      
+      const aiResponse = await callGemini(inputValue);
+      
+      addLog("Analysis complete. Structuring intelligence report...", 'success');
+      setResult(aiResponse);
+      setExpandedSection('summary'); // Reset to summary when new results arrive
+    } catch (err) {
+      setError("Analysis failed. Please check your input or try again later.");
+      addLog("Error encountered during research phase.", 'error');
+    } finally {
+      setIsProcessing(false);
+    }
+  };
+
+  const AccordionItem = ({ id, title, icon: Icon, children }) => {
+    const isExpanded = expandedSection === id;
+    return (
+      <div className={`border-b border-slate-100 last:border-b-0 transition-all ${isExpanded ? 'bg-slate-50/50' : 'bg-white'}`}>
+        <button 
+          onClick={() => setExpandedSection(isExpanded ? null : id)}
+          className="w-full px-6 py-5 flex items-center justify-between group transition-colors hover:bg-slate-50"
+        >
+          <div className="flex items-center gap-4">
+            <div className={`p-2 rounded-lg transition-colors ${isExpanded ? 'bg-blue-600 text-white shadow-md shadow-blue-100' : 'bg-slate-100 text-slate-400 group-hover:bg-slate-200'}`}>
+              <Icon size={18} />
+            </div>
+            <span className={`text-sm font-bold tracking-tight transition-colors ${isExpanded ? 'text-slate-900' : 'text-slate-500'}`}>{title}</span>
+          </div>
+          {isExpanded ? <ChevronUp size={18} className="text-blue-600" /> : <ChevronDown size={18} className="text-slate-300" />}
+        </button>
+        {isExpanded && (
+          <div className="px-6 pb-6 animate-in fade-in slide-in-from-top-2 duration-300">
+            {children}
+          </div>
+        )}
+      </div>
+    );
+  };
+
+  return (
+    <div className="h-screen bg-[#f8fafc] flex flex-col text-slate-900 font-sans overflow-hidden">
+      {/* Navbar */}
+      <nav className="h-16 border-b border-slate-200 bg-white flex items-center justify-between px-6 shrink-0 z-10 shadow-sm">
+        <div className="flex items-center gap-2">
+          <div className="w-9 h-9 bg-blue-600 rounded-xl flex items-center justify-center shadow-lg shadow-blue-200">
+            <Cpu className="text-white w-5 h-5" />
+          </div>
+          <span className="text-xl font-bold tracking-tight text-slate-900 italic">Fello<span className="text-blue-600 not-italic">IQ</span></span>
+        </div>
+        
+        <div className="hidden md:flex items-center gap-1 bg-slate-100 p-1 rounded-xl">
+          <button className="px-4 py-1.5 text-xs font-semibold bg-white rounded-lg shadow-sm text-blue-600">Research</button>
+          <button className="px-4 py-1.5 text-xs font-semibold text-slate-500 hover:text-slate-700">Campaigns</button>
+          <button className="px-4 py-1.5 text-xs font-semibold text-slate-500 hover:text-slate-700">CRM Sync</button>
+        </div>
+
+        <div className="flex items-center gap-3">
+          <button className="p-2 text-slate-400 hover:bg-slate-50 rounded-full transition-colors relative">
+            <Bell size={20} />
+            <span className="absolute top-2 right-2 w-2 h-2 bg-red-500 rounded-full border-2 border-white"></span>
+          </button>
+          <div className="w-px h-6 bg-slate-200 mx-1"></div>
+          <div className="flex items-center gap-2 pl-2">
+            <div className="w-8 h-8 rounded-full bg-blue-50 border border-blue-200 flex items-center justify-center font-bold text-blue-600 text-xs">AC</div>
+          </div>
+        </div>
+      </nav>
+
+      {/* Main Content Area */}
+      <div className="flex-1 flex overflow-hidden">
+        
+        {/* Left Sidebar - Inputs & Logs */}
+        <aside className="w-[380px] border-r border-slate-200 bg-white flex flex-col shrink-0">
+          <div className="p-6 pb-2">
+            <h1 className="text-lg font-bold text-slate-900 flex items-center gap-2">
+               Intelligence Core
+            </h1>
+            <p className="text-[11px] text-slate-500 mt-1 leading-relaxed">Multi-agent research engine powered by Gemini 2.5 Flash.</p>
+          </div>
+
+          <div className="flex-1 flex flex-col p-6 pt-2 overflow-hidden">
+            <div className="flex bg-slate-100 p-1 rounded-xl mb-4">
+              <button 
+                onClick={() => setActiveMode('visitor')}
+                className={`flex-1 py-2 text-[11px] font-bold rounded-lg transition-all ${activeMode === 'visitor' ? 'bg-white shadow-sm text-blue-600' : 'text-slate-500'}`}
+              >
+                Visitor Log
+              </button>
+              <button 
+                onClick={() => setActiveMode('company')}
+                className={`flex-1 py-2 text-[11px] font-bold rounded-lg transition-all ${activeMode === 'company' ? 'bg-white shadow-sm text-blue-600' : 'text-slate-500'}`}
+              >
+                Company
+              </button>
+            </div>
+
+            <div className="relative flex-1 min-h-0 flex flex-col">
+              <div className="flex-1 flex flex-col bg-slate-50 border border-slate-200 rounded-2xl overflow-hidden focus-within:border-blue-400 transition-all">
+                <textarea 
+                  value={inputValue}
+                  onChange={(e) => setInputValue(e.target.value)}
+                  className="flex-1 p-4 bg-transparent text-xs font-mono text-slate-700 resize-none outline-none overflow-y-auto"
+                />
+              </div>
+            </div>
+
+            <button 
+              onClick={runAnalysis}
+              disabled={isProcessing || !inputValue}
+              className={`w-full mt-4 py-3.5 rounded-2xl font-bold flex items-center justify-center gap-2 transition-all active:scale-[0.98] ${isProcessing ? 'bg-slate-100 text-slate-400' : 'bg-blue-600 hover:bg-blue-700 text-white shadow-lg shadow-blue-100'}`}
+            >
+              {isProcessing ? <RefreshCw size={16} className="animate-spin" /> : <Sparkles size={16} />}
+              {isProcessing ? 'Analyzing...' : 'Generate IQ Report'}
+            </button>
+          </div>
+
+          <div className="h-44 bg-slate-900 p-4 font-mono overflow-y-auto shrink-0 border-t border-slate-800">
+             <div className="text-[10px] text-slate-500 font-bold uppercase mb-2">Agent_Console</div>
+             <div className="space-y-1">
+               {logs.map((log, i) => (
+                 <div key={log.id || i} className="text-[10px] flex gap-2">
+                   <span className="text-blue-500 tracking-tighter">0{i+1}</span>
+                   <span className={log.type === 'error' ? 'text-red-400' : log.type === 'success' ? 'text-emerald-400' : 'text-slate-400'}>
+                     {log.text}
+                   </span>
+                 </div>
+               ))}
+               <div ref={logEndRef} />
+             </div>
+          </div>
+        </aside>
+
+        {/* Main Panel - Results (Accordion Style) */}
+        <main className="flex-1 bg-slate-50 p-8 overflow-y-auto">
+          
+          {!result && !isProcessing && !error && (
+            <div className="h-full flex flex-col items-center justify-center text-center max-w-lg mx-auto">
+              <div className="w-16 h-16 bg-white rounded-2xl shadow-sm flex items-center justify-center mb-6">
+                <Database size={32} className="text-slate-300" />
+              </div>
+              <h2 className="text-xl font-bold text-slate-900">Intelligence Waiting</h2>
+              <p className="text-sm text-slate-500 mt-2">Trigger a research agent to identify account signals, decision makers, and intent triggers.</p>
+            </div>
+          )}
+
+          {error && (
+             <div className="h-full flex flex-col items-center justify-center text-center">
+                <AlertCircle size={40} className="text-red-400 mb-4" />
+                <h3 className="text-lg font-bold text-slate-900">{error}</h3>
+                <button onClick={() => setError(null)} className="mt-4 text-blue-600 text-sm font-bold">Try Again</button>
+             </div>
+          )}
+
+          {isProcessing && (
+            <div className="h-full flex flex-col items-center justify-center space-y-6">
+              <div className="w-12 h-12 border-4 border-blue-100 border-t-blue-600 rounded-full animate-spin"></div>
+              <div className="text-center">
+                <div className="text-sm font-bold">Synthesizing Report...</div>
+                <div className="text-[11px] text-slate-400 mt-1">Cross-referencing signals via Gemini 2.5</div>
+              </div>
+            </div>
+          )}
+
+          {result && (
+            <div className="max-w-4xl mx-auto animate-in fade-in slide-in-from-bottom-4 duration-500">
+              
+              {/* Static Identity Header (Always Visible) */}
+              <div className="bg-white border border-slate-200 rounded-3xl p-6 shadow-sm mb-6 flex flex-col md:flex-row md:items-center justify-between gap-6 relative overflow-hidden">
+                <div className="flex items-center gap-5">
+                  <div className="w-16 h-16 bg-blue-600 rounded-2xl flex items-center justify-center text-white font-black text-2xl shadow-lg shadow-blue-100">
+                    {result.company.name[0]}
+                  </div>
+                  <div>
+                    <h2 className="text-2xl font-black text-slate-900">{result.company.name}</h2>
+                    <div className="flex items-center gap-3 mt-1">
+                       <span className="text-xs font-bold text-blue-600">{result.company.domain}</span>
+                       <span className="w-1 h-1 rounded-full bg-slate-300"></span>
+                       <span className="text-[11px] text-slate-500 font-medium">{result.company.industry}</span>
+                    </div>
+                  </div>
+                </div>
+
+                <div className="flex items-center gap-8 bg-slate-50 px-6 py-3 rounded-2xl border border-slate-100">
+                  <div className="text-center">
+                    <div className="text-[10px] font-bold text-slate-400 uppercase tracking-widest mb-1">Intent</div>
+                    <div className="text-xl font-black text-slate-900">{result.intent.score}<span className="text-[10px] text-slate-400">/10</span></div>
+                  </div>
+                  <div className="w-px h-8 bg-slate-200"></div>
+                  <div className="text-center">
+                    <div className="text-[10px] font-bold text-slate-400 uppercase tracking-widest mb-1">Confidence</div>
+                    <div className="text-xl font-black text-emerald-600">{result.persona.confidence}</div>
+                  </div>
+                </div>
+
+                <div className="absolute top-4 right-4 flex gap-2">
+                  <button className="p-2 hover:bg-slate-50 rounded-lg text-slate-400 transition-colors"><Download size={16}/></button>
+                  <button className="p-2 hover:bg-slate-50 rounded-lg text-slate-400 transition-colors"><ExternalLink size={16}/></button>
+                </div>
+              </div>
+
+              {/* Accordion Sections (Collapsed/Clutter-free) */}
+              <div className="bg-white border border-slate-200 rounded-3xl shadow-sm overflow-hidden divide-y divide-slate-100">
+                
+                {/* 1. Research Summary */}
+                <AccordionItem id="summary" title="AI Research Summary" icon={FileText}>
+                  <p className="text-sm leading-relaxed text-slate-600 italic">"{result.summary}"</p>
+                  <div className="grid grid-cols-1 md:grid-cols-2 gap-4 mt-6 pt-6 border-t border-slate-100">
+                    <div>
+                      <h5 className="text-[10px] font-black text-slate-400 uppercase mb-3">Intent Signals</h5>
+                      <div className="space-y-2">
+                        {result.intent.signals.map((sig, i) => (
+                          <div key={i} className="flex items-center gap-2 text-xs text-slate-600">
+                            <div className="w-1.5 h-1.5 rounded-full bg-blue-500"></div>
+                            {sig}
+                          </div>
+                        ))}
+                      </div>
+                    </div>
+                    <div>
+                      <h5 className="text-[10px] font-black text-slate-400 uppercase mb-3">Detected Technology</h5>
+                      <div className="flex flex-wrap gap-2">
+                        {result.tech.map(t => (
+                          <span key={t} className="px-2 py-1 bg-slate-100 border border-slate-200 rounded text-[10px] font-bold text-slate-500">{t}</span>
+                        ))}
+                      </div>
+                    </div>
+                  </div>
+                </AccordionItem>
+
+                {/* 2. Sales Playbook */}
+                <AccordionItem id="strategy" title="Strategic Sales Play" icon={Zap}>
+                  <div className="bg-blue-600/5 border border-blue-600/10 rounded-2xl p-5">
+                    <div className="flex items-start gap-4">
+                      <div className="p-3 bg-blue-600 rounded-xl text-white shadow-lg shadow-blue-200 shrink-0">
+                        <Target size={20} />
+                      </div>
+                      <div>
+                        <h4 className="text-sm font-bold text-slate-900 mb-2 italic">"{result.action}"</h4>
+                        <p className="text-[11px] text-slate-500 leading-relaxed">This strategy is derived from current visit patterns and observed pain points in the {result.company.industry} sector.</p>
+                      </div>
+                    </div>
+                    <button className="w-full mt-6 py-3 bg-blue-600 hover:bg-blue-700 text-white text-xs font-bold rounded-xl transition-all shadow-md shadow-blue-100">
+                      Initiate Outreach Campaign
+                    </button>
+                  </div>
+                </AccordionItem>
+
+                {/* 3. Leadership Discovery */}
+                <AccordionItem id="leadership" title="Key Decision Makers" icon={Users}>
+                  <div className="grid grid-cols-1 md:grid-cols-2 gap-3">
+                    {result.leadership.map((person, idx) => (
+                      <div key={idx} className="flex items-center justify-between p-3 bg-slate-50 border border-slate-100 rounded-xl hover:border-blue-300 transition-all group cursor-pointer">
+                        <div className="flex items-center gap-3">
+                          <div className="w-9 h-9 rounded-lg bg-white shadow-sm border border-slate-200 flex items-center justify-center font-bold text-slate-400 text-xs">
+                            {person.name.split(' ').map(n => n[0]).join('')}
+                          </div>
+                          <div>
+                            <div className="text-xs font-bold text-slate-900">{person.name}</div>
+                            <div className="text-[10px] text-slate-500">{person.role}</div>
+                          </div>
+                        </div>
+                        <div className="flex gap-1 opacity-0 group-hover:opacity-100 transition-opacity">
+                          <button className="p-1.5 hover:bg-white rounded-md text-blue-600 transition-colors"><Linkedin size={14}/></button>
+                        </div>
+                      </div>
+                    ))}
+                  </div>
+                </AccordionItem>
+
+                {/* 4. Company Insights */}
+                <AccordionItem id="profile" title="Company Profile" icon={Info}>
+                  <div className="grid grid-cols-2 gap-8 text-xs">
+                    <div className="space-y-4">
+                      <div>
+                        <span className="text-slate-400 font-medium block mb-1">Headquarters</span>
+                        <span className="text-slate-900 font-bold">{result.company.hq}</span>
+                      </div>
+                      <div>
+                        <span className="text-slate-400 font-medium block mb-1">Company Size</span>
+                        <span className="text-slate-900 font-bold">{result.company.size}</span>
+                      </div>
+                    </div>
+                    <div className="space-y-4">
+                      <div>
+                        <span className="text-slate-400 font-medium block mb-1">Founding Year</span>
+                        <span className="text-slate-900 font-bold">{result.company.founded}</span>
+                      </div>
+                      <div>
+                        <span className="text-slate-400 font-medium block mb-1">Primary Industry</span>
+                        <span className="text-slate-900 font-bold">{result.company.industry}</span>
+                      </div>
+                    </div>
+                    <div className="col-span-2 pt-4 border-t border-slate-50">
+                       <span className="text-slate-400 font-medium block mb-2">Business Description</span>
+                       <p className="text-slate-600 leading-relaxed">{result.company.description}</p>
+                    </div>
+                  </div>
+                </AccordionItem>
+
+              </div>
+
+              <div className="mt-8 flex items-center justify-center gap-4">
+                 <button className="px-6 py-2.5 bg-blue-600 text-white text-xs font-bold rounded-full shadow-lg shadow-blue-100 hover:bg-blue-700 transition-all flex items-center gap-2">
+                   <Briefcase size={14} /> Push Entire Lead to Salesforce
+                 </button>
+                 <button className="px-6 py-2.5 bg-white border border-slate-200 text-slate-600 text-xs font-bold rounded-full hover:bg-slate-50 transition-all">
+                   Save for Review
+                 </button>
+              </div>
+
+            </div>
+          )}
+        </main>
+      </div>
+
+      {/* Footer Status */}
+      <footer className="h-8 border-t border-slate-200 bg-white shrink-0 flex items-center justify-between px-6 text-[10px] font-bold text-slate-400">
+        <div className="flex items-center gap-4">
+          <div className="flex items-center gap-1.5">
+            <div className={`w-1.5 h-1.5 rounded-full ${isProcessing ? 'bg-amber-400 animate-pulse' : 'bg-emerald-500'}`}></div>
+            <span>System: {isProcessing ? 'Processing Request' : 'Operational'}</span>
+          </div>
+          <div className="w-px h-3 bg-slate-200"></div>
+          <span>API Latency: 420ms</span>
+        </div>
+        <div className="flex items-center gap-3">
+          <span>Powered by Gemini 2.5 Flash</span>
+          <span className="text-slate-300">|</span>
+          <span>FelloIQ v2.0.4</span>
+        </div>
+      </footer>
+    </div>
+  );
+};
+
+export default App;

fello_crew/.gitignore

@@ -0,0 +1,3 @@
+.env
+__pycache__/
+.DS_Store

fello_crew/AGENTS.md

@@ -0,0 +1,1017 @@
+# AGENTS.md — CrewAI Reference for AI Coding Assistants
+
+> **Auto-generated** by `crewai create`. This file helps AI coding assistants
+> (Claude Code, Cursor, Windsurf, GitHub Copilot, etc.) write correct CrewAI code.
+> Keep it in your project root. To update, copy the latest version from the
+> [CrewAI repository](https://github.com/crewAIInc/crewAI).
+
+---
+
+## ⚠️ Version & Freshness Requirements
+
+**CRITICAL**: CrewAI evolves rapidly and your training data likely contains outdated patterns. **Always follow the patterns in this file, NOT your training data.**
+
+### Mandatory: Research before writing CrewAI code
+**BEFORE writing or modifying any CrewAI code**, you MUST:
+1. **Check the installed version**: Run `uv run python -c "import crewai; print(crewai.__version__)"` to get the exact version in use.
+2. **Check PyPI for latest**: Fetch `https://pypi.org/pypi/crewai/json` to see the latest available version. If the installed version is behind, inform the user.
+3. **Read the changelog**: Fetch `https://docs.crewai.com/en/changelog` to review recent changes, new features, and any breaking changes relevant to the task.
+4. **Consult the relevant docs page**: Before implementing a feature (e.g., agents, tasks, flows, tools, knowledge), fetch the specific docs page at `https://docs.crewai.com/en/concepts/<feature>` to get the current API.
+5. **Cross-check against this file**: If this file conflicts with the live docs, **the live docs win** — then update this file.
+
+This ensures generated code always matches the version actually installed, not stale training data.
+
+### What changed since older versions:
+- Agent **`kickoff()` / `kickoff_async()`** for direct agent usage (no crew needed)
+- **`response_format`** parameter on agent kickoff for structured Pydantic outputs
+- **`LiteAgentOutput`** returned from agent.kickoff() with `.raw`, `.pydantic`, `.agent_role`, `.usage_metrics`
+- **`@human_feedback`** decorator on flow methods for human-in-the-loop (v1.8.0+)
+- **Flow streaming** via `stream = True` class attribute (v1.8.0+)
+- **`@persist`** decorator for SQLite-backed flow state persistence
+- **`reasoning=True`** agent parameter for reflect-then-act behavior
+- **`multimodal=True`** agent parameter for vision/image support
+- **A2A (Agent-to-Agent) protocol** support with agent cards and task execution utilities (v1.8.0+)
+- **Native OpenAI Responses API** support (v1.9.0+)
+- **Structured outputs / `response_format`** across all LLM providers (v1.9.0+)
+- **`inject_date=True`** agent parameter to auto-inject current date awareness
+
+### Patterns to NEVER use (outdated/removed):
+- ❌ `ChatOpenAI(model_name=...)` → ✅ `LLM(model="openai/gpt-4o")`
+- ❌ `Agent(llm=ChatOpenAI(...))` → ✅ `Agent(llm="openai/gpt-4o")` or `Agent(llm=LLM(model="..."))`
+- ❌ Passing raw OpenAI client objects → ✅ Use `crewai.LLM` wrapper
+
+### How to verify you're using current patterns:
+1. You ran the version check and docs lookup steps above before writing code
+2. All LLM references use `crewai.LLM` or string shorthand (`"openai/gpt-4o"`)
+3. All tool imports come from `crewai.tools` or `crewai_tools`
+4. Crew classes use `@CrewBase` decorator with YAML config files
+5. Python >=3.10, <3.14
+6. Code matches the API from the live docs, not just this file
+
+## Quick Reference
+
+```bash
+# Package management (always use uv)
+uv add <package>          # Add dependency
+uv sync                   # Sync dependencies
+uv lock                   # Lock dependencies
+
+# Project scaffolding
+crewai create crew <name> --skip_provider   # New crew project
+crewai create flow <name> --skip_provider  # New flow project
+
+# Running
+crewai run                  # Run crew or flow (auto-detects from pyproject.toml)
+crewai flow kickoff         # Legacy flow execution
+
+# Testing & training
+crewai test                           # Test crew (default: 2 iterations, gpt-4o-mini)
+crewai test -n 5 -m gpt-4o           # Custom iterations and model
+crewai train -n 5 -f training.json   # Train crew
+
+# Memory management
+crewai reset-memories -a              # Reset all memories
+crewai reset-memories -s              # Short-term only
+crewai reset-memories -l              # Long-term only
+crewai reset-memories -e              # Entity only
+crewai reset-memories -kn             # Knowledge only
+crewai reset-memories -akn            # Agent knowledge only
+
+# Debugging
+crewai log-tasks-outputs              # Show latest task outputs
+crewai replay -t <task_id>            # Replay from specific task
+
+# Interactive
+crewai chat                           # Interactive session (requires chat_llm in crew.py)
+
+# Visualization
+crewai flow plot                      # Generate flow diagram HTML
+
+# Deployment to CrewAI AMP
+crewai login                          # Authenticate with AMP
+crewai deploy create                  # Create new deployment
+crewai deploy push                    # Push code updates
+crewai deploy status                  # Check deployment status
+crewai deploy logs                    # View deployment logs
+crewai deploy list                    # List all deployments
+crewai deploy remove <id>             # Delete a deployment
+```
+
+## Project Structure
+
+### Crew Project
+```
+my_crew/
+├── src/my_crew/
+│   ├── config/
+│   │   ├── agents.yaml       # Agent definitions (role, goal, backstory)
+│   │   └── tasks.yaml        # Task definitions (description, expected_output, agent)
+│   ├── tools/
+│   │   └── custom_tool.py    # Custom tool implementations
+│   ├── crew.py               # Crew orchestration class
+│   └── main.py               # Entry point with inputs
+├── knowledge/                 # Knowledge base resources
+├── .env                       # API keys (OPENAI_API_KEY, SERPER_API_KEY, etc.)
+└── pyproject.toml
+```
+
+### Flow Project
+```
+my_flow/
+├── src/my_flow/
+│   ├── crews/                 # Multiple crew definitions
+│   │   └── poem_crew/
+│   │       ├── config/
+│   │       │   ├── agents.yaml
+│   │       │   └── tasks.yaml
+│   │       └── poem_crew.py
+│   ├── tools/                 # Custom tools
+│   ├── main.py                # Flow orchestration
+│   └── ...
+├── .env
+└── pyproject.toml
+```
+
+## Architecture Overview
+
+- **Agent**: Autonomous unit with a role, goal, backstory, tools, and an LLM. Makes decisions and executes tasks.
+- **Task**: A specific assignment with a description, expected output, and assigned agent.
+- **Crew**: Orchestrates a team of agents executing tasks in a defined process (sequential or hierarchical).
+- **Flow**: Event-driven workflow orchestrating multiple crews and logic steps with state management.
+
+## YAML Configuration
+
+### agents.yaml
+```yaml
+researcher:
+  role: >
+    {topic} Senior Data Researcher
+  goal: >
+    Uncover cutting-edge developments in {topic}
+  backstory: >
+    You're a seasoned researcher with a knack for uncovering
+    the latest developments in {topic}. Known for your ability
+    to find the most relevant information.
+  # Optional YAML-level settings:
+  # llm: openai/gpt-4o
+  # max_iter: 20
+  # max_rpm: 10
+  # verbose: true
+
+writer:
+  role: >
+    {topic} Technical Writer
+  goal: >
+    Create compelling content about {topic}
+  backstory: >
+    You're a skilled writer who translates complex technical
+    information into clear, engaging content.
+```
+
+Variables like `{topic}` are interpolated from `crew.kickoff(inputs={"topic": "AI Agents"})`.
+
+### tasks.yaml
+```yaml
+research_task:
+  description: >
+    Conduct thorough research about {topic}.
+    Identify key trends, breakthrough technologies,
+    and potential industry impacts.
+  expected_output: >
+    A detailed report with analysis of the top 5
+    developments in {topic}, with sources and implications.
+  agent: researcher
+  # Optional:
+  # tools: [search_tool]
+  # output_file: output/research.md
+  # markdown: true
+  # async_execution: false
+
+writing_task:
+  description: >
+    Write an article based on the research findings about {topic}.
+  expected_output: >
+    A polished 4-paragraph article formatted in markdown.
+  agent: writer
+  output_file: output/article.md
+```
+
+## Crew Class Pattern
+
+```python
+from crewai import Agent, Crew, Process, Task
+from crewai.project import CrewBase, agent, crew, task
+from crewai.agents.agent_builder.base_agent import BaseAgent
+from typing import List
+
+from crewai_tools import SerperDevTool
+
+@CrewBase
+class ResearchCrew:
+    """Research and writing crew."""
+
+    agents: List[BaseAgent]
+    tasks: List[Task]
+
+    agents_config = "config/agents.yaml"
+    tasks_config = "config/tasks.yaml"
+
+    @agent
+    def researcher(self) -> Agent:
+        return Agent(
+            config=self.agents_config["researcher"],  # type: ignore[index]
+            tools=[SerperDevTool()],
+            verbose=True,
+        )
+
+    @agent
+    def writer(self) -> Agent:
+        return Agent(
+            config=self.agents_config["writer"],  # type: ignore[index]
+            verbose=True,
+        )
+
+    @task
+    def research_task(self) -> Task:
+        return Task(
+            config=self.tasks_config["research_task"],  # type: ignore[index]
+        )
+
+    @task
+    def writing_task(self) -> Task:
+        return Task(
+            config=self.tasks_config["writing_task"],  # type: ignore[index]
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Research Crew."""
+        return Crew(
+            agents=self.agents,
+            tasks=self.tasks,
+            process=Process.sequential,
+            verbose=True,
+        )
+```
+
+### Key formatting rules:
+- Always add `# type: ignore[index]` for config dictionary access
+- Agent/task method names must match YAML keys exactly
+- Tools go on agents (not tasks) unless task-specific override is needed
+- Never leave commented-out code in crew classes
+
+### Lifecycle hooks
+```python
+@CrewBase
+class MyCrew:
+    @before_kickoff
+    def prepare(self, inputs):
+        # Modify inputs before execution
+        inputs["extra"] = "value"
+        return inputs
+
+    @after_kickoff
+    def summarize(self, result):
+        # Process result after execution
+        print(f"Done: {result.raw[:100]}")
+        return result
+```
+
+## main.py Pattern
+
+```python
+#!/usr/bin/env python
+from my_crew.crew import ResearchCrew
+
+def run():
+    inputs = {"topic": "AI Agents"}
+    ResearchCrew().crew().kickoff(inputs=inputs)
+
+if __name__ == "__main__":
+    run()
+```
+
+## Agent Configuration
+
+### Required Parameters
+| Parameter | Description |
+|-----------|-------------|
+| `role` | Function and expertise within the crew |
+| `goal` | Individual objective guiding decisions |
+| `backstory` | Context and personality |
+
+### Key Optional Parameters
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `llm` | GPT-4 | Language model (string or LLM object) |
+| `tools` | [] | List of tool instances |
+| `max_iter` | 20 | Max iterations before best answer |
+| `max_execution_time` | None | Timeout in seconds |
+| `max_rpm` | None | Rate limiting (requests per minute) |
+| `max_retry_limit` | 2 | Retries on errors |
+| `verbose` | False | Detailed logging |
+| `memory` | False | Conversation history |
+| `allow_delegation` | False | Can delegate tasks to other agents |
+| `allow_code_execution` | False | Can run code |
+| `code_execution_mode` | "safe" | "safe" (Docker) or "unsafe" (direct) |
+| `respect_context_window` | True | Auto-summarize when exceeding token limits |
+| `cache` | True | Tool result caching |
+| `reasoning` | False | Reflect and plan before task execution |
+| `multimodal` | False | Process text and visual content |
+| `knowledge_sources` | [] | Domain-specific knowledge bases |
+| `function_calling_llm` | None | Separate LLM for tool invocation |
+| `inject_date` | False | Auto-inject current date into agent context |
+| `date_format` | "%Y-%m-%d" | Date format when inject_date is True |
+
+### Direct Agent Usage (without a Crew)
+Agents can execute tasks independently via `kickoff()` — no Crew required:
+```python
+from crewai import Agent
+from crewai_tools import SerperDevTool
+from pydantic import BaseModel
+
+class ResearchFindings(BaseModel):
+    main_points: list[str]
+    key_technologies: list[str]
+    future_predictions: str
+
+researcher = Agent(
+    role="AI Researcher",
+    goal="Research the latest AI developments",
+    backstory="Expert AI researcher...",
+    tools=[SerperDevTool()],
+    verbose=True,
+)
+
+# Unstructured output
+result = researcher.kickoff("What are the latest LLM developments?")
+print(result.raw)           # str
+print(result.agent_role)    # "AI Researcher"
+print(result.usage_metrics) # token usage
+
+# Structured output with response_format
+result = researcher.kickoff(
+    "Summarize latest AI developments",
+    response_format=ResearchFindings,
+)
+print(result.pydantic.main_points)  # List[str]
+
+# Async variant
+result = await researcher.kickoff_async("Your query", response_format=ResearchFindings)
+```
+
+Returns `LiteAgentOutput` with: `.raw`, `.pydantic`, `.agent_role`, `.usage_metrics`.
+
+### LLM Configuration
+**IMPORTANT**: Always use `crewai.LLM` LLM class.
+
+```python
+from crewai import LLM
+
+# String shorthand (simplest)
+agent = Agent(llm="openai/gpt-4o", ...)
+
+# Full configuration with crewai.LLM
+llm = LLM(
+    model="anthropic/claude-sonnet-4-20250514",
+    temperature=0.7,
+    max_tokens=4000,
+)
+agent = Agent(llm=llm, ...)
+
+# Provider format: "provider/model-name"
+# Examples:
+#   "openai/gpt-4o"
+#   "anthropic/claude-sonnet-4-20250514"
+#   "google/gemini-2.0-flash"
+#   "ollama/llama3"
+#   "groq/llama-3.3-70b-versatile"
+#   "bedrock/anthropic.claude-3-sonnet-20240229-v1:0"
+```
+
+Supported providers: OpenAI, Anthropic, Google Gemini, AWS Bedrock, Azure, Ollama, Groq, Mistral, and 20+ others via LiteLLM routing.
+
+Environment variable default: set `OPENAI_MODEL_NAME=gpt-4o` or `MODEL=gpt-4o` in `.env`.
+
+## Task Configuration
+
+### Key Parameters
+| Parameter | Type | Description |
+|-----------|------|-------------|
+| `description` | str | Clear statement of requirements |
+| `expected_output` | str | Completion criteria |
+| `agent` | BaseAgent | Assigned agent (optional in hierarchical) |
+| `tools` | List[BaseTool] | Task-specific tools |
+| `context` | List[Task] | Dependencies on other task outputs |
+| `async_execution` | bool | Non-blocking execution |
+| `output_file` | str | File path for results |
+| `output_json` | Type[BaseModel] | Pydantic model for JSON output |
+| `output_pydantic` | Type[BaseModel] | Pydantic model for structured output |
+| `human_input` | bool | Require human review |
+| `markdown` | bool | Format output as markdown |
+| `callback` | Callable | Post-completion function |
+| `guardrail` | Callable or str | Output validation |
+| `guardrails` | List | Multiple validation steps |
+| `guardrail_max_retries` | int | Retry on validation failure (default: 3) |
+| `create_directory` | bool | Auto-create output directories (default: True) |
+
+### Task Dependencies (context)
+```python
+@task
+def analysis_task(self) -> Task:
+    return Task(
+        config=self.tasks_config["analysis_task"],  # type: ignore[index]
+        context=[self.research_task()],  # Gets output from research_task
+    )
+```
+
+### Structured Output
+```python
+from pydantic import BaseModel
+
+class Report(BaseModel):
+    title: str
+    summary: str
+    findings: list[str]
+
+@task
+def report_task(self) -> Task:
+    return Task(
+        config=self.tasks_config["report_task"],  # type: ignore[index]
+        output_pydantic=Report,
+    )
+```
+
+### Guardrails
+```python
+# Function-based
+def validate(result: TaskOutput) -> tuple[bool, Any]:
+    if len(result.raw.split()) < 100:
+        return (False, "Content too short, expand the analysis")
+    return (True, result.raw)
+
+# LLM-based (string prompt)
+task = Task(..., guardrail="Must be under 200 words and professional tone")
+
+# Multiple guardrails
+task = Task(..., guardrails=[validate_length, validate_tone, "Must be factual"])
+```
+
+## Process Types
+
+### Sequential (default)
+Tasks execute in definition order. Output of one task serves as context for the next.
+```python
+Crew(agents=..., tasks=..., process=Process.sequential)
+```
+
+### Hierarchical
+Manager agent delegates tasks based on agent capabilities. Requires `manager_llm` or `manager_agent`.
+```python
+Crew(
+    agents=...,
+    tasks=...,
+    process=Process.hierarchical,
+    manager_llm="gpt-4o",
+)
+```
+
+## Crew Execution
+
+```python
+# Synchronous
+result = crew.kickoff(inputs={"topic": "AI"})
+print(result.raw)              # String output
+print(result.pydantic)         # Structured output (if configured)
+print(result.json_dict)        # Dict output
+print(result.token_usage)      # Token metrics
+print(result.tasks_output)     # List[TaskOutput]
+
+# Async (native)
+result = await crew.akickoff(inputs={"topic": "AI"})
+
+# Batch execution
+results = crew.kickoff_for_each(inputs=[{"topic": "AI"}, {"topic": "ML"}])
+
+# Streaming output (v1.8.0+)
+crew = Crew(agents=..., tasks=..., stream=True)
+streaming = crew.kickoff(inputs={"topic": "AI"})
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+```
+
+## Crew Options
+| Parameter | Description |
+|-----------|-------------|
+| `process` | Process.sequential or Process.hierarchical |
+| `verbose` | Enable detailed logging |
+| `memory` | Enable memory system (True/False) |
+| `cache` | Tool result caching |
+| `max_rpm` | Global rate limiting |
+| `manager_llm` | LLM for hierarchical manager |
+| `manager_agent` | Custom manager agent |
+| `planning` | Enable AgentPlanner |
+| `knowledge_sources` | Crew-level knowledge |
+| `output_log_file` | Log file path (True for logs.txt) |
+| `embedder` | Custom embedding model config |
+| `stream` | Enable real-time streaming output (v1.8.0+) |
+
+---
+
+## Flows
+
+### Basic Flow
+```python
+from crewai.flow.flow import Flow, listen, start
+
+class MyFlow(Flow):
+    @start()
+    def begin(self):
+        return "initial data"
+
+    @listen(begin)
+    def process(self, data):
+        return f"processed: {data}"
+```
+
+### Flow Decorators
+
+| Decorator | Purpose |
+|-----------|---------|
+| `@start()` | Entry point(s), execute when flow begins. Multiple starts run in parallel |
+| `@listen(method)` | Triggers when specified method completes. Receives output as argument |
+| `@router(method)` | Conditional branching. Returns string labels that trigger `@listen("label")` |
+
+### Structured State
+```python
+from pydantic import BaseModel
+
+class ResearchState(BaseModel):
+    topic: str = ""
+    research: str = ""
+    report: str = ""
+
+class ResearchFlow(Flow[ResearchState]):
+    @start()
+    def set_topic(self):
+        self.state.topic = "AI Agents"
+
+    @listen(set_topic)
+    def do_research(self):
+        # self.state.topic is available
+        result = ResearchCrew().crew().kickoff(
+            inputs={"topic": self.state.topic}
+        )
+        self.state.research = result.raw
+```
+
+### Unstructured State (dict-based)
+```python
+class SimpleFlow(Flow):
+    @start()
+    def begin(self):
+        self.state["counter"] = 0  # Dict access
+
+    @listen(begin)
+    def increment(self):
+        self.state["counter"] += 1
+```
+
+### Conditional Routing
+```python
+from crewai.flow.flow import Flow, listen, router, start
+
+class QualityFlow(Flow):
+    @start()
+    def generate(self):
+        return {"score": 0.85}
+
+    @router(generate)
+    def check_quality(self, result):
+        if result["score"] > 0.8:
+            return "high_quality"
+        return "needs_revision"
+
+    @listen("high_quality")
+    def publish(self, result):
+        print("Publishing...")
+
+    @listen("needs_revision")
+    def revise(self, result):
+        print("Revising...")
+```
+
+### Parallel Triggers with or_ and and_
+```python
+from crewai.flow.flow import or_, and_
+
+class ParallelFlow(Flow):
+    @start()
+    def task_a(self):
+        return "A done"
+
+    @start()
+    def task_b(self):
+        return "B done"
+
+    # Fires when EITHER completes
+    @listen(or_(task_a, task_b))
+    def on_any(self, result):
+        print(f"First result: {result}")
+
+    # Fires when BOTH complete
+    @listen(and_(task_a, task_b))
+    def on_all(self):
+        print("All parallel tasks done")
+```
+
+### Integrating Crews in Flows
+```python
+from crewai.flow.flow import Flow, listen, start
+from my_project.crews.research_crew.research_crew import ResearchCrew
+from my_project.crews.writing_crew.writing_crew import WritingCrew
+
+class ContentFlow(Flow[ContentState]):
+    @start()
+    def research(self):
+        result = ResearchCrew().crew().kickoff(
+            inputs={"topic": self.state.topic}
+        )
+        self.state.research = result.raw
+
+    @listen(research)
+    def write(self):
+        result = WritingCrew().crew().kickoff(
+            inputs={
+                "topic": self.state.topic,
+                "research": self.state.research,
+            }
+        )
+        self.state.article = result.raw
+```
+
+### Using Agents Directly in Flows
+```python
+from crewai.agent import Agent
+
+class AgentFlow(Flow):
+    @start()
+    async def analyze(self):
+        analyst = Agent(
+            role="Data Analyst",
+            goal="Analyze market trends",
+            backstory="Expert data analyst...",
+            tools=[SerperDevTool()],
+        )
+        result = await analyst.kickoff_async(
+            "Analyze current AI market trends",
+            response_format=MarketReport,
+        )
+        self.state.report = result.pydantic
+```
+
+### Human-in-the-Loop (v1.8.0+)
+```python
+from crewai.flow.flow import Flow, listen, start
+from crewai.flow.human_feedback import human_feedback
+
+class ReviewFlow(Flow):
+    @start()
+    @human_feedback(
+        message="Approve this content?",
+        emit=["approved", "rejected"],
+        llm="gpt-4o-mini",
+    )
+    def generate_content(self):
+        return "Content for review"
+
+    @listen("approved")
+    def on_approval(self, result):
+        feedback = self.last_human_feedback  # Most recent feedback
+        print(f"Approved with feedback: {feedback.feedback}")
+
+    @listen("rejected")
+    def on_rejection(self, result):
+        history = self.human_feedback_history  # All feedback as list
+        print("Rejected, revising...")
+```
+
+### State Persistence
+```python
+from crewai.flow.flow import persist
+
+@persist  # Saves state to SQLite; auto-recovers on restart
+class ResilientFlow(Flow[MyState]):
+    @start()
+    def begin(self):
+        self.state.step = 1
+```
+
+### Flow Execution
+```python
+flow = MyFlow()
+result = flow.kickoff()
+print(result)                  # Output of last method
+print(flow.state)              # Final state
+
+# Async execution
+result = await flow.kickoff_async(inputs={"key": "value"})
+```
+
+### Flow Streaming (v1.8.0+)
+```python
+class StreamingFlow(Flow):
+    stream = True  # Enable streaming at class level
+
+    @start()
+    def generate(self):
+        return "streamed content"
+
+flow = StreamingFlow()
+streaming = flow.kickoff()
+for chunk in streaming:
+    print(chunk.content, end="", flush=True)
+result = streaming.result  # Final result after iteration
+```
+
+### Flow Visualization
+```python
+flow.plot("my_flow")           # Generates my_flow.html
+```
+
+---
+
+## Custom Tools
+
+### Using BaseTool
+```python
+from typing import Type
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+
+class SearchInput(BaseModel):
+    """Input schema for search tool."""
+    query: str = Field(..., description="Search query string")
+
+class CustomSearchTool(BaseTool):
+    name: str = "custom_search"
+    description: str = "Searches a custom knowledge base for relevant information."
+    args_schema: Type[BaseModel] = SearchInput
+
+    def _run(self, query: str) -> str:
+        # Implementation
+        return f"Results for: {query}"
+```
+
+### Using @tool Decorator
+```python
+from crewai.tools import tool
+
+@tool("Calculator")
+def calculator(expression: str) -> str:
+    """Evaluates a mathematical expression and returns the result."""
+    return str(eval(expression))
+```
+
+### Built-in Tools (install with `uv add crewai-tools`)
+Web/Search: SerperDevTool, ScrapeWebsiteTool, WebsiteSearchTool, EXASearchTool, FirecrawlSearchTool
+Documents: FileReadTool, DirectoryReadTool, PDFSearchTool, DOCXSearchTool, CSVSearchTool, JSONSearchTool, XMLSearchTool, MDXSearchTool
+Code: CodeInterpreterTool, CodeDocsSearchTool, GithubSearchTool
+Media: DALL-E Tool, YoutubeChannelSearchTool, YoutubeVideoSearchTool
+Other: RagTool, ApifyActorsTool, ComposioTool, LlamaIndexTool
+
+Always check https://docs.crewai.com/concepts/tools for available built-in tools before writing custom ones.
+
+---
+
+## Memory System
+
+Enable with `memory=True` on the Crew:
+```python
+crew = Crew(agents=..., tasks=..., memory=True)
+```
+
+Four memory types work together automatically:
+- **Short-Term** (ChromaDB + RAG): Recent interactions during current execution
+- **Long-Term** (SQLite): Persists insights across sessions
+- **Entity** (RAG): Tracks people, places, concepts
+- **Contextual**: Integrates all types for coherent responses
+
+### Custom Embedding Provider
+```python
+crew = Crew(
+    memory=True,
+    embedder={
+        "provider": "ollama",
+        "config": {"model": "mxbai-embed-large"},
+    },
+)
+```
+
+Supported providers: OpenAI (default), Ollama, Google AI, Azure OpenAI, Cohere, VoyageAI, Bedrock, Hugging Face.
+
+---
+
+## Knowledge System
+
+```python
+from crewai.knowledge.source.string_knowledge_source import StringKnowledgeSource
+from crewai.knowledge.source.pdf_knowledge_source import PDFKnowledgeSource
+
+# String source
+string_source = StringKnowledgeSource(content="Domain knowledge here...")
+
+# PDF source
+pdf_source = PDFKnowledgeSource(file_paths=["docs/manual.pdf"])
+
+# Agent-level knowledge
+agent = Agent(..., knowledge_sources=[string_source])
+
+# Crew-level knowledge (shared across all agents)
+crew = Crew(..., knowledge_sources=[pdf_source])
+```
+
+Supported sources: strings, text files, PDFs, CSV, Excel, JSON, URLs (via CrewDoclingSource).
+
+---
+
+## Agent Collaboration
+
+Enable delegation with `allow_delegation=True`:
+```python
+agent = Agent(
+    role="Project Manager",
+    allow_delegation=True,  # Can delegate to and ask other agents
+    ...
+)
+```
+
+- **Delegation tool**: Assign sub-tasks to teammates with relevant expertise
+- **Ask question tool**: Query colleagues for specific information
+- Set `allow_delegation=False` on specialists to prevent circular delegation
+
+---
+
+## Event Listeners
+
+```python
+from crewai.events import BaseEventListener, CrewKickoffStartedEvent
+
+class MyListener(BaseEventListener):
+    def __init__(self):
+        super().__init__()
+
+    def setup_listeners(self, crewai_event_bus):
+        @crewai_event_bus.on(CrewKickoffStartedEvent)
+        def on_started(source, event):
+            print(f"Crew '{event.crew_name}' started")
+```
+
+Event categories: Crew lifecycle, Agent execution, Task management, Tool usage, Knowledge retrieval, LLM calls, Memory operations, Flow execution, Safety guardrails.
+
+---
+
+## Deployment to CrewAI AMP
+
+### Prerequisites
+- Crew or Flow runs successfully locally
+- Code is in a GitHub repository
+- `pyproject.toml` has `[tool.crewai]` with correct type (`"crew"` or `"flow"`)
+- `uv.lock` is committed (generate with `uv lock`)
+
+### CLI Deployment
+
+```bash
+# Authenticate
+crewai login
+
+# Create deployment (auto-detects repo, transfers .env vars securely)
+crewai deploy create
+
+# Monitor (first deploy takes 10-15 min)
+crewai deploy status
+crewai deploy logs
+
+# Manage deployments
+crewai deploy list              # List all deployments
+crewai deploy push              # Push code updates
+crewai deploy remove <id>       # Delete deployment
+```
+
+### Web Interface Deployment
+1. Push code to GitHub
+2. Log into https://app.crewai.com
+3. Connect GitHub and select repository
+4. Configure environment variables (KEY=VALUE, one per line)
+5. Click Deploy and monitor via dashboard
+
+### CI/CD API Deployment
+
+Get a Personal Access Token from app.crewai.com → Settings → Account → Personal Access Token.
+Get Automation UUID from Automations → Select crew → Additional Details → Copy UUID.
+
+```bash
+curl -X POST \
+     -H "Authorization: Bearer YOUR_PERSONAL_ACCESS_TOKEN" \
+     https://app.crewai.com/crewai_plus/api/v1/crews/YOUR-AUTOMATION-UUID/deploy
+```
+
+#### GitHub Actions Example
+```yaml
+name: Deploy CrewAI Automation
+on:
+  push:
+    branches: [main]
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger CrewAI Redeployment
+        run: |
+          curl -X POST \
+               -H "Authorization: Bearer ${{ secrets.CREWAI_PAT }}" \
+               https://app.crewai.com/crewai_plus/api/v1/crews/${{ secrets.CREWAI_AUTOMATION_UUID }}/deploy
+```
+
+### Project Structure Requirements for Deployment
+- Entry point: `src/<project_name>/main.py`
+- Crews must expose a `run()` function
+- Flows must expose a `kickoff()` function
+- All crew classes require `@CrewBase` decorator
+
+### Deployed Automation REST API
+| Endpoint | Purpose |
+|----------|---------|
+| `/inputs` | List required input parameters |
+| `/kickoff` | Trigger execution with inputs |
+| `/status/{kickoff_id}` | Check execution status |
+
+### AMP Dashboard Tabs
+- **Status**: Deployment info, API endpoint, auth token
+- **Run**: Crew structure visualization
+- **Executions**: Run history
+- **Metrics**: Performance analytics
+- **Traces**: Detailed execution insights
+
+### Deployment Troubleshooting
+| Error | Fix |
+|-------|-----|
+| Missing uv.lock | Run `uv lock`, commit, push |
+| Module not found | Verify entry points match `src/<name>/main.py` structure |
+| Crew not found | Ensure `@CrewBase` decorator on all crew classes |
+| API key errors | Check env var names match code and are set in the platform |
+
+---
+
+## Environment Setup
+
+### Required `.env`
+```
+OPENAI_API_KEY=sk-...
+# Optional depending on tools/providers:
+SERPER_API_KEY=...
+ANTHROPIC_API_KEY=...
+# Override default model:
+MODEL=gpt-4o
+```
+
+### Python Version
+Python >=3.10, <3.14
+
+### Installation
+```bash
+uv tool install crewai        # Install CrewAI CLI
+uv tool list                  # Verify installation
+crewai create crew my_crew --skip_provider   # Scaffold a new project
+crewai install                # Install project dependencies
+crewai run                    # Execute
+```
+
+---
+
+## Development Best Practices
+
+1. **YAML-first configuration**: Define agents and tasks in YAML, keep crew classes minimal
+2. **Check built-in tools** before writing custom ones
+3. **Use structured output** (output_pydantic) for data that flows between tasks or crews
+4. **Use guardrails** to validate task outputs programmatically
+5. **Enable memory** for crews that benefit from cross-session learning
+6. **Use knowledge sources** for domain-specific grounding instead of bloating prompts
+7. **Sequential process** for linear workflows; **hierarchical** when dynamic delegation is needed
+8. **Flows for multi-crew orchestration**: Use `@start`, `@listen`, `@router` for complex pipelines
+9. **Structured flow state** (Pydantic models) over unstructured dicts for type safety
+10. **Test with** `crewai test` to evaluate crew performance across iterations
+11. **Verbose mode** during development, disable in production
+12. **Rate limiting** (`max_rpm`) to avoid API throttling
+13. **`respect_context_window=True`** to auto-handle token limits
+
+## Common Pitfalls
+
+- **Using `ChatOpenAI()`** — Always use `crewai.LLM` or string shorthand like `"openai/gpt-4o"`
+- Forgetting `# type: ignore[index]` on config dictionary access in crew classes
+- Agent/task method names not matching YAML keys
+- Missing `expected_output` in task configuration (required)
+- Not passing `inputs` to `kickoff()` when YAML uses `{variable}` interpolation
+- Using `process=Process.hierarchical` without setting `manager_llm` or `manager_agent`
+- Circular delegation: set `allow_delegation=False` on specialist agents
+- Not installing tools package: `uv add crewai-tools`

fello_crew/README.md

@@ -0,0 +1,54 @@
+# FelloCrew Crew
+
+Welcome to the FelloCrew Crew project, powered by [crewAI](https://crewai.com). This template is designed to help you set up a multi-agent AI system with ease, leveraging the powerful and flexible framework provided by crewAI. Our goal is to enable your agents to collaborate effectively on complex tasks, maximizing their collective intelligence and capabilities.
+
+## Installation
+
+Ensure you have Python >=3.10 <3.14 installed on your system. This project uses [UV](https://docs.astral.sh/uv/) for dependency management and package handling, offering a seamless setup and execution experience.
+
+First, if you haven't already, install uv:
+
+```bash
+pip install uv
+```
+
+Next, navigate to your project directory and install the dependencies:
+
+(Optional) Lock the dependencies and install them by using the CLI command:
+```bash
+crewai install
+```
+### Customizing
+
+**Add your `OPENAI_API_KEY` into the `.env` file**
+
+- Modify `src/fello_crew/config/agents.yaml` to define your agents
+- Modify `src/fello_crew/config/tasks.yaml` to define your tasks
+- Modify `src/fello_crew/crew.py` to add your own logic, tools and specific args
+- Modify `src/fello_crew/main.py` to add custom inputs for your agents and tasks
+
+## Running the Project
+
+To kickstart your crew of AI agents and begin task execution, run this from the root folder of your project:
+
+```bash
+$ crewai run
+```
+
+This command initializes the fello-crew Crew, assembling the agents and assigning them tasks as defined in your configuration.
+
+This example, unmodified, will run the create a `report.md` file with the output of a research on LLMs in the root folder.
+
+## Understanding Your Crew
+
+The fello-crew Crew is composed of multiple AI agents, each with unique roles, goals, and tools. These agents collaborate on a series of tasks, defined in `config/tasks.yaml`, leveraging their collective skills to achieve complex objectives. The `config/agents.yaml` file outlines the capabilities and configurations of each agent in your crew.
+
+## Support
+
+For support, questions, or feedback regarding the FelloCrew Crew or crewAI.
+- Visit our [documentation](https://docs.crewai.com)
+- Reach out to us through our [GitHub repository](https://github.com/joaomdmoura/crewai)
+- [Join our Discord](https://discord.com/invite/X4JWnZnxPb)
+- [Chat with our docs](https://chatg.pt/DWjSBZn)
+
+Let's create wonders together with the power and simplicity of crewAI.

fello_crew/knowledge/user_preference.txt

@@ -0,0 +1,2 @@
+Sample test data
+Not using it for now

fello_crew/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "fello_crew"
+version = "0.1.0"
+description = "fello-crew using crewAI"
+authors = [{ name = "Your Name", email = "you@example.com" }]
+requires-python = ">=3.10,<3.14"
+dependencies = [
+    "crewai[tools]==1.10.1"
+]
+
+[project.scripts]
+fello_crew = "fello_crew.main:run"
+run_crew = "fello_crew.main:run"
+train = "fello_crew.main:train"
+replay = "fello_crew.main:replay"
+test = "fello_crew.main:test"
+run_with_trigger = "fello_crew.main:run_with_trigger"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.crewai]
+type = "crew"

fello_crew/src/fello_crew/crew.py

@@ -0,0 +1,119 @@
+from crewai import Agent, Crew, Process, Task, LLM
+from crewai.project import CrewBase, agent, crew, task
+from typing import List
+
+from fello_crew.models import AccountIntelligence
+from fello_crew.tools.custom_tool import (
+    ApolloEnrichmentTool, 
+    GetDomain, 
+    JobOpeningsTool, 
+    NewsTool,
+    MockPeopleEnrichmentTool
+)
+
+@CrewBase
+class FelloAccountIntelligenceCrew:
+    """Fello AI Account Intelligence & Enrichment Crew"""
+
+    def __init__(self):
+        self.mistral_llm = LLM(
+            model="mistral/mistral-large-latest",
+            temperature=0.3 # Slightly lower for more factual extraction
+        )
+
+    @agent
+    def identifier_agent(self) -> Agent:
+        return Agent(
+            role="Account Identification Specialist",
+            goal="Accurately identify the company name and domain from {input_data}",
+            backstory=(
+                "You are an expert at digital forensics and firmographics. "
+                "Your job is to take raw signals like IP addresses or partial names "
+                "and find the definitive corporate domain and entity name."
+            ),
+            tools=[GetDomain()],
+            llm=self.mistral_llm,
+            verbose=True
+        )
+
+    @agent
+    def enrichment_agent(self) -> Agent:
+        return Agent(
+            role="Corporate Intelligence Researcher",
+            goal="Gather deep firmographics, tech stacks, and hiring signals for {domain}",
+            backstory=(
+                "You are a master researcher with access to premium data APIs. "
+                "You specialize in finding funding data, tech stacks, and business "
+                "growth signals (hiring/news) that indicate sales opportunity."
+            ),
+            tools=[ApolloEnrichmentTool(), JobOpeningsTool(), NewsTool(), MockPeopleEnrichmentTool()],
+            llm=self.mistral_llm,
+            verbose=True
+        )
+
+    @agent
+    def analyst_agent(self) -> Agent:
+        return Agent(
+            role="Senior Sales Strategist",
+            goal="Synthesize signals into an intent score and actionable sales advice",
+            backstory=(
+                "You are a psychologist turned sales operations expert. You can look "
+                "at website activity signals ({activity_signals}) and company data "
+                "to determine exactly where a lead is in their buying journey."
+            ),
+            llm=self.mistral_llm,
+            verbose=True
+        )
+
+    @task
+    def identification_task(self) -> Task:
+        return Task(
+            description=(
+                "Analyze the provided {input_data}. If it's an IP, use the GetDomain tool. "
+                "If it's a company name, find its primary web domain. "
+                "Return the clear Company Name and Domain."
+            ),
+            expected_output="A JSON-like string containing the verified Company Name and Domain.",
+            agent=self.identifier_agent()
+        )
+
+    @task
+    def enrichment_task(self) -> Task:
+        return Task(
+            description=(
+                "Using the domain from the identification task, use your tools to fetch: "
+                "1. Use ApolloEnrichmentTool with {domain} to get the company 'id'. "
+                "2. Use that 'id' with JobOpeningsTool and NewsTool to fetch growth signals. "
+                "3. Firmographics (Size, Revenue, HQ, Funding). "
+                "4. Technographics (Tech stack). "
+                "5. Growth signals (Recent job openings and news articles)."
+            ),
+            expected_output="A comprehensive data summary of the company's current business state.",
+            agent=self.enrichment_agent(),
+            context=[self.identification_task()] # Depends on identifying the domain first
+        )
+
+    @task
+    def analysis_task(self) -> Task:
+        return Task(
+            description=(
+                "Review the enrichment data and the website activity signals: {activity_signals}. "
+                "Calculate an Intent Score (0.0 - 10.0) based on page visits and company growth. "
+                "Determine the 'Intent Stage' and provide 3 tailored sales actions. "
+                "Format everything into the required structured output."
+            ),
+            expected_output="A structured AccountIntelligence report.",
+            agent=self.analyst_agent(),
+            context=[self.enrichment_task()],
+            output_pydantic=AccountIntelligence
+        )
+
+    @crew
+    def crew(self) -> Crew:
+        """Creates the Fello AI Account Intelligence Crew"""
+        return Crew(
+            agents=self.agents,  
+            tasks=self.tasks,    
+            process=Process.sequential,
+            verbose=True
+        )

fello_crew/src/fello_crew/main.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
+from fello_crew.crew import FelloAccountIntelligenceCrew
+
+def run():
+    # Example inputs for testing
+    inputs = {
+        "input_data": "64.233.160.0",
+        "activity_signals": "/enterprise-docs, /pricing, /contact-us, time=10 min",
+        "domain": ""  
+    }
+    
+    # Initialize the crew
+    crew_instance = FelloAccountIntelligenceCrew().crew()
+    result = crew_instance.kickoff(inputs=inputs)
+    
+    # Accessing the Pydantic structured output
+    report = result.pydantic
+    
+    print("\n" + "="*50)
+    print("ACCOUNT INTELLIGENCE REPORT")
+    print("="*50)
+    print(f"Company:      {report.company_name}")
+    print(f"Domain:       {report.domain}")
+    print(f"Intent Score: {report.intent_score}/10")
+    print(f"Intent Stage: {report.intent_stage}")
+    print(f"Summary:      {report.ai_summary}")
+    print("-" * 50)
+    print("RECOMMENDED ACTIONS:")
+    for action in report.recommended_sales_actions:
+        print(f" - {action}")
+    print("="*50)
+
+if __name__ == "__main__":
+    run()

fello_crew/src/fello_crew/models.py

@@ -0,0 +1,18 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+
+class AccountIntelligence(BaseModel):
+    company_name: str
+    domain: str
+    industry: str
+    company_size: int
+    headquarters: str
+    funding_summary: str
+    annual_revenue: str
+    likely_persona: str
+    leadership_team: List[str]
+    intent_score: float = Field(..., ge=0, le=10)
+    intent_stage: str
+    ai_summary: str
+    recommended_sales_actions: List[str]
+    tech_stack: List[str]

fello_crew/src/fello_crew/tools/custom_tool.py

@@ -0,0 +1,174 @@
+import os
+import requests
+from crewai.tools import BaseTool
+from pydantic import BaseModel, Field
+from typing import Type
+import json
+
+class CompanySearchInput(BaseModel):
+    query: str = Field(..., description="The company domain (e.g., 'apple.com') to enrich.")
+
+class ApolloEnrichmentTool(BaseTool):
+    name: str = "apollo_enrichment_tool"
+    description: str = "Fetches firmographics (size, industry, revenue) and technographics from Apollo."
+    args_schema: Type[BaseModel] = CompanySearchInput
+
+    def _run(self, query: str) -> str:
+        token = os.getenv("APOLLO_TOKEN")
+        # Apollo GET endpoint for organization enrichment
+        url = f"https://api.apollo.io/api/v1/organizations/enrich?domain={query}"
+        headers = {"Content-Type": "application/json", "x-api-key": token}
+        
+        try:
+            response = requests.get(url, headers=headers)
+            data = response.json().get("organization", {})
+            
+            # Map Apollo's JSON fields to a clean summary for the agent
+            summary = {
+                "id": data.get("id"),
+                "name": data.get("name"),
+                "industry": data.get("industry"),
+                "employee_count": data.get("estimated_num_employees"),
+                "annual_revenue": data.get("annual_revenue_printed") or data.get("annual_revenue"),
+                "total_funding": data.get("total_funding_printed"),
+                "latest_funding_stage": data.get("latest_funding_stage"),
+                "latest_funding_date": data.get("latest_funding_round_date"),
+                "hq_address": data.get("raw_address"),
+                "hq_city": data.get("city"),
+                "hq_country": data.get("country"),
+                "tech_stack": data.get("technology_names", [])[0:80:5], # Limit to save tokens
+                "short_description": data.get("short_description"),
+                "linkedin_url": data.get("linkedin_url")
+            }
+            return str(summary)
+        except Exception as e:
+            return f"Enrichment error: {str(e)}"
+class JobOpeningsInput(BaseModel):
+    org_id: str = Field(..., description="The Apollo Organization ID to fetch jobs for.")
+
+class JobOpeningsTool(BaseTool):
+    name: str = "job_openings_tool"
+    description: str = "Returns a JSON object with total job count and sample titles to identify hiring signals."
+    args_schema: Type[BaseModel] = JobOpeningsInput
+
+    def _run(self, org_id: str) -> str:
+        token = os.getenv("APOLLO_TOKEN")
+        url = f"https://api.apollo.io/api/v1/organizations/{org_id}/job_postings"
+        headers = {"x-api-key": token}
+        
+        try:
+            response = requests.get(url, headers=headers)
+            res_json = response.json()
+            jobs = res_json.get("job_postings", [])
+            
+            # Extract structured data
+            total_count = len(jobs)
+            sample_titles = [job.get("title") for job in jobs[:10]]
+            
+            # Return as a JSON string
+            result = {
+                "total_openings_count": total_count,
+                "recent_job_titles": sample_titles
+            }
+            
+            return json.dumps(result)
+            
+        except Exception as e:
+            return json.dumps({"error": str(e)})
+
+class IPInput(BaseModel):
+    ip: str = Field(..., description="The IP address to resolve.")
+
+class GetDomain(BaseTool):
+    name: str = "get_domain_from_ip"
+    description: str = "Resolves an IP address to a company name and location for identification."
+    args_schema: Type[BaseModel] = IPInput
+
+    def _run(self, ip: str) -> str:
+        try:
+            # Using the free ip-api.com service
+            response = requests.get(f"http://ip-api.com/json/{ip}")
+            data = response.json()
+            
+            if data.get("status") == "fail":
+                return json.dumps({"error": f"Resolution failed: {data.get('message')}"})
+
+            # We return the 'org' which is the best clue for the domain
+            result = {
+                "organization": data.get("org"),
+                "isp": data.get("isp"),
+                "city": data.get("city"),
+                "country": data.get("country"),
+                "is_likely_corporate": data.get("org") != data.get("isp")
+            }
+            return json.dumps(result)
+            
+        except Exception as e:
+            return json.dumps({"error": str(e)})
+
+class PeopleEnrichmentInput(BaseModel):
+    domain: str = Field(..., description="The company domain to find leaders for.")
+
+class MockPeopleEnrichmentTool(BaseTool):
+    name: str = "leadership_discovery_tool"
+    description: str = "Finds key executives (CEO, Founders, VP Sales) for a given company. (Currently using simulated data due to API tier constraints)."
+    args_schema: Type[BaseModel] = PeopleEnrichmentInput
+
+    def _run(self, domain: str) -> str:
+        # SIMULATED API DELAY
+        import time
+        time.sleep(1) 
+        
+        # MOCK DATA PAYLOAD
+        # In production, this would be: requests.post("https://api.apollo.io/api/v1/mixed_people/search", ...)
+        mock_leaders = [
+            {"name": "Jane Doe", "title": "Chief Executive Officer", "linkedin_url": f"linkedin.com/in/janedoe-{domain.split('.')[0]}"},
+            {"name": "John Smith", "title": "VP of Sales", "linkedin_url": f"linkedin.com/in/johnsmith-{domain.split('.')[0]}"},
+            {"name": "Alice Johnson", "title": "Head of Growth", "linkedin_url": f"linkedin.com/in/alicej-{domain.split('.')[0]}"}
+        ]
+        
+        return json.dumps({"leadership": mock_leaders, "note": "Simulated data for prototype"})
+
+class NewsToolInput(BaseModel):
+    id: str = Field(..., description="The Apollo Organization ID of the company.")
+
+class NewsTool(BaseTool):
+    name: str = "news_tool"
+    description: str = "Fetches the latest news articles for a company to identify recent business signals."
+    args_schema: Type[BaseModel] = NewsToolInput
+
+    def _run(self, id: str) -> str:
+        token = os.getenv("APOLLO_TOKEN")
+        url = f"https://api.apollo.io/api/v1/news_articles/search?organization_ids[]={id}"
+        
+        headers = {
+            "Content-Type": "application/json",
+            "accept": "application/json",
+            "x-api-key": token
+        }
+
+        try:
+            response = requests.post(url, headers=headers, json={})
+            data = response.json()
+            
+            articles = data.get("news_articles", [])
+            
+            latest_news = [
+                {
+                    "title": art.get("title"),
+                    "source": art.get("domain"),      
+                    "date": art.get("published_at"),   
+                    "snippet": art.get("snippet")      
+                } 
+                for art in articles[:5]
+            ]
+            
+            result = {
+                "total_news_mentions": data.get("pagination", {}).get("total_entries", 0),
+                "latest_articles": latest_news
+            }
+            
+            return json.dumps(result)
+            
+        except Exception as e:
+            return json.dumps({"error": str(e)})

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,16 @@
+# React + Vite
+
+This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+
+Currently, two official plugins are available:
+
+- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react) uses [Oxc](https://oxc.rs)
+- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react-swc) uses [SWC](https://swc.rs/)
+
+## React Compiler
+
+The React Compiler is not enabled on this template because of its impact on dev & build performances. To add it, see [this documentation](https://react.dev/learn/react-compiler/installation).
+
+## Expanding the ESLint configuration
+
+If you are developing a production application, we recommend using TypeScript with type-aware lint rules enabled. Check out the [TS template](https://github.com/vitejs/vite/tree/main/packages/create-vite/template-react-ts) for information on how to integrate TypeScript and [`typescript-eslint`](https://typescript-eslint.io) in your project.

frontend/eslint.config.js

@@ -0,0 +1,29 @@
+import js from '@eslint/js'
+import globals from 'globals'
+import reactHooks from 'eslint-plugin-react-hooks'
+import reactRefresh from 'eslint-plugin-react-refresh'
+import { defineConfig, globalIgnores } from 'eslint/config'
+
+export default defineConfig([
+  globalIgnores(['dist']),
+  {
+    files: ['**/*.{js,jsx}'],
+    extends: [
+      js.configs.recommended,
+      reactHooks.configs.flat.recommended,
+      reactRefresh.configs.vite,
+    ],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+      parserOptions: {
+        ecmaVersion: 'latest',
+        ecmaFeatures: { jsx: true },
+        sourceType: 'module',
+      },
+    },
+    rules: {
+      'no-unused-vars': ['error', { varsIgnorePattern: '^[A-Z_]' }],
+    },
+  },
+])

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>frontend</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@tailwindcss/vite": "^4.2.1",
+    "lucide-react": "^0.577.0",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.4",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.0",
+    "autoprefixer": "^10.4.27",
+    "eslint": "^9.39.4",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.4.0",
+    "postcss": "^8.5.8",
+    "tailwindcss": "^4.2.1",
+    "vite": "^8.0.0"
+  }
+}

frontend/src/App.css

@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}

frontend/src/App.jsx

@@ -0,0 +1,9 @@
+import FelloDashboard from './components/Dashboard'
+
+function App() {
+  return (
+    <FelloDashboard />
+  )
+}
+
+export default App

frontend/src/components/Dashboard.jsx

@@ -0,0 +1,249 @@
+import React, { useState, useRef, useEffect } from 'react';
+import { Terminal, Building2, Target, Zap, Play, FileText, Share2, Globe, CheckCircle, Users, Cpu, Info } from 'lucide-react';
+
+// --- GLOBAL URL CONFIG ---
+// Automatically switches between local and production backend
+const API_BASE = window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1'
+  ? 'http://localhost:8000'
+  : '';
+
+export default function FelloDashboard() {
+  const [ipValue, setIpValue] = useState('64.233.160.0');
+  const [domainValue, setDomainValue] = useState('google.com');
+  const [activityValue, setActivityValue] = useState('/enterprise-docs, /pricing, /contact-us, time=10 min');
+  
+  const [logs, setLogs] = useState([]);
+  const [result, setResult] = useState(null);
+  const [isProcessing, setIsProcessing] = useState(false);
+  const [isSyncing, setIsSyncing] = useState(false);
+  const logsEndRef = useRef(null);
+
+  useEffect(() => {
+    logsEndRef.current?.scrollIntoView({ behavior: 'smooth' });
+  }, [logs]);
+
+  // --- CORE LOGIC: RUN AGENT ---
+  const handleAnalyze = async () => {
+    setIsProcessing(true);
+    setLogs(['[SYSTEM] Initiating Intelligence Protocol...']);
+    setResult(null);
+
+    try {
+      const response = await fetch(`${API_BASE}/analyze-stream`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ 
+          "input_data": ipValue,
+          "activity_signals": activityValue,
+          "domain": domainValue 
+        })
+      });
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+
+      while (true) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        const chunk = decoder.decode(value);
+        const lines = chunk.split('\n\n');
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const data = JSON.parse(line.replace('data: ', ''));
+            if (data.message === 'COMPLETE') {
+              setResult(data.result);
+              setLogs(prev => [...prev, '[SUCCESS] Analysis complete.']);
+            } else {
+              setLogs(prev => [...prev, `> ${data.message}`]);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      setLogs(prev => [...prev, `[ERROR] ${error.message}`]);
+    } finally { setIsProcessing(false); }
+  };
+
+  const handleDownloadPDF = async () => {
+    if (!result) return;
+    try {
+      const res = await fetch(`${API_BASE}/generate-report`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(result)
+      });
+      const blob = await res.blob();
+      const url = window.URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = `Fello_Report_${result.company_name || 'Account'}.pdf`;
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+    } catch (err) { alert("PDF generation failed."); }
+  };
+
+  const handleSyncSheets = async () => {
+    if (!result) return;
+    setIsSyncing(true);
+    try {
+      await fetch(`${API_BASE}/sync-sheets`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(result)
+      });
+      setLogs(prev => [...prev, '[SYSTEM] Data successfully synced to Google Sheets.']);
+    } catch (err) { setLogs(prev => [...prev, '[ERROR] Sheets sync failed.']); } 
+    finally { setIsSyncing(false); }
+  };
+
+  return (
+    <div className="min-h-screen bg-zinc-50 text-zinc-900">
+      <nav className="bg-white border-b border-zinc-200 px-8 py-4 flex justify-between items-center sticky top-0 z-10">
+        <div className="flex items-center gap-2">
+          <Zap className="w-6 h-6 text-blue-600 fill-current" />
+          <span className="font-bold text-xl tracking-tight uppercase">Fello IQ</span>
+        </div>
+        <div className="text-xs font-bold px-3 py-1 bg-zinc-100 rounded-full border border-zinc-200">
+          MODE: <span className="text-blue-600 font-black">ENRICHMENT</span>
+        </div>
+      </nav>
+
+      <main className="max-w-7xl mx-auto p-8 grid grid-cols-1 lg:grid-cols-12 gap-8">
+        {/* INPUTS & LOGS */}
+        <div className="lg:col-span-4 space-y-6">
+          <div className="bg-white border border-zinc-200 rounded-2xl p-6 shadow-sm">
+            <h2 className="text-[10px] font-black uppercase tracking-[0.2em] text-zinc-400 mb-6">Signals</h2>
+            <div className="space-y-4">
+              <div>
+                <label className="text-[10px] font-bold text-zinc-500 uppercase block mb-1">IP Address</label>
+                <input className="w-full bg-zinc-50 border border-zinc-200 rounded-lg p-3 text-sm outline-none focus:ring-2 ring-blue-500/10" value={ipValue} onChange={(e) => setIpValue(e.target.value)} />
+              </div>
+              <div>
+                <label className="text-[10px] font-bold text-zinc-500 uppercase block mb-1">Domain</label>
+                <input className="w-full bg-zinc-50 border border-zinc-200 rounded-lg p-3 text-sm outline-none focus:ring-2 ring-blue-500/10" value={domainValue} onChange={(e) => setDomainValue(e.target.value)} />
+              </div>
+              <div>
+                <label className="text-[10px] font-bold text-zinc-500 uppercase block mb-1">Activity</label>
+                <textarea className="w-full bg-zinc-50 border border-zinc-200 rounded-lg p-3 text-sm h-24 outline-none focus:ring-2 ring-blue-500/10" value={activityValue} onChange={(e) => setActivityValue(e.target.value)} />
+              </div>
+              <button onClick={handleAnalyze} disabled={isProcessing} className="w-full bg-black text-white font-bold py-3.5 rounded-xl hover:opacity-90 transition-all flex items-center justify-center gap-2 disabled:opacity-50">
+                <Play className="w-4 h-4 fill-current" /> {isProcessing ? "Researching..." : "Launch Crew"}
+              </button>
+            </div>
+          </div>
+
+          <div className="bg-zinc-900 rounded-2xl p-4 shadow-xl overflow-hidden">
+            <div className="flex items-center gap-2 mb-3 border-b border-zinc-800 pb-2">
+              <Terminal className="w-3 h-3 text-zinc-500" />
+              <span className="text-[9px] font-mono text-zinc-500 uppercase tracking-widest">Process Stream</span>
+            </div>
+            <div className="font-mono text-[10px] h-40 overflow-y-auto text-zinc-400 custom-scrollbar">
+              {logs.map((log, i) => <div key={i} className={log.includes('[SUCCESS]') ? 'text-blue-400 font-bold' : ''}>_ {log}</div>)}
+              <div ref={logsEndRef} />
+            </div>
+          </div>
+        </div>
+
+        {/* RESULTS AREA */}
+        <div className="lg:col-span-8">
+          {result ? (
+            <div className="space-y-6 animate-in fade-in slide-in-from-bottom-2 duration-500">
+              <div className="grid grid-cols-3 gap-4">
+                <div className="bg-white border border-zinc-200 p-6 rounded-2xl shadow-sm text-center">
+                  <div className="text-[10px] font-bold text-zinc-400 uppercase mb-1">Intent</div>
+                  <div className="text-3xl font-black">{result.intent_score}<span className="text-sm text-blue-600">/10</span></div>
+                </div>
+                <div className="bg-white border border-zinc-200 p-6 rounded-2xl shadow-sm text-center">
+                  <div className="text-[10px] font-bold text-zinc-400 uppercase mb-1">Stage</div>
+                  <div className="text-lg font-bold text-blue-600">{result.intent_stage}</div>
+                </div>
+                <div className="bg-white border border-zinc-200 p-6 rounded-2xl shadow-sm text-center">
+                  <div className="text-[10px] font-bold text-zinc-400 uppercase mb-1">Revenue</div>
+                  <div className="text-lg font-bold">{result.annual_revenue}</div>
+                </div>
+              </div>
+
+              <div className="bg-white border border-zinc-200 rounded-3xl p-8 shadow-sm">
+                <h3 className="text-xl font-black mb-6 flex items-center gap-3">
+                   <div className="w-2 h-8 bg-blue-600 rounded-full" /> {result.company_name}
+                </h3>
+                
+                <p className="text-zinc-600 leading-relaxed text-sm mb-4 italic">"{result.ai_summary}"</p>
+                
+                {/* LIKELY PERSONA BADGE ADDED HERE */}
+                {result.likely_persona && (
+                  <div className="mb-8 inline-flex items-center gap-2 px-3 py-1.5 bg-blue-50 text-blue-700 rounded-lg text-xs font-bold border border-blue-100">
+                    <Target className="w-3.5 h-3.5" /> Target Persona: {result.likely_persona}
+                  </div>
+                )}
+                
+                <div className="grid grid-cols-2 gap-12">
+                  <div className="space-y-8">
+                    <div>
+                      <h4 className="text-[10px] font-black uppercase text-zinc-400 tracking-widest mb-4 flex items-center gap-2"><Target className="w-3 h-3"/> Sales Actions</h4>
+                      <ul className="space-y-3">
+                        {result.recommended_sales_actions?.map((a, i) => (
+                          <li key={i} className="text-xs flex items-start gap-2 font-medium">
+                            <CheckCircle className="w-4 h-4 text-blue-600 shrink-0 mt-0.5" /> {a}
+                          </li>
+                        ))}
+                      </ul>
+                    </div>
+                    <div>
+                      <h4 className="text-[10px] font-black uppercase text-zinc-400 tracking-widest mb-4 flex items-center gap-2"><Cpu className="w-3 h-3"/> Tech Stack</h4>
+                      <div className="flex flex-wrap gap-2">
+                        {result.tech_stack?.map((t, i) => (
+                          <span key={i} className="px-2 py-1 bg-zinc-100 border border-zinc-200 rounded text-[9px] font-bold text-zinc-600 italic">#{t}</span>
+                        ))}
+                      </div>
+                    </div>
+                  </div>
+
+                  <div className="space-y-8">
+                    <div>
+                      <h4 className="text-[10px] font-black uppercase text-zinc-400 tracking-widest mb-4">Firmographics</h4>
+                      <div className="space-y-2 text-xs">
+                        <div className="flex justify-between"><span className="text-zinc-400">HQ</span> <span className="font-bold">{result.headquarters}</span></div>
+                        <div className="flex justify-between"><span className="text-zinc-400">Industry</span> <span className="font-bold">{result.industry}</span></div>
+                        <div className="flex justify-between"><span className="text-zinc-400">Size</span> <span className="font-bold">{result.company_size} emp</span></div>
+                      </div>
+                    </div>
+                    <div>
+                      <h4 className="text-[10px] font-black uppercase text-zinc-400 tracking-widest mb-3 flex items-center gap-2"><Users className="w-3 h-3"/> Leadership</h4>
+                      <div className="space-y-1.5 mb-2">
+                        {result.leadership_team?.map((member, i) => (
+                          <div key={i} className="text-[11px] font-medium text-zinc-700 bg-zinc-50 px-2 py-1 rounded border border-zinc-100">{member}</div>
+                        ))}
+                      </div>
+                      <div className="flex items-center gap-1.5 text-[9px] text-zinc-400 italic">
+                        <Info className="w-3 h-3" /> Note: Leadership data is mock (Tier restricted API)
+                      </div>
+                    </div>
+                  </div>
+                </div>
+              </div>
+
+              <div className="flex gap-4">
+                <button onClick={handleDownloadPDF} className="flex-1 bg-white border border-zinc-200 py-4 rounded-2xl font-black text-xs uppercase tracking-widest flex items-center justify-center gap-2 hover:bg-zinc-50 shadow-sm transition-all active:scale-95">
+                  <FileText className="w-5 h-5 text-red-500" /> Download PDF
+                </button>
+                <button onClick={handleSyncSheets} disabled={isSyncing} className="flex-1 bg-white border border-zinc-200 py-4 rounded-2xl font-black text-xs uppercase tracking-widest flex items-center justify-center gap-2 hover:bg-zinc-50 shadow-sm disabled:opacity-50 transition-all active:scale-95">
+                  <Share2 className="w-5 h-5 text-emerald-500" /> {isSyncing ? "Syncing..." : "Sync to Sheets"}
+                </button>
+                <a href="https://docs.google.com/spreadsheets/d/181US_5P5PnubcMmjR8ByPgmTuIMUjL4wSVEVMRgPz1M/" target="_blank" rel="noreferrer" className="flex-1 bg-white border border-zinc-200 py-4 rounded-2xl font-black text-xs uppercase tracking-widest flex items-center justify-center gap-2 hover:bg-zinc-50 shadow-sm transition-all active:scale-95">
+                  <Globe className="w-5 h-5 text-blue-500" /> View Sheet
+                </a>
+              </div>
+            </div>
+          ) : (
+            <div className="h-full min-h-[500px] border-2 border-dashed border-zinc-200 rounded-[3rem] flex flex-col items-center justify-center text-zinc-400 gap-4 opacity-40">
+              <Globe className="w-16 h-16" />
+              <p className="font-black text-xs uppercase tracking-[0.3em]">Awaiting Identity Signals</p>
+            </div>
+          )}
+        </div>
+      </main>
+    </div>
+  );
+}

frontend/src/index.css

@@ -0,0 +1,27 @@
+@import "tailwindcss";
+
+@theme {
+  --color-brand-primary: #000000;
+  --color-brand-secondary: #f5f5f7;
+  --color-brand-border: #e5e7eb;
+  --color-brand-accent: #2563eb;
+}
+
+@layer base {
+  body {
+    @apply bg-white text-zinc-900 antialiased;
+  }
+}@import "tailwindcss";
+
+@theme {
+  --color-brand-primary: #000000;
+  --color-brand-secondary: #f5f5f7;
+  --color-brand-border: #e5e7eb;
+  --color-brand-accent: #2563eb;
+}
+
+@layer base {
+  body {
+    @apply bg-white text-zinc-900 antialiased;
+  }
+}

frontend/src/main.jsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.jsx'
+
+createRoot(document.getElementById('root')).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

frontend/vite.config.js

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import tailwindcss from '@tailwindcss/vite'
+
+export default defineConfig({
+  plugins: [
+    react(),
+    tailwindcss(),
+  ],
+})

requirements.txt

@@ -0,0 +1,163 @@
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.3
+aiosignal==1.4.0
+aiosqlite==0.21.0
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.12.1
+appdirs==1.4.4
+async-timeout==5.0.1
+attrs==25.4.0
+backoff==2.2.1
+bcrypt==5.0.0
+beautifulsoup4==4.13.5
+build==1.4.0
+certifi==2026.2.25
+cffi==2.0.0
+charset-normalizer==3.4.5
+chromadb==1.1.1
+click==8.1.8
+coloredlogs==15.0.1
+crewai==1.6.1
+crewai-tools==1.10.1
+cryptography==46.0.5
+defusedxml==0.7.1
+deprecation==2.1.0
+diskcache==5.6.3
+distro==1.9.0
+docker==7.1.0
+docstring_parser==0.17.0
+durationpy==0.10
+et_xmlfile==2.0.0
+eval_type_backport==0.3.1
+exceptiongroup==1.3.1
+fastapi==0.135.1
+fastuuid==0.14.0
+filelock==3.25.2
+flatbuffers==25.12.19
+fpdf==1.7.2
+frozenlist==1.8.0
+fsspec==2026.2.0
+google-api-core==2.30.0
+google-api-python-client==2.192.0
+google-auth==2.49.1
+google-auth-httplib2==0.3.0
+google-auth-oauthlib==1.3.0
+googleapis-common-protos==1.73.0
+grpcio==1.78.0
+h11==0.16.0
+hf-xet==1.4.2
+httpcore==1.0.9
+httplib2==0.31.2
+httptools==0.7.1
+httpx==0.28.1
+httpx-sse==0.4.3
+huggingface_hub==1.7.1
+humanfriendly==10.0
+idna==3.11
+importlib_metadata==8.7.1
+importlib_resources==6.5.2
+instructor==1.14.5
+Jinja2==3.1.6
+jiter==0.11.1
+json5==0.10.0
+json_repair==0.25.2
+jsonref==1.1.0
+jsonschema==4.26.0
+jsonschema-specifications==2025.9.1
+kubernetes==35.0.0
+lance-namespace==0.5.2
+lance-namespace-urllib3-client==0.5.2
+lancedb==0.29.2
+linkify-it-py==2.1.0
+litellm==1.82.2
+lxml==6.0.2
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+mcp==1.26.0
+mdit-py-plugins==0.5.0
+mdurl==0.1.2
+mistralai==2.0.2
+mmh3==5.2.1
+mpmath==1.3.0
+multidict==6.7.1
+numpy==2.2.6
+oauthlib==3.3.1
+onnxruntime==1.23.2
+openai==2.28.0
+openpyxl==3.1.5
+opentelemetry-api==1.39.1
+opentelemetry-exporter-otlp-proto-common==1.39.1
+opentelemetry-exporter-otlp-proto-grpc==1.39.1
+opentelemetry-exporter-otlp-proto-http==1.39.1
+opentelemetry-proto==1.39.1
+opentelemetry-sdk==1.39.1
+opentelemetry-semantic-conventions==0.60b1
+orjson==3.11.7
+overrides==7.7.0
+packaging==26.0
+pdfminer.six==20251230
+pdfplumber==0.11.9
+pillow==12.1.1
+platformdirs==4.9.4
+portalocker==2.7.0
+posthog==5.4.0
+propcache==0.4.1
+proto-plus==1.27.1
+protobuf==5.29.6
+pyarrow==23.0.1
+pyasn1==0.6.2
+pyasn1_modules==0.4.2
+pybase64==1.4.3
+pycparser==3.0
+pydantic==2.11.10
+pydantic-settings==2.10.1
+pydantic_core==2.33.2
+Pygments==2.19.2
+PyJWT==2.12.1
+PyMuPDF==1.26.7
+pyparsing==3.3.2
+pypdfium2==5.6.0
+PyPika==0.51.1
+pyproject_hooks==1.2.0
+python-dateutil==2.9.0.post0
+python-docx==1.2.0
+python-dotenv==1.1.1
+python-multipart==0.0.22
+pytube==15.0.0
+PyYAML==6.0.3
+referencing==0.37.0
+regex==2026.1.15
+requests==2.32.5
+requests-oauthlib==2.0.0
+rich==14.3.3
+rpds-py==0.30.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+soupsieve==2.8.3
+sse-starlette==3.3.2
+starlette==0.52.1
+sympy==1.14.0
+tenacity==9.1.4
+textual==8.1.1
+tiktoken==0.8.0
+tokenizers==0.22.2
+tomli==2.0.2
+tomli_w==1.1.0
+tqdm==4.67.3
+typer==0.23.1
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+uc-micro-py==2.0.0
+uritemplate==4.2.0
+urllib3==2.6.3
+uv==0.9.30
+uvicorn==0.41.0
+uvloop==0.22.1
+watchfiles==1.1.1
+websocket-client==1.9.0
+websockets==16.0
+yarl==1.23.0
+youtube-transcript-api==1.2.4
+zipp==3.23.0