Instructions to use lailaba/lailaba-ai with libraries, inference providers, notebooks, and local apps. Follow these links to get started.
- Libraries
- Transformers
How to use lailaba/lailaba-ai with Transformers:
# Use a pipeline as a high-level helper from transformers import pipeline pipe = pipeline("text-generation", model="lailaba/lailaba-ai") 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("lailaba/lailaba-ai") model = AutoModelForCausalLM.from_pretrained("lailaba/lailaba-ai", 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 lailaba/lailaba-ai with vLLM:
Install from pip and serve model
# Install vLLM from pip: pip install vllm # Start the vLLM server: vllm serve "lailaba/lailaba-ai" # Call the server using curl (OpenAI-compatible API): curl -X POST "http://localhost:8000/v1/chat/completions" \ -H "Content-Type: application/json" \ --data '{ "model": "lailaba/lailaba-ai", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }'Use Docker
docker model run hf.co/lailaba/lailaba-ai
- SGLang
How to use lailaba/lailaba-ai 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 "lailaba/lailaba-ai" \ --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": "lailaba/lailaba-ai", "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 "lailaba/lailaba-ai" \ --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": "lailaba/lailaba-ai", "messages": [ { "role": "user", "content": "What is the capital of France?" } ] }' - Docker Model Runner
How to use lailaba/lailaba-ai with Docker Model Runner:
docker model run hf.co/lailaba/lailaba-ai
Lailaba AI
Lailaba AI is a compact language model developed by Abdullahi Ibrahim Lailaba (a student/researcher connected to the Federal University Birnin Kebbi). It is based on the Qwen3-0.6B architecture and customized for programming, technology, education, research, cybersecurity learning, and general technical assistance.
This repository provides the complete model checkpoint, including its weights and configuration, for use with compatible Hugging Face Transformers tooling. It is distributed as a standalone model rather than as a LoRA adapter.
Intended uses
Lailaba AI is intended for experimentation and assistance with tasks such as:
- Programming, Python, and software development
- Web development and APIs
- Artificial intelligence and machine learning
- Linux and command-line tools
- Cloud computing and software integration
- Cybersecurity education and defensive security concepts
- Learning, research, and technical explanations
The model may also be used as a starting point for chat applications, educational tools, developer utilities, and other text-based applications. It can be further fine-tuned for specialized tasks.
Quick start
Install dependencies
Qwen3 support requires a compatible version of Transformers. Install or upgrade the required packages:
pip install -U "transformers>=4.51.0" torch accelerate
Load and run the model
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
model_id = "lailaba/lailaba-ai"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype="auto",
device_map="auto"
)
prompt = "Explain what an API is in simple terms."
inputs = tokenizer(
prompt,
return_tensors="pt"
).to(model.device)
with torch.no_grad():
outputs = model.generate(
**inputs,
max_new_tokens=256,
do_sample=True,
temperature=0.7,
top_p=0.9
)
# Decode only the newly generated tokens.
new_tokens = outputs[0][inputs["input_ids"].shape[-1]:]
response = tokenizer.decode(
new_tokens,
skip_special_tokens=True
)
print(response)
Conversational use
For chat applications, use the tokenizer's built-in chat template when it is available. The following example formats a system message and a user message before generating a reply.
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
model_id = "lailaba/lailaba-ai"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
model_id,
torch_dtype="auto",
device_map="auto"
)
messages = [
{
"role": "system",
"content": "You are Lailaba AI, a helpful technical assistant."
},
{
"role": "user",
"content": "What is Python?"
}
]
inputs = tokenizer.apply_chat_template(
messages,
tokenize=True,
add_generation_prompt=True,
return_tensors="pt"
).to(model.device)
with torch.no_grad():
outputs = model.generate(
inputs,
max_new_tokens=256
)
new_tokens = outputs[0][inputs.shape[-1]:]
response = tokenizer.decode(
new_tokens,
skip_special_tokens=True
)
print(response)
The chat example assumes that the tokenizer configuration in this repository includes a compatible chat template.
Example
User: What is an API?
Lailaba AI: An API (Application Programming Interface) is a set of rules that allows different software applications to communicate. One application can send a request to an API, and the API can return information or perform an operation for it.
This is an illustrative example, not a benchmark result or a guarantee of model behavior.
Cybersecurity use
The model can be used to explore cybersecurity concepts, secure programming, Linux security, network-security fundamentals, and defensive security practices.
Users are responsible for ensuring that security-related activities are authorized and comply with applicable laws and organizational policies.
Limitations and responsible use
Lailaba AI is a compact experimental model. Its size may limit its ability to handle complex reasoning, long instructions, advanced programming tasks, and specialized technical questions.
The model may:
- Generate incorrect or incomplete information.
- Produce code with bugs or security weaknesses.
- Misinterpret prompts or follow instructions inconsistently.
- Generate plausible-sounding but unsupported claims.
- Lack up-to-date information about recent events and technologies.
Do not rely on its outputs as the sole basis for important decisions. Review, test, and validate generated content---especially code and security-related guidance---before using it.
Evaluation
Formal benchmark results have not yet been published for this release. No benchmark scores or performance claims are made in this model card. Future evaluations may cover programming, instruction following, technical question answering, mathematics, and general reasoning.
Model lineage and development
Lailaba AI is based on the Qwen3-0.6B architecture and is part of the Lailaba AI project. It is intended to evolve through further experimentation, evaluation, and improvements to training and deployment.
For details about the upstream architecture and its terms, consult the Qwen3 model documentation.
Repository contents
The repository contains the files needed to load the standalone checkpoint. Depending on the export, these may include:
lailaba-ai/
βββ config.json
βββ generation_config.json
βββ tokenizer_config.json
βββ tokenizer.json
βββ special_tokens_map.json
βββ model.safetensors
βββ README.md
The actual filenames and number of weight shards may differ in the published repository.
License
This repository is marked as Apache-2.0. The model is based on Qwen3-0.6B; review the upstream model repository and applicable license terms when redistributing or using the model commercially.
Developer
Abdullahi Ibrahim Lailaba
- Hugging Face:
lailaba - Model:
lailaba/lailaba-ai
Feedback and contributions
Feedback, testing, and independent evaluations are welcome. Please report reproducible issues with the prompt, expected behavior, and actual output where possible.
Lailaba AI --- Build. Learn. Create.
A compact experimental language model for programming, technology, education, research, and technical assistance.
- Downloads last month
- 813