Instructions to use terminalgnosis/kundalini with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use terminalgnosis/kundalini with Transformers:

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

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

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("terminalgnosis/kundalini")
model = AutoModelForCausalLM.from_pretrained("terminalgnosis/kundalini", 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=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use terminalgnosis/kundalini with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/terminalgnosis/kundalini

SGLang

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

Docker Model Runner
How to use terminalgnosis/kundalini with Docker Model Runner:
```
docker model run hf.co/terminalgnosis/kundalini
```

Kundalini 1B

Kundalini 1B is a high-performance, lightweight 1.23-billion parameter conversational artificial intelligence model developed by Terminal Gnosis. Built for low latency, memory efficiency, and broad domain comprehension, it delivers fast and insightful responses across reasoning, coding, general dialogue, and philosophical knowledge.

Model Highlights

Fast and Ultra-Lightweight: With a compact 1.23B parameter architecture, Kundalini can run with minimal memory overhead on edge hardware, standard CPUs, and resource-constrained environments.
Multilingual Support: Capable of understanding and generating responses across multiple languages.
Multitask Performance: Optimized for conversational assistance, structured reasoning, software engineering, and philosophical discourse.
Universal Deployment Compatibility: Stored in standard safetensors format with full 16-bit precision, allowing smooth integration across popular inference engines.

Quickstart and Usage

1. Using Transformers (AutoModelForCausalLM)

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_id = "terminalgnosis/kundalini"

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

messages = [
    {"role": "system", "content": "You are Kundalini, an insightful, intelligent, and precise AI assistant."},
    {"role": "user", "content": "Who are you and what is your purpose?"}
]

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

outputs = model.generate(
    **inputs,
    max_new_tokens=256,
    temperature=0.7,
    top_p=0.9,
    do_sample=True
)

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

2. Using Text Generation Pipeline

from transformers import pipeline

generator = pipeline("text-generation", model="terminalgnosis/kundalini", device_map="auto")

messages = [
    {"role": "user", "content": "Explain the concept of Kundalini awakening in simple words."}
]

response = generator(messages, max_new_tokens=200)
print(response[0]["generated_text"][-1]["content"])

Prompt Format

Kundalini utilizes a structured role-based dialogue format:

<|start_header_id|>system<|end_header_id|>

You are Kundalini, an insightful, intelligent, and precise AI assistant.<|eot_id|>
<|start_header_id|>user<|end_header_id|>

What is Kundalini energy?<|eot_id|>
<|start_header_id|>assistant<|end_header_id|>

Model Specifications

Attribute	Details
Model Name	Kundalini 1B
Creator / Organization	terminalgnosis
Total Parameters	1.23 Billion (`1,235,814,400`)
Model Format	Safetensors (`model.safetensors`)
Tensor Type / Precision	16-bit BFloat16
Context Length	8,192 tokens
Language Scope	Multilingual
License	Apache 2.0

Intended Use Cases

Philosophical and Spiritual Exploration: Delving into consciousness, meditation principles, and analytical perspectives.
Conversational Assistance: Everyday interactions, writing refinement, conceptual summarization, and query resolution.
Software Development: Writing, debugging, and explaining code in Python, JavaScript, and other major languages.
Edge and Local Systems: Running local inference on mobile devices, low-VRAM servers, and personal workstations.

Limitations

Factual Accuracy: As with all generative language models, outputs should be verified for mission-critical decisions.
Model Scale: Specialized deep domain tasks requiring extensive multi-step mathematical derivations may benefit from larger parameter scale architectures.

Developed By

Author / Organization: terminalgnosis
Model Name: Kundalini

Downloads last month: 538

Safetensors

Model size

1B params

Tensor type

BF16