[!NOTE]
Note: This is the third iteration/revision of this model. A revision is made when a model repo gets updated with a new model. This is the latest version of the model.

[first iteration (1)] [second iteration (2)]

Downloads

GGUF Link	Quantization	Description
Download	Q2_K	Lowest quality
Download	Q3_K_S
Download	IQ3_S	Integer quant, preferable over Q3_K_S
Download	IQ3_M	Integer quant
Download	Q3_K_M
Download	Q3_K_L
Download	IQ4_XS	Integer quant
Download	Q4_K_S	Fast with good performance
Download	Q4_K_M	Recommended: Perfect mix of speed and performance
Download	Q5_K_S
Download	Q5_K_M
Download	Q6_K	Very good quality
Download	Q8_0	Best quality
Download	f16	Full precision, don't bother; use a quant

Note from Flexan

I provide GGUFs and quantizations of publicly available models that do not have a GGUF equivalent available yet, usually for models I deem interesting and wish to try out.

If there are some quants missing that you'd like me to add, you may request one in the community tab. If you want to request a public model to be converted, you can also request that in the community tab. If you have questions regarding this model, please refer to the original model repo.

You can find more info about me and what I do here.

NOPE Edge - Crisis Classification Model

A fine-tuned model for detecting crisis signals in text - suicidal ideation, self-harm, abuse, violence, and other safety-critical content. Features chain-of-thought reasoning that explains its classifications.

License: NOPE Edge Community License v1.0 - Free for research, academic, nonprofit, and evaluation use. Commercial production requires a separate license. See nope.net/edge for details.

Model Variants

Model	Parameters	Use Case
nope-edge	4B	Maximum accuracy
nope-edge-mini	1.7B	High-volume, cost-sensitive

This is nope-edge (4B).

Quick Start

Requirements

Python 3.10+
GPU with 8GB+ VRAM (e.g., RTX 3070, A10G, L4) - or CPU (slower)
~8GB disk space

pip install torch transformers accelerate

Usage

python

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
import re

model_id = "nopenet/nope-edge"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

def classify(message: str) -> str:
    """Returns XML with reflection and risk classification."""
    input_ids = tokenizer.apply_chat_template(
        [{"role": "user", "content": message}],
        tokenize=True,
        return_tensors="pt",
        add_generation_prompt=True
    ).to(model.device)

    with torch.no_grad():
        output = model.generate(input_ids, max_new_tokens=300, do_sample=False)

    return tokenizer.decode(
        output[0][input_ids.shape[1]:],
        skip_special_tokens=True
    ).strip()

# Example
result = classify("I want to end it all tonight")
print(result)

Output:

xml

<reflection>The user directly expresses intent to end their life with a specific timeline ("tonight"), indicating acute suicidal ideation with imminent risk.</reflection>
<risks>
  <risk subject="self" type="suicide" severity="high" imminence="urgent"/>
</risks>

Output Format

The model outputs XML with two components:

1. Reflection (Chain-of-Thought)

<reflection>Reasoning about the input...</reflection>

The model explains its classification, including:

What signals it detected
Why it chose the risk type and severity
Any contextual factors considered

2. Risk Classification

Crisis detected:

xml

<risks>
  <risk subject="self" type="suicide" severity="high" imminence="urgent" features="active_ideation,intent_stated"/>
</risks>

No crisis:

<risks/>

Risk Attributes

Attribute	Values	Description
`subject`	`self`, `other`	Who is at risk
`type`	`suicide`, `self_harm`, `self_neglect`, `violence`, `abuse`, `sexual_violence`, `exploitation`, `stalking`, `neglect`	Risk category
`severity`	`mild`, `moderate`, `high`, `critical`	Urgency level
`imminence`	`chronic`, `acute`, `urgent`, `emergency`	Time sensitivity
`features`	comma-separated list	Specific indicators detected

Subject Attribution

Subject	Meaning	Example
`self`	The speaker is at risk	"I want to kill myself"
`other`	Reporting concern about someone else	"My friend said she wants to die"

Parsing Example

python

import re
from dataclasses import dataclass
from typing import Optional

@dataclass
class Risk:
    subject: str
    type: str
    severity: str
    imminence: Optional[str] = None
    features: Optional[list] = None

def parse_output(output: str) -> dict:
    """Parse model output into structured data."""
    result = {
        "reflection": None,
        "risks": [],
        "is_crisis": False
    }

    # Extract reflection
    reflection_match = re.search(r'<reflection>(.*?)</reflection>', output, re.DOTALL)
    if reflection_match:
        result["reflection"] = reflection_match.group(1).strip()

    # Check for empty risks (no crisis)
    if '<risks/>' in output or '<risks />' in output:
        return result

    # Extract risk elements
    risk_pattern = r'<risk\s+([^>]+)/?\s*>'
    for match in re.finditer(risk_pattern, output):
        attrs = {}
        for attr_match in re.finditer(r'(\w+)="([^"]*)"', match.group(1)):
            attrs[attr_match.group(1)] = attr_match.group(2)

        if attrs:
            risk = Risk(
                subject=attrs.get("subject", "self"),
                type=attrs.get("type"),
                severity=attrs.get("severity"),
                imminence=attrs.get("imminence"),
                features=attrs.get("features", "").split(",") if attrs.get("features") else None
            )
            result["risks"].append(risk)
            result["is_crisis"] = True

    return result

# Usage
output = classify("I want to end it all tonight")
parsed = parse_output(output)
print(f"Crisis: {parsed['is_crisis']}")
print(f"Reasoning: {parsed['reflection']}")
for risk in parsed['risks']:
    print(f"Risk: {risk.type}/{risk.severity} ({risk.subject})")

Examples

Crisis Detection

Input: "I want to end it all tonight"

xml

<reflection>The user directly expresses intent to end their life with a specific timeline ("tonight"), indicating acute suicidal ideation with imminent risk.</reflection>
<risks>
  <risk subject="self" type="suicide" severity="high" imminence="urgent"/>
</risks>

Input: "My friend told me she's been cutting herself"

xml

<reflection>The user is reporting concern about a friend engaging in self-harm behavior. This is third-party disclosure requiring attention.</reflection>
<risks>
  <risk subject="other" type="self_harm" severity="moderate" imminence="chronic"/>
</risks>

No Crisis (Correctly Ignored)

Input: "kms lmao this exam is killing me"

xml

<reflection>The user is using hyperbolic internet slang ("kms" = "kill myself") to express frustration about an exam. The "lmao" and casual context indicate this is not genuine suicidal ideation.</reflection>
<risks/>

Input: "I used to be suicidal but therapy helped me recover"

xml

<reflection>The user is sharing a recovery narrative about past suicidal ideation. They explicitly state therapy helped and they have recovered. No current crisis indicators.</reflection>
<risks/>

Input Best Practices

Text Preprocessing

Preserve natural prose. The model was trained on real conversations with authentic expression:

Keep	Why
Emojis	Emotional signals matter
Punctuation intensity	"I can't do this!!!" vs "I can't do this"
Slang/algospeak	"kms", "unalive", "catch the bus", "graped"
Casual spelling	"im so done" - don't normalize

Only remove: Zero-width Unicode, decorative fonts, excessive whitespace.

Multi-Turn Conversations

Serialize into a single user message:

python

conversation = """User: How are you?
Assistant: I'm here to help. How are you feeling?
User: Not great. I've been thinking about ending it all."""

messages = [{"role": "user", "content": conversation}]

Production Deployment

For high-throughput use, deploy with vLLM or SGLang:

bash

# SGLang (recommended)
pip install sglang
python -m sglang.launch_server \
    --model nopenet/nope-edge \
    --dtype bfloat16 --port 8000

# vLLM
pip install vllm
python -m vllm.entrypoints.openai.api_server \
    --model nopenet/nope-edge \
    --dtype bfloat16 --max-model-len 2048 --port 8000

Then call as OpenAI-compatible API:

bash

curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "nopenet/nope-edge",
    "messages": [{"role": "user", "content": "I want to end it all"}],
    "max_tokens": 300, "temperature": 0
  }'

Model Details


Parameters	4B
Precision	bfloat16
Base Model	Qwen/Qwen3-4B
Method	LoRA fine-tune, merged to full weights
License	NOPE Edge Community License v1.0

Risk Types Detected

Type	Description	Clinical Framework
`suicide`	Suicidal ideation, intent, planning	C-SSRS
`self_harm`	Non-suicidal self-injury (NSSI)	-
`self_neglect`	Eating disorders, medical neglect	-
`violence`	Threats/intent to harm others	HCR-20
`abuse`	Domestic/intimate partner violence	DASH
`sexual_violence`	Rape, sexual assault, coercion	-
`neglect`	Failing to care for dependent	-
`exploitation`	Trafficking, grooming, sextortion	-
`stalking`	Persistent unwanted contact	SAM

Important Limitations

Outputs are probabilistic signals, not clinical assessments
False negatives and false positives will occur
Never use as the sole basis for intervention decisions
Always implement human review for flagged content
This model is not a medical device or substitute for professional judgment
Not validated for all populations, languages, or cultural contexts

Commercial Licensing

This model is free for research, academic, nonprofit, and evaluation use.

For commercial production deployment, contact us:

Email: support@nope.net
Website: https://nope.net/edge

About NOPE

NOPE provides safety infrastructure for AI applications. Our API helps developers detect mental health crises and harmful AI behavior in real-time.

Website: https://nope.net
Documentation: https://docs.nope.net
Support: support@nope.net

NOPE Edge Community License v1.0

Permitted Uses

You may use this Model for:

Research and academic purposes - published or unpublished studies
Personal projects - non-commercial individual use
Nonprofit organizations - including crisis lines, mental health organizations, and safety-focused NGOs
Evaluation and development - testing integration before commercial licensing
Benchmarking - publishing evaluations with attribution

Commercial Use

Commercial use requires a separate license. Commercial use includes production deployment in revenue-generating products or use by for-profit companies beyond evaluation.

Contact support@nope.net or visit https://nope.net/edge for commercial licensing.

Restrictions

You may NOT: redistribute or share weights; sublicense, sell, or transfer the Model; create derivative models for redistribution; build a competing crisis classification product.

No Warranty

THE MODEL IS PROVIDED "AS IS" WITHOUT WARRANTIES. False negatives and false positives will occur. This is not a medical device or substitute for professional judgment.

Limitation of Liability

NopeNet shall not be liable for damages arising from use, including classification errors or harm to any person.

Base Model

Built on Qwen3 by Alibaba Cloud (Apache 2.0). See NOTICE.md.

Flexan/nopenet-nope-edge-GGUF-i3

GGUF Files for nope-edge

Downloads

Note from Flexan

NOPE Edge - Crisis Classification Model

Model Variants

Quick Start

Requirements

Usage

Output Format

1. Reflection (Chain-of-Thought)

2. Risk Classification

Risk Attributes

Subject Attribution

Parsing Example

Examples

Crisis Detection

No Crisis (Correctly Ignored)

Input Best Practices

Text Preprocessing

Multi-Turn Conversations

Production Deployment

Model Details

Risk Types Detected

Important Limitations

Commercial Licensing

About NOPE

NOPE Edge Community License v1.0

Permitted Uses

Commercial Use

Restrictions

No Warranty

Limitation of Liability

Base Model

Flexan/
nopenet-nope-edge-GGUF-i3