Instructions to use ArjunShukla/PromptForge-Optimizer with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use ArjunShukla/PromptForge-Optimizer with PEFT:

from peft import PeftModel
from transformers import AutoModelForCausalLM

base_model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-1.5B-Instruct")
model = PeftModel.from_pretrained(base_model, "ArjunShukla/PromptForge-Optimizer")

Transformers

How to use ArjunShukla/PromptForge-Optimizer with Transformers:

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

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

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("ArjunShukla/PromptForge-Optimizer", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use ArjunShukla/PromptForge-Optimizer with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/ArjunShukla/PromptForge-Optimizer

SGLang

How to use ArjunShukla/PromptForge-Optimizer 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 "ArjunShukla/PromptForge-Optimizer" \
    --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": "ArjunShukla/PromptForge-Optimizer",
		"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 "ArjunShukla/PromptForge-Optimizer" \
        --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": "ArjunShukla/PromptForge-Optimizer",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use ArjunShukla/PromptForge-Optimizer with Docker Model Runner:
```
docker model run hf.co/ArjunShukla/PromptForge-Optimizer
```

PromptForge-Optimizer

LoRA adapter that rewrites weak / vague prompts into clear, specific, actionable LLM prompts while preserving the original intent and topic.

Part of PromptForge — local-first prompt quality scoring + optimization.

Model Details

Model Description

PromptForge-Optimizer is a PEFT/LoRA fine-tune of Qwen/Qwen2.5-1.5B-Instruct. Given a weak user prompt (plus optional quality analysis context), it generates an improved prompt with audience, constraints, structure, and output format — without changing the core topic.

Developed by: PromptForge contributors
Model type: Causal LM adapter (LoRA / PEFT)
Language(s): English
License: MIT
Finetuned from: Qwen/Qwen2.5-1.5B-Instruct

Model Sources

Repository: https://github.com/arjun988/promptModel
Companion model: PromptForge-Quality (ModernBERT multi-dimension prompt scorer)
Demo: Gradio app in the PromptForge repo (demo/app.py)

Uses

Direct Use

Rewrite vague prompts into production-ready LLM instructions
Pair with PromptForge-Quality for score → optimize → re-score workflows
Local / offline prompt tooling (CLI, Python API, Gradio)

Example weak → strong:

Weak	Optimized (intent preserved)
`Make an app about social media like facebook and stuff`	Social media / Facebook-like app prompt with profiles, feed, likes, constraints, output format

Downstream Use

Prompt engineering assistants
IDE / agent tooling that improves user instructions before calling an LLM
Synthetic data pipelines that need higher-quality prompts

Out-of-Scope Use

Not a general chat assistant
Not a substitute for domain experts (legal, medical, safety-critical advice)
Not guaranteed to preserve intent on topics far outside the curated training set
Do not use to generate harmful, deceptive, or disallowed content

Bias, Risks, and Limitations

Trained on curated synthetic weak→strong pairs; coverage is strongest on coding apps, writing, data, research, and planning prompts
May invent plausible audience / stack details (e.g. “product managers”, “Flask”) when the weak prompt is underspecified
Small base model (1.5B) — quality is good for local use, not frontier-LLM rewrite quality
Inference includes validation + fallback in the PromptForge package; raw adapter output alone may still drift

Recommendations

Prefer the PromptForge Python package / CLI (chat template + stop tokens + validation) over raw generate
For new domains, add your own weak→strong pairs and retrain the LoRA
Always review optimized prompts before sending them to production LLMs

How to Get Started with the Model

Install & use with `tuneprompt` (recommended)

pip install tuneprompt

python -m promptforge download \
  --quality-repo ArjunShukla/PromptForge-Quality \
  --optimizer-repo ArjunShukla/PromptForge-Optimizer

python -m promptforge run "Make an app about social media like facebook and stuff"
# or: tuneprompt run "Make an app about social media like facebook and stuff"

from promptforge import PromptForge

pf = PromptForge(
    quality_model_path="ArjunShukla/PromptForge-Quality",
    optimizer_model_path="ArjunShukla/PromptForge-Optimizer",
)
print(pf.run("Build me a website for a startup")["optimized_prompt"])

Package: tuneprompt on PyPI · Import: promptforge · CLI: tuneprompt / promptforge · Code: https://github.com/arjun988/promptModel

Load the adapter directly (PEFT)

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

base = "Qwen/Qwen2.5-1.5B-Instruct"
adapter = "ArjunShukla/PromptForge-Optimizer"

tokenizer = AutoTokenizer.from_pretrained(adapter, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(base, trust_remote_code=True, device_map="auto")
model = PeftModel.from_pretrained(model, adapter)

Use Qwen’s chat template (tokenizer.apply_chat_template) — do not hand-roll <|system|> tags.

Training Details

Training Data

~800 curated high-quality weak → strong prompt pairs
~140 unique topic-preserving seeds (coding, writing, data, research, general)
Intent rule: optimized prompt must keep the same topic as the weak prompt
Assistant-only loss masking (system/user tokens not trained)

Training Procedure

Training Hyperparameters

Setting	Value
Base model	`Qwen/Qwen2.5-1.5B-Instruct`
Method	LoRA (PEFT)
LoRA rank / alpha	16 / 32
Target modules	q/k/v/o + MLP projections
Max sequence length	512
Epochs	6
Effective batch size	8 (batch 1 × grad accum 8)
Learning rate	1e-4
Precision	fp16
Gradient checkpointing	enabled
Config	`configs/optimizer_fast_8gb.yaml`

Speeds, Sizes, Times

Hardware: NVIDIA GeForce RTX 5060 Laptop GPU (8 GB)
Wall time: ~87 minutes (6 epochs)
Adapter size on disk: ~82 MB
Train loss: ~0.47
Validation loss: ~0.121

Evaluation

Metrics

Signal	Result
Validation loss	0.121
Example quality lift (scorer)	e.g. 41.5 → 94.0 on a social-media app prompt
Intent preservation	Topic keywords retained (social / Facebook)
Validation gate	Rejects empty / repetitive / low-intent outputs

Evaluation is primarily: held-out SFT loss + pipeline checks (score delta, instruction preservation, repetition detection). Not a public leaderboard benchmark.

Summary

The adapter reliably expands vague prompts into structured instructions on in-distribution topics. Off-distribution prompts may fall back to a safer template when used through PromptForge.

Environmental Impact

Hardware Type: NVIDIA RTX 5060 Laptop (8 GB)
Hours used: ~1.5 h for this adapter run
Cloud Provider: N/A (local)
Compute Region: N/A
Carbon Emitted: Not measured

Technical Specifications

Model Architecture and Objective

Causal language model (Qwen2.5 Instruct) + LoRA
Objective: SFT to map weak prompt (+ analysis) → optimized prompt text only

Compute Infrastructure

Hardware

RTX 5060 Laptop GPU, 8 GB VRAM

Software

PyTorch (CUDA)
Transformers
PEFT / LoRA
PromptForge training scripts

Framework versions

PEFT 0.20.0

Citation

@software{promptforge_optimizer,
  title = {PromptForge-Optimizer},
  author = {PromptForge Contributors},
  year = {2026},
  url = {https://huggingface.co/ArjunShukla/PromptForge-Optimizer}
}

Model Card Contact

Open an issue on the PromptForge GitHub repository.

Downloads last month: -

Model tree for ArjunShukla/PromptForge-Optimizer

Base model

Qwen/Qwen2.5-1.5B

Finetuned

Qwen/Qwen2.5-1.5B-Instruct

Adapter

(1383)

this model