OpenAI Integration

import OpenAI from "openai";
import { MemoryStackClient } from "@memorystack/sdk";

// Initialize clients
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY
});

const memoryOS = new MemoryStackClient({
  apiKey: process.env.MEMORYSTACK_API_KEY
});

async function chatWithMemory(userMessage: string, userId?: string) {
  // 1. Get relevant memories for context
  const memories = await memoryOS.listMemories({
    user_id: userId,
    limit: 5,
    order: "desc"
  });

  // 2. Build context from memories
  const context = memories.results
    .map(m => `[${m.memory_type}] ${m.content}`)
    .join("\n");

  // 3. Call OpenAI with context
  const completion = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      {
        role: "system",
        content: `You are a helpful assistant. Here's what you know about the user:\n${context}`
      },
      {
        role: "user",
        content: userMessage
      }
    ]
  });

  const aiResponse = completion.choices[0].message.content;

  // 4. Save conversation to Memorystack
  await memoryOS.addConversation(userMessage, aiResponse, userId);

  return aiResponse;
}

// Usage
const response = await chatWithMemory(
  "What programming language do I prefer?",
  "user_123"
);

console.log(response);

async function streamChatWithMemory(userMessage: string, userId?: string) {
  // Get memories for context
  const memories = await memoryOS.getUserMemories(userId, 5);
  const context = memories.results
    .map(m => `[${m.memory_type}] ${m.content}`)
    .join("\n");

  // Stream OpenAI response
  const stream = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      {
        role: "system",
        content: `Context: ${context}`
      },
      {
        role: "user",
        content: userMessage
      }
    ],
    stream: true
  });

  // Collect the full response
  let fullResponse = "";

  for await (const chunk of stream) {
    const content = chunk.choices[0]?.delta?.content || "";
    fullResponse += content;
    process.stdout.write(content); // Stream to console
  }

  // Save to Memorystack after streaming completes
  await memoryOS.addConversation(userMessage, fullResponse, userId);

  return fullResponse;
}

const functions = [
  {
    name: "search_memories",
    description: "Search user's memories for relevant information",
    parameters: {
      type: "object",
      properties: {
        query: {
          type: "string",
          description: "What to search for in memories"
        },
        memory_type: {
          type: "string",
          enum: ["preference", "fact", "experience", "goal"],
          description: "Type of memory to search"
        }
      },
      required: ["query"]
    }
  }
];

async function chatWithFunctions(userMessage: string, userId?: string) {
  const completion = await openai.chat.completions.create({
    model: "gpt-4",
    messages: [
      { role: "user", content: userMessage }
    ],
    functions,
    function_call: "auto"
  });

  const message = completion.choices[0].message;

  // If OpenAI wants to call a function
  if (message.function_call) {
    const args = JSON.parse(message.function_call.arguments);

    // Search memories
    const memories = await memoryOS.listMemories({
      user_id: userId,
      memory_type: args.memory_type,
      limit: 10
    });

    // Send results back to OpenAI
    const secondCompletion = await openai.chat.completions.create({
      model: "gpt-4",
      messages: [
        { role: "user", content: userMessage },
        message,
        {
          role: "function",
          name: "search_memories",
          content: JSON.stringify(memories.results)
        }
      ]
    });

    return secondCompletion.choices[0].message.content;
  }

  return message.content;
}