jonex

AI Multimodal Domain Knowledge Engine Built for Enterprise Agents · Powered by the Dual Engines of Jonex Wiki and Graph Ontology

English | 中文

Overview | Quick Start | Local Development | API Quickstart | Integration profile | Document and video parsing | Runtime requirements | Community & Security | License

---

Overview

Jonex unifies an all-in-one multimodal parsing engine with an AI-ready knowledge engine. Ontology compiles domain reasoning into the knowledge layer before retrieval begins.

It is an end-to-end enterprise AI knowledge platform that turns raw content into reusable knowledge services. Jonex connects data ingestion, multimodal parsing, domain knowledge compilation, vector and graph indexing, source-grounded retrieval, feedback loops, and business applications in one governed system.

Quick Start

Docker Compose is the fastest way to run the complete platform.

Docker requirements

• Docker Engine or Docker Desktop
• Docker Compose v2 with Buildx
• make on macOS or Linux
• Sufficient disk space and time for the first build, which downloads container images, Python dependencies, and RAG models

1. Clone the repository

git clone https://github.com/yuezhiai/jonex.git
cd jonex

2. Initialize configuration

make init

This creates:

• deploy/.env for the platform, database, object storage, and LLM Gateway
• deploy/.env.rag for LightRAG, embeddings, and parsing
• deploy/.env.mcp for the MCP server
• Frontend .env files for Shell, Core Business, Ecosystem Management, Platform Management, and Dev Gateway

3. Configure model connections

Configure at least one OpenAI-compatible LLM and embedding provider in deploy/.env:

LLMGW_UPSTREAM_LLM_HOST=https://your-openai-compatible-host/v1
LLMGW_UPSTREAM_LLM_API_KEY=your_llm_api_key

LLMGW_UPSTREAM_EMBED_HOST=https://your-embedding-host/v1
LLMGW_UPSTREAM_EMBED_API_KEY=your_embedding_api_key

If your model names differ from the defaults, update the matching LLM_MODEL / EMBEDDING_MODEL keys — they are defined in both deploy/.env and deploy/.env.rag, and EMBEDDING_MODEL must be kept identical in the two files (it is used to build the vector index).

Keep LIGHTRAG_API_KEY identical in deploy/.env and deploy/.env.rag. For audio, video, or advanced image processing, also configure the VLM and ASR connections in deploy/.env.

4. Build and start

make build
make up
make ps

The first build creates the shared jonex/python-base:local image before Compose builds the platform services in parallel.

Use make logs to follow service logs when troubleshooting; press Ctrl+C to stop following them without stopping the platform.

5. Open Jonex

Visit:

http://localhost/

Local demo credentials:

Username: admin
Password: admin123
Tenant: tenant_jonex_demo

Security warning: These credentials are for local evaluation only. Change or remove the default administrator account before binding Jonex to a non-loopback interface, sharing the deployment, or exposing it to any network. Complete the production checklist in SECURITY.md before deployment.

Windows PowerShell

.\jonex.ps1 init
.\jonex.ps1 build
.\jonex.ps1 up
.\jonex.ps1 ps

Use .\jonex.ps1 logs when you need to follow service logs.

If script execution is restricted:

powershell -ExecutionPolicy Bypass -File .\jonex.ps1 help

Stop the platform

make down

On Windows:

.\jonex.ps1 down

Local Development

Local development uses root-level environment files and VSCode Debug. It is separate from the Docker deployment configuration under deploy/.

Toolchain requirements

• Python >=3.12.13
• Node.js >=20.18.0 (Node.js 22 LTS recommended)
• pnpm >=9.0.0
• A current stable version of uv

Initialize the local environment

cp .env.local.example .env.local
cp .env.rag.local.example .env.rag.local
mkdir -p .vscode
cp docs/examples/launch.json.example .vscode/launch.json
make frontends-install

Set local middleware addresses in .env.local to 127.0.0.1, or replace SERVER_IP with a remote infrastructure host. Backend processes are started from VSCode Run and Debug; the Makefile no longer starts host backend processes.

Start the required local dependencies:

make dev-infra-up  # PostgreSQL, Redis, etcd, MinIO, and Milvus
# Or, when running the complete RAG stack locally:
make dev-deps-up   # Middleware plus LightRAG and Atomic RAG

Start the frontend gateway and applications in separate terminals:

make dev-gateway
make dev-frontend

Open http://localhost:8080.

Your First Knowledge Search in Five Minutes

1. Sign in with the local demo credentials admin / admin123 in the demo tenant tenant_jonex_demo.
2. Open Core Business and create or select a domain space.
3. Create a knowledge base and organize it with folders or tags.
4. Select a parser profile or preset for the content you plan to ingest.
5. Upload files, or configure a REST API or S3-compatible data source.
6. Wait for multimodal parsing and knowledge compilation to finish.
7. Inspect the parsing results, compiled ontology, relationships, and knowledge graph.
8. Open Knowledge Search, ask a question, verify its references, and submit feedback.

API Quickstart

All external APIs are exposed through the unified Gateway.

Sign in

curl -X POST "http://localhost/api/v1/auth/login" \
  -H "Content-Type: application/json" \
  -H "X-Tenant-ID: tenant_jonex_demo" \
  -d '{"username":"admin","password":"admin123"}'

Use the returned access_token to call ontology-first search:

curl -X POST "http://localhost/api/v1/knowledge-base/search/ontology" \
  -H "Authorization: Bearer