OmniMind — UI Showcase

Architecture

A real system diagram, rendered live in your browser (not a static image) — the actual shape of how a request moves from the browser down to the local model and back.

flowchart TD
    WEB["Next.js Frontend"] --> ING["Kubernetes Ingress"]
    ING --> AUTH

    subgraph API["Backend API — four-layer bounded contexts"]
        AUTH["Identity and Auth
JWT, RBAC: owner / admin / member / viewer"]
        CHAT["Conversation
streaming chat"]
        RAGC["RAG
upload, chunk, embed, hybrid retrieve, rerank, cite"]
        SEARCH["Federated Search
internal documents + live web, fused"]
        AGENT["Agent Orchestration
ReAct loop, Supervisor + specialist agents"]
        GATEWAY["Model Gateway
provider router, circuit breaker"]
    end

    AUTH --> CHAT & RAGC & SEARCH & AGENT
    CHAT --> GATEWAY
    RAGC --> GATEWAY
    SEARCH --> GATEWAY
    AGENT --> GATEWAY

    GATEWAY -->|local, $0| OLLAMA["Ollama
local model"]
    GATEWAY -.->|optional fallback| CLOUD["Cloud providers
optional"]

    subgraph Guard["Security Layer"]
        INJ["Prompt-Injection Detection
neutralizes untrusted tool output"]
        PII["PII Redaction
applied to every log line"]
    end
    AGENT <--> INJ

    subgraph Ingestion["Event-Driven Ingestion"]
        OUTBOX["Outbox"] --> KAFKA["Kafka"] --> WORKER["Worker
extract, chunk, embed, index"]
    end
    RAGC --> OUTBOX

    subgraph Data["Data Layer"]
        PG[("PostgreSQL")]
        VEC[("Vector Store")]
    end
    AUTH --> PG
    CHAT --> PG
    AGENT --> PG
    RAGC --> VEC
    WORKER --> VEC
    WORKER --> PG

    subgraph Infra["Infrastructure"]
        K8S["Kubernetes / Helm"]
        OBS["Prometheus + Grafana"]
    end
    K8S -.->|deploys| API
    K8S -.->|deploys| Ingestion
    OBS -.->|scrapes| API

How it's built

A high-level look at what's actually running behind these screens — a real system, not a demo shim.

Local-first inference

Every chat/RAG/agent response is generated by a locally-hosted open model (Ollama), not a cloud API — no data leaves the machine, and there's a multi-provider router with automatic fallback if a paid provider is ever added.

Agentic coding, safely

A companion process on your own machine connects a real project over an outbound WebSocket. Path containment and the blocked-command list are enforced there, not server-side, so the agent can never reach outside the folder you connected — and every write and every shell command needs an explicit human approval first.

Hybrid retrieval

Documents are chunked, embedded, and indexed in a vector store, then retrieved via a fusion of vector similarity and lexical (BM25) search, re-ranked by a cross-encoder, and cited claim-by-claim in the final answer — never an unverified summary.

Federated search

The same retrieval pipeline is fused with live, self-hosted web search, so one answer can cite both a private document and a real web source side by side.

Multi-agent orchestration

A ReAct-style agent loop calls tools (retrieval, calculation, web search) as many times as a goal needs, with every reasoning step persisted and visible — including a Supervisor mode that delegates subtasks to specialist agents.

Event-driven ingestion

Document processing runs as an asynchronous saga over Kafka (outbox pattern, idempotent consumers, dead-letter queue on failure) — uploads return instantly and index in the background.

Multi-tenant RBAC

Organizations can have multiple users with different roles (owner, admin, member, viewer). Role-gated actions are enforced server-side with real 403s — demonstrated below with real API responses, not a mockup.

Security hardening

Deterministic prompt-injection detection neutralizes suspicious instructions found in retrieved content before they ever reach the model, and PII is redacted from logs automatically.

Observable & containerized

Request latency, LLM cost, and agent step counts are scraped into Prometheus and visualized in Grafana. The whole stack deploys via Helm to a Kubernetes cluster, not just Docker Compose.

Walkthrough

Every screenshot below is a real, unedited capture of the app actually running — real login, real document, real model responses, real agent trace.

Auth

Sign in

Email/password auth issuing a short-lived JWT carrying the user's organization and role as claims — the same claims every role-gated endpoint checks server-side.

Auth

Create an account

Registering creates a brand-new organization with the registering user as its owner — the seed of that org's tenant. Every subsequent teammate joins this same organization via invite, shown further down.

Chat

Streamed conversation

A real question answered by the local model, token-streamed over Server-Sent Events — the exact model named in the header (qwen2.5:7b) generated this response on this machine.

OmniMind documents panel with a cited RAG answer

RAG

Ask your documents

A PDF was uploaded, chunked, embedded, and indexed — this answer is grounded entirely in that document, with a per-claim citation resolving back to the exact page and a real reranker relevance score.

OmniMind federated search combining internal documents and the live web

Documents + the live web, fused

One answer, two source kinds: a fact from the uploaded document sits alongside real, live results from a self-hosted web search — fused by reciprocal rank fusion and re-ranked together, not just concatenated.

Agent

Visible multi-step reasoning

Given a goal, the agent decided on its own to search the document first, then pipe the retrieved number into a calculator tool — every step logged and shown, not hidden behind a single black-box response.

Grafana dashboard showing live OmniMind metrics

Observability

Real metrics, not vanity numbers

Request latency, LLM cost, and per-agent step counts, scraped straight out of the running API and rendered live — the same traffic from every screen above is what produced this graph.

Coding agent — it changes real files on your machine

A local companion process connects a project on your own laptop over an outbound WebSocket, so nothing has to be exposed. The agent reads and searches that project, proposes surgical patches and commands — and nothing touches disk until you approve it. The security boundary is enforced on your machine, not on the server.

Coding

Explore, then patch — not rewrite

The agent listed the project, read package.json line-numbered, and proposed replacing one exact snippet. Only the react line changes; formatting and every other dependency survive byte-for-byte. Rewriting whole files is refused outright, because a model regenerating a file it was only asked to edit is how formatting gets destroyed.

A rejected patch showing no changes were made, and a pending shell command awaiting Approve and Run

Human in the loop

Every write and every command is gated

Reject and the file is untouched — the transcript says so explicitly. Shell execution is opt-in per connection, needs a separate approval each time, and a denylist of catastrophic commands is re-checked on your own machine regardless of what the server decided.

$ omnimind-code --root ~/projects/task-scheduler --enable-commands › Run app.js with node. If it fails, fix the cause and run it again until it works. ⏺ read_file(app.js) 1| const nums = [1, 2, 3, 4, 5]; 2| const total = nums.reduce((a, b) => a + b, 0); 3| console.log("Sum:", totl); ⏺ run_command(node app.js) ReferenceError: totl is not defined ✗ exit code 1 … continuing automatically (round 1/4) ⏺ propose_file_patch(app.js) -console.log("Sum:", totl); +console.log("Sum:", total); ✓ applied to app.js ⏺ run_command(node app.js) Sum: 15 ✓ exit code 0 … continuing automatically (round 2/4) Everything now works as expected.

Terminal

One engine, two front-ends

The same agent drives a terminal client, omnimind-code, over the identical API the browser uses — so a session started in one continues in the other. This is a real transcript: one typed goal, and it ran the file, read the actual ReferenceError, patched the cause, re-ran it, and stopped once the exit code was 0. Long-running commands like npm start are started as background processes whose logs the agent can read, which is what makes "run this project" work at all.

Multi-tenant RBAC, proven with real requests

There's no dedicated "team management" screen yet — this is enforced entirely server-side. Here's the real, unedited API exchange: an owner invites a teammate into the same organization, and that teammate's role is genuinely checked before every gated action.

# owner invites a teammate — a one-time password is returned exactly once POST /v1/organization/members → {"user": {"email": "teammate@omnimind.example", "role": "viewer", "organization_id": "af870ed2-e4a0-4a36-a2fc-13abfcd8ec14"}, ...} # listing members shows both users under the exact same organization_id GET /v1/organization/members → [{"email": "demo@omnimind.example", "role": "owner", "organization_id": "af870ed2-...ec14"}, {"email": "teammate@omnimind.example", "role": "viewer", "organization_id": "af870ed2-...ec14"}] # the teammate logs in for real, then tries an owner-only action GET /v1/organization/members (as teammate) → HTTP 403 → {"error": {"code": "authorization_error", "message": "This action requires one of roles ('owner', 'admin'); your role is 'viewer'."}}