convez.ai
MCP Server
OmateLabs

speed-to-lead-agent

OmateLabs/speed-to-lead-agent

Ver no GitHub
BomPluginScore · de 0 a 100

Open-source AI agent that qualifies & responds to inbound leads in seconds — multi-agent (LangGraph) + a LoRA-fine-tuned intent classifier + MCP server. Bring your own keys.

Instalação

$npx convez-ai OmateLabs/speed-to-lead-agent

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
1
Forks
1
Acompanhando
0
Saúde
85%
Último commit
há 2 meses
Versão
—
Issues abertas
13
Contribuidores
1

README

A tradução para o português deste README ainda está na fila.

⚡ speed-to-lead-agent

Qualify and respond to every inbound lead in seconds — with an AI agent you self-host.

A multi-agent pipeline (LangGraph) that takes a raw inbound lead, scores its fit, drafts a personalized reply, and routes it to your CRM/Slack. Bring your own keys; runs locally with none.

CI Python 3.12 License: MIT Ruff Typed: mypy strict


Why this exists

Speed is the highest-leverage variable in inbound sales. In the canonical study ("The Short Life of Online Sales Leads," Harvard Business Review, 2011 — Oldroyd, McElheran & Elkington), firms that attempted to contact a lead within an hour were ~7× more likely to have a meaningful conversation with a decision-maker than those who waited just an hour longer — and ~60× more than those who waited 24+ hours. Yet most teams reply in hours or days because a human has to read, qualify, and write every first response.

This agent collapses that delay to seconds: it qualifies the lead, drafts a tailored reply, and hands your team a ready-to-send message (or auto-sends the high-confidence ones) — so no good lead goes cold while someone is in a meeting.

Self-hosted and open-source. A free, ownable alternative to per-seat "instant lead response" SaaS — your lead data never leaves your infrastructure.

What it does

flowchart LR
    W([Webhook<br/>form · Cal · Typeform]) -->|202, instant| Q[[Redis queue]]
    Q --> R(research<br/>enrich company)
    R --> QL(qualify<br/>fine-tuned classifier)
    QL -->|spam/non-buyer| D[discard + log]
    QL -->|real lead| DR(draft<br/>personalized reply)
    DR --> RT(route<br/>CRM · Slack · send)
    RT --> M[(funnel metrics<br/>attribution · latency)]
  • Instant intake — the webhook returns 202 immediately and a worker runs the slow part, so capture never blocks on an LLM call.
  • Explainable qualification — every lead gets a tier (hot/warm/cold/spam), an ICP-fit score, a buyer-intent label, and human-readable reasons. A confidence gate decides auto-send vs. human review.
  • Personalized drafts — intent-aware first-touch replies, provider-agnostic (Gemini/Groq/OpenAI/… via litellm) with a keyless template fallback.
  • Real GTM integrations — Twenty / HubSpot CRM, Slack alerts, email — behind your own keys.
  • Funnel analytics — source attribution, qualification rate, and speed-to-lead p50/p95, exposed as JSON and Prometheus.
  • MCP server — the same capabilities exposed to Claude/Cursor as tools.

Quickstart (zero keys, 2 minutes)

git clone https://github.com/OmateLabs/speed-to-lead-agent
cd speed-to-lead-agent
make install      # uv sync
make demo         # runs sample leads through the full pipeline — no signups

You'll see each sample lead qualified, scored, and routed, plus a funnel summary. Then run the API:

make serve        # http://127.0.0.1:8000  (docs at /docs)

curl -s localhost:8000/leads/sync -H 'content-type: application/json' -d '{
  "email": "maria@northwind-logistics.com",
  "name": "Maria Chen",
  "message": "Need pricing for a 40-person team — can we book a demo?",
  "source": "google_ads"
}' | python -m json.tool

Configuration (bring your own keys)

Copy .env.example to .env. Every key is optional — a missing one disables that feature, it never breaks the app. With none set, you're in DEMO_MODE (local stub model + console adapters).

VariableEnablesRequired?Get it
LLM_API_KEY + LLM_MODELLLM-written replies (else templated)optionalGemini / Groq (free)
TWENTY_API_URL + TWENTY_API_KEYPush leads to Twenty CRMoptionalTwenty → Settings → API
HUBSPOT_API_KEYPush leads to HubSpotoptionalHubSpot private app
SLACK_WEBHOOK_URLNew-lead Slack alertsoptionalSlack webhooks
WEBHOOK_SIGNING_SECRETVerify inbound webhook signaturesrecommendedself-generated
GREENHOUSE_API_KEYATS / recruiting-pipeline modeoptionalGreenhouse Harvest

The classifier

Qualification runs behind a single Qualifier interface with two implementations:

  1. RuleQualifier — a transparent, deterministic baseline (the keyless default). Strong, auditable, zero dependencies.
  2. LoRA-fine-tuned intent classifier — DistilBERT fine-tuned with PEFT/LoRA (PyTorch), 744K trainable params (1.1% of the model), served as its own inference path. make train produces the adapter (~30s on a laptop); when present it loads automatically, otherwise the rule baseline is used.

Result — on a hand-written, held-out realistic set (messages unseen in training):

StrategyAccuracyMacro-F1$/1k leads
Rule baseline (keyword)0.5000.500$0
LoRA classifier0.9380.933~$0 (local)

Nearly 2× the intent accuracy of keyword rules on phrasing it never saw — for ~$0, locally, in milliseconds. That's the case for fine-tuning over a per-lead LLM call. Full methodology in docs/benchmarks.md and MODEL_CARD.md.

Tech

Python 3.12 · FastAPI · LangGraph multi-agent · pydantic · litellm · Hugging Face + PEFT/LoRA · FAISS · Redis · MCP · Docker / Helm · GitHub Actions · Langfuse + Prometheus/Grafana.

Project layout

src/speed_to_lead/
├── api/           FastAPI app, webhook security
├── agents/        LangGraph pipeline (research → qualify → draft → route)
├── services/      qualify · enrich · draft  (swappable behind protocols)
├── integrations/  CRM (Twenty/HubSpot) · Slack · email
├── analytics/     attribution + speed-to-lead funnel metrics
├── ml/            LoRA fine-tune + eval (the classifier)
├── worker/        async queue (in-memory → Redis)
└── mcp_server/    Model Context Protocol server

Deploy

  • Single host: docker compose up — api + worker + Redis + Postgres.
  • Kubernetes: helm install stl infra/helm/ (or kubectl apply -f infra/k8s/) — liveness/readiness probes, resource limits, non-root, optional HPA, and bring-your-own-key via a referenced Secret.
  • Serverless: it's a standard ASGI app — deploys to Hugging Face Spaces / Cloud Run / Render unchanged.

Roadmap

  • Multi-agent pipeline + keyless demo + funnel analytics
  • LoRA-fine-tuned classifier + eval scorecard
  • MCP server · FAISS ICP similarity · ATS (Greenhouse) connector
  • Langfuse tracing + Prometheus/Grafana dashboards (config-as-code)
  • Deploy (HF Spaces / Cloud Run) + demo GIF

License

MIT © 2026 Omate Labs

Ver o original no GitHub

Bom para

Relacionados