I would like to use angular + zeroMQ to get info via socket, it it possible to use netMQ…
- User
I would like to use angular + zeroMQ to get info via socket, it it possible to use netMQ C# as backend and use angular zeroMQ as frontend?
Assistant
Yes, it is absolutely possible to use a NetMQ C# backend and an Angular frontend to get information, but not directly via ZeroMQ sockets from the browser.
Here's why and how:
The Core Limitation
Web browsers (and thus Angular applications running within them) operate within a security sandbox. They cannot directly open arbitrary TCP/UDP sockets or connect to ZeroMQ sockets. Browsers are limited to standard web protocols like HTTP(S) and WebSockets. ZeroMQ uses its own unique messaging patterns and framing over raw TCP.
The Solution: A Backend Bridge
The solution is to use your NetMQ C# backend as a bridge or proxy between the ZeroMQ network and the Angular frontend.
Here are the common architectural patterns for this:
-
Recommended: WebSockets (for real-time, bi-directional communication)
- NetMQ Backend (C#): Your C# application (e.g., an ASP.NET Core Web API) will have two main responsibilities:
- ZeroMQ Client/Server: It will use
NetMQto connect to your ZeroMQ network (e.g., subscribe to aPUBsocket, connect to aREPsocket, etc.) to receive the data you need. - WebSocket Server: It will also host a WebSocket server endpoint. When data is received from ZeroMQ, the backend pushes it to all connected Angular clients via their WebSocket connections. It can also receive messages from Angular clients via WebSockets and forward them to the ZeroMQ network if needed.
- ZeroMQ Client/Server: It will use
- Angular Frontend: Your Angular application will use the browser's built-in
WebSocketAPI (or a library wrapper likerxjs-websocketsfor a reactive approach) to connect to the WebSocket endpoint exposed by your C# backend. It will listen for messages coming over the WebSocket and update the UI accordingly.
- NetMQ Backend (C#): Your C# application (e.g., an ASP.NET Core Web API) will have two main responsibilities:
-
Alternative: HTTP (REST API or Server-Sent Events for less real-time needs)
- NetMQ Backend (C#): Your C# application (e.g., an ASP.NET Core Web API) will expose standard REST API endpoints.
- Polling: Angular makes an HTTP request to an endpoint. The backend, upon receiving the request, uses NetMQ to fetch the latest data from ZeroMQ and returns it as a JSON response. Angular then periodically polls this endpoint. This is less efficient for real-time updates.
- Server-Sent Events (SSE): The backend can establish an SSE connection with the Angular frontend. When data is received from ZeroMQ, the backend pushes it down the SSE stream to the Angular client. This is unidirectional (server-to-client).
- Angular Frontend: Uses Angular's
HttpClientfor standard REST calls orEventSourcefor Server-Sent Events.
- NetMQ Backend (C#): Your C# application (e.g., an ASP.NET Core Web API) will expose standard REST API endpoints.
How it Works (WebSockets Example - Most Common)
- ZeroMQ Network: You have a ZeroMQ network (e.g., a
PUBsocket publishing sensor data, orREPworkers waiting for requests). - NetMQ C# Backend:
- An ASP.NET Core application starts up.
- It initializes a
NetMQ.SubscriberSocket(if listening to a PUB) orNetMQ.RequestSocket(if making requests) and connects to the ZeroMQ endpoints (tcp://your-zmq-ip:port). - It also configures an endpoint for WebSockets (e.g.,
/ws). - When the
NetMQ.SubscriberSocketreceives a message, the backend processes it and sends it over all active WebSocket connections to the browser clients. - If the Angular app needs to send a command, it sends it over its WebSocket connection. The backend receives it and sends it via
NetMQ.PushSocketorNetMQ.RequestSocketto the ZeroMQ network.
- Angular Frontend:
- When your Angular component loads, it creates a
new WebSocket('ws://your-backend-ip:port/ws'). - It sets up
onmessageevent listeners to receive data pushed from the C# backend. - It can use
webSocket.send(message)to send data back to the C# backend.
- When your Angular component loads, it creates a
Conceptual Code Snippets
C# Backend (ASP.NET Core with NetMQ & WebSockets)
// Simplified Program.cs or Startup.cs in ASP.NET Core using Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Http; using Microsoft.Extensions.DependencyInjection; using NetMQ; using NetMQ.Sockets; using System.Net.WebSockets; using System.Text; using System.Threading.Tasks; using System.Collections.Concurrent; using System.Threading; public class Startup { private ConcurrentDictionary<WebSocket, bool> _sockets = new ConcurrentDictionary<WebSocket, bool>(); private SubscriberSocket _subscriber; private Thread _zmqThread; public void ConfigureServices(IServiceCollection services) { // Add other services if needed } public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { app.UseWebSockets(); // Start ZeroMQ subscriber in a background thread _subscriber = new SubscriberSocket(); _subscriber.Connect("tcp://localhost:5556"); // Your ZeroMQ Publisher address _subscriber.Subscribe(""); // Subscribe to all topics or specific ones _zmqThread = new Thread(() => { while (true) { try { var msg = _subscriber.ReceiveFrameString(); Console.WriteLine($"Received from ZMQ: {msg}"); BroadcastMessageToWebSockets(msg).GetAwaiter().GetResult(); } catch (Exception ex) { Console.WriteLine($"ZMQ error: {ex.Message}"); } } }); _zmqThread.IsBackground = true; _zmqThread.Start(); app.Use(async (context, next) => { if (context.Request.Path == "/ws") { if (context.WebSockets.IsWebSocketRequest) { WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync(); _sockets.TryAdd(webSocket, true); Console.WriteLine("WebSocket connected!"); // Keep the connection open until disconnected await ReceiveMessages(webSocket); _sockets.TryRemove(webSocket, out _); Console.WriteLine("WebSocket disconnected!"); } else { context.Response.StatusCode = StatusCodes.Status400BadRequest; } } else { await next(); } }); } private async Task ReceiveMessages(WebSocket webSocket) { var buffer = new byte[1024 * 4]; WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); while (!result.CloseStatus.HasValue) { var message = Encoding.UTF8.GetString(buffer, 0, result.Count); Console.WriteLine($"Received from client: {message}"); // Here you can process the message and send it to your ZeroMQ network if needed // e.g., using a RequestSocket or PushSocket to another ZMQ endpoint result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); } await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); } private async Task BroadcastMessageToWebSockets(string message) { var bytes = Encoding.UTF8.GetBytes(message); foreach (var pair in _sockets) { var ws = pair.Key; if (ws.State == WebSocketState.Open) { await ws.SendAsync(new ArraySegment<byte>(bytes, 0, bytes.Length), WebSocketMessageType.Text, true, CancellationToken.None); } } } }Angular Frontend (TypeScript)
import { Component, OnDestroy, OnInit } from '@angular/core'; import { Subject, WebSocketSubject } from 'rxjs/webSocket'; import { takeUntil } from 'rxjs/operators'; @Component({ selector: 'app-data-display', template: ` <h2>Real-time Data</h2> <div *ngFor="let data of receivedData">{{ data }}</div> <button (click)="sendMessage()">Send Test Message</button> `, }) export class DataDisplayComponent implements OnInit, OnDestroy { receivedData: string[] = []; private socket$: WebSocketSubject<string>; private ngUnsubscribe = new Subject<void>(); ngOnInit(): void { // Connect to your C# backend's WebSocket endpoint this.socket$ = new WebSocketSubject('ws://localhost:5000/ws'); // Adjust port/IP as needed this.socket$.pipe(takeUntil(this.ngUnsubscribe)).subscribe( (message: string) => { console.log('Received from backend:', message); this.receivedData.unshift(message); // Add to the top if (this.receivedData.length > 10) { this.receivedData.pop(); // Keep list short } }, (err) => console.error('WebSocket error:', err), () => console.log('WebSocket connection closed') ); } sendMessage(): void { const testMessage = `Hello from Angular at ${new Date().toLocaleTimeString()}`; this.socket$.next(testMessage); console.log('Sent message:', testMessage); } ngOnDestroy(): void { this.ngUnsubscribe.next(); this.ngUnsubscribe.complete(); if (this.socket$) { this.socket$.complete(); // Close the WebSocket connection } } }This setup allows your Angular frontend to receive real-time data that originates from a ZeroMQ network, with your NetMQ C# backend serving as the essential intermediary.
-
- User
show complete example both backend and frontend
Assistant
Okay, this is a fantastic real-world scenario! As discussed, the key is using a WebSocket bridge on the C# backend.
I'll provide you with:
- A Simple ZeroMQ Publisher (Python): To simulate your ZeroMQ data source.
- ASP.NET Core Backend (C# with NetMQ & WebSockets): This will subscribe to ZeroMQ and push data to Angular via WebSockets. It also handles messages from Angular.
- Angular Frontend (with RxJS WebSockets): This will connect to the C# backend's WebSocket endpoint and display the received data, and also send data back.
1. ZeroMQ Publisher (Python) -
zmq_publisher.pyThis will simulate your data source. It publishes a simple "Hello" message every second.
Prerequisites:
- Python installed
pip install pyzmq
# zmq_publisher.py import zmq import time import random context = zmq.Context() socket = context.socket(zmq.PUB) # Bind to a TCP port. This is where your C# backend will connect. socket.bind("tcp://*:5556") print("ZMQ Publisher started on tcp://*:5556") print("Press Ctrl+C to stop.") message_count = 0 try: while True: message_count += 1 # Example data: a simple string with a timestamp and a random number data = f"Hello from ZMQ! Message #{message_count} - Timestamp: {time.time()} - Random: {random.randint(1, 100)}" # ZeroMQ PUB/SUB usually has topics. Let's use an empty topic for simplicity # or a specific one if you want to filter on the subscriber side. # For this example, we'll just send the message as the content. # If you wanted a topic: socket.send_string("my_topic", zmq.SNDMORE) ; socket.send_string(data) socket.send_string(data) print(f"Published: '{data}'") time.sleep(1) # Publish every 1 second except KeyboardInterrupt: print("\nZMQ Publisher stopped.") finally: socket.close() context.term()
2. ASP.NET Core Backend (C#)
This project will act as the ZeroMQ subscriber and WebSocket server.
Project Setup:
- Create a new ASP.NET Core Web API project:
dotnet new webapi -n ZmqWebSocketBridgecd ZmqWebSocketBridge - Install NetMQ:
dotnet add package NetMQ - Modify
Program.cs(for .NET 6+ Minimal API) orStartup.csandProgram.csfor older versions. I'll use the .NET 6+ Minimal API approach.
ZmqWebSocketBridge/Program.csusing Microsoft.AspNetCore.Builder; using Microsoft.AspNetCore.Hosting; using Microsoft.AspNetCore.Http; using Microsoft.Extensions.DependencyInjection; using Microsoft.Extensions.Hosting; using NetMQ; using NetMQ.Sockets; using System; using System.Collections.Concurrent; using System.Net.WebSockets; using System.Text; using System.Threading; using System.Threading.Tasks; // Define a class to manage the ZeroMQ subscriber and WebSocket broadcasting public class ZmqWebSocketService : IHostedService, IDisposable { private readonly ConcurrentDictionary<WebSocket, bool> _sockets = new ConcurrentDictionary<WebSocket, bool>(); private SubscriberSocket _subscriber; private Thread _zmqThread; private CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource(); public ZmqWebSocketService() { // Initialize ZeroMQ subscriber _subscriber = new SubscriberSocket(); // Connect to the Python publisher's address _subscriber.Connect("tcp://localhost:5556"); _subscriber.Subscribe(""); // Subscribe to all topics } public Task StartAsync(CancellationToken cancellationToken) { _zmqThread = new Thread(() => ZmqReceiveLoop(_cancellationTokenSource.Token)) { IsBackground = true, // Allows the application to exit even if this thread is running Name = "ZMQ Listener Thread" }; _zmqThread.Start(); Console.WriteLine("ZMQ WebSocket Service Started. Listening for ZMQ messages and accepting WebSocket connections on /ws"); return Task.CompletedTask; } private void ZmqReceiveLoop(CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { try { if (_subscriber.TryReceiveFrameString(TimeSpan.FromMilliseconds(100), out string msg)) { Console.WriteLine($"[ZMQ Received]: {msg}"); // Broadcast the received ZMQ message to all connected WebSockets BroadcastMessageToWebSockets(msg).GetAwaiter().GetResult(); } } catch (NetMQException ex) when (ex.ErrorCode == NetMQErrorCode.Terminating) { Console.WriteLine("NetMQ socket is terminating, stopping ZMQ receive loop."); break; } catch (Exception ex) { Console.WriteLine($"[ZMQ Error]: {ex.Message}"); } } Console.WriteLine("ZMQ Receive Loop Terminated."); } // This method is called by the ASP.NET Core middleware to register new WebSocket clients public async Task AddSocket(WebSocket webSocket) { _sockets.TryAdd(webSocket, true); Console.WriteLine($"WebSocket Connected: Total {_sockets.Count} active connections."); await ReceiveMessagesFromWebSocket(webSocket); } private async Task ReceiveMessagesFromWebSocket(WebSocket webSocket) { var buffer = new byte[1024 * 4]; try { WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); while (!result.CloseStatus.HasValue) { var message = Encoding.UTF8.GetString(buffer, 0, result.Count); Console.WriteLine($"[WS Client Received]: {message}"); // --- Handle messages from Angular here --- // You could send this message to another ZeroMQ socket (e.g., REQ, PUSH) // For this example, we'll just echo it back. await SendMessageToWebSocket(webSocket, $"Echo: {message}"); result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); } await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); } catch (WebSocketException ex) // Client disconnects abruptly { Console.WriteLine($"WebSocket Error (client disconnect?): {ex.Message}"); } catch (Exception ex) { Console.WriteLine($"Unhandled exception in ReceiveMessagesFromWebSocket: {ex.Message}"); } finally { _sockets.TryRemove(webSocket, out _); Console.WriteLine($"WebSocket Disconnected: Total {_sockets.Count} active connections."); webSocket.Dispose(); } } private async Task BroadcastMessageToWebSockets(string message) { var bytes = Encoding.UTF8.GetBytes(message); foreach (var pair in _sockets.ToArray()) // .ToArray() to prevent collection modified during iteration { var ws = pair.Key; if (ws.State == WebSocketState.Open) { try { await ws.SendAsync(new ArraySegment<byte>(bytes, 0, bytes.Length), WebSocketMessageType.Text, true, CancellationToken.None); } catch (Exception ex) { Console.WriteLine($"Error sending to WebSocket: {ex.Message}. Removing socket."); _sockets.TryRemove(ws, out _); // Remove problematic socket } } else { // Socket is not open, remove it _sockets.TryRemove(ws, out _); } } } private async Task SendMessageToWebSocket(WebSocket webSocket, string message) { var bytes = Encoding.UTF8.GetBytes(message); if (webSocket.State == WebSocketState.Open) { try { await webSocket.SendAsync(new ArraySegment<byte>(bytes, 0, bytes.Length), WebSocketMessageType.Text, true, CancellationToken.None); } catch (Exception ex) { Console.WriteLine($"Error sending specific message to WebSocket: {ex.Message}. Removing socket."); _sockets.TryRemove(webSocket, out _); } } else { _sockets.TryRemove(webSocket, out _); } } public Task StopAsync(CancellationToken cancellationToken) { Console.WriteLine("ZMQ WebSocket Service Stopping..."); _cancellationTokenSource.Cancel(); // Signal ZMQ thread to stop _zmqThread?.Join(); // Wait for ZMQ thread to finish // Close all active websockets foreach(var pair in _sockets.ToArray()) { var ws = pair.Key; if (ws.State == WebSocketState.Open) { try { ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Service shutting down", CancellationToken.None).GetAwaiter().GetResult(); } catch (Exception ex) { Console.WriteLine($"Error closing WebSocket during shutdown: {ex.Message}"); } } } _sockets.Clear(); // Dispose NetMQ resources _subscriber?.Dispose(); NetMQConfig.Cleanup(false); // Only call this if you want to explicitly cleanup NetMQ resources // generally not needed if sockets are disposed. Console.WriteLine("ZMQ WebSocket Service Stopped."); return Task.CompletedTask; } public void Dispose() { _cancellationTokenSource.Dispose(); _subscriber?.Dispose(); } } // Minimal API Startup var builder = WebApplication.CreateBuilder(args); // Add services to the container. builder.Services.AddControllers(); // For standard API controllers, though not strictly needed for this WebSocket example builder.Services.AddHostedService<ZmqWebSocketService>(); // Register our custom service builder.Services.AddSingleton<ZmqWebSocketService>(); // Register as singleton for direct injection into middleware // Add CORS policy for Angular development server (e.g., http://localhost:4200) builder.Services.AddCors(options => { options.AddPolicy("AllowAngularApp", builder => builder.WithOrigins("http://localhost:4200") // Angular default port .AllowAnyHeader() .AllowAnyMethod() .AllowCredentials()); // If you are using cookies/auth tokens }); var app = builder.Build(); // Configure the HTTP request pipeline. app.UseRouting(); app.UseCors("AllowAngularApp"); // Enable CORS app.UseWebSockets(); // Enable WebSocket support // WebSocket endpoint middleware app.Use(async (context, next) => { if (context.Request.Path == "/ws") { if (context.WebSockets.IsWebSocketRequest) { var zmqWebSocketService = context.RequestServices.GetRequiredService<ZmqWebSocketService>(); WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync(); await zmqWebSocketService.AddSocket(webSocket); } else { context.Response.StatusCode = StatusCodes.Status400BadRequest; } } else { await next(); } }); app.MapControllers(); // If you have other API controllers app.Run();
3. Angular Frontend
This will connect to the C# backend via WebSockets.
Project Setup:
- Create a new Angular project (if you don't have one):
ng new angular-zmq-frontend --no-standalone --skip-tests(Choose scss, and no routing for simplicity)cd angular-zmq-frontend - Open
src/app/app.component.tsandsrc/app/app.component.html.
angular-zmq-frontend/src/app/app.component.tsimport { Component, OnInit, OnDestroy } from '@angular/core'; import { Subject } from 'rxjs'; import { takeUntil } from 'rxjs/operators'; import { WebSocketSubject } from 'rxjs/webSocket'; @Component({ selector: 'app-root', templateUrl: './app.component.html', styleUrls: ['./app.component.scss'] }) export class AppComponent implements OnInit, OnDestroy { title = 'Angular ZMQ Data Display'; private socket$: WebSocketSubject<string>; private ngUnsubscribe = new Subject<void>(); // Used for unsubscribing on destroy receivedMessages: string[] = []; messageToSend: string = ''; connectionStatus: string = 'Connecting...'; ngOnInit(): void { this.connectWebSocket(); } connectWebSocket(): void { // Replace 'localhost:5000' with your backend's actual address and port // Ensure you use 'ws://' for unencrypted WebSockets or 'wss://' for encrypted (HTTPS) this.socket$ = new WebSocketSubject('ws://localhost:5000/ws'); this.socket$.pipe( takeUntil(this.ngUnsubscribe) // Automatically unsubscribe when component is destroyed ).subscribe( (message: string) => { console.log('Received from backend:', message); this.receivedMessages.unshift(`[${new Date().toLocaleTimeString()}] ${message}`); // Add new messages to top if (this.receivedMessages.length > 20) { // Keep list from getting too long this.receivedMessages.pop(); } this.connectionStatus = 'Connected'; }, (error) => { console.error('WebSocket Error:', error); this.connectionStatus = `Disconnected: ${error.code} - ${error.reason}`; // Implement reconnection logic here if desired setTimeout(() => this.connectWebSocket(), 3000); // Attempt to reconnect after 3 seconds }, () => { console.log('WebSocket Connection Closed'); this.connectionStatus = 'Closed'; // Handle closure, potentially attempt reconnection setTimeout(() => this.connectWebSocket(), 3000); // Attempt to reconnect after 3 seconds } ); } sendMessage(): void { if (this.messageToSend.trim()) { console.log('Sending message:', this.messageToSend); this.socket$.next(this.messageToSend); // Send message to backend this.messageToSend = ''; // Clear input } } ngOnDestroy(): void { this.ngUnsubscribe.next(); this.ngUnsubscribe.complete(); if (this.socket$) { this.socket$.complete(); // Close the WebSocket connection gracefully } } }angular-zmq-frontend/src/app/app.component.html<div class="container"> <h1>{{ title }}</h1> <div class="status"> Connection Status: <span [class.connected]="connectionStatus === 'Connected'" [class.disconnected]="connectionStatus !== 'Connected'">{{ connectionStatus }}</span> </div> <div class="message-sender"> <input type="text" [(ngModel)]="messageToSend" placeholder="Type a message to backend..."> <button (click)="sendMessage()" [disabled]="connectionStatus !== 'Connected'">Send to Backend</button> </div> <h2>Received ZMQ Messages (via Backend WebSocket)</h2> <div class="message-list"> <div *ngIf="receivedMessages.length === 0" class="no-messages"> Waiting for messages... Ensure ZMQ Publisher and C# Backend are running. </div> <div *ngFor="let message of receivedMessages" class="message-item"> {{ message }} </div> </div> </div>angular-zmq-frontend/src/app/app.component.scss(optional, for basic styling).container { font-family: Arial, sans-serif; max-width: 800px; margin: 20px auto; padding: 20px; border: 1px solid #ccc; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); } h1, h2 { text-align: center; color: #333; } .status { text-align: center; margin-bottom: 20px; font-size: 1.1em; } .status .connected { color: green; font-weight: bold; } .status .disconnected { color: red; font-weight: bold; } .message-sender { display: flex; gap: 10px; margin-bottom: 20px; input { flex-grow: 1; padding: 10px; border: 1px solid #ddd; border-radius: 4px; } button { padding: 10px 15px; background-color: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer; &:hover:not(:disabled) { background-color: #0056b3; } &:disabled { background-color: #cccccc; cursor: not-allowed; } } } .message-list { border: 1px solid #eee; padding: 10px; max-height: 400px; overflow-y: auto; background-color: #f9f9f9; border-radius: 4px; } .no-messages { text-align: center; color: #888; padding: 20px; } .message-item { padding: 8px 0; border-bottom: 1px dotted #e0e0e0; font-family: 'Courier New', Courier, monospace; font-size: 0.9em; &:last-child { border-bottom: none; } }
How to Run
-
Start ZeroMQ Publisher (Python): Open a terminal/command prompt:
python zmq_publisher.pyYou should see messages like "Published: 'Hello from ZMQ!...'". -
Start ASP.NET Core Backend (C#): Open a new terminal/command prompt, navigate to the
ZmqWebSocketBridgedirectory:dotnet runIt will typically run onhttps://localhost:7164andhttp://localhost:5000. The WebSocket endpoint will bews://localhost:5000/ws. You should see messages about ZMQ and WebSocket connections in this console. -
Start Angular Frontend: Open a new terminal/command prompt, navigate to the
angular-zmq-frontenddirectory:ng serve --openThis will compile the Angular app and open it in your browser (usuallyhttp://localhost:4200).
Expected Behavior
- The Python publisher will continuously print messages to its console.
- The C# backend will show "ZMQ Received" messages, indicating it's getting data from the Python publisher.
- When you open the Angular app in your browser, the C# backend will log "WebSocket Connected!".
- The Angular app will immediately start displaying the "Hello from ZMQ!" messages pushed from the C# backend.
- If you type a message into the Angular app's input field and click "Send to Backend", the C# backend's console will show "[WS Client Received]" and then immediately send an "Echo:" message back, which Angular will also display.
This setup provides a robust and scalable way to integrate ZeroMQ into a web application by using a backend service as the essential bridge.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.