import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';
import { ConversationChain } from 'langchain/chains';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Short-term memory using conversation history
class ShortTermMemory {
  constructor(llm, maxTokens = 2000) {
    this.llm = llm;
    this.maxTokens = maxTokens;
    this.messages = [];
  }

  addMessage(role, content) {
    this.messages.push({ role, content });
    this.trimHistory();
  }

  trimHistory() {
    // Simple implementation - keep last 10 messages
    if (this.messages.length > 10) {
      this.messages = this.messages.slice(-10);
    }
  }

  getContext() {
    return this.messages.map((m) => `${m.role}: ${m.content}`).join('\n');
  }

  async chat(input) {
    this.addMessage('user', input);

    const prompt = ChatPromptTemplate.fromTemplate(
      `Current conversation:
{messages}

User: {input}

AI:`,
    );

    const chain = prompt.pipe(this.llm).pipe(new StringOutputParser());
    const response = await chain.invoke({
      messages: this.getContext(),
      input: input,
    });

    this.addMessage('assistant', response);
    return response;
  }
}

// Usage
const memory = new ShortTermMemory(llm);

console.log(await memory.chat('My name is John.'));
console.log(await memory.chat("What's my name?"));
console.log(await memory.chat('What was the last thing I told you?'));

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

// Simulated external storage (in production, use a real database)
const memoryStore = new Map();

// Long-term memory with embeddings (simplified)
class LongTermMemory {
  constructor(llm) {
    this.llm = llm;
    this.store = memoryStore;
  }

  // Store a memory with metadata
  async store(key, content, metadata = {}) {
    const memory = {
      content,
      metadata,
      timestamp: Date.now(),
    };
    this.store.set(key, memory);
    console.log(`Stored memory: ${key}`);
    return memory;
  }

  // Retrieve memories by key
  retrieve(key) {
    return this.store.get(key) || null;
  }

  // Retrieve all memories
  getAll() {
    return Array.from(this.store.values());
  }

  // Search memories (simplified - in production use vector similarity)
  async search(query) {
    const memories = this.getAll();
    // Simple keyword matching
    return memories.filter((m) => m.content.toLowerCase().includes(query.toLowerCase()));
  }

  // Learn from interaction
  async learn(key, content, metadata) {
    return this.store(key, content, metadata);
  }

  // Forget/clear memories
  forget(key) {
    this.store.delete(key);
    console.log(`Deleted memory: ${key}`);
  }
}

// Semantic memory for facts
class SemanticMemory {
  constructor() {
    this.facts = new Map();
  }

  addFact(subject, predicate, object) {
    this.facts.set(`${subject}::${predicate}`, object);
    console.log(`Added fact: ${subject} ${predicate} ${object}`);
  }

  getFact(subject, predicate) {
    return this.facts.get(`${subject}::${predicate}`);
  }

  query(subject) {
    const facts = {};
    for (const [key, value] of this.facts.entries()) {
      if (key.startsWith(`${subject}::`)) {
        const predicate = key.split('::')[1];
        facts[predicate] = value;
      }
    }
    return facts;
  }
}

// Usage
const longTermMemory = new LongTermMemory(llm);
const semanticMemory = new SemanticMemory();

// Store user preferences
await longTermMemory.learn('user:john:prefers', 'Prefers email over phone calls', {
  category: 'communication',
});
await longTermMemory.learn('user:john:interests', 'Interested in AI and machine learning', {
  category: 'interests',
});

// Add semantic facts
semanticMemory.addFact('John', 'lives in', 'New York');
semanticMemory.addFact('John', 'works as', 'Software Engineer');
semanticMemory.addFact('AI', 'stands for', 'Artificial Intelligence');

// Retrieve
console.log(longTermMemory.retrieve('user:john:prefers'));
console.log(semanticMemory.query('John'));

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate } from "@langchain/core/prompts";
import { StringOutputParser } from "@langchain/core/output_parsers";

const llm = new ChatOpenAI({ temperature: 0.7 });

// Memory with automatic summarization
class SummarizingMemory {
  constructor(llm, maxMessages = 10) {
    this.llm = llm;
    this.maxMessages = maxMessages;
    this.messages = [];
    this.summary = "";
  }

  async addMessage(role, content) {
    this.messages.push({ role, content });

    // If we exceed max messages, summarize older ones
    if (this.messages.length > this.maxMessages) {
      await this.summarize();
    }
  }

  async summarize() {
    if (this.messages.length < 5) return;

    const messagesToSummarize = this.messages.slice(0, -5);
    const keepMessages = this.messages.slice(-5);

    const summarizePrompt = ChatPromptTemplate.fromTemplate(
      `Summarize the following conversation concisely, preserving key information:

{messages}`
    );

    const chain = summarizePrompt.pipe(this.llm).pipe(new StringOutputParser());
    this.summary = await chain.invoke({
      messages: messagesToSummarize.map(m => `${m.role}: ${m.content}`).join('\n')
    });

    this.messages = keepMessages;
    console.log("Memory summarized:", this.summary.substring(0, 100) + "...");
  }

  getContext() {
    let context = "";
    if (this.summary) {
      context += `Previous conversation summary: ${this.summary}\n\n`;
    }
    context += "Recent messages:\n" + this.messages.map(m => `${m.role}: ${m.content}`).join('\n');
    return context;
  }

  async chat(input) {
    await this.addMessage('user', input);

    const prompt = ChatPromptTemplate.fromTemplate(
      `{context}

User: {input}

AI:`
    );

    const chain = prompt.pipe(this.llm).pipe(new StringOutputParser());
    const response = await chain.invoke({
      context: this.getContext(),
      input: input
    });

    await this.addMessage('assistant', response);
    return response;
  }
}

// Usage
const memory = new SummarizingMemory(llm);

// Simulate a long conversation
await memory.chat("I bought a new car last week.");
await memory.chat("It's a red Tesla Model 3.");
await memory.chat("I use it for my daily commute to work.");
await memory.chat("The commute is about 30 miles each way.");
await memory.chat("I charge it at home overnight.");
await memory.chat("My previous car was a Honda Accord.");
await memory.chat("I sold it to my neighbor.");
await memory.chat("I prefer the Tesla because of lower maintenance.");
await memory.chat("What's your opinion on electric vehicles?");
await memory.chat("Should I get a home charger installed?");

// The system should have summarized earlier messages
console.log("\n--- Final Response ---`);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Episodic memory for storing specific interactions
class EpisodicMemory {
  constructor(llm) {
    this.llm = llm;
    this.episodes = [];
  }

  // Store a new episode
  async storeEpisode(title, events, outcome, metadata = {}) {
    const episode = {
      id: Date.now(),
      title,
      events,
      outcome,
      metadata,
      timestamp: new Date().toISOString(),
    };

    // Generate a summary for quick retrieval
    const summaryPrompt = ChatPromptTemplate.fromTemplate(
      `Create a brief one-sentence summary of this episode:

Title: {title}
Events: {events}
Outcome: {outcome}`,
    );

    const chain = summaryPrompt.pipe(this.llm).pipe(new StringOutputParser());
    episode.summary = await chain.invoke({ title, events, outcome });

    this.episodes.push(episode);
    console.log(`Stored episode: ${episode.summary}`);
    return episode;
  }

  // Retrieve episode by ID
  getEpisode(id) {
    return this.episodes.find((e) => e.id === id);
  }

  // Get recent episodes
  getRecentEpisodes(count = 5) {
    return this.episodes.slice(-count).reverse();
  }

  // Find episodes by similarity (simplified)
  async findEpisodes(query) {
    const relevant = [];
    for (const episode of this.episodes) {
      // Simple relevance check
      const text = `${episode.title} ${episode.events} ${episode.outcome}`.toLowerCase();
      if (text.includes(query.toLowerCase())) {
        relevant.push(episode);
      }
    }
    return relevant;
  }

  // Learn from past episodes
  async learnFromPast(query) {
    const relevant = await this.findEpisodes(query);

    if (relevant.length === 0) return 'No relevant past experiences found.';

    const learnPrompt = ChatPromptTemplate.fromTemplate(
      `Based on these past experiences:

{experiences}

What lessons can be learned to apply to a new similar situation?`,
    );

    const chain = learnPrompt.pipe(this.llm).pipe(new StringOutputParser());
    return chain.invoke({
      experiences: relevant.map((e) => `Episode: ${e.summary}\nOutcome: ${e.outcome}`).join('\n\n'),
    });
  }
}

// Usage
const episodicMemory = new EpisodicMemory(llm);

// Store some trading episodes
await episodicMemory.storeEpisode(
  'First stock purchase',
  'Researched AAPL, read analyst reports, decided to buy',
  'Bought 10 shares at $150, now worth $180',
  { type: 'trading', stock: 'AAPL' },
);

await episodicMemory.storeEpisode(
  'Crypto investment',
  'Saw trending topic about Bitcoin, bought immediately',
  'Lost 20% due to market correction',
  { type: 'trading', asset: 'Bitcoin' },
);

await episodicMemory.storeEpisode(
  'Dividend investing',
  'Researched dividend stocks, picked stable companies',
  'Portfolio generates passive income quarterly',
  { type: 'investing', strategy: 'dividend' },
);

// Query past experiences
console.log('\n--- Learning from past ---');
const lessons = await episodicMemory.learnFromPast('stock trading');
console.log(lessons);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// Memory item with priority
class MemoryItem {
  constructor(content, priority = 5, metadata = {}) {
    this.id = Date.now() + Math.random();
    this.content = content;
    this.priority = priority; // 0-10 scale
    this.metadata = metadata;
    this.accessCount = 0;
    this.lastAccessed = Date.now();
    this.createdAt = Date.now();
  }

  access() {
    this.accessCount++;
    this.lastAccessed = Date.now();
  }

  // Calculate importance score based on multiple factors
  getImportanceScore() {
    const recencyScore = Math.max(0, 10 - (Date.now() - this.lastAccessed) / (1000 * 60 * 60)); // Decay over hours
    const usageScore = Math.min(5, this.accessCount);
    return this.priority * 0.5 + recencyScore * 0.3 + usageScore * 0.2;
  }
}

// Priority-based memory manager
class PriorityMemory {
  constructor(llm, maxSize = 100) {
    this.llm = llm;
    this.maxSize = maxSize;
    this.memories = [];
  }

  // Add a new memory with auto-calculated priority
  async addMemory(content, metadata = {}) {
    // Use LLM to assess importance
    const priorityPrompt = ChatPromptTemplate.fromTemplate(
      `Rate the importance of this memory from 0-10:
Memory: {content}

Metadata: {metadata}

Respond with only a number:`,
    );

    const chain = priorityPrompt.pipe(this.llm).pipe(new StringOutputParser());
    const priority =
      parseInt(await chain.invoke({ content, metadata: JSON.stringify(metadata) })) || 5;

    const memory = new MemoryItem(content, Math.min(10, Math.max(0, priority)), metadata);
    this.memories.push(memory);

    // Evict lowest priority memories if over capacity
    if (this.memories.length > this.maxSize) {
      this.evictLowPriority();
    }

    console.log(`Added memory with priority ${priority}: ${content.substring(0, 50)}...`);
    return memory;
  }

  // Remove lowest priority memories
  evictLowPriority() {
    // Sort by importance score and remove bottom 10%
    this.memories.sort((a, b) => b.getImportanceScore() - a.getImportanceScore());
    const toRemove = Math.floor(this.maxSize * 0.1);
    const removed = this.memories.splice(0, toRemove);
    console.log(`Evicted ${removed.length} low-priority memories`);
  }

  // Retrieve most important memories for current context
  async retrieveForContext(context, limit = 5) {
    // Calculate relevance to current context
    const contextLower = context.toLowerCase();

    const scoredMemories = this.memories.map((memory) => {
      memory.access();
      const relevanceScore = memory.content.toLowerCase().includes(contextLower) ? 5 : 0;
      const importanceScore = memory.getImportanceScore();
      return {
        memory,
        totalScore: importanceScore * 0.6 + relevanceScore * 0.4,
      };
    });

    // Sort by total score
    scoredMemories.sort((a, b) => b.totalScore - a.totalScore);

    return scoredMemories.slice(0, limit).map((s) => s.memory);
  }

  // Get all memories sorted by importance
  getTopMemories(limit = 10) {
    return [...this.memories]
      .sort((a, b) => b.getImportanceScore() - a.getImportanceScore())
      .slice(0, limit);
  }
}

// Usage
const priorityMemory = new PriorityMemory(llm);

// Add memories with different priorities
await priorityMemory.addMemory('User prefers morning meetings', { category: 'preference' });
await priorityMemory.addMemory('User is allergic to nuts', { category: 'health', critical: true });
await priorityMemory.addMemory("User's birthday is December 25th", {
  category: 'personal',
  important: true,
});
await priorityMemory.addMemory('User likes coffee with milk', { category: 'preference' });
await priorityMemory.addMemory('User works as a software engineer', { category: 'work' });

// Simulate context - user is planning a meeting
const relevantMemories = await priorityMemory.retrieveForContext('meeting schedule');
console.log('\n--- Relevant memories for meeting context ---');
relevantMemories.forEach((m) => console.log(`- ${m.content}`));

// Get top priority memories
console.log('\n--- Top priority memories ---');
const topMemories = priorityMemory.getTopMemories(3);
topMemories.forEach((m) =>
  console.log(`- ${m.content} (score: ${m.getImportanceScore().toFixed(2)})`),
);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

// Simple embedding simulation (in production, use actual embeddings like OpenAIEmbeddings)
function simpleEmbedding(text) {
  // Create a simple hash-based pseudo-embedding
  const hash = text.split('').reduce((acc, char) => {
    return (acc << 5) - acc + char.charCodeAt(0);
  }, 0);

  // Convert to fixed-size vector
  const vector = [];
  let seed = Math.abs(hash);
  for (let i = 0; i < 64; i++) {
    seed = (seed * 1103515245 + 12345) & 0x7fffffff;
    vector.push((seed % 1000) / 1000);
  }
  return vector;
}

// Cosine similarity between two vectors
function cosineSimilarity(vec1, vec2) {
  const dotProduct = vec1.reduce((sum, v, i) => sum + v * vec2[i], 0);
  const mag1 = Math.sqrt(vec1.reduce((sum, v) => sum + v * v, 0));
  const mag2 = Math.sqrt(vec2.reduce((sum, v) => sum + v * v, 0));
  return dotProduct / (mag1 * mag2);
}

// Vector-based memory with semantic search
class VectorMemory {
  constructor(llm) {
    this.llm = llm;
    this.memories = [];
  }

  // Store memory with embedding
  async store(key, content, metadata = {}) {
    const embedding = simpleEmbedding(content);

    const memory = {
      key,
      content,
      metadata,
      embedding,
      timestamp: Date.now(),
    };

    this.memories.push(memory);
    console.log(`Stored memory: ${key} (embedding created)`);
    return memory;
  }

  // Semantic search using vector similarity
  async semanticSearch(query, topK = 3) {
    // Generate embedding for query
    const queryEmbedding = simpleEmbedding(query);

    // Calculate similarity scores
    const results = this.memories.map((memory) => ({
      memory,
      similarity: cosineSimilarity(queryEmbedding, memory.embedding),
    }));

    // Sort by similarity and return top K
    results.sort((a, b) => b.similarity - a.similarity);

    const topResults = results.slice(0, topK);
    console.log(`\nSemantic search for "${query}":`);
    topResults.forEach((r) => {
      console.log(`  - ${r.memory.key} (similarity: ${r.similarity.toFixed(4)})`);
      console.log(`    ${r.memory.content}`);
    });

    return topResults.map((r) => ({
      key: r.memory.key,
      content: r.memory.content,
      metadata: r.memory.metadata,
      similarity: r.similarity,
    }));
  }

  // Hybrid search: keyword + semantic
  async hybridSearch(query, topK = 3) {
    const queryLower = query.toLowerCase();

    // Score based on keyword matches
    const keywordScores = this.memories.map((memory) => {
      const contentLower = memory.content.toLowerCase();
      const keyLower = memory.key.toLowerCase();

      let score = 0;
      const queryWords = queryLower.split(' ');

      for (const word of queryWords) {
        if (contentLower.includes(word)) score += 1;
        if (keyLower.includes(word)) score += 2;
      }

      return { memory, keywordScore: score };
    });

    // Get semantic results
    const semanticResults = await this.semanticSearch(query, this.memories.length);

    // Combine scores (weighted)
    const combinedResults = this.memories.map((memory) => {
      const keywordResult = keywordScores.find((k) => k.memory.key === memory.key);
      const semanticResult = semanticResults.find((s) => s.key === memory.key);

      const combinedScore =
        (keywordResult ? keywordResult.keywordScore * 0.4 : 0) +
        (semanticResult ? semanticResult.similarity * 0.6 : 0);

      return { memory, combinedScore };
    });

    // Sort by combined score
    combinedResults.sort((a, b) => b.combinedScore - a.combinedScore);

    return combinedResults.slice(0, topK).map((r) => ({
      key: r.memory.key,
      content: r.memory.content,
      score: r.combinedScore,
    }));
  }
}

// Usage
const vectorMemory = new VectorMemory(llm);

// Store various memories
await vectorMemory.store('project_deadline', 'The Q4 project deadline is December 15th', {
  type: 'work',
});
await vectorMemory.store('meeting_notes', 'Team meeting every Tuesday at 2pm', {
  type: 'schedule',
});
await vectorMemory.store('client_preferences', 'Client prefers email communication over phone', {
  type: 'preference',
});
await vectorMemory.store('budget_info', 'Marketing budget for 2024 is $50,000', {
  type: 'finance',
});
await vectorMemory.store('tech_stack', 'Team uses React and Node.js for development', {
  type: 'technical',
});

// Semantic search
await vectorMemory.semanticSearch('team schedule meeting time');

// Hybrid search
console.log('\n--- Hybrid Search ---');
const hybridResults = await vectorMemory.hybridSearch('when is the team meeting');
console.log(hybridResults);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

// Integrated Memory System combining all memory types
class IntegratedMemorySystem {
  constructor(llm) {
    this.llm = llm;

    // Short-term memory (conversation history)
    this.shortTerm = {
      messages: [],
      maxLength: 10,
      add(role, content) {
        this.messages.push({ role, content, timestamp: Date.now() });
        if (this.messages.length > this.maxLength) {
          this.messages = this.messages.slice(-this.maxLength);
        }
      },
      getHistory() {
        return this.messages.map((m) => `${m.role}: ${m.content}`).join('\n');
      },
      clear() {
        this.messages = [];
      },
    };

    // Long-term memory (persistent storage)
    this.longTerm = new Map();

    // Semantic memory (facts and knowledge)
    this.semantic = new Map();

    // Episodic memory (experiences)
    this.episodes = [];
  }

  // --- Short-Term Memory Operations ---

  addToShortTerm(role, content) {
    this.shortTerm.add(role, content);
  }

  getShortTermContext() {
    return this.shortTerm.getHistory();
  }

  // --- Long-Term Memory Operations ---

  async storeLongTerm(key, content, category = 'general') {
    const memory = {
      content,
      category,
      timestamp: Date.now(),
      accessCount: 0,
    };
    this.longTerm.set(key, memory);
    console.log(`Stored to long-term: ${key}`);
    return memory;
  }

  retrieveLongTerm(key) {
    const memory = this.longTerm.get(key);
    if (memory) {
      memory.accessCount++;
    }
    return memory;
  }

  searchLongTerm(query) {
    const results = [];
    for (const [key, memory] of this.longTerm.entries()) {
      if (memory.content.toLowerCase().includes(query.toLowerCase())) {
        results.push({ key, ...memory });
      }
    }
    return results;
  }

  // --- Semantic Memory Operations ---

  addSemanticFact(subject, predicate, object) {
    const key = `${subject}::${predicate}`;
    this.semantic.set(key, object);
    console.log(`Added semantic fact: ${subject} ${predicate} ${object}`);
  }

  getSemanticFact(subject, predicate) {
    return this.semantic.get(`${subject}::${predicate}`);
  }

  querySemanticSubject(subject) {
    const facts = {};
    for (const [key, value] of this.semantic.entries()) {
      if (key.startsWith(`${subject}::`)) {
        const predicate = key.split('::')[1];
        facts[predicate] = value;
      }
    }
    return facts;
  }

  // --- Episodic Memory Operations ---

  async storeEpisode(title, events, outcome) {
    const episode = {
      id: Date.now(),
      title,
      events,
      outcome,
      timestamp: new Date().toISOString(),
    };

    // Generate summary
    const prompt = ChatPromptTemplate.fromTemplate(
      `Summarize this episode in one sentence: {title} - {events}`,
    );
    const chain = prompt.pipe(this.llm).pipe(new StringOutputParser());
    episode.summary = await chain.invoke({ title, events });

    this.episodes.push(episode);
    return episode;
  }

  getRecentEpisodes(count = 5) {
    return this.episodes.slice(-count).reverse();
  }

  // --- Unified Retrieval ---

  async retrieveRelevant(query, options = {}) {
    const {
      includeShortTerm = true,
      includeLongTerm = true,
      includeSemantic = true,
      includeEpisodes = true,
      maxResults = 5,
    } = options;

    const results = [];

    // Short-term
    if (includeShortTerm) {
      const history = this.shortTerm.getHistory();
      if (history.toLowerCase().includes(query.toLowerCase())) {
        results.push({ type: 'short-term', source: 'current conversation', relevance: 1.0 });
      }
    }

    // Long-term
    if (includeLongTerm) {
      const ltResults = this.searchLongTerm(query);
      results.push(...ltResults.map((r) => ({ type: 'long-term', ...r, relevance: 0.8 })));
    }

    // Semantic
    if (includeSemantic) {
      const queryLower = query.toLowerCase();
      const queryWords = queryLower.split(' ');

      for (const [key, value] of this.semantic.entries()) {
        const [subject, predicate] = key.split('::');
        for (const word of queryWords) {
          if (subject.toLowerCase().includes(word) || value.toLowerCase().includes(word)) {
            results.push({ type: 'semantic', subject, predicate, object: value, relevance: 0.9 });
            break;
          }
        }
      }
    }

    // Episodes
    if (includeEpisodes) {
      const queryLower = query.toLowerCase();
      for (const episode of this.episodes) {
        const text = `${episode.title} ${episode.events} ${episode.outcome}`.toLowerCase();
        if (text.includes(queryLower)) {
          results.push({ type: 'episode', ...episode, relevance: 0.7 });
        }
      }
    }

    // Sort by relevance and limit
    results.sort((a, b) => b.relevance - a.relevance);
    return results.slice(0, maxResults);
  }

  // --- Chat with Full Memory ---

  async chat(input) {
    this.addToShortTerm('user', input);

    // Retrieve relevant memories
    const relevantMemories = await this.retrieveRelevant(input);

    // Build context
    let context = '';
    if (relevantMemories.length > 0) {
      context += 'Relevant memories:\n';
      relevantMemories.forEach((m, i) => {
        if (m.type === 'long-term') context += `${i + 1}. [Long-term] ${m.content}\n`;
        if (m.type === 'semantic')
          context += `${i + 1}. [Fact] ${m.subject} ${m.predicate} ${m.object}\n`;
        if (m.type === 'episode') context += `${i + 1}. [Episode] ${m.summary}\n`;
      });
      context += '\n';
    }

    context += 'Current conversation:\n' + this.getShortTermContext();

    // Generate response
    const prompt = ChatPromptTemplate.fromTemplate(
      `{context}

User: {input}

Assistant:`,
    );

    const chain = prompt.pipe(this.llm).pipe(new StringOutputParser());
    const response = await chain.invoke({ context, input });

    this.addToShortTerm('assistant', response);
    return { response, memories: relevantMemories };
  }
}

// Usage
const memorySystem = new IntegratedMemorySystem(llm);

// Populate different memory types
memorySystem.addToShortTerm('user', "I'm looking for information about our project.");
memorySystem.addToShortTerm(
  'assistant',
  "I'd be happy to help! What specific information do you need?",
);

// Long-term memory
await memorySystem.storeLongTerm(
  'project_alpha',
  'Project Alpha is a machine learning initiative',
  'project',
);
await memorySystem.storeLongTerm('budget_2024', '2024 budget is $100,000', 'finance');

// Semantic memory
memorySystem.addSemanticFact('Project Alpha', 'lead by', 'John Smith');
memorySystem.addSemanticFact('Project Alpha', 'deadline', 'March 2024');

// Episodic memory
await memorySystem.storeEpisode(
  'Client meeting',
  'Discussed project timeline and budget constraints',
  'Agreed to 3-month extension',
);

// Chat with full memory context
console.log('\n--- Chat with Integrated Memory ---');
const result = await memorySystem.chat('Tell me about Project Alpha');
console.log('Response:', result.response);
console.log('\nRetrieved memories:', result.memories);

import { ChatOpenAI } from '@langchain/openai';
import { ChatPromptTemplate } from '@langchain/core/prompts';
import { StringOutputParser } from '@langchain/core/output_parsers';

const llm = new ChatOpenAI({ temperature: 0.7 });

// User profile memory for personalized interactions
class UserProfileMemory {
  constructor(llm) {
    this.llm = llm;
    this.profiles = new Map();
  }

  // Create or update user profile
  async updateProfile(userId, interactionData) {
    let profile = this.profiles.get(userId) || {
      userId,
      preferences: {},
      traits: {},
      history: [],
      statistics: {
        totalInteractions: 0,
        topics: new Map(),
        sentiment: { positive: 0, neutral: 0, negative: 0 },
      },
    };

    // Analyze interaction to extract preferences and traits
    const analysisPrompt = ChatPromptTemplate.fromTemplate(
      `Analyze this user interaction and extract:
1. Preferences (communication style, interests, etc.)
2. Traits (patience level, detail level, etc.)

Interaction: {interaction}

Respond in JSON format:
{
  "preferences": {"key": "value"},
  "traits": {"key": "value"}
}`,
    );

    try {
      const chain = analysisPrompt.pipe(this.llm).pipe(new StringOutputParser());
      const analysis = JSON.parse(await chain.invoke({ interaction: interactionData }));

      // Merge preferences
      profile.preferences = { ...profile.preferences, ...analysis.preferences };
      profile.traits = { ...profile.traits, ...analysis.traits };
    } catch (e) {
      console.log('Analysis parse error, using basic extraction');
    }

    // Update statistics
    profile.statistics.totalInteractions++;
    profile.history.push({
      timestamp: Date.now(),
      data: interactionData,
    });

    // Keep only last 100 interactions
    if (profile.history.length > 100) {
      profile.history = profile.history.slice(-100);
    }

    this.profiles.set(userId, profile);
    console.log(`Updated profile for user ${userId}`);
    return profile;
  }

  // Get user profile
  getProfile(userId) {
    return this.profiles.get(userId) || null;
  }

  // Get preference
  getPreference(userId, key) {
    const profile = this.profiles.get(userId);
    return profile ? profile.preferences[key] : null;
  }

  // Get trait
  getTrait(userId, key) {
    const profile = this.profiles.get(userId);
    return profile ? profile.traits[key] : null;
  }

  // Generate personalized response style based on profile
  getResponseStyle(userId) {
    const profile = this.profiles.get(userId);
    if (!profile) return {};

    const style = {
      formality: profile.preferences.formality || 'neutral',
      detailLevel: profile.preferences.detailLevel || 'medium',
      communicationStyle: profile.preferences.communicationStyle || 'friendly',
    };

    return style;
  }

  // Generate summary of user
  async generateProfileSummary(userId) {
    const profile = this.profiles.get(userId);
    if (!profile) return 'No profile found for this user.';

    const summaryPrompt = ChatPromptTemplate.fromTemplate(
      `Create a brief summary of this user profile:

Preferences: {preferences}
Traits: {traits}
Total Interactions: {totalInteractions}

User Summary:`,
    );

    const chain = summaryPrompt.pipe(this.llm).pipe(new StringOutputParser());
    return chain.invoke({
      preferences: JSON.stringify(profile.preferences),
      traits: JSON.stringify(profile.traits),
      totalInteractions: profile.statistics.totalInteractions,
    });
  }
}

// Usage
const userProfile = new UserProfileMemory(llm);

// Simulate user interactions and build profile
await userProfile.updateProfile('user_123', 'I prefer concise responses, just give me the facts');
await userProfile.updateProfile(
  'user_123',
  'Can you explain this in more detail? I like thorough explanations',
);
await userProfile.updateProfile('user_123', 'Please format your answers with bullet points');

// Get user profile
const profile = userProfile.getProfile('user_123');
console.log('\n--- User Profile ---');
console.log('Preferences:', profile.preferences);
console.log('Traits:', profile.traits);
console.log('Total Interactions:', profile.statistics.totalInteractions);

// Get response style
const responseStyle = userProfile.getResponseStyle('user_123');
console.log('\n--- Response Style ---');
console.log(responseStyle);

// Generate summary
const summary = await userProfile.generateProfileSummary('user_123');
console.log('\n--- Profile Summary ---');
console.log(summary);