Llama 2 70B: Enterprise Architecture

const express = require('express');
const cluster = require('cluster');
const os = require('os');
const { Ollama } = require('ollama-node');

class EnterpriseAIServer {
    constructor() {
        this.app = express();
        this.ollama = new Ollama();
        this.workers = os.cpus().length;
        this.setupMiddleware();
        this.setupRoutes();
        this.setupCluster();
    }

    setupMiddleware() {
        this.app.use(express.json({ limit: '50mb' }));
        this.app.use(express.urlencoded({ extended: true, limit: '50mb' }));

        // Rate limiting
        const rateLimit = require('express-rate-limit');
        const limiter = rateLimit({
            windowMs: 60 * 1000, // 1 minute
            max: 1000 // limit each IP to 1000 requests per windowMs
        });
        this.app.use('/api/', limiter);
    }

    setupRoutes() {
        // Health check endpoint
        this.app.get('/health', (req, res) => {
            res.json({
                status: 'healthy',
                model: 'llama2:70b',
                workers: this.workers,
                uptime: process.uptime()
            });
        });

        // Enterprise batch processing
        this.app.post('/api/batch', async (req, res) => {
            try {
                const { prompts, options = {} } = req.body;

                if (!Array.isArray(prompts) || prompts.length > 100) {
                    return res.status(400).json({
                        error: 'Invalid prompts array (max 100 items)'
                    });
                }

                const results = await Promise.all(
                    prompts.map(prompt => this.processPrompt(prompt, options))
                );

                res.json({
                    results,
                    processed: results.length,
                    model: 'llama2:70b'
                });
            } catch (error) {
                res.status(500).json({ error: error.message });
            }
        });

        // Streaming endpoint for real-time applications
        this.app.post('/api/stream', (req, res) => {
            const { prompt } = req.body;

            res.setHeader('Content-Type', 'text/event-stream');
            res.setHeader('Cache-Control', 'no-cache');
            res.setHeader('Connection', 'keep-alive');

            this.ollama.generate({
                model: 'llama2:70b',
                prompt: prompt,
                stream: true
            }).then(stream => {
                stream.on('data', (chunk) => {
                    res.write(`data: ${JSON.stringify(chunk)}

`);
                });
                stream.on('end', () => {
                    res.end();
                });
            }).catch(error => {
                res.write(`data: ${JSON.stringify({ error: error.message })}

`);
                res.end();
            });
        });
    }

    async processPrompt(prompt, options) {
        return new Promise((resolve, reject) => {
            this.ollama.generate({
                model: 'llama2:70b',
                prompt: prompt,
                options: {
                    temperature: 0.7,
                    top_p: 0.9,
                    ...options
                }
            }).then(response => {
                    resolve({
                        prompt,
                        response: response.response,
                        model: 'llama2:70b',
                        done: response.done,
                        context: response.context
                    });
                }).catch(reject);
        });
    }

    setupCluster() {
        if (cluster.isMaster) {
            console.log(`Master ${process.pid} is running`);

            // Fork workers
            for (let i = 0; i < this.workers; i++) {
                cluster.fork();
            }

            cluster.on('exit', (worker, code, signal) => {
                console.log(`Worker ${worker.process.pid} died`);
                cluster.fork(); // Replace the dead worker
            });
        } else {
            console.log(`Worker ${process.pid} started`);
            const PORT = process.env.PORT || 3000;
            this.app.listen(PORT, () => {
                console.log(`Enterprise AI Server running on port ${PORT}`);
            });
        }
    }
}

// Initialize enterprise server
const server = new EnterpriseAIServer();