LangChain

// sales_copilot.ts — Memsy + LangChain LCEL example.
import { MemsyClient } from "@memsy-io/memsy";
import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { RunnablePassthrough } from "@langchain/core/runnables";
import { StringOutputParser } from "@langchain/core/output_parsers";

const memsy = new MemsyClient({
  baseUrl: process.env.MEMSY_BASE_URL!,
  apiKey: process.env.MEMSY_API_KEY!,
});
const llm = new ChatOpenAI({ model: "gpt-4o-mini" });

// Org structure for this rep. Memsy uses these to organize memories at
// the role and team level — not just per-user.
const ROLE_ID = "role_account_executive";
const TEAM_ID = "team_enterprise";

async function recall(inputs: {
  actorId: string;
  question: string;
}): Promise<string> {
  const hits = await memsy.search(inputs.question, {
    actorId: inputs.actorId,
    limit: 5,
  });
  if (hits.results.length === 0) return "(no prior context yet)";
  return hits.results.map((r) => `- ${r.content}`).join("\n");
}

const prompt = ChatPromptTemplate.fromMessages([
  [
    "system",
    "You are a sales copilot. Ground every answer in the rep's prior " +
      "deals and team playbooks. If the context below is relevant, cite " +
      "it concretely — the objection, what worked, what didn't.\n\n" +
      "Relevant memory:\n{memories}",
  ],
  ["human", "{question}"],
]);

const chain = RunnablePassthrough.assign({ memories: recall })
  .pipe(prompt)
  .pipe(llm)
  .pipe(new StringOutputParser());

async function chat(
  actorId: string,
  sessionId: string,
  question: string,
): Promise<string> {
  const answer = await chain.invoke({ actorId, question });
  await memsy.ingest([
    {
      actorId,
      sessionId,
      roleId: ROLE_ID,
      teamId: TEAM_ID,
      kind: "user_message",
      content: question,
    },
    {
      actorId,
      sessionId,
      roleId: ROLE_ID,
      teamId: TEAM_ID,
      kind: "assistant_message",
      content: answer,
    },
  ]);
  return answer;
}

async function main(): Promise<void> {
  const debrief = [
    "Just closed an enterprise deal. Procurement pushed back hard on price — " +
      "said our list pricing was about 30% above their internal benchmark.",
    "What worked: I dropped the feature-by-feature pricing comparison and led " +
      "with a 3-year TCO model — onboarding, support, integration costs included. " +
      "That reframed the conversation around total value, not sticker price.",
    "Procurement explicitly called out the TCO model as what got them to sign " +
      "off. Worth tracking the pattern for future deals.",
  ];

  console.log("=== Session 1: deal debrief ===");
  for (const note of debrief) {
    const reply = await chat("rep_001", "session_deal_debrief", note);
    console.log(`Rep:       ${note}`);
    console.log(`Copilot:   ${reply}\n`);
  }

  console.log("Waiting for Memsy to index the debrief...");
  await new Promise((resolve) => setTimeout(resolve, 5000));

  console.log("=== Session 2: new prospect ===");
  const question =
    "A new enterprise prospect's procurement just pushed back on our pricing " +
    "for the renewal expansion — they say it's well above their benchmark. " +
    "How should I approach the next call?";
  const reply = await chat("rep_001", "session_new_prospect", question);
  console.log(`Rep:       ${question}`);
  console.log(`Copilot:   ${reply}`);
}

main().catch((err) => {
  console.error(err);
  process.exit(1);
});