AI SDR

pip install maximem-synap maximem-synap-openai-agents openai-agents celery redis

from agents import function_tool

@function_tool
async def enrich_prospect(prospect_id: str) -> dict:
    """Fetch role, company, seniority, recent activity from your enrichment provider."""
    return await enrichment.lookup(prospect_id)

@function_tool
async def recent_signals(company_id: str) -> list[dict]:
    """Recent news, hires, funding, product launches at a company. Last 90 days."""
    return await signals.recent(company_id, days=90)

@function_tool
async def get_sequence_state(prospect_id: str) -> dict:
    """Where this prospect is in the sequence: current step, touches sent, replies."""
    return await sequences.state(prospect_id)

@function_tool
async def draft_email(prospect_id: str, kind: str, context: dict) -> dict:
    """Return a draft. kind: 'first_touch' | 'follow_up' | 'objection_response' | 'book_meeting'."""
    return {"subject": "...", "body": "...", "draft_id": "..."}

@function_tool
async def send_email(draft_id: str) -> dict:
    """Send the previously-drafted email via your transactional provider."""
    return await email.send_draft(draft_id)

@function_tool
async def book_meeting(prospect_id: str, preferred_times: list[str]) -> dict:
    """Generate a Cal.com link or hold proposed slots on the rep's calendar."""
    return await calendar.book(prospect_id, preferred_times)

@function_tool
async def log_interaction(prospect_id: str, kind: str, details: dict) -> dict:
    """Log a touch into your CRM."""
    return await crm.log(prospect_id, kind, details)

SYSTEM = """You are an AI SDR. The user is a prospect or your own internal sequence orchestrator.

When asked to draft a touch:
- Always pull sequence_state, enrich_prospect, and recent_signals first.
- Use prior touches and replies from memory — never re-tread points the prospect ignored or rejected.
- Personalize on real facts. Generic "I see your company is growing" lines are forbidden.
- Match the prospect's prior tone if you have one. Otherwise, be direct, no buzzwords, one ask per email.

When a reply arrives, classify it: interested | objection | out_of_office | unsubscribe | not_now.
- interested → book a meeting via book_meeting.
- objection → store the objection in memory and draft a response addressing it.
- out_of_office → snooze the sequence.
- unsubscribe → kill the sequence immediately, log in CRM.
- not_now → snooze to the date they suggest, or 30 days default.

Always log_interaction with what you did and why."""

async def run_sdr(prospect_id: str, instruction: str) -> str:
    synap_search = create_search_tool(sdk=sdk, user_id=prospect_id, customer_id=CUSTOMER_ID)
    synap_store  = create_store_tool(sdk=sdk, user_id=prospect_id, customer_id=CUSTOMER_ID)

    agent = Agent(
        name="ai_sdr",
        instructions=SYSTEM,
        tools=[
            FunctionTool(synap_search, name_override="synap_search"),
            FunctionTool(synap_store,  name_override="synap_store"),
            enrich_prospect, recent_signals, get_sequence_state,
            draft_email, send_email, book_meeting, log_interaction,
        ],
    )
    result = await Runner.run(agent, input=instruction)
    return result.final_output

@celery.task
async def run_due_touches():
    due = await sequences.due_now()  # your DB query
    for prospect_id in due:
        await run_sdr(prospect_id, "It's time for the next touch. Decide and execute.")

async def handle_email_reply(prospect_id: str, body: str, from_email: str):
    await sdk.memories.create(
        document=f"Prospect reply (from {from_email}):\n{body}",
        document_type="prospect-reply",
        user_id=prospect_id,
        customer_id=CUSTOMER_ID,
        metadata={"channel": "email", "direction": "inbound"},
    )
    await run_sdr(prospect_id, "The prospect replied. Read their message and decide.")