History

Chat History

Manage and retrieve conversation history for context-aware interactions.

Method

chat.getHistory(): ChatMessage[]
chat.addToHistory(message: ChatMessage): void
chat.clearHistory(): void

Chat Message Format

interface ChatMessage {
  role: 'user' | 'assistant' | 'system';
  content: string;
  timestamp?: Date;
  metadata?: Record<string, any>;
}

Properties

role · string · required

The role of the message sender: user, assistant, or system

content · string · required

The text content of the message

timestamp · Date

When the message was created (auto-generated if not provided)

metadata · Record<string, any>

Additional metadata associated with the message

Examples

Basic History Management

import { Chat } from 'nebula-sdk';

const chat = new Chat({
  apiKey: 'your-api-key',
  model: 'llama-3.3-70b-instruct'
});

// Send a message and automatically add to history
const response = await chat.send({
  message: 'Hello, I need help with coding',
  systemPrompt: 'You are a helpful programming assistant.'
});

// Get current history
const history = chat.getHistory();
console.log('Conversation history:', history);

// Manually add a message to history
chat.addToHistory({
  role: 'user',
  content: 'What is TypeScript?',
  timestamp: new Date()
});

// Clear all history
chat.clearHistory();

Context Management

Automatic Context

When using chat.send() or chat.stream(), you can include context automatically:

// Send with full conversation context
const response = await chat.send({
  message: 'What did we discuss earlier?',
  context: chat.getHistory(), // Include full history
  systemPrompt: 'Reference our previous conversation.'
});

Selective Context

Include only relevant parts of the conversation:

const history = chat.getHistory();

// Include only last 5 messages for context
const recentContext = history.slice(-5);

const response = await chat.send({
  message: 'Summarize our recent discussion',
  context: recentContext
});

Context Summarization

For long conversations, summarize older messages:

async function getOptimizedContext() {
  const history = chat.getHistory();
  
  if (history.length <= 10) {
    return history;
  }
  
  // Keep recent messages as-is
  const recentMessages = history.slice(-5);
  
  // Summarize older messages
  const olderMessages = history.slice(0, -5);
  const summary = await chat.send({
    message: 'Summarize this conversation briefly',
    context: olderMessages,
    systemPrompt: 'Provide a concise summary of the key points discussed.'
  });
  
  return [
    {
      role: 'system',
      content: `Previous conversation summary: ${summary.content}`,
      timestamp: new Date()
    },
    ...recentMessages
  ];
}

// Use optimized context
const optimizedContext = await getOptimizedContext();
const response = await chat.send({
  message: 'Based on everything we\'ve discussed...',
  context: optimizedContext
});

History Export/Import

Export History

function exportHistory(chat: Chat): string {
  const history = chat.getHistory();
  return JSON.stringify(history, null, 2);
}

// Export to file
const historyJson = exportHistory(chat);
require('fs').writeFileSync('chat-history.json', historyJson);

Import History

function importHistory(chat: Chat, historyJson: string): void {
  const history = JSON.parse(historyJson);
  
  chat.clearHistory();
  history.forEach((message: ChatMessage) => {
    chat.addToHistory({
      ...message,
      timestamp: new Date(message.timestamp) // Convert string back to Date
    });
  });
}

// Import from file
const historyJson = require('fs').readFileSync('chat-history.json', 'utf8');
importHistory(chat, historyJson);

Best Practices

Memory Management

// Limit history size to prevent memory issues
const MAX_HISTORY_SIZE = 50;

function maintainHistorySize(chat: Chat) {
  const history = chat.getHistory();
  
  if (history.length > MAX_HISTORY_SIZE) {
    // Keep system messages and recent messages
    const systemMessages = history.filter(msg => msg.role === 'system');
    const recentMessages = history.slice(-(MAX_HISTORY_SIZE - systemMessages.length));
    
    chat.clearHistory();
    [...systemMessages, ...recentMessages].forEach(msg => {
      chat.addToHistory(msg);
    });
  }
}

Privacy and Security

// Remove sensitive information from history
function sanitizeHistory(chat: Chat) {
  const history = chat.getHistory();
  const sensitivePatterns = [
    /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b/, // Credit card numbers
    /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/, // Email addresses
    /\b\d{3}-\d{2}-\d{4}\b/ // SSN pattern
  ];
  
  chat.clearHistory();
  
  history.forEach(message => {
    let sanitizedContent = message.content;
    
    sensitivePatterns.forEach(pattern => {
      sanitizedContent = sanitizedContent.replace(pattern, '[REDACTED]');
    });
    
    chat.addToHistory({
      ...message,
      content: sanitizedContent
    });
  });
}

Error Handling

try {
  const history = chat.getHistory();
  
  // Validate history before using
  const validHistory = history.filter(msg => 
    msg.role && msg.content && typeof msg.content === 'string'
  );
  
  const response = await chat.send({
    message: 'Continue our conversation',
    context: validHistory
  });
} catch (error) {
  console.error('Error using chat history:', error);
  
  // Fallback: clear corrupted history
  chat.clearHistory();
}

Related

• Create Chat Instance
• Stream Responses
• Memory Storage