Instructions to use FerrellSyntheticIntelligence/JEDI with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use FerrellSyntheticIntelligence/JEDI with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="FerrellSyntheticIntelligence/JEDI")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("FerrellSyntheticIntelligence/JEDI", dtype="auto")

llama-cpp-python

How to use FerrellSyntheticIntelligence/JEDI with llama-cpp-python:

# !pip install llama-cpp-python

from llama_cpp import Llama

llm = Llama.from_pretrained(
	repo_id="FerrellSyntheticIntelligence/JEDI",
	filename="model/LFM2.5-1.2B-Instruct-Q4_K_M.gguf",
)

llm.create_chat_completion(
	messages = [
		{
			"role": "user",
			"content": "What is the capital of France?"
		}
	]
)

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

How to use FerrellSyntheticIntelligence/JEDI with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M
# Run inference directly in the terminal:
./llama-cli -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M
# Run inference directly in the terminal:
./build/bin/llama-cli -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M

Use Docker

docker model run hf.co/FerrellSyntheticIntelligence/JEDI:Q4_K_M

LM Studio
Jan

vLLM

How to use FerrellSyntheticIntelligence/JEDI with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "FerrellSyntheticIntelligence/JEDI"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "FerrellSyntheticIntelligence/JEDI",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/FerrellSyntheticIntelligence/JEDI:Q4_K_M

SGLang

How to use FerrellSyntheticIntelligence/JEDI with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "FerrellSyntheticIntelligence/JEDI" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "FerrellSyntheticIntelligence/JEDI",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "FerrellSyntheticIntelligence/JEDI" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "FerrellSyntheticIntelligence/JEDI",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Ollama
How to use FerrellSyntheticIntelligence/JEDI with Ollama:
```
ollama run hf.co/FerrellSyntheticIntelligence/JEDI:Q4_K_M
```

Unsloth Studio

How to use FerrellSyntheticIntelligence/JEDI with Unsloth Studio:

Install Unsloth Studio (macOS, Linux, WSL)

curl -fsSL https://unsloth.ai/install.sh | sh
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for FerrellSyntheticIntelligence/JEDI to start chatting

Install Unsloth Studio (Windows)

irm https://unsloth.ai/install.ps1 | iex
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for FerrellSyntheticIntelligence/JEDI to start chatting

Using HuggingFace Spaces for Unsloth

# No setup required
# Open https://huggingface.co/spaces/unsloth/studio in your browser
# Search for FerrellSyntheticIntelligence/JEDI to start chatting

How to use FerrellSyntheticIntelligence/JEDI with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M

Configure the model in Pi

# Install Pi:
npm install -g @mariozechner/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "FerrellSyntheticIntelligence/JEDI:Q4_K_M"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Hermes Agent new

How to use FerrellSyntheticIntelligence/JEDI with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default FerrellSyntheticIntelligence/JEDI:Q4_K_M

Run Hermes

hermes

Atomic Chat new

OpenClaw new

How to use FerrellSyntheticIntelligence/JEDI with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf FerrellSyntheticIntelligence/JEDI:Q4_K_M

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "FerrellSyntheticIntelligence/JEDI:Q4_K_M" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

Docker Model Runner
How to use FerrellSyntheticIntelligence/JEDI with Docker Model Runner:
```
docker model run hf.co/FerrellSyntheticIntelligence/JEDI:Q4_K_M
```

Lemonade

How to use FerrellSyntheticIntelligence/JEDI with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull FerrellSyntheticIntelligence/JEDI:Q4_K_M

Run and chat with the model

lemonade run user.JEDI-Q4_K_M

List all available models

lemonade list

JEDI / README.md

FerrellSyntheticIntelligence

Upload README.md with huggingface_hub

4483bdd verified about 18 hours ago

preview code

Raw

History Blame Contribute Delete

8.23 kB

	---
	language:
	- en
	license: mit
	library_name: transformers
	pipeline_tag: text-generation
	tags:
	- jedi
	- cybersecurity
	- nanobot
	- swarm-intelligence
	- vitalis
	- lfm
	- liquid-foundation-model
	- lora
	- qlora
	- veritas
	- machiavelli
	- sovereign-ai
	- ferrell-synthetic-intelligence
	base_model: LiquidAI/LFM2.5-1.2B-Instruct
	model_type: liquidfm
	inference: true
	---

	# JEDI — Joint Entity Defense Infrastructure (LFM2.5-1.2B)

	[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
	[![Python 3.10+](https://img.shields.io/badge/Python-3.10+-blue.svg)](https://www.python.org/downloads/)
	[![Transformers](https://img.shields.io/badge/Transformers-5.x-yellow.svg)](https://huggingface.co/docs/transformers)
	[![llama.cpp](https://img.shields.io/badge/llama.cpp-GGUF-green.svg)](https://github.com/ggerganov/llama.cpp)
	[![Platform](https://img.shields.io/badge/Platform-ARM64%20%7C%20x86_64-lightgrey.svg)]()
	[![GPU](https://img.shields.io/badge/GPU-Optional-brightgreen.svg)]()

	JEDI is a cybersecurity operations AI built on Liquid AI's `LFM2.5-1.2B-Instruct` architecture, fine-tuned to think like a mentalist + Machiavelli strategist. It connects every technical concept to psychology, history, and human nature rather than memorizing facts.

	This repo contains the full project: training data, generation scripts, the Veritas truth-verification layer, the LoRA fine-tuning pipeline, benchmark runners, and the inference/terminal front-ends.

	---

	## What This Repo Contains

	\| Path \| What it is \|
	\|------\|-----------\|
	\| `training_data_master.jsonl` \| 20,847 examples, ~2.67M tokens — the master fine-tuning dataset (all sources merged) \|
	\| `training_data_connective_v3.jsonl` \| 5,763 cross-domain examples (Machiavelli × Technical × Psychology) \|
	\| `training_data_veritas.jsonl` \| 723 VERITAS verification examples (self-check, confidence scoring, correction) \|
	\| `self_refine_corrections.jsonl` \| 8,999 corrections generated from the test bank \|
	\| `test_10k.jsonl` \| 8,999 evaluation questions across 10 domains \|
	\| `generate_connective_v3.py` \| Generator for cross-domain training data \|
	\| `generate_veritas.py` \| Generator for the Veritas truth layer \|
	\| `generate_10k_test.py` \| Generator for the 10K eval bank \|
	\| `self_refine_pipeline.py` \| Self-Refine merge/correction pipeline (`merge` / `generate`) \|
	\| `tune_jedi.py` \| LoRA / QLoRA fine-tuning script (the one to run on your laptop) \|
	\| `eval_benchmarks.py` \| Problem-solving / code / reasoning / safety benchmark runner \|
	\| `jedi_terminal.py` \| Parrot-OS-styled cyberdeck terminal front-end \|
	\| `jedi_tui.py` / `jedi_chat.py` / `jedi_cortex.py` \| Other interaction front-ends \|
	\| `model/LFM2.5-1.2B-Instruct-Q4_K_M.gguf` \| The base GGUF model (Q4_K_M, 730 MB) \|
	\| `requirements.txt` \| Python dependencies \|

	---

	## Project Status (as of last sync)

	\| Item \| Status \|
	\|------\|--------\|
	\| Connective training data generator \| ✅ Done (5,763 examples) \|
	\| Veritas truth-verification layer \| ✅ Done (723 examples) \|
	\| Master dataset merge \| ✅ Done (20,847 examples, 2.67M tokens) \|
	\| 10K eval bank \| ✅ Done (8,999 questions) \|
	\| LoRA fine-tuning script \| ✅ Written (`tune_jedi.py`) — NEEDS TO BE RUN \|
	\| Fine-tuned adapter \| ❌ Not yet produced (`jedi_lora_adapter/`) \|
	\| Benchmark numbers post-fine-tune \| ❌ Not yet measured \|
	\| Upload to HF \| ✅ In progress (this push) \|

	Key fact: No fine-tuning has actually completed yet. The weights in `model/` are still the base LFM2.5-1.2B-Instruct. The training data and the script are ready — the run is the missing step.

	---

	## What Was Done vs. What's Left

	### ✅ Completed
	1. Connective training data — 5,763 examples that tie Machiavelli principles + psychology biases to concrete technical topics (SQLi, XSS, SSRF, IDOR, zero-trust, etc.). Goal was teaching understanding, not rote recall.
	2. Veritas layer — 723 examples teaching the model to self-verify, assign confidence scores (90–100% fact, 70–89% inference, <50% speculation), and correct its own errors.
	3. Self-Refine pipeline — generates corrected examples from the test bank and merges all sources into `training_data_master.jsonl`.
	4. 10K eval bank — 8,999 questions across recon / exploit / defense / attribution / incident / compliance / psychology / tutor / whiterabbit / software-engineering.
	5. Terminal UI — Parrot-OS two-line prompt, neon-northern-lights palette, ASCII "JEDI" banner, dynamic status bar, tool panel, White Rabbit Mode animation.

	### ⏳ Left To Do (in order)
	1. Run `tune_jedi.py` to produce `jedi_lora_adapter/` (QLoRA, r=16, ~1 epoch over 20K examples).
	2. Run `eval_benchmarks.py` on the fine-tuned model to get post-training numbers.
	3. Convert the LoRA adapter to GGUF (so it can be applied to the GGUF base at inference) — see below.
	4. Optionally re-run all the big public benchmarks (MMLU / MMLU-Pro / GPQA / IFEval / BFCL) and record the scores.
	5. Apply adapter in the terminal — load `model/` + LoRA at runtime.

	---

	## How To Finish It (on your laptop)

	### 1. Clone & install
	```bash
	git lfs install
	git clone https://huggingface.co/FerrellSyntheticIntelligence/JEDI
	cd JEDI
	pip install -r requirements.txt
	# If you want LoRA training:
	pip install "transformers>=5.2.0" peft bitsandbytes datasets accelerate torch
	```

	### 2. Run the fine-tune (CPU or GPU)
	```bash
	# Quick smoke test first (100 examples, 20 steps):
	python3 tune_jedi.py --quick

	# Full run:
	python3 tune_jedi.py
	```
	This produces `jedi_lora_adapter/` (PEFT LoRA weights). On a laptop GPU this takes minutes; on CPU it can take hours. The script uses 4-bit QLoRA so VRAM/RAM stays low.

	### 3. Apply the adapter to the GGUF for inference
	Two options:
	- Transformers path: `python3 tune_jedi.py --apply` loads base + LoRA and tests a generation.
	- GGUF path (recommended for the terminal): convert the LoRA to a GGUF adapter and load it with `llama_cpp`:
	```python
	from llama_cpp import Llama
	llm = Llama(model_path="model/LFM2.5-1.2B-Instruct-Q4_K_M.gguf",
	lora_path="jedi_lora_adapter/adapter.bin") # after conversion
	```

	### 4. Re-benchmark
	```bash
	python3 eval_benchmarks.py
	```
	Then compare to the pre-fine-tune baseline in `eval_results.json`.

	---

	## Data Format

	All training files are ShareGPT-style JSONL:
	```json
	{"messages":[{"role":"system","content":"..."},{"role":"user","content":"..."},{"role":"assistant","content":"..."}],"domain":"machiavelli_psych"}
	```
	The `tune_jedi.py` script converts this to the LFM2.5 ChatML template (`<\|im_start\|>...<\|im_end\|>`) and masks the loss on non-assistant turns.

	### Domain distribution in `training_data_master.jsonl`
	`cybersec_exploit` (1785), `self_refine_` (≈7000 across coding/recon/defense/incident/attribution/psych/tutor/whiterabbit), `veritas_` (723), `machiavelli_psych` (6769), `cybersec_defense` (1154), `cybersec_recon` (254), `whiterabbit` (343), `cybersec_swarm` (247), etc.

	---

	## Architecture

	```
	User Input
	→ Quadruflow Router (LOGICAL / FACTUAL / CREATIVE / PROCEDURAL)
	→ Chain Amplifier (reasoning scaffold)
	→ LFM2.5 1.2B Inference (llama-cpp or transformers)
	→ VERITAS Loop (self-verify, confidence, correct)
	→ Attestation Loop (3-check quality gate)
	→ Memory Store (FAISS + Ebbinghaus decay)
	→ JEDI Modules (swarm, legal gate, comms, ledger)
	→ Response
	```

	The Veritas layer is what's new since the original JEDI release: the model now rates its own confidence and flags speculation instead of presenting guesses as fact.

	---

	## Intended Use & Ethics
	- Built for authorized defense only — all operations require legal authorization.
	- Immutable audit ledger for every action.
	- Built-in safety gate refuses harmful requests.
	- Human-in-the-loop required for kinetic actions.

	## Citation
	```bibtex
	@misc{jedi2026,
	title={JEDI: Joint Entity Defense Infrastructure},
	author={Ferrell Synthetic Intelligence},
	year={2026},
	url={https://huggingface.co/FerrellSyntheticIntelligence/JEDI},
	license={MIT}
	}
	```

	## Contact
	[Ferrell Synthetic Intelligence](https://huggingface.co/FerrellSyntheticIntelligence) — Neuro_Nomad