Install SentriNode — pick your stack

Choose your platform & installation method

For Python apps calling OpenAI or Anthropic. Every call is traced — cost, tokens, latency — with no change to your existing code.

1. Install the SDK, plus whichever provider library you use. sentrinode-llm does not pull these in for you.

shell

pip install sentrinode-llm anthropic

2. Save this as test_llm.py. This is Python — it goes in a file, not typed into a terminal prompt. instrument() only patches the client, so the example makes a real call afterwards; without one, nothing is sent.

test_llm.py

import os import sentrinode_llm import anthropic sentrinode_llm.instrument( tenant="your-tenant", api_key=os.environ["SENTRINODE_API_KEY"], ) client = anthropic.Anthropic() client.messages.create( model="claude-haiku-4-5-20251001", max_tokens=64, messages=[{"role": "user", "content": "hello"}], ) print("sent - check your dashboard")

3. Run it. Keep keys in the environment rather than in the file, so they can’t be committed by accident.

PowerShell

# Windows PowerShell $env:SENTRINODE_API_KEY="your-api-key" $env:ANTHROPIC_API_KEY="your-anthropic-key" python test_llm.py

bash

# macOS / Linux export SENTRINODE_API_KEY="your-api-key" export ANTHROPIC_API_KEY="your-anthropic-key" python test_llm.py

Your call appears on the dashboard within a few seconds. In production, drop the arguments to instrument() entirely and set SENTRINODE_TENANT and SENTRINODE_API_KEY in the environment — the SDK reads them itself.

A native Node SDK is in the works. coming soon

Until then, Node and Next.js apps can send telemetry today over OpenTelemetry — point any OTLP exporter at the ingest endpoint with your tenant headers. See the cURL / OTLP tab for the endpoint and headers.

Any language. Point an OpenTelemetry/HTTP exporter at the ingest endpoint with your tenant headers — no language-specific SDK required.

endpoint

POST https://api.sentrinode.com/v1/otlp/traces Headers: X-Tenant-Id: your-tenant X-SentriNode-Key: your-api-key Content-Type: application/json Body: standard OTLP/HTTP JSON spans (use gen_ai.* attributes for LLM cost)

Monitor the machine itself — CPU, memory, disk and network — with the OpenTelemetry Collector. Works on Windows, macOS and Linux; nothing SentriNode-specific to install.

config.yaml

receivers: hostmetrics: collection_interval: 10s scrapers: cpu: memory: disk: network: load: exporters: otlphttp: endpoint: https://api.sentrinode.com headers: X-Tenant-Id: your-tenant X-SentriNode-Key: your-api-key service: pipelines: metrics: receivers: [hostmetrics] exporters: [otlphttp]

Save that as otel-config.yaml, then run the collector against it:

shell

docker run --rm -v "$PWD/otel-config.yaml":/etc/otel/config.yaml otel/opentelemetry-collector-contrib:latest --config=/etc/otel/config.yaml

Host metrics arrive as node state — they populate the nodes view, not the LLM cost panels. For cost and token tracking, use the Python or Node tab instead.

Two ways to run SentriNode yourself. The difference is whether you bring a Supabase project or not.

A. Standalone — no Supabase. Postgres holds tenants and API keys, and the whole stack comes up from one file. Ingest, storage, budgets, alerts and the /v1 API.

shell

cp .env.selfhost.example .env.selfhost # edit it: set POSTGRES_PASSWORD and SENTRINODE_INTERNAL_API_KEY docker compose -f docker-compose.selfhost.yml --env-file .env.selfhost up -d --build

There is no dashboard to create a key from, so mint one in Postgres. The raw key is shown once:

shell

docker compose -f docker-compose.selfhost.yml exec postgres psql -U sentrinode -d sentrinode -- then, inside psql: select sentrinode_create_tenant('my-team'); select sentrinode_create_api_key('my-team', 'laptop'); -- copy the snk_... it prints; it is not recoverable

What you get: ingest on port 8000, the /v1 API, budgets and alerts. What you don’t: the web dashboard — it authenticates through Supabase Auth, so it is not part of the standalone stack. Read your data through the /v1 endpoints.

B. Full stack, dashboard included — runs Supabase’s own components locally (Postgres, GoTrue, PostgREST) alongside SentriNode, so you get the web dashboard, accounts and row-level security with nothing hosted elsewhere.

shell

# the anon/service keys are JWTs signed with your secret - generate, don't invent python selfhost/generate-keys.py > .env.selfhost-full cat .env.selfhost-full.example >> .env.selfhost-full docker compose -f docker-compose.selfhost-full.yml --env-file .env.selfhost-full up -d --build

Dashboard on :3000, ingest on :8000. Sign up in the UI to create the first account, then set DISABLE_SIGNUP=true so nobody else can. Budget about 4 GB of RAM — nine containers including Postgres and Neo4j.

Where your traces live. Both self-host options write every LLM call to disk as JSON Lines — one file per tenant per UTC day, on the trace_data volume. No database and no cloud account: the in-memory view is only 60 seconds of rates and 24 hours of buckets, and it does not survive a restart, so this is what gives you real history.

shell

# what is there docker compose -f docker-compose.selfhost.yml exec sentrinode-ingest ls -R /data/traces # today's spend for one tenant docker compose -f docker-compose.selfhost.yml exec sentrinode-ingest sh -c "cat /data/traces/my-team/$(date -u +%F).jsonl" | jq -s "map(.cost_usd) | add"

Files are pruned by age and by total size — TRACE_RETENTION_DAYS (30) and TRACE_MAX_TOTAL_MB (2048). The size cap is the one that matters: age alone lets a busy month fill the disk, and a full volume stops ingestion.

C. With hosted Supabase — the same stack the hosted product runs, including Neo4j and the graph API. Needs a Supabase project with the migrations in supabase/migrations/ applied.

shell

cp .env.example .env # fill in your Supabase values docker compose -f docker-compose.hetzner.yml up -d --build

New to this? The self-hosting guide has a four-step walkthrough, plus configuration, backups and troubleshooting.

The repository is currently private — email support@sentrinode.com for access before either option.