Laminar Documentation

The app-server is organized into several core modules:

• API: Provides endpoints for external access, such as triggering a pipeline by its ID.
• DB: Handles all database interactions. Submodule names typically correspond to their respective database tables.
• Language model: Contains structs and methods for interacting directly with language models.
• Routes: Uses the actix_web router to manage and direct incoming HTTP requests.

Laminar is designed for high-throughput agent observability using a high-performance stack:

• Rust backend: Core performance engine.
• gRPC ingestion: Low-overhead trace collection.
• ClickHouse: Used for high-speed analytics.
• Postgres: Manages transactional state.
• RabbitMQ: Handles asynchronous processing.
• OpenTelemetry-native: Built from the ground up for OTel compatibility.

Laminar provides several specialized features for LLM and agent observability:

• Deep agent debugging: Uses a span-tree structure to enable causal reasoning.
• Real-time trace visibility: Monitor long-running operations as they happen.
• Span Replay: Replay from captured spans as a first-class workflow for iteration.
• Browser-agent session replay: Synchronized session replay tied directly to traces for browser-automation agents.
• OpenTelemetry support: Native ingestion for existing pipelines.
• Deployment flexibility: Managed cloud or self-hosted via Docker Compose.

Install the Laminar TS SDK and instrumentation packages via npm, initialize it with your project API key, and use the observe wrapper to trace function inputs and outputs.

import { Laminar } from '@lmnr-ai/lmnr';
import { OpenAI } from 'openai';
import { observe } from '@lmnr-ai/lmnr';

// Initialize
Laminar.initialize({ projectApiKey: process.env.LMNR_PROJECT_API_KEY });

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Trace function inputs/outputs
const poemWriter = observe({name: 'poemWriter'}, async (topic) => {
  const response = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: `write a poem about ${topic}` }],
  });
  return response.choices[0].message.content;
});

await poemWriter('laminar flow');

Install the Laminar Python SDK using pip, initialize it with your project API key, and use the @observe() decorator to trace functions.

import os
from openai import OpenAI
from lmnr import observe, Laminar

# Initialize
Laminar.initialize(project_api_key="<LMNR_PROJECT_API_KEY>")

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

@observe()  # Decorate functions to trace
def poem_writer(topic):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "user", "content": f"write a poem about {topic}"},
        ],
    )
    return response.choices[0].message.content

if __name__ == "__main__":
    print(poem_writer(topic="laminar flow"))

The Dockerfile is TARGETARCH-aware and automatically downloads the matching ONNX Runtime build. Use docker buildx to target specific architectures.

For AWS x86 (amd64):

docker buildx build --platform linux/amd64 -t lmnr/pii-redactor:latest .

For ARM64 (e.g., Graviton):

docker buildx build --platform linux/arm64 -t lmnr/pii-redactor:latest .

Laminar Signals allow you to define a question using a prompt and a schema, which can then be executed across both real-time and historical traces. This enables:

• Detecting and alerting on specific failure modes as they occur.
• Backfilling historical traces to validate new hypotheses.
• Converting production trace history into labeled datasets without manual scripting.

Laminar is fully open source and can be self-hosted on your own infrastructure. To run the entire stack—including tracing, evaluations, datasets, and the UI—locally, use Docker Compose. This allows for full control over your data and zero licensing fees for self-hosting.

docker compose up -d