The Goldilocks Model: Not Too Big, Not Too Small, Just Right

import ollama
from typing import Generator

class Llama2Assistant:
    def __init__(self, model="llama2:13b"):
        self.client = ollama.Client()
        self.model = model
        self.context = []

    def chat(self, message: str, stream=False):
        """Send a message and get response"""
        response = self.client.chat(
            model=self.model,
            messages=[
                {"role": "system", "content": "You are a helpful assistant."},
                {"role": "user", "content": message}
            ],
            stream=stream
        )

        if stream:
            return self._handle_stream(response)
        return response['message']['content']

    def _handle_stream(self, response: Generator):
        """Handle streaming responses"""
        full_response = ""
        for chunk in response:
            if 'message' in chunk:
                content = chunk['message']['content']
                full_response += content
                yield content
        self.context.append(full_response)

    def analyze_document(self, document: str, query: str):
        """Analyze a document with specific query"""
        prompt = f"""
        Document: {document}

        Task: {query}

        Provide a detailed analysis:
        """
        return self.chat(prompt)

    def generate_code(self, description: str, language="python"):
        """Generate code from description"""
        prompt = f"""
        Create {language} code for: {description}

        Requirements:
        - Include error handling
        - Add comments
        - Follow best practices

        Code:
        """
        return self.chat(prompt)

# Usage example
assistant = Llama2Assistant()

# Regular chat
response = assistant.chat("Explain quantum computing")

# Streaming response
for chunk in assistant.chat("Write a story", stream=True):
    print(chunk, end="", flush=True)

# Document analysis
analysis = assistant.analyze_document(
    document="Q3 revenue report...",
    query="Identify key growth drivers"
)

import express from 'express';
import { Ollama } from 'ollama-js';

const app = express();
const ollama = new Ollama();

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

// Chat endpoint
app.post('/api/chat', async (req, res) => {
  const { message, context, temperature = 0.7 } = req.body;

  try {
    const response = await ollama.chat({
      model: 'llama2:13b',
      messages: [
        ...(context || []),
        { role: 'user', content: message }
      ],
      options: {
        temperature,
        top_p: 0.9
      }
    });

    res.json({
      response: response.message.content,
      usage: {
        prompt_tokens: response.prompt_eval_count,
        completion_tokens: response.eval_count,
        total_tokens: response.prompt_eval_count + response.eval_count
      }
    });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

// Streaming endpoint
app.post('/api/stream', async (req, res) => {
  const { message } = req.body;

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

  try {
    const stream = await ollama.chat({
      model: 'llama2:13b',
      messages: [{ role: 'user', content: message }],
      stream: true
    });

    for await (const chunk of stream) {
      res.write(`data: ${JSON.stringify(chunk)}\n\n`);
    }
    res.end();
  } catch (error) {
    res.write(`data: ${JSON.stringify({ error: error.message })}\n\n`);
    res.end();
  }
});

// Batch processing
app.post('/api/batch', async (req, res) => {
  const { tasks } = req.body;

  const results = await Promise.all(
    tasks.map(async (task) => {
      const response = await ollama.generate({
        model: 'llama2:13b',
        prompt: task.prompt,
        options: task.options || {}
      });
      return {
        task_id: task.id,
        result: response.response
      };
    })
  );

  res.json({ results });
});

app.listen(3000, () => {
  console.log('Llama 2 13B API running on port 3000');
});