# Low-level event iteration — see every event type
with client.messages.stream(
    model="claude-3-5-sonnet-20241022",
    max_tokens=512,
    messages=[{"role": "user", "content": "Say hello"}]
) as stream:
    for event in stream:
        match event.type:
            case "message_start":
                # First event — contains model, message id
                print(f"Started: {event.message.id}")
            case "content_block_start":
                # A new content block begins (text or tool_use)
                print(f"Block type: {event.content_block.type}")
            case "content_block_delta":
                # A chunk of text (text_delta) or tool input (input_json_delta)
                if event.delta.type == "text_delta":
                    print(event.delta.text, end="", flush=True)
            case "content_block_stop":
                # Content block finished
                pass
            case "message_delta":
                # Stop reason and final token counts
                print(f"\nStop: {event.delta.stop_reason}")
            case "message_stop":
                # Streaming complete
                print("Stream finished")

# OpenAI streaming — similar pattern
with client.chat.completions.stream(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Say hello"}]
) as stream:
    for chunk in stream:
        delta = chunk.choices[0].delta
        if delta.content:
            print(delta.content, end="", flush=True)

// Browser JavaScript — EventSource API for SSE
async function streamChat(message) {
  const response = await fetch('/chat/stream', {
    method: 'POST',
    headers: {'Content-Type': 'application/json'},
    body: JSON.stringify({message})
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let buffer = '';

  while (true) {
    const {done, value} = await reader.read();
    if (done) break;

    buffer += decoder.decode(value, {stream: true});
    const lines = buffer.split('\n');
    buffer = lines.pop();   // keep incomplete line in buffer

    for (const line of lines) {
      if (!line.startsWith('data: ')) continue;
      const data = JSON.parse(line.slice(6));

      if (data.text) {
        document.getElementById('response').textContent += data.text;
      }
      if (data.done) {
        console.log('Tokens:', data.usage);
      }
    }
  }
}

// Python client consuming the stream
import httpx, json

async def consume_stream(message: str):
    async with httpx.AsyncClient(timeout=60) as http:
        async with http.stream("POST", "http://localhost:8000/chat/stream",
                               json={"message": message}) as response:
            async for line in response.aiter_lines():
                if not line.startswith("data: "):
                    continue
                data = json.loads(line[6:])
                if data.get("text"):
                    print(data["text"], end="", flush=True)

import anthropic
from dataclasses import dataclass, field
from typing import Optional
from datetime import datetime

@dataclass
class Turn:
    role:      str
    content:   str
    timestamp: str = field(default_factory=lambda: datetime.utcnow().isoformat())
    tokens:    Optional[int] = None

class ConversationManager:
    def __init__(
        self,
        system_prompt: str = "",
        model: str = "claude-3-5-sonnet-20241022",
        max_tokens: int = 2048,
    ):
        self.client        = anthropic.Anthropic()
        self.system_prompt = system_prompt
        self.model         = model
        self.max_tokens    = max_tokens
        self.history: list[Turn] = []

    def _build_messages(self) -> list[dict]:
        return [
            {"role": t.role, "content": t.content}
            for t in self.history
        ]

    def chat(self, user_message: str) -> str:
        self.history.append(Turn(role="user", content=user_message))

        response = self.client.messages.create(
            model=self.model,
            max_tokens=self.max_tokens,
            system=self.system_prompt,
            messages=self._build_messages()
        )

        reply = response.content[0].text
        self.history.append(Turn(
            role="assistant",
            content=reply,
            tokens=response.usage.output_tokens
        ))
        return reply

    def chat_stream(self, user_message: str):
        self.history.append(Turn(role="user", content=user_message))
        full_reply = ""

        with self.client.messages.stream(
            model=self.model,
            max_tokens=self.max_tokens,
            system=self.system_prompt,
            messages=self._build_messages()
        ) as stream:
            for text in stream.text_stream:
                full_reply += text
                yield text
            final = stream.get_final_message()

        self.history.append(Turn(
            role="assistant",
            content=full_reply,
            tokens=final.usage.output_tokens
        ))

    def clear(self):
        self.history = []

    @property
    def turn_count(self) -> int:
        return len([t for t in self.history if t.role == "user"])

# Usage
conv = ConversationManager(system_prompt="You are a helpful coding assistant.")
print(conv.chat("My name is Ajay and I work with DPDK"))
print(conv.chat("What is my name and what technology do I work with?"))
print(conv.turn_count)   # 2

def sliding_window(
    messages: list[dict],
    max_tokens: int = 100_000,
    min_turns: int = 2
) -> list[dict]:
    """
    Keep as many recent messages as fit within max_tokens.
    Always keep at least min_turns (user+assistant pairs).
    """
    # Always keep messages in pairs (user + assistant)
    # Start from most recent, work backwards
    result = []
    token_count = 0
    pairs = []

    # Group into user+assistant pairs
    i = 0
    while i < len(messages) - 1:
        if messages[i]["role"] == "user" and messages[i+1]["role"] == "assistant":
            pairs.append((messages[i], messages[i+1]))
            i += 2
        else:
            i += 1

    # Always include last user message
    if messages and messages[-1]["role"] == "user":
        result = [messages[-1]]
        token_count = count_tokens(messages[-1]["content"])
        pairs_to_check = pairs
    else:
        pairs_to_check = pairs

    # Add pairs from most recent backwards until we hit the limit
    included = []
    for user_msg, asst_msg in reversed(pairs_to_check):
        pair_tokens = count_tokens(user_msg["content"]) + count_tokens(asst_msg["content"])
        if token_count + pair_tokens > max_tokens and len(included) >= min_turns:
            break
        included.insert(0, (user_msg, asst_msg))
        token_count += pair_tokens

    for u, a in included:
        result = [u, a] + result

    return result

import redis, json

r = redis.Redis(host="localhost", port=6379, decode_responses=True)

def save_message_redis(session_id: str, role: str, content: str, ttl: int = 3600):
    """Store message in Redis list. TTL in seconds (default: 1 hour)."""
    key = f"conv:{session_id}"
    message = json.dumps({"role": role, "content": content})
    r.rpush(key, message)        # append to list
    r.expire(key, ttl)           # reset TTL on each message

def load_history_redis(session_id: str, last_n: int = 0) -> list[dict]:
    """Load conversation history from Redis."""
    key = f"conv:{session_id}"
    start = -last_n * 2 if last_n else 0
    raw = r.lrange(key, start, -1)
    return [json.loads(m) for m in raw]

def clear_history_redis(session_id: str):
    r.delete(f"conv:{session_id}")

# When to use SQLite vs Redis:
# SQLite  — single server, persistent storage, needs query/search, < 1k concurrent users
# Redis   — multi-server, ephemeral (TTL), fast read/write, > 1k concurrent sessions
# Both    — use Redis as cache + SQLite/PostgreSQL for durable archive