Instructions to use COGERPHEREAILABS/meridian-ac-nano with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use COGERPHEREAILABS/meridian-ac-nano with Transformers:

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

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

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("COGERPHEREAILABS/meridian-ac-nano")
model = AutoModelForCausalLM.from_pretrained("COGERPHEREAILABS/meridian-ac-nano", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use COGERPHEREAILABS/meridian-ac-nano with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/COGERPHEREAILABS/meridian-ac-nano

SGLang

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

Docker Model Runner
How to use COGERPHEREAILABS/meridian-ac-nano with Docker Model Runner:
```
docker model run hf.co/COGERPHEREAILABS/meridian-ac-nano
```

Meridian-AC-Nano

Overview

Meridian-AC-Nano is a compact (~596M parameter) research proofreading and academic-writing model developed by COGERPHERE AI Labs. It is the flagship model of the MERIDIAN 0.1 research programme and is specialized for grammar correction, spelling and punctuation fixes, LaTeX correction, academic tone refinement, and restrained no-over-edit text refinement.

The model is trained on a chat-first, multi-task corpus covering proofreading, LaTeX repair, academic writing, code correction, identity/chat, instruction following, and hard negatives. It loads as a standard causal language model with a ChatML chat template.

Capabilities

Meridian-AC-Nano supports, as verified by the training corpus and per-task evaluation:

Research proofreading — correcting grammar, spelling, punctuation, and wording while preserving meaning.
Grammar correction — grammatical and spelling fixes across academic text.
LaTeX-aware proofreading — fixing syntax and formatting errors in LaTeX source.
Academic / research writing refinement — tone refinement and text improvement.
Text refinement / no-over-edit tasks — minimal, meaning-preserving edits (restraint).

Out-of-Scope Use

The model is not intended for production medical, legal, or financial advice; factual knowledge recall; or large-scale general-purpose coding. It is a small model fine-tuned for a specialized proofreading/academic-writing niche.

Evaluation

Results on the held-out test set (n=162, seed 42, greedy decoding) for the flagship run (main_nano):

Metric	Value
ROUGE-1	0.9308
ROUGE-2	0.9138
ROUGE-L	0.929
BLEU-4	0.8797
Exact match (%)	74.69
LaTeX validity (%)	97.53
LaTeX validity (LaTeX subset, %)	95.24
Quality score	0.9032

Per-Task Results

Task	n	ROUGE-L	BLEU-4	Exact match (%)
academic	13	0.9744	0.9231	92.31
chat	33	0.7142	0.6064	6.06
code	21	1.0000	1.0000	100.00
hard_negative	6	1.0000	1.0000	100.00
identity	4	0.7667	0.5167	50.00
instruction	10	0.9553	0.8484	70.00
latex	42	0.9978	0.9762	95.24
proofread	23	0.9884	0.9543	91.30
restraint	10	1.0000	1.0000	100.00

Training

Fine-tuning was performed on a chat-first multi-task corpus using the Unsloth LoRA pipeline on an NVIDIA RTX 3050 (6 GB Laptop GPU).

Hyperparameter	Value
LoRA rank	32
LoRA alpha	64
LoRA dropout	0.05
Target modules	`q_proj`, `v_proj`
Epochs	3
Learning rate	2e-4
Weight decay	0.01
Warmup steps	50
Optimizer	paged_adamw_8bit
Batch size / grad accum	1 / 8
Max sequence length	2048
Seed	42

Training Data

Split	Examples
Train	1,275
Validation	158
Test	162
Total	1,595

Task categories (all splits): proofread (230), latex (413), academic (130), chat (324), code (198), identity (40), restraint (100), hard_negative (60), instruction (100).

Data sources: manual curation (120), synthetic generation (561), augmented (92), template (822).

Limitations

Small model: 0.6B parameters; conversational/chat quality is best-effort and lower than larger models.
Factual knowledge: not a general knowledge or instruction-tuned model at the scale of frontier models.
Chat exact match is low (6.06%) — expected for open-ended chat responses, which are not verbatim reproducible.
Domain scope: trained primarily on academic/LaTeX/proofreading content; performance on unrelated domains is not evaluated.

Usage

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

repo_id = "COGERPHEREAILABS/meridian-ac-nano"

tokenizer = AutoTokenizer.from_pretrained(repo_id)
model = AutoModelForCausalLM.from_pretrained(repo_id, dtype=torch.float16)

messages = [
    {
        "role": "system",
        "content": "You are Meridian, a precise research proofreading assistant. Correct grammar, spelling, punctuation, and wording while preserving the original meaning.",
    },
    {
        "role": "user",
        "content": "The results indicates that the model perform very well on the proofreading task.",
    },
]

text = tokenizer.apply_chat_template(
    messages, tokenize=False, add_generation_prompt=True, return_dict=False
)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(**inputs, do_sample=False, max_new_tokens=128)

response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(response)

Ollama users can pull the GGUF distribution directly:

ollama run hf.co/COGERPHEREAILABS/meridian-ac-nano-GGUF:Q8_0

License

Apache-2.0. See the base model attribution below for the underlying license terms.

Base Model Attribution

Meridian-AC-Nano is a LoRA fine-tune of Qwen/Qwen3-0.6B (Apache-2.0), sourced via ModelScope (ungated base checkpoint). Full attribution and the base model card are available at https://huggingface.co/Qwen/Qwen3-0.6B. The weights are therefore released under Apache-2.0.

Citation

If you use this model in your research, please cite:

@software{cogerphere_meridian_nano,
  author  = {Tripathi, Shivanshi and Pandey, Yuvraj},
  title   = {MERIDIAN 0.1: SLM-Driven Academic Proofreading Models},
  year    = {2026},
  publisher = {COGERPHERE AI Labs},
  url     = {https://github.com/COGERPHEREAILABS/Meridian-SLM-Driven-Models-Research},
  doi     = {10.5281/zenodo.21863555}
}

Contact

COGERPHERE AI Labs — GitHub · DOI 10.5281/zenodo.21863555

Downloads last month: 19

Safetensors

Model size

0.6B params

Tensor type

F16

Model tree for COGERPHEREAILABS/meridian-ac-nano

Base model

Qwen/Qwen3-0.6B-Base

Finetuned

Qwen/Qwen3-0.6B

Finetuned

(1416)

this model

Space using COGERPHEREAILABS/meridian-ac-nano 1

Evaluation results

Rouge1 on meridian_nano test set (n=162, seed 42)
test set self-reported

0.931
Rouge2 on meridian_nano test set (n=162, seed 42)
test set self-reported

0.914
RougeL on meridian_nano test set (n=162, seed 42)
test set self-reported

0.929
Bleu4 on meridian_nano test set (n=162, seed 42)
test set self-reported

0.880
Exact Match on meridian_nano test set (n=162, seed 42)
test set self-reported

74.690
LaTeX validity on meridian_nano test set (n=162, seed 42)
test set self-reported

97.530