⬡ ELIXARA

An elixir, historically, was never just a liquid.

It was the product of a slow, deliberate process — raw matter, broken down, refined, reduced, until only the potent essence remained. Alchemists spent lifetimes on this. Not because they lacked intelligence, but because they believed that within ordinary things lived something extraordinary, waiting to be extracted.

Elixara takes that idea and gives it a hard drive.

Somewhere inside your plant's twenty thousand PDFs — the pump manuals no one rereads, the root-cause analysis filed and forgotten, the regulation clause buried on page 47 of a document that predates the current team — lives the actual intelligence of your operation. Not scattered. Not lost. Unextracted.

The -ara suffix carries the aura of that essence once it's freed: legible, searchable, citable, alive. Elixara doesn't manufacture knowledge. It distills what already exists, and gives it a voice.

Industrial plants don't lack information. They drown in it.

A NASSCOM–EY study of Indian heavy manufacturing found an average of 7 to 12 disconnected systems per site, each speaking its own dialect, none listening to the others. McKinsey quantified the cost: 35% of a knowledge worker's time spent not doing the job, but finding what they need to do it.

Run the arithmetic on a plant with 1,000 engineers. 35% is roughly 350 engineer-years, lost annually — not to poor decisions, but to decisions made too slowly, or without the one document that would have made them obvious.

The clock is louder than the fragmentation. An estimated 25% of India's experienced industrial engineers retire within this decade. They carry tribal knowledge that was never written down twice — the "we tried that approach in 2019 and here's exactly why it failed" kind of knowledge. Unlike a server, a retiring engineer cannot be backed up.

Elixara exists because that knowledge cliff is not inevitable. It is a data architecture problem — and data architecture problems, given sufficient care, can be solved.

Treat every document in a plant as a neuron in a single industrial brain.

MinerU extracts the raw signal from the page. The chunker finds where one idea ends and the next begins, and injects structural context before either is ever embedded. nomic-embed-text draws the synaptic connections across 768 dimensions. ChromaDB holds the memory without needing a server. BM25 and dense vector retrieval, fused via Reciprocal Rank Fusion, vote on what's relevant. A cross-encoder reranker double-checks that vote with full joint attention over the query and each candidate passage. phi4-mini — running entirely on your CPU, no cloud, no API key, no monthly bill — synthesizes the relevant fragments into a cited, streamed, honest answer.

No single component here is exotic. The intelligence isn't in any one piece — it's in how deliberately they're wired together, and in the discipline to keep every claim traceable back to a real document, a real page, a real sentence.

Every answer Elixara gives is grounded in a real excerpt, cited inline, with a confidence score attached. You can upvote or downvote answers to continuously calibrate that confidence over time. If the knowledge base genuinely doesn't contain the answer, Elixara says so — explicitly, every time. It does not guess at torque values. It does not paraphrase a safety regulation. It would rather admit ignorance than invent a hazard.

graph TD
    Client[Web Client<br/>React 18 + Vite] <-->|HTTP / SSE| Gateway[API Gateway<br/>Node + Express :4000]

    Gateway <-->|/docs · /upload · /jobs| Ingest[Ingest Service<br/>FastAPI :5001]
    Gateway <-->|/query · /stream| RAG[RAG Service<br/>FastAPI :5002]
    Gateway <-->|/nodes · /edges · /path| Graph[Graph Service<br/>FastAPI :5003]
    Gateway <-->|/scan · /report| Compliance[Compliance Service<br/>FastAPI :5004]

    Ingest -->|Parse + OCR| MinerU[MinerU CLI<br/>CPU pipeline backend]
    Ingest -->|Write metadata + entities| Mongo[(MongoDB)]
    Ingest -->|Store 768-dim vectors| Chroma[(ChromaDB)]

    RAG -->|Cache-aside · TTL 1h| Redis[(Memurai / Redis)]
    RAG -->|Read chunks| Mongo
    RAG -->|Cosine search| Chroma
    RAG -->|Generate + Embed| Ollama[Ollama<br/>phi4-mini · nomic-embed-text]

    Graph -->|BFS + CRUD| Mongo
    Compliance -->|Cross-check each clause| RAG

The data flow, in one breath:

A PDF lands on disk → MinerU produces clean Markdown and a structural map → the chunker respects document headings, injects hierarchical context into each segment before it's embedded → phi4-mini extracts equipment tags, regulation IDs, personnel names, and dates in a single JSON-mode pass → nomic-embed-text encodes each chunk as a 768-dimensional vector using the search_document: prefix that preserves retrieval accuracy most pipelines quietly sacrifice → the graph builder upserts every named entity as a node and every co-occurrence as a weighted edge → the document is now queryable, connected, and cited. Permanently.

Every choice below was made against one hard constraint: runs on a CPU laptop, costs nothing to operate, never phones home.

elixara/
├── .env.example                      ← copy to .env before first run
├── package.json                      ← root orchestration (Windows-adapted)
│
├── frontend/                         ← React 18 SPA
│   └── src/
│       ├── pages/                      12 routes: dashboard · upload · query · graph ·
│       │                               equipment · failures · compliance · maintenance ·
│       │                               analytics · settings · library · login
│       ├── components/                 layout · ui primitives · docs · query · graph · charts
│       ├── store/                      Zustand slices: app · docs · query · graph
│       ├── hooks/                      ingestion polling · SSE streaming · D3 lifecycle
│       └── api/                        thin axios wrappers per domain
│
├── gateway/                          ← Node.js API Gateway :4000
│   ├── routes/                         docs · query · graph · compliance · health · auth
│   └── middleware/                     JWT auth · multer upload · morgan logging
│
└── services/                         ← Python microservices
    ├── shared/                         config · mongo · chroma · ollama_client · models
    ├── ingest_service/    :5001        MinerU → chunk → NER → embed → graph build
    ├── rag_service/       :5002        dense + BM25 + RRF → rerank → stream
    ├── graph_service/     :5003        node/edge CRUD · BFS pathfinder
    └── compliance_service/ :5004       regulation DB · RAG-backed gap scan

Install these once, before touching the project folder. MongoDB, Memurai, and Ollama each register as background Windows services or processes — you will not restart them manually every session.

Pull both required models once (~2.7GB total):

ollama pull phi4-mini
ollama pull nomic-embed-text

On where you build this. Avoid hosting the project inside a OneDrive-synced folder. OneDrive attempts to sync every file the moment venv or node_modules creates it — producing intermittent file-lock errors during pip install. If you hit unexplained permission errors, move the project to C:\dev\elixara and the problem disappears.

Every command below assumes you're in the elixara\ project root, in a PowerShell terminal. VS Code's integrated terminal is fine.

git clone <your-repo-url> elixara
cd elixara

Copy-Item .env.example .env

The defaults already point at localhost for MongoDB, Memurai, and Ollama. No edits required for local development.

MinerU carries heavy dependencies (PaddleOCR, ONNX Runtime), so it lives in a dedicated environment outside the project's own venvs:

python -m venv $HOME\.mineru_env
C:\Users\<you>\.mineru_env\Scripts\Activate.ps1

Use the full explicit path rather than $HOME when activating — the $HOME-prefixed form can pick up invisible characters on copy-paste in PowerShell that silently break the command. If PowerShell refuses with "execution of scripts is disabled", run this once and retry: Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

pip install "mineru[core]"

MinerU 3.x downloads its parsing models automatically on first real use. Trigger that download now, deliberately, with a real PDF:

mineru -p "C:\path\to\any\test.pdf" -o C:\temp\mineru_test -b pipeline

The first run pulls roughly 1GB of models (layout detection, OCR, table recognition) and can take 5–15 minutes. Every subsequent run is fast. Confirm it worked:

Get-ChildItem -Recurse C:\temp\mineru_test -Filter *.md

Output structure note. MinerU 3.4 nests output one level deeper than older documentation describes — <output_dir>\<filename>\auto\<filename>.md, not directly under <filename>\. The codebase already searches recursively with rglob("*.md"), so no code change is needed.

Exit the environment and add MinerU permanently to your PATH:

deactivate
[Environment]::SetEnvironmentVariable("Path", $env:Path + ";$HOME\.mineru_env\Scripts", "User")

Fully close and reopen VS Code — not just a new terminal tab. PATH changes only take effect after a full application restart. Then verify:

mineru --version

npm install

cd frontend && npm install && cd ..
cd gateway  && npm install && cd ..

MinerU 3.4 pulls in gradio as an optional dependency, which requires newer fastapi and python-multipart than the original pins. Open services\shared\requirements.txt and confirm:

fastapi>=0.115.2
python-multipart>=0.0.18

If they still show exact pins, loosen them — otherwise pip install will fail with a ResolutionImpossible error.

ingest_service:

cd services\ingest_service
python -m venv .venv
.\.venv\Scripts\pip.exe install -r requirements.txt
cd ..\..

rag_service — install CPU-only PyTorch before the requirements file, or sentence-transformers will pull a CUDA build:

cd services\rag_service
python -m venv .venv
.\.venv\Scripts\pip.exe install torch==2.3.1+cpu --index-url https://download.pytorch.org/whl/cpu
.\.venv\Scripts\pip.exe install -r requirements.txt
cd ..\..

graph_service and compliance_service:

cd services\graph_service
python -m venv .venv && .\.venv\Scripts\pip.exe install -r requirements.txt
cd ..\..

cd services\compliance_service
python -m venv .venv && .\.venv\Scripts\pip.exe install -r requirements.txt
cd ..\..

mongosh --eval "db.runCommand({ ping: 1 })"
memurai-cli ping
ollama list

If Ollama shows no models, pull phi4-mini and nomic-embed-text as listed in Prerequisites. If Memurai doesn't respond, open services.msc and confirm the Memurai service is set to Running.

From the project root, one command starts everything — frontend, gateway, and all four Python microservices, concurrently:

npm run dev:all

Give it a few seconds. You're looking for six clean startup lines with no traceback beneath any of them:

[dev:frontend]   VITE ready
[dev:gateway]    ⬡  Elixara Gateway running on :4000
[dev:ingest]     Uvicorn running on http://127.0.0.1:5001
[dev:rag]        Uvicorn running on http://127.0.0.1:5002
[dev:graph]      Uvicorn running on http://127.0.0.1:5003
[dev:compliance] Uvicorn running on http://127.0.0.1:5004

Then open:

Demo login: demo / elixara2024 — or hit ⚡ Judge Demo Access for an instant token.

python scripts\seed_demo.py

Uploads sample PDFs through the full ingestion pipeline. If demo_docs\ doesn't exist yet, add your own PDFs first — or drag files directly onto the Upload page in the running app.

python scripts\check_health.py

Or open the Settings page inside the app (http://localhost:5173/settings) — it live-polls every service and Ollama itself, showing a green or red dot with latency for each.

A fully healthy stack:

{
  "ingest":     { "status": "ok" },
  "rag":        { "status": "ok" },
  "graph":      { "status": "ok" },
  "compliance": { "status": "ok" },
  "ollama":     { "status": "ok" }
}

There is something almost stubborn about the idea at the center of this project.

Not that the problem is hard — though it is. Not that the technology is novel — though it is assembled carefully. But that the answer was already there. Not behind a paywall. Not requiring a new sensor, a new survey, a new budget line. Buried, instead, under the ordinary weight of twelve disconnected systems and a PDF nobody has opened since the inspection that produced it.

I built Elixara because I kept thinking about those retiring engineers — the ones who carry in their heads the reason a particular pump keeps failing, the way a particular regulation intersects with a particular equipment class, the shortcut that saved three hours the last time this exact alarm fired. When they leave, that knowledge doesn't get archived. It evaporates.

Elixara doesn't claim to know more than your engineers do. It claims to remember what they already knew, and to say it back the moment someone needs it — with the receipt attached, every time, so that trust is never asked for without being earned.

The plant already has a brain. Elixara is how it finally speaks.

Distributed under the MIT License. See LICENSE for details.