M04 — Memory & Conversation

// memory_anthropic.mjs
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
const SYSTEM = "You are Acme Support.";
const history = [];                       // the memory — you own it

async function chat(userMsg) {
  history.push({ role: "user", content: userMsg });
  const resp = await client.messages.create({
    model: "claude-sonnet-5", max_tokens: 512, system: SYSTEM, messages: history,
  });
  const reply = resp.content.filter(b => b.type === "text").map(b => b.text).join("");
  history.push({ role: "assistant", content: reply });
  return reply;
}

console.log(await chat("Hi, I'm Sam. Where's order AC-1042?"));
console.log(await chat("Great — actually, can you cancel it?"));

# memory_gemini.py  (manual history)
from google import genai
from google.genai import types

client = genai.Client()
config = types.GenerateContentConfig(system_instruction="You are Acme Support.")
history = []                              # list of types.Content — you own it

def chat(user_msg: str) -> str:
    history.append(types.Content(role="user", parts=[types.Part(text=user_msg)]))
    resp = client.models.generate_content(
        model="gemini-2.5-flash", contents=history, config=config,
    )
    history.append(resp.candidates[0].content)   # remember the model's turn
    return resp.text

print(chat("Hi, I'm Sam. Where's order AC-1042?"))
print(chat("Great — actually, can you cancel it?"))

// memory_gemini.mjs  (manual history)
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});
const config = { systemInstruction: "You are Acme Support." };
const history = [];                       // list of Content — you own it

async function chat(userMsg) {
  history.push({ role: "user", parts: [{ text: userMsg }] });
  const resp = await ai.models.generateContent({
    model: "gemini-2.5-flash", contents: history, config,
  });
  history.push(resp.candidates[0].content);
  return resp.text;
}

console.log(await chat("Hi, I'm Sam. Where's order AC-1042?"));
console.log(await chat("Great — actually, can you cancel it?"));

# memory_openai.py  (Responses API, manual input list)
from openai import OpenAI

client = OpenAI()
SYSTEM = "You are Acme Support."
history = []                              # the memory — you own it

def chat(user_msg: str) -> str:
    history.append({"role": "user", "content": user_msg})
    resp = client.responses.create(model="gpt-5.5", instructions=SYSTEM, input=history)
    history.extend(resp.output)           # append the model's output items
    return resp.output_text

print(chat("Hi, I'm Sam. Where's order AC-1042?"))
print(chat("Great — actually, can you cancel it?"))

// memory_openai.mjs  (Responses API, manual input list)
import OpenAI from "openai";

const client = new OpenAI();
const SYSTEM = "You are Acme Support.";
let history = [];                         // the memory — you own it

async function chat(userMsg) {
  history.push({ role: "user", content: userMsg });
  const resp = await client.responses.create({ model: "gpt-5.5", instructions: SYSTEM, input: history });
  history = history.concat(resp.output);  // append the model's output items
  return resp.output_text;
}

console.log(await chat("Hi, I'm Sam. Where's order AC-1042?"));
console.log(await chat("Great — actually, can you cancel it?"));

// Anthropic: no built-in session — wrap the manual pattern in a class.
import Anthropic from "@anthropic-ai/sdk";

class Conversation {
  constructor(system) {
    this.client = new Anthropic();
    this.system = system;
    this.history = [];
  }
  async send(msg) {
    this.history.push({ role: "user", content: msg });
    const r = await this.client.messages.create({
      model: "claude-sonnet-5", max_tokens: 512,
      system: this.system, messages: this.history,
    });
    const reply = r.content.filter(b => b.type === "text").map(b => b.text).join("");
    this.history.push({ role: "assistant", content: reply });
    return reply;
  }
}

const convo = new Conversation("You are Acme Support.");
console.log(await convo.send("Hi, I'm Sam. Where's order AC-1042?"));
console.log(await convo.send("Great — cancel it."));

# Google: a built-in chat SESSION keeps the history for you.
from google import genai
from google.genai import types

client = genai.Client()
chat = client.chats.create(
    model="gemini-2.5-flash",
    config=types.GenerateContentConfig(system_instruction="You are Acme Support."),
)

print(chat.send_message("Hi, I'm Sam. Where's order AC-1042?").text)
print(chat.send_message("Great — cancel it.").text)   # history handled automatically
# Inspect it anytime:
for turn in chat.get_history():
    print(turn.role, turn.parts[0].text[:40])

// Google: a built-in chat SESSION keeps the history for you.
import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({});
const chat = ai.chats.create({
  model: "gemini-2.5-flash",
  config: { systemInstruction: "You are Acme Support." },
});

console.log((await chat.sendMessage({ message: "Hi, I'm Sam. Where's order AC-1042?" })).text);
console.log((await chat.sendMessage({ message: "Great — cancel it." })).text);
// chat.getHistory() returns the stored turns.

# OpenAI: the SERVER stores the state — reference it by id, don't resend history.
from openai import OpenAI

client = OpenAI()

r1 = client.responses.create(
    model="gpt-5.5",
    instructions="You are Acme Support.",
    input="Hi, I'm Sam. Where's order AC-1042?",
)
print(r1.output_text)

r2 = client.responses.create(
    model="gpt-5.5",
    input="Great — cancel it.",
    previous_response_id=r1.id,   # <-- server recalls the prior turn; no resend
)
print(r2.output_text)
# Responses are stored by default. Pass store=False to opt out (then thread manually).

// OpenAI: the SERVER stores the state — reference it by id.
import OpenAI from "openai";

const client = new OpenAI();

const r1 = await client.responses.create({
  model: "gpt-5.5",
  instructions: "You are Acme Support.",
  input: "Hi, I'm Sam. Where's order AC-1042?",
});
console.log(r1.output_text);

const r2 = await client.responses.create({
  model: "gpt-5.5",
  input: "Great — cancel it.",
  previous_response_id: r1.id,   // server recalls the prior turn; no resend
});
console.log(r2.output_text);