JurisNode Vault

SPDX-License-Identifier: Apache-2.0

Overview

JurisNode Vault is an offline local AI document analysis prototype for attorneys, legal technologists, and developers. It runs a local FastAPI backend, SQLite database, React frontend, and optional local Ollama models so users can inspect, adapt, and run the system on trusted local hardware.

The project uses fictional dummy legal data by default. It is intended as an open source starting point for private internal experimentation, not as a legal advice product or production compliance system.

What JurisNode Vault Does

JurisNode Vault ingests plain-text documents, stores them locally, splits them into searchable chunks, retrieves relevant passages, and returns document-grounded responses. When local Ollama is running, the project can use configured local models for generation and embeddings. No external APIs are required by the project.

Who This Is For

• Attorneys and legal professionals evaluating local AI-assisted document workflows.
• Legal technologists prototyping private document vaults.
• Developers studying offline retrieval-augmented generation patterns for legal text.
• Law firms that want a codebase they can inspect and adapt before any internal review.

Important Legal Disclaimer

JurisNode Vault does not provide legal advice, does not replace attorney judgment, and does not create an attorney-client relationship. Users must not rely on AI output as legal advice. Attorneys must independently verify every output against the source documents, controlling law, court rules, procedural requirements, and professional obligations.

The author provides no warranty and accepts no liability for legal outcomes, compliance failures, confidentiality breaches, privacy issues, court filing errors, hallucinations, model outputs, misuse, or any other consequence of using or modifying this project.

Privacy First Design

The default architecture is local-first. Documents, database records, retrieval chunks, and model calls stay on the user's machine when Ollama, the backend, the database, and documents are kept on trusted local hardware. Privacy depends on the user preserving that local boundary and securing the host environment.

No Cloud Requirement

No OpenAI, Anthropic, Google, or other hosted model API is required or used by default. The project does not require external API keys.

Local Ollama Requirement

For local model-backed answers, install Ollama and pull the configured models:

ollama pull gemma4:e4b
ollama pull gemma4:e2b
ollama pull embeddinggemma:latest

The backend expects Ollama at http://localhost:11434 unless OLLAMA_BASE_URL is changed.

Dummy Data Notice

All included legal files are fictional dummy data. They are not real client files, real pleadings, real legal advice, or real case records. Replace or remove sample data before adapting the project for any private internal use.

Attorney Responsibility

Attorneys and law firms are fully responsible for privilege, confidentiality, client consent, data security, retention, deletion, audit logging, access controls, encryption, regulatory compliance, professional responsibility rules, court rules, local AI rules, privacy laws, and technology competence duties.

Features

• Local FastAPI backend.
• Local SQLite storage.
• React and Vite frontend.
• Dummy legal document seeding.
• Document upload and indexing.
• Local retrieval over document chunks.
• Chat history stored locally.
• Optional local Ollama generation.
• No raw SQL endpoint or shell execution endpoint.
• Pytest coverage for core backend behavior.

Architecture

• backend/: FastAPI server, database schema, document store, seed script, and Ollama client.
• frontend/: React TypeScript Vite application.
• sample_documents/: fictional dummy legal documents.
• data/: default local SQLite database location after seeding.
• tests/: backend tests.
• docs/: architecture, security, roadmap, and local model notes.

What Attorneys Can Do With It

Attorneys can use the prototype to inspect local AI workflows, review dummy pleadings, summarize internal notes, organize case facts, search uploaded text, draft internal research notes, compare document sections, extract timelines, prepare issue lists, review contract clauses, and evaluate whether a private document vault is worth developing further.

What Attorneys Should Not Do With It

Attorneys should not treat model output as legal advice, file AI-generated text without independent review, upload confidential documents before security review, expose the backend to the public internet, use it as a substitute for legal research platforms, or rely on it as a compliance-certified system.

Installation Summary

Install Python 3.11 or 3.12, Node.js LTS, Git, and Ollama. Then clone the repository, install Python and Node dependencies, seed dummy data, run the backend, and run the frontend.

Windows Installation

See WINDOWS_INSTALL.md for a complete Windows 11 walkthrough, including Git, Python, Node.js, Ollama, model pulls, backend setup, frontend setup, and troubleshooting.

Linux Development Installation

git clone https://github.com/dotdigitize/jurisnode-vault.git
cd jurisnode-vault
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
npm install

Install Ollama separately and pull the local models listed above if you want model-backed generation.

Running the Backend

source .venv/bin/activate
uvicorn backend.server:app --host 127.0.0.1 --port 8000

The API runs at http://127.0.0.1:8000.

Running the Frontend

In a second terminal:

npm run dev

Open http://localhost:5173.

Seeding Dummy Data

source .venv/bin/activate
python -m backend.seed_data

This loads fictional files from sample_documents/ into the local SQLite database.

Testing

source .venv/bin/activate
python -m pytest
npm run build

Using Local Models

The default model configuration is:

OLLAMA_BASE_URL=http://localhost:11434
CHAT_MODEL=gemma4:e4b
WORKER_MODEL=gemma4:e2b
EMBED_MODEL=embeddinggemma:latest

You can change these values in .env after copying .env.example.

Security Model

JurisNode Vault is local-only by default. The backend is intended to bind to localhost, SQLite stores data locally, and Ollama runs locally. The project does not expose raw SQL endpoints, shell execution, or cloud API integrations by default.

This is not a complete security program. Users are responsible for host security, filesystem permissions, database encryption, backups, deletion, audit requirements, access controls, network exposure, and review before use with privileged or confidential documents.

Limitations

• Prototype quality retrieval and ranking.
• No authentication or multi-user authorization.
• SQLite is unencrypted by default.
• Plain-text document support is the primary path.
• Local model outputs can be inaccurate, incomplete, hallucinated, outdated, or jurisdictionally wrong.
• No guarantee of legal accuracy, procedural compliance, confidentiality, privacy, or fitness for any use.

Roadmap

• Stronger document parsing.
• Configurable embedding providers that preserve local-only operation.
• Better matter management and metadata.
• Optional authentication for local firm deployments.
• Audit logging and export tools.
• Expanded tests and security review notes.
• Desktop packaging with a local sidecar.

License

JurisNode Vault is open source under the Apache License 2.0. See LICENSE.