Ragner: Enterprise AI Decision-Intelligence Workspace

Ragner is an enterprise AI decision-intelligence workspace. People ask in natural language. The system searches the organization's own knowledge—documents, connectors, a knowledge graph, and governed metrics—and returns an answer with citations. When the question needs it, the same turn can traverse relationships, read approved numbers, or show a prediction card from a trained trend model.

This article is the wide view: what the product is, how a question becomes an answer, how knowledge and identity are bounded, and where the honest limits sit.

Ragner is built by Dev Forge. You can run it on your own infrastructure or as a managed service.

What problem it is built for

Enterprise knowledge is scattered: files, wikis, tickets, databases, and APIs. Generic AI chat is fluent when it has evidence and fluent when it does not. Sponsors then cannot tell a grounded claim from a confident guess.

Ragner is built so that:

Retrieval stays inside the caller's tenant, active role, and attribute slice of the corpus.

Every claim the model is allowed to make can be opened as a citation.

When hybrid search finds no usable evidence, the turn refuses instead of inventing.

Cheap lookups and expensive agent work are routed from the question itself, before HyDE, paraphrases, or extra tools run.

It is not a chatbot glued to a search box. Isolation, grounding, governance, and an evaluation loop are part of the product.

Who uses it

An account has one or more roles per organization (tenant). In the top bar you pick Organization and Role. The UI shows only what the active role allows. Switching role updates permissions immediately; you do not sign out. The API does not trust the header blindly: you can voluntarily act as a lower role, but you cannot elevate past what the JWT or API key already grants.

Viewers ask and read. Analysts curate knowledge and inspect quality. Admins connect sources, set policy, and run evaluations.

How a question becomes an answer

A Workspace turn is a graph of stages, not an unconstrained loop. The browser streams SSE events (progress, step, token, complete, error). You can hover agent router after a turn to see the intensity and path the server chose.

1. Identity and tenant. Sign-in is OIDC (Keycloak). Each API call resolves a tenant after authentication. PostgreSQL row-level security plus composite tenant keys keep rows from leaking across organizations.

2. Query routing (question only). Before expensive retrieve, a bilingual router maps flags on the question text to intensity—not exclusive product labels. Lite intensity handles lookups with no graph, SQL, prediction, or dependent-chain language. Standard intensity handles graph, SQL, or prediction language. Deep intensity handles cases where a later tool must consume an earlier tool's result.

3. Hybrid retrieval. Connectors and uploads become versioned documents. Structure-aware chunking produces parent sections and retrieval-sized children. Vectors in pgvector run concurrently with sparse search (Okapi BM25 by default). Reciprocal-rank fusion, optional personalization from citation feedback, and a cross-encoder reranker produce the evidence set. Surviving child hits can auto-merge to the parent section so the model sees a full heading, not a truncated window.

4. Allow-listed tools. The agent may call only: hybrid_search (unstructured knowledge), graph_impact (dependency and ownership traversal), sql_analytics (parameterized, read-only, tenant-bound views), ml_prediction (trend-model forecasts), rest_api (tenant allow-listed connections), and workflow_action (HTTPS webhooks after synthesis, with a one-time approval token).

5. Grounding and synthesis. Policy clamps citations to retrieved sources, compresses evidence into a context budget, and streams tokens from the configured LLM (OpenAI-compatible or Anthropic, with an independent fallback). If there is no usable evidence, the turn fails closed. Optional faithfulness and Self-RAG critique can regenerate. Finalized chats can insert a quality row for Insights.

6. Feedback. Thumbs up / thumbs down on the answer and on each citation feed personalized ranking and org-wide document weights—applied at query time without re-embedding.

Knowledge: one corpus with provenance

Analysts upload PDF, Word, and Excel, or admins sync connectors: bounded website crawls, GitHub / GitLab / Bitbucket, Confluence, JDBC read replicas (PostgreSQL, MySQL, SQL Server, Oracle), REST / OpenAPI GET allow-lists, IMAP, and other catalog types. Credentials are encrypted at rest and never returned in API JSON. Egress is HTTPS-first with SSRF protections.

Documents carry allowed roles (Viewer / Analyst / Admin overlap) and optional required attributes (project, department, clearance, team, custom keys). A connector can stamp the same attribute map onto every synced file until an analyst overrides it.

The Knowledge library still lists tagged files so analysts can edit tags. Chat, Search preview, graph evidence, and suggestion seeds do not. That split is deliberate: hide at retrieve, not at curate.

Relationships, numbers, and "what's next"

Paragraph search is not enough for "what depends on this service?" or "what happened in Q2?" or "what is likely next quarter?"

Knowledge graph. Services, people, projects, and technologies sit in a tenant graph beside chat. Optional GraphRAG community summaries and per-document RAPTOR trees help abstract questions retrieve a synthesized node instead of dozens of chunks.

Governed SQL. Metric definitions are read-only and bound to tenant id. JDBC catalog profiling helps admins decide what is safe to expose. There are no unsupervised writes to production databases.

Predictive intelligence. A dedicated prediction service trains trend models on tenant-aggregate history (sales, churn). Confidence comes from the model's own fit—residual intervals, walk-forward MAPE, staging to production promote—not from confident phrasing. Per-entity cards appear only when entity history exists. High-priority recommendations may suggest a workflow; they never auto-run it.

Memory that outlives one chat

A named investigation attaches several Workspace sessions over days or weeks. It keeps a rolling brief and key findings, and it boosts pinned or previously cited documents in retrieval. After each recorded turn, a Chain-of-Density rewrite keeps the brief short while fusing missing entities—no summary bloat, no invented facts.

Security, in layers

Ragner does not treat "the model promised" as an access control.

1. Tenant isolation. Composite keys and PostgreSQL RLS. Identity is hybrid realm-per-tenant: tokens from /realms/{org-slug} cannot select another organization.

2. Active role. Viewer / Analyst / Admin from signed tenant_roles (or API-key configuration). X-Active-Role is client-declared and server-validated.

3. Document allowed roles. A file can be limited to some of those three roles. Empty roles stay tenant-wide.

4. Document ABAC. JWT access_attributes plus optional extra claims (project, department, clearance, team, classification) are matched against document required_attributes. AND across keys, OR within a key. Clearance uses a lattice: public < internal < confidential < secret < top-secret. Empty document attributes mean no extra restriction. API keys have no attributes and cannot retrieve tagged documents.

Both allowed roles and ABAC must pass. Fail-closed: missing user attributes hide a tagged document from retrieve.

Governance and residency

Admins set region policy, remote-AI toggles, and an effective-policy preview. Residency rules can block remote LLM, embeddings, and rerankers; local and deterministic fallbacks apply so a constrained region still answers instead of hanging. REST and workflow actions can require a human approval token. Append-only tenant audit events record tool use.

Measuring whether it works

Insights tracks queries, grounded rate, latency, and feedback. Administration runs golden evaluation datasets (full pipeline or retrieval-only), quality gates, and promotion of production feedback into test cases. Scorers include deterministic claim support plus optional RAGAS-native and TruLens-native judges. Org-wide citation learning raises documents that help and lowers noisy false positives—without re-embedding.

The improvement loop is: ship connectors → monitor → add eval cases → tune retrieval.

What Ragner will not do

These are product boundaries, not a backlog disguised as humility.

No unsupervised writes to production databases. SQL tools are read-only and tenant-bound.

No invented facts when retrieval finds no usable evidence.

Residency policy can block remote models; local fallbacks apply.

REST and workflow actions can require a one-time human approval.

Viewers cannot elevate past JWT or API-key roles via headers or prompt tricks.

Predictions are tenant-aggregate rates by default—not invented per-employee or per-customer scores.

Lite intensity still searches; it does not skip the corpus to save a round trip.

Technical foundation

A deployable reference stack, not slideware. Web: React + TypeScript, SSE streaming chat, resizable analyst / graph layout. API: Java 21 Spring Boot, OIDC (Keycloak), tenant-scoped API keys. Workers: Kafka for ingestion, connector sync, evaluations, retrieval learning. Data: PostgreSQL + pgvector with RLS; Redis for limits, caches, and tool approvals. Ops: Flyway migrations, Actuator health, Prometheus metrics, OTLP tracing hooks. Models: OpenAI-compatible embeddings and LLM; optional Anthropic; local fallbacks. Forecasts: Native Java trend models, feature store, model registry; optional MLflow.

Pilot on Docker Compose. Harden on Kubernetes with documented migrations, network policies, and observability. Commercial path: discovery → pilot with measurable criteria → production hardening → continuous optimization.

Conclusion

Ragner brings enterprise-grade AI decision-intelligence to organizations that need grounded, governed, auditable answers from their own knowledge. By combining hybrid retrieval, role-based access control, attribute-based document filtering, and a staged agent architecture, it ensures that every answer is traceable to its sources, that knowledge stays within proper boundaries, and that the system fails closed rather than inventing facts. For enterprises building on AI, Ragner is the foundation that turns scattered knowledge into reliable, decision-ready intelligence.