How to Build an AI SDR (With LangGraph)

export LEADOCEAN_API_KEY="paste-your-key-here"
export ANTHROPIC_API_KEY="paste-your-model-key-here"
pip install langgraph langchain langchain-anthropic httpx

import os, time
import httpx

BASE = "https://api.leadocean.io"
HEADERS = {"x-api-key": os.environ["LEADOCEAN_API_KEY"]}
RECORD_CAP = 15          # hard ceiling for one run
spent = 0                # LeadOcean records spent in this run


class Halt(Exception):
    """Stop the graph. The message goes back to the model."""


def call(method, path, *, params=None, body=None, reserve=0):
    if spent + reserve > RECORD_CAP:
        raise Halt(f"Run cap of {RECORD_CAP} records reached. Write the drafts you have.")
    for attempt in range(4):
        r = httpx.request(method, BASE + path, params=params, json=body,
                          headers=HEADERS, timeout=30)
        if r.status_code == 429:
            if r.headers.get("X-Quota-State") in ("paced", "over-limit"):
                raise Halt("The account hit its fair-use pace and is slowed to one request "
                           f"a minute until {r.headers.get('X-Quota-Reset')}. Stop and report.")
            time.sleep(int(r.headers.get("Retry-After", "1")))   # plan rate limit
            continue
        if r.status_code == 402:
            raise Halt("The free records are spent. They do not reset. Stop and report.")
        if r.status_code == 503:
            time.sleep(2 ** attempt)                              # transient, never billed
            continue
        if r.status_code == 404:
            return None                                           # nobody matched, free
        r.raise_for_status()
        return r.json()
    raise Halt("LeadOcean did not answer after 4 tries. Stop and report.")

from langchain.tools import tool
import leadocean as lo

FILTER_KEYS = ("jobLevel", "jobFunction", "country", "industry", "employeeRange", "title")


def _body(args):
    return {k: v for k, v in args.items() if k in FILTER_KEYS and v}


@tool
def count_audience(jobLevel: list[str] | None = None, jobFunction: list[str] | None = None,
                   country: list[str] | None = None, industry: list[str] | None = None,
                   employeeRange: list[str] | None = None, title: list[str] | None = None) -> str:
    """Count mailable people for an ICP. Free. Call this first.
    Values are exact strings: jobLevel "VP", country "US", employeeRange "51-200"."""
    args = dict(jobLevel=jobLevel, jobFunction=jobFunction, country=country,
                industry=industry, employeeRange=employeeRange, title=title)
    res = lo.call("POST", "/v1/people/search", params={"count": "true"},
                  body=_body(args) | {"limit": 1})
    return f"{res['meta']['total']} people match. No records spent."


@tool
def search_people(jobLevel: list[str] | None = None, jobFunction: list[str] | None = None,
                  country: list[str] | None = None, industry: list[str] | None = None,
                  employeeRange: list[str] | None = None, title: list[str] | None = None,
                  limit: int = 10) -> str:
    """Search people for an ICP. Costs 1 record per person returned. Max 10.
    Returns person_id, name, headline and whether an email exists."""
    limit = max(1, min(limit, 10))
    args = dict(jobLevel=jobLevel, jobFunction=jobFunction, country=country,
                industry=industry, employeeRange=employeeRange, title=title)
    res = lo.call("POST", "/v1/people/search", body=_body(args) | {"limit": limit},
                  reserve=limit)
    rows = res["data"]
    lo.spent += len(rows)
    return str([{
        "person_id": r["meta"]["source_ids"]["person_id"],
        "name": r["profile_data"].get("profile_full_name"),
        "headline": r["profile_data"].get("profile_headline"),
        "has_email": r["contact_data"].get("has_email"),
        "email_status": r["contact_data"].get("email_status"),
    } for r in rows])


@tool
def enrich_person(person_id: str) -> str:
    """Full lookup for one person_id from search_people. Costs 1 record.
    Returns emails and career history (past roles, education, certifications)."""
    res = lo.call("POST", "/v1/people/enrich",
                  body={"person_id": person_id, "reveal_email": True}, reserve=1)
    if res is None:
        return "Not found. No record spent."
    lo.spent += 1
    d = res["data"]
    return str({"contact": d.get("contact_data"), "resume": d.get("resume_data")})

from langchain.chat_models import init_chat_model
from langchain.messages import SystemMessage, ToolMessage
from langgraph.graph import StateGraph, MessagesState, START, END
import leadocean as lo
from tools import count_audience, search_people, enrich_person

tools = [count_audience, search_people, enrich_person]
by_name = {t.name: t for t in tools}
model = init_chat_model("claude-sonnet-5", temperature=0)
model_with_tools = model.bind_tools(tools)

SYSTEM = """You are an SDR for Acme, which sells project management software.
ICP: VP of Sales at US software companies with 51 to 200 staff.

1. Call count_audience with the ICP filters and report the total.
2. Call search_people with the same filters and limit 10.
3. Pick the 3 best fits: has_email true and email_status verified first.
4. Call enrich_person for those 3 only.
5. For each, draft a first-touch email: subject under 6 words, body under 90 words,
   one line taken from the career history, one question as the call to action.

Use only facts from tool results. If a field is missing, leave it out. Send nothing.
Filter values are exact strings: jobLevel "VP", jobFunction "Sales & Business Development",
country "US", industry "Software Development", employeeRange "51-200"."""


class State(MessagesState):
    halted: bool


def llm_call(state: State):
    m = model if state.get("halted") else model_with_tools
    return {"messages": [m.invoke([SystemMessage(content=SYSTEM)] + state["messages"])]}


def tool_node(state: State):
    out, halted = [], False
    for tc in state["messages"][-1].tool_calls:
        try:
            text = by_name[tc["name"]].invoke(tc["args"])
        except lo.Halt as stop:
            text, halted = str(stop), True
        out.append(ToolMessage(content=text, tool_call_id=tc["id"]))
    return {"messages": out, "halted": halted}


def should_continue(state: State):
    return "tool_node" if state["messages"][-1].tool_calls else END


g = StateGraph(State)
g.add_node("llm_call", llm_call)
g.add_node("tool_node", tool_node)
g.add_edge(START, "llm_call")
g.add_conditional_edges("llm_call", should_continue, ["tool_node", END])
g.add_edge("tool_node", "llm_call")
agent = g.compile()

from langchain.messages import HumanMessage
from agent import agent
import leadocean as lo

result = agent.invoke({"messages": [HumanMessage(content="Draft this week's outreach.")],
                       "halted": False})
print(result["messages"][-1].content)
print(f"LeadOcean records spent: {lo.spent}")

from fastmcp.client import Client
from langchain.mcp import MCPAdapter


async def load_leadocean_tools():
    async with MCPAdapter(Client("https://api.leadocean.io/mcp", auth="oauth")) as adapter:
        return await adapter.list_tools()

leadocean_count_leads  title ["VP Sales","Head of Sales"]  country ["US"]
  industry ["Software Development"]  employeeRange ["51-200"]

2026-10-21  total: 360 (mailable: verified, catch_all_valid, catch_all)
            totalAll: 863  distinctCompanies: 317  records spent: 0

{
  "success": true,
  "data": [
    {
      "profile_data": { "profile_full_name": "Jane Doe", "profile_headline": "VP Sales at Acme" },
      "contact_data": { "has_email": true, "email_status": "verified" },
      "meta": { "source_ids": { "person_id": "<digits>" } }
    }
  ],
  "meta": { "count": 10, "limit": 10, "nextCursor": "<opaque cursor>" }
}