Instructions to use alchemyst-ai/chintan-v1 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use alchemyst-ai/chintan-v1 with Transformers:

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

pipe = pipeline("text-generation", model="alchemyst-ai/chintan-v1")
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("alchemyst-ai/chintan-v1")
model = AutoModelForCausalLM.from_pretrained("alchemyst-ai/chintan-v1", 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 alchemyst-ai/chintan-v1 with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/alchemyst-ai/chintan-v1

SGLang

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

Docker Model Runner
How to use alchemyst-ai/chintan-v1 with Docker Model Runner:
```
docker model run hf.co/alchemyst-ai/chintan-v1
```

Alchemyst-AI/Chintan

Chintan is Alchemyst AI's conversational language model, fine-tuned and optimized for serving on our own inference infrastructure. It is exposed through the Alchemyst LLM Gateway as an OpenAI-compatible API.

Model description

Chintan is a small-footprint decoder-only language model for structured, goal-driven conversation. It was trained on real multi-turn dialogues with explicit objectives rather than generic web text, and is designed for products where the conversation must go somewhere: counselling, onboarding, feedback collection, and other scripted-but-natural interactions.

Developed by: Alchemyst AI (https://getalchemystai.com)
Model type: causal language model (text generation)
Languages: English, Hindi / Hinglish (natural code-switching)
License: Alchemyst Research License — see LICENSE. Commercial use requires a separate agreement.

Intended uses

Structured, goal-driven conversation. The model keeps multi-turn interactions moving forward, asks the right next question, and gracefully steers when a user drifts off-script.

Persona fidelity. Chintan holds a persona — tone, register, and role — across long sessions without collapsing back into generic assistant voice. Give it a character brief and it stays in character, turn after turn.

Multilingual, code-switched conversation. The model is comfortable in English and Hindi/Hinglish and switches between them mid-conversation the way real Indian users speak — without announcing the switch or losing the thread. Mixed-script turns like "kya aapko yeh details chahiye?" are handled natively.

Grounded personalization. The model works from a context sheet — user details, role or program specifics, prior conversation state — and weaves those facts into natural speech instead of reciting them.

Out-of-scope uses

Chintan is a conversationalist, not a general-purpose assistant. It is not tuned for code generation, long-form document synthesis, open-domain knowledge work, or factual question answering beyond its conversation context. For those workloads, use a larger frontier model.

Do not use the model to impersonate real individuals, for medical/legal/ financial advice, or in safety-critical decision loops without human oversight.

Technical specifications


Model type	causal LM, decoder-only
Parameters	0.6 B
Precision	bfloat16
Context length	40,960 tokens
Hidden size	1024
Layers	28
Attention heads	16 (8 KV heads, GQA)
Vocabulary	151,936 tokens
Tokenizer	BPE
Framework	transformers

Performance (single NVIDIA L40S, 46 GB)

Served via SGLang, bf16, with continuous batching enabled:

Metric	Measured
Response latency, short replies (~30 tokens)	~80–130 ms
Response latency, medium replies (~130–190 tokens)	~370–500 ms
First-token latency under light load	sub-100 ms
Throughput	hundreds of tokens/s aggregate; batching scales near-linearly until GPU memory saturates

Numbers are end-to-end gateway latencies (auth, routing, and metering included), measured on the production gateway stack. Latency scales primarily with output length; input context up to a few thousand tokens contributes negligibly thanks to prefix caching.

Usage

The model is served behind the Alchemyst LLM Gateway with a standard OpenAI-compatible surface:

curl http://<gateway>/v1/chat/completions \
  -H "Authorization: Bearer $ALCHEMYST_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "Alchemyst-AI/Chintan",
    "messages": [{"role": "user", "content": "Hi, who is this?"}],
    "stream": true
  }'

Streaming (SSE) and realtime WebSocket sessions are both supported.

Bias, risks, and limitations

The model is trained on conversational data reflecting the demographics and scenarios of its training corpus; outputs may carry those biases.
It can produce incorrect or fabricated details when a conversation requires facts beyond its context sheet.
Low-latency design trades off against the depth and world knowledge of much larger models.

Citation

@software{alchemyst_chintan,
  title  = {Chintan: a conversational language model},
  author = {Alchemyst AI},
  year   = {2026},
  url    = {https://getalchemystai.com}
}

Downloads last month: 5

Safetensors

Model size

0.6B params

Tensor type

BF16