Building Your First AI Chatbot with LLM APIs

import express from 'express';
import { WebSocket, WebSocketServer } from 'ws';
import { OpenAI } from 'openai';
import Redis from 'ioredis';
import { v4 as uuidv4 } from 'uuid';
import jwt from 'jsonwebtoken';

// Initialize services
const app = express();
const redis = new Redis();
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Types
interface Message {
  role: 'user' | 'assistant' | 'system';
  content: string;
  timestamp: Date;
}

interface Session {
  id: string;
  userId: string;
  messages: Message[];
  metadata: {
    created: Date;
    lastActive: Date;
    messageCount: number;
  };
}

interface ChatRequest {
  message: string;
  sessionId?: string;
  stream?: boolean;
}

// Session Manager
class SessionManager {
  private readonly TTL = 3600 * 24; // 24 hours

  async createSession(userId: string): Promise<Session> {
    const session: Session = {
      id: uuidv4(),
      userId,
      messages: [],
      metadata: {
        created: new Date(),
        lastActive: new Date(),
        messageCount: 0
      }
    };

    await this.saveSession(session);
    return session;
  }

  async getSession(sessionId: string): Promise<Session | null> {
    const data = await redis.get(`session:${sessionId}`);
    if (!data) return null;
    
    const session = JSON.parse(data);
    // Update last active
    session.metadata.lastActive = new Date();
    await this.saveSession(session);
    
    return session;
  }

  async saveSession(session: Session): Promise<void> {
    await redis.setex(
      `session:${session.id}`,
      this.TTL,
      JSON.stringify(session)
    );
  }

  async addMessage(sessionId: string, message: Message): Promise<void> {
    const session = await this.getSession(sessionId);
    if (!session) throw new Error('Session not found');

    session.messages.push(message);
    session.metadata.messageCount++;
    session.metadata.lastActive = new Date();

    // Implement sliding window to manage context size
    const MAX_MESSAGES = 50;
    if (session.messages.length > MAX_MESSAGES) {
      // Keep system message and recent messages
      const systemMessage = session.messages.find(m => m.role === 'system');
      const recentMessages = session.messages.slice(-MAX_MESSAGES + 1);
      session.messages = systemMessage ? [systemMessage, ...recentMessages] : recentMessages;
    }

    await this.saveSession(session);
  }

  async getSummary(sessionId: string): Promise<string> {
    const session = await this.getSession(sessionId);
    if (!session || session.messages.length === 0) return '';

    // Generate summary of older messages for context
    const oldMessages = session.messages.slice(0, -10);
    if (oldMessages.length < 5) return '';

    const summaryPrompt = `Summarize this conversation concisely: ${
      oldMessages.map(m => `${m.role}: ${m.content}`).join('\n')
    }`;

    const summary = await openai.chat.completions.create({
      model: 'gpt-3.5-turbo',
      messages: [{ role: 'user', content: summaryPrompt }],
      max_tokens: 150
    });

    return summary.choices[0].message.content || '';
  }
}

// Conversation Handler
class ConversationHandler {
  constructor(private sessionManager: SessionManager) {}

  async processMessage(
    sessionId: string,
    userMessage: string,
    stream: boolean = false
  ): Promise<any> {
    const session = await this.sessionManager.getSession(sessionId);
    if (!session) throw new Error('Invalid session');

    // Add user message
    await this.sessionManager.addMessage(sessionId, {
      role: 'user',
      content: userMessage,
      timestamp: new Date()
    });

    // Build context with optimization
    const context = await this.buildContext(session);

    if (stream) {
      return this.streamResponse(sessionId, context);
    } else {
      return this.getResponse(sessionId, context);
    }
  }

  private async buildContext(session: Session): Promise<any[]> {
    const messages: any[] = [];

    // Add system prompt
    messages.push({
      role: 'system',
      content: process.env.SYSTEM_PROMPT || 
        'You are a helpful assistant. Be concise and friendly.'
    });

    // Add conversation summary if needed
    if (session.messages.length > 20) {
      const summary = await this.sessionManager.getSummary(session.id);
      if (summary) {
        messages.push({
          role: 'system',
          content: `Previous conversation summary: ${summary}`
        });
      }
    }

    // Add recent messages
    const recentMessages = session.messages.slice(-10);
    messages.push(...recentMessages.map(m => ({
      role: m.role,
      content: m.content
    })));

    return messages;
  }

  private async getResponse(
    sessionId: string,
    messages: any[]
  ): Promise<string> {
    try {
      const completion = await openai.chat.completions.create({
        model: 'gpt-3.5-turbo',
        messages,
        temperature: 0.7,
        max_tokens: 500
      });

      const assistantMessage = completion.choices[0].message.content || '';
      
      // Save assistant response
      await this.sessionManager.addMessage(sessionId, {
        role: 'assistant',
        content: assistantMessage,
        timestamp: new Date()
      });

      return assistantMessage;
    } catch (error) {
      console.error('LLM Error:', error);
      return 'I apologize, but I encountered an error. Please try again.';
    }
  }

  private async *streamResponse(
    sessionId: string,
    messages: any[]
  ): AsyncGenerator<string> {
    try {
      const stream = await openai.chat.completions.create({
        model: 'gpt-3.5-turbo',
        messages,
        temperature: 0.7,
        max_tokens: 500,
        stream: true
      });

      let fullResponse = '';
      
      for await (const chunk of stream) {
        const content = chunk.choices[0]?.delta?.content || '';
        if (content) {
          fullResponse += content;
          yield content;
        }
      }

      // Save complete response
      await this.sessionManager.addMessage(sessionId, {
        role: 'assistant',
        content: fullResponse,
        timestamp: new Date()
      });
    } catch (error) {
      console.error('Stream Error:', error);
      yield 'Error: Unable to generate response';
    }
  }
}

// Initialize handlers
const sessionManager = new SessionManager();
const conversationHandler = new ConversationHandler(sessionManager);

// Middleware
app.use(express.json());
app.use(cors());

// Authentication middleware
const authenticateUser = (req: any, res: any, next: any) => {
  const token = req.headers.authorization?.split(' ')[1];
  if (!token) {
    return res.status(401).json({ error: 'No token provided' });
  }

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET!);
    req.userId = decoded.userId;
    next();
  } catch (error) {
    return res.status(401).json({ error: 'Invalid token' });
  }
};

// REST Endpoints
app.post('/api/sessions', authenticateUser, async (req, res) => {
  try {
    const session = await sessionManager.createSession(req.userId);
    res.json({ sessionId: session.id });
  } catch (error) {
    res.status(500).json({ error: 'Failed to create session' });
  }
});

app.post('/api/chat', authenticateUser, async (req, res) => {
  try {
    const { message, sessionId } = req.body;
    
    const response = await conversationHandler.processMessage(
      sessionId,
      message,
      false
    );

    res.json({ response });
  } catch (error) {
    res.status(500).json({ error: 'Failed to process message' });
  }
});

app.get('/api/sessions/:sessionId/history', authenticateUser, async (req, res) => {
  try {
    const session = await sessionManager.getSession(req.params.sessionId);
    if (!session || session.userId !== req.userId) {
      return res.status(404).json({ error: 'Session not found' });
    }

    res.json({ messages: session.messages });
  } catch (error) {
    res.status(500).json({ error: 'Failed to retrieve history' });
  }
});

// WebSocket for streaming
const wss = new WebSocketServer({ port: 8080 });

wss.on('connection', (ws: WebSocket) => {
  ws.on('message', async (data: string) => {
    try {
      const { type, sessionId, message, token } = JSON.parse(data);

      // Verify token
      const decoded = jwt.verify(token, process.env.JWT_SECRET!) as any;

      if (type === 'chat') {
        const stream = conversationHandler.processMessage(
          sessionId,
          message,
          true
        );

        for await (const chunk of stream) {
          ws.send(JSON.stringify({
            type: 'stream',
            content: chunk
          }));
        }

        ws.send(JSON.stringify({ type: 'done' }));
      }
    } catch (error) {
      ws.send(JSON.stringify({
        type: 'error',
        message: 'Failed to process request'
      }));
    }
  });
});

// Error recovery middleware
app.use((error: any, req: any, res: any, next: any) => {
  console.error('Unhandled error:', error);
  res.status(500).json({
    error: 'An unexpected error occurred',
    message: process.env.NODE_ENV === 'development' ? error.message : undefined
  });
});

// Start server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});