yuezhiai/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

If you find value in Jonex, please ⭐ Star the project to support us.

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.

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

• 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

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

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

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.

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.

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.

.\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

make down

On Windows:

.\jonex.ps1 down

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

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

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.

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.

All external APIs are exposed through the unified Gateway.

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 <access_token>" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "What are the key risks described in these documents?",
    "knowledge_base_ids": ["<knowledge-base-id>"],
    "mode": "hybrid",
    "top_k": 5,
    "with_reasoning": true
  }'

The response includes the answer, matched knowledge bases, ontology instances, RAG usage, structured source references, and an optional reasoning trace.

In production, the browser communicates only with Frontend Gateway. Business APIs, capability services, and infrastructure components are not directly exposed to frontend applications.

• RAG-Anything and MinerU can be connected for multimodal content processing and document parsing
• LightRAG can be connected through the graph-enhanced retrieval adapter
• Neo4j and Milvus are packaged graph and vector persistence integrations
• OpenAI-compatible endpoints provide replaceable LLM, embedding, reranking, VLM, and ASR services

• Deploy the Atomic RAG parser with Docker Compose, run it as an independently scaled capability, or register a compatible parser service through a parser profile
• Process video locally with ASR, keyframes, and vision-language models, or route media analysis to a configured cloud service
• Scale parsing workers independently from the core platform; GPU acceleration is optional for model-heavy workloads

• Read CONTRIBUTING.md before opening an issue or pull request.
• Participation is governed by CODE_OF_CONDUCT.md.
• Report vulnerabilities privately according to SECURITY.md; do not include vulnerability details in a public issue.
• See CHANGELOG.md for release notes and compatibility changes.

This repository is licensed under the Jonex Open Source License, based on Apache License 2.0 with additional conditions. Third-party components remain under their respective licenses; see NOTICE and THIRD_PARTY_NOTICES.md.

Jonex — AI Multimodal Domain Knowledge Engine

Providing enterprise Agents with ontology-powered knowledge services that are reasoning-ready, traceable, and callable.

Enjoying Jonex?

Click ⭐ Star to support us, thank you!

© 2026 JONEX