Instructions to use DarkWhiteProductions/Urvashi-3B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use DarkWhiteProductions/Urvashi-3B with Transformers:

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

pipe = pipeline("text-generation", model="DarkWhiteProductions/Urvashi-3B", trust_remote_code=True)
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("DarkWhiteProductions/Urvashi-3B", trust_remote_code=True, device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use DarkWhiteProductions/Urvashi-3B with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/DarkWhiteProductions/Urvashi-3B

SGLang

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

Docker Model Runner
How to use DarkWhiteProductions/Urvashi-3B with Docker Model Runner:
```
docker model run hf.co/DarkWhiteProductions/Urvashi-3B
```

You need to agree to share your contact information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

URVASHI (LLaMA Backbone)

Overview

URVASHI is a research-grade large language model architecture designed for expressive language modeling, roleplay, specialization, and large-scale model merging.

This release represents the first stable URVASHI checkpoint, instantiated on top of a LLaMA-family backbone and converted into a native URVASHI architecture with full architectural parity and warm-started weights.

Important: URVASHI is an architecture, not a fine-tune.
The underlying LLaMA model is used strictly as an initialization substrate.

Design Philosophy

URVASHI is built around a different set of priorities than reasoning-first architectures:

1. Expressivity First

URVASHI is optimized for:

Natural dialogue
Roleplay and character consistency
Stylistic diversity
Creative and emotional language generation

This makes it especially suitable for RP models, narrative systems, and persona-driven assistants.

2. Merge-Friendly Architecture

URVASHI is intentionally designed to support:

Fine-tuned model families (RP, code, instruction, alignment)
Weight merging and blending
Progressive specialization

The architecture serves as a stable convergence layer for multiple LLaMA-derived specializations.

3. Evolutionary Headroom

URVASHI is designed to evolve beyond a single base model, with planned support for:

Mixture-of-Experts (MoE)
Alternative attention routing
Long-context scaling (YaRN-style methods)
Hybrid expressive–reasoning variants

Model Details

Model type: Decoder-only causal language model
Backbone: LLaMA-family (weights converted, not wrapped)
Parameters: Backbone-dependent (e.g., 7B / 13B / 34B)
Architecture: URVASHI (native implementation)
Normalization: RMSNorm
Attention: Multi-Head / Grouped Query (backbone-compatible)
Positional encoding: Rotary (RoPE)
Weight tying: Enabled (token embeddings ↔ LM head)

What This Model Is (and Is Not)

✅ What URVASHI Is

A clean architectural re-implementation of LLaMA-style LLMs
A base expressive backbone for RP and dialogue models
A merge-friendly convergence architecture
A foundation for multiple specialized descendants

❌ What URVASHI Is Not

Not a reasoning-optimized architecture
Not instruction-aligned by default
Not RLHF-tuned
Not a safety-fine-tuned chat model

For reasoning-focused or architecture-first research, see the INDRA model line instead.

Intended Use

URVASHI is intended for:

Roleplay and narrative generation
Character-driven assistants
Creative writing systems
Model merging and specialization research
Expressive dialogue experimentation

Example downstream variants may include:

urvashi-rp
urvashi-dolphin
urvashi-code
urvashi-instruct
urvashi-merged

Example Usage

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

tokenizer = AutoTokenizer.from_pretrained("shashwatmudgal/urvashi-llama")
model = AutoModelForCausalLM.from_pretrained(
    "shashwatmudgal/urvashi-llama",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

prompt = "You are a medieval bard telling a story by the fire."
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(
        **inputs,
        max_new_tokens=200,
        do_sample=True,
        temperature=0.8,
    )

print(tokenizer.decode(output[0], skip_special_tokens=True))

Training & Conversion Details

Initialization: Warm-started from a LLaMA-family checkpoint
Training: No additional fine-tuning performed
Conversion:
- Layer-by-layer weight mapping
- Architecture verified via generation parity tests
- Token embeddings and LM head intentionally tied

This checkpoint is functionally equivalent to the original LLaMA model at initialization, while enabling URVASHI-specific architectural evolution.

Limitations

No instruction tuning
No safety fine-tuning
No alignment or moderation layers
Outputs may reflect biases present in original pretraining data

Roadmap

Planned future work includes:

Roleplay-tuned URVASHI variants
Dolphin-style expressive alignment
Large-scale URVASHI merges
MoE-based URVASHI models
Hybrid expressive–reasoning experiments

Citation

If you use URVASHI in academic or research work, please cite it as:

URVASHI: Expressive Language Architecture for Model Specialization and Merging
Shashwat Mudgal, 2026

Acknowledgements

Meta AI for the original LLaMA research
The open-source fine-tuning community
Hugging Face Transformers for tooling and ecosystem support

Disclaimer

“URVASHI is an independent architecture that can optionally be initialized from LLaMA-family weights. Any derivative relationship exists at the level of initialization, not design, and is further attenuated by continued training.”
“Architecturally original; weight-initialized from LLaMA.”

Author

Shashwat Mudgal Independent Researcher Project: URVASHI

LICENCE

Refer to the LICENCE file.

Downloads last month: 10

Safetensors

Model size

3B params

Tensor type

F32