Salesforce: Enterprise Sales Assistant

pip install maximem-synap maximem-synap-openai-agents openai-agents simple-salesforce

uv add maximem-synap maximem-synap-openai-agents openai-agents simple-salesforce
# pip-compatible (existing venv): uv pip install maximem-synap maximem-synap-openai-agents openai-agents simple-salesforce

npm install @maximem/synap-js-sdk @maximem/synap-vercel-adk ai @ai-sdk/openai zod jsforce

# .env
SYNAP_API_KEY=...
OPENAI_API_KEY=...
SALESFORCE_CLIENT_ID=...
SALESFORCE_CLIENT_SECRET=...

# .env.local
SYNAP_API_KEY=...
OPENAI_API_KEY=...
SALESFORCE_CLIENT_ID=...
SALESFORCE_CLIENT_SECRET=...

SESSIONS: dict[str, str] = {}

def conv_for(session_id: str) -> str:
    return SESSIONS.setdefault(session_id, str(uuid.uuid4()))

const SESSIONS = new Map<string, string>();

function convFor(sessionId: string): string {
  if (!SESSIONS.has(sessionId)) SESSIONS.set(sessionId, crypto.randomUUID());
  return SESSIONS.get(sessionId)!;
}

from agents import function_tool

@function_tool
async def get_account(account_id: str) -> dict:
    """Return account name, industry, ARR, owner, and open opp count."""
    sf = await get_sf_client_for_rep()
    return sf.Account.get(account_id)

@function_tool
async def get_opportunities(account_id: str, stage: str = None) -> list[dict]:
    """List open opps for an account, optionally filtered by stage."""
    sf = await get_sf_client_for_rep()
    soql = f"SELECT Id, Name, StageName, Amount, CloseDate FROM Opportunity WHERE AccountId = '{account_id}'"
    if stage: soql += f" AND StageName = '{stage}'"
    return sf.query(soql)["records"]

@function_tool
async def get_contacts(account_id: str) -> list[dict]:
    sf = await get_sf_client_for_rep()
    return sf.query(
        f"SELECT Id, Name, Title, Email FROM Contact WHERE AccountId = '{account_id}'"
    )["records"]

@function_tool
async def query_pipeline(stage: str = None, close_before: str = None) -> list[dict]:
    """Query the rep's own pipeline. Returns opps owned by the current rep."""
    sf = await get_sf_client_for_rep()
    soql = "SELECT Id, AccountId, Name, StageName, Amount, CloseDate FROM Opportunity WHERE OwnerId = '{me}'"
    if stage: soql += f" AND StageName = '{stage}'"
    if close_before: soql += f" AND CloseDate <= {close_before}"
    return sf.query(soql.format(me=sf.user_id))["records"]

@function_tool
async def log_activity(opportunity_id: str, subject: str, body: str) -> dict:
    sf = await get_sf_client_for_rep()
    return sf.Task.create({"WhatId": opportunity_id, "Subject": subject, "Description": body})

@function_tool
async def update_opportunity(opportunity_id: str, fields: dict) -> dict:
    sf = await get_sf_client_for_rep()
    return sf.Opportunity.update(opportunity_id, fields)

@function_tool
async def create_task(opportunity_id: str, subject: str, due_date: str) -> dict:
    sf = await get_sf_client_for_rep()
    return sf.Task.create({
        "WhatId": opportunity_id, "Subject": subject,
        "ActivityDate": due_date, "Status": "Open",
    })

import { tool } from "ai";
import { z } from "zod";

const sfTools = {
  get_account: tool({
    description: "Return account name, industry, ARR, owner, and open opp count.",
    parameters: z.object({ accountId: z.string() }),
    execute: async ({ accountId }) => (await getSfClient()).sobject("Account").retrieve(accountId),
  }),
  get_opportunities: tool({
    description: "List open opps for an account, optionally filtered by stage.",
    parameters: z.object({ accountId: z.string(), stage: z.string().optional() }),
    execute: async ({ accountId, stage }) => {
      const sf = await getSfClient();
      let soql = `SELECT Id, Name, StageName, Amount, CloseDate FROM Opportunity WHERE AccountId = '${accountId}'`;
      if (stage) soql += ` AND StageName = '${stage}'`;
      return (await sf.query(soql)).records;
    },
  }),
  get_contacts: tool({
    description: "List contacts on an account.",
    parameters: z.object({ accountId: z.string() }),
    execute: async ({ accountId }) => {
      const sf = await getSfClient();
      return (await sf.query(
        `SELECT Id, Name, Title, Email FROM Contact WHERE AccountId = '${accountId}'`
      )).records;
    },
  }),
  log_activity: tool({
    description: "Log an activity / call note against an opportunity.",
    parameters: z.object({ opportunityId: z.string(), subject: z.string(), body: z.string() }),
    execute: async ({ opportunityId, subject, body }) =>
      (await getSfClient()).sobject("Task").create({
        WhatId: opportunityId, Subject: subject, Description: body,
      }),
  }),
  update_opportunity: tool({
    description: "Update fields on an opportunity (stage, amount, close date, etc.).",
    parameters: z.object({ opportunityId: z.string(), fields: z.record(z.any()) }),
    execute: async ({ opportunityId, fields }) =>
      (await getSfClient()).sobject("Opportunity").update({ Id: opportunityId, ...fields }),
  }),
  create_task: tool({
    description: "Create a follow-up task tied to an opportunity.",
    parameters: z.object({
      opportunityId: z.string(), subject: z.string(), dueDate: z.string(),
    }),
    execute: async ({ opportunityId, subject, dueDate }) =>
      (await getSfClient()).sobject("Task").create({
        WhatId: opportunityId, Subject: subject, ActivityDate: dueDate, Status: "Open",
      }),
  }),
};

import os, uuid, asyncio
from agents import Agent, FunctionTool, Runner
from maximem_synap import MaximemSynapSDK
from synap_openai_agents import create_search_tool, create_store_tool

sdk = MaximemSynapSDK()
await sdk.initialize()

async def handle_message(rep_id: str, org_id: str, session_id: str, text: str) -> str:
    conv_id = conv_for(session_id)

    synap_search = create_search_tool(sdk=sdk, user_id=rep_id, customer_id=org_id)
    synap_store  = create_store_tool(sdk=sdk, user_id=rep_id, customer_id=org_id)

    agent = Agent(
        name="sf_sales_assistant",
        instructions=SYSTEM,
        tools=[
            FunctionTool(synap_search, name_override="synap_search"),
            FunctionTool(synap_store,  name_override="synap_store"),
            get_account, get_opportunities, get_contacts, query_pipeline,
            log_activity, update_opportunity, create_task,
        ],
    )

    result = await Runner.run(agent, input=text)
    reply = result.final_output

    asyncio.create_task(sdk.memories.create(
        document=f"Rep: {text}\nAssistant: {reply}",
        document_type="ai-chat-conversation",
        user_id=rep_id,
        customer_id=org_id,
        metadata={"conversation_id": conv_id, "channel": "sf-sidebar"},
    ))
    return reply

import { generateText } from "ai";
import { openai } from "@ai-sdk/openai";
import { createSynap } from "@maximem/synap-vercel-adk";

const synap = await createSynap({ apiKey: process.env.SYNAP_API_KEY! });

export async function handleMessage(
  repId: string,
  orgId: string,
  sessionId: string,
  text: string,
): Promise<string> {
  const conversationId = convFor(sessionId);

  const model = synap.wrap(openai("gpt-4o"), {
    userId: repId,
    customerId: orgId,
    conversationId,
  });

  const { text: reply } = await generateText({
    model,
    system: SYSTEM,
    prompt: text,
    tools: sfTools,
  });

  return reply;
}

asyncio.create_task(sdk.memories.create(
    document=note_text,
    document_type="sales-note",
    user_id=rep_id,
    customer_id=org_id,
    metadata={"account_id": account_id, "opportunity_id": opp_id},
))

synap.sdk.memories.create({
  document: noteText,
  documentType: "sales-note",
  userId: repId,
  customerId: orgId,
  metadata: { accountId, opportunityId: oppId },
});