Bol-AI is a custom conversational AI assistant developed and fine-tuned by Vivek Vijay Dalvi under MAHAVEER AI. This project focuses on delivering a highly optimized, lightweight, and intelligent conversational experience that can run on standard hardware, including mobile devices.

The model has been engineered with a custom identity, enhanced with multilingual datasets (English, Marathi, Hindi), and fine-tuned for superior instruction-following and coding assistance.

Official Documentation: bol-ai-docs.vercel.app/

✨ Core Features

Intelligent Conversational Responses: Human-like, context-aware replies.
Custom AI Personality System: Unique identity and behavior engineered by Vivek Dalvi.
Multilingual Understanding: Natively supports English, Marathi, and Hindi.
Expert Coding Assistance: Optimized for instruction-following in various programming languages.
Ultra-Lightweight & Fast: At just 2.5 GB, it is designed for efficient local deployment on standard hardware.
Privacy-Focused: Runs 100% offline, ensuring user data remains secure.
Mobile Ready: Optimized to run on high-end mobile devices with sufficient RAM.

🧠 Full Model Information

Property	Details
Model Name	Bol-AI
AI Category	Conversational AI Assistant
Developer	Vivek Vijay Dalvi
Organization	MAHAVEER AI
Base Model	MiniCPM-V-4.6 (Heavily Fine-Tuned)
Base Model Developer	OpenBMB
Architecture	Transformer
Parameter Count	~1.7 Billion
Context Length	32,000 Tokens
Model Size	2.42 GB
Quantization	4-bit Optimized (NF4)
Model Format	SafeTensors
Primary Language	English
Supported Languages	English, Marathi, Hindi
License	Apache-2.0

🛠️ Training & Customization

Bol-AI's superior performance is the result of extensive fine-tuning and engineering, including:

Conversational Fine-Tuning: Trained on over 65,000 high-quality instruction rows.
Identity Engineering: Deeply baked identity ensures the model recognizes its creator and purpose.
Response Optimization: Tuned for accuracy, relevance, and consistency.
Multilingual Data Integration: Enhanced with custom datasets for Indian languages.
Behavioral Tuning: Personality and interaction style refined for a professional assistant experience.

💻 System Requirements

Bol-AI is highly optimized to run on a wide range of devices.

Desktop / Laptop

Component	Minimum (CPU-Only)	Recommended (GPU for Speed)
System RAM	8GB	16GB+
GPU VRAM	Not Required	4GB+ (NVIDIA CUDA Recommended)
Storage	5GB+	5GB+ (SSD Recommended)
OS	Windows 10/11, Linux, macOS	Windows 10/11, Linux

Mobile (via Termux or similar apps)

Component	Minimum
Device RAM	8GB
Storage	5GB+ Free Space
OS	Android 10+
Processor	Modern 8-core CPU (e.g., Snapdragon 7xx+)

Note: Performance on mobile devices will be slower than on a desktop with a dedicated GPU.

🚀 Example Usage

python

# ==============================================================================
# BOL-AI v1.0 PRO - OFFICIAL EXECUTION SCRIPT
# Developer: Vivek Vijay Dalvi | Company: MAHAVEER AI
# ==============================================================================

# INSTALLATION:

#  Force update transformers and dependencies

#  !pip install -U transformers accelerate bitsandbytes sentencepiece

#  pip install torch transformers accelerate bitsandbytes sentencepiece

import torch
import torch.nn.functional as F
import os
import json
from transformers import AutoTokenizer, AutoModel

# Ensure UTF-8 support for Windows
os.environ["PYTHONUTF8"] = "1"

# Repository ID or Local Path
MODEL_ID = "mahaveerai/bol-ai"

# Generation Settings
TEMPERATURE = 0.1
MAX_NEW_TOKENS = 300

def load_bol_ai():
    """Load model with a temporary mask to bypass custom architecture errors"""
    print("Initializing Bol-AI v1.0 Pro Engine...")
    
    # Load tokenizer
    tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
    
    # Handle custom model_type 'bol_ai_v1' by using a temporary memory fix
    from transformers import AutoConfig
    try:
        # Try loading directly
        model = AutoModel.from_pretrained(
            MODEL_ID,
            torch_dtype=torch.bfloat16,
            device_map="auto",
            trust_remote_code=True
        )
    except KeyError:
        # If 'bol_ai_v1' causes a KeyError, load using the base architecture blueprint
        print("Applying architecture mapping...")
        config = AutoConfig.from_pretrained("openbmb/MiniCPM-V-4.6", trust_remote_code=True)
        model = AutoModel.from_pretrained(
            MODEL_ID,
            config=config,
            torch_dtype=torch.bfloat16,
            device_map="auto",
            trust_remote_code=True
        )
    
    model.eval()
    return tokenizer, model

def custom_generate(tokenizer, model, user_input):
    """Manual generation loop to bypass missing .chat() or .generate() methods"""
    # Format the prompt to trigger the trained identity
    prompt = f"User: {user_input}\nBol-AI:"
    input_ids = tokenizer(prompt, return_tensors="pt").input_ids.to(model.device)
    
    # Dynamically find the Language Model Head (the 'voice box')
    lm_head = None
    with torch.no_grad():
        out = model(input_ids)
        # Get hidden state dimension
        h = out.last_hidden_state if hasattr(out, "last_hidden_state") else out[0]
        dim = h.shape[-1]
        
        # Search for the correct linear layer or embedding weight
        for name, module in model.named_modules():
            if isinstance(module, torch.nn.Linear) and module.in_features == dim and module.out_features > 20000:
                lm_head = lambda x: module(x.to(module.weight.dtype))
                break
        if not lm_head:
            for module in model.modules():
                if isinstance(module, torch.nn.Embedding) and module.embedding_dim == dim and module.num_embeddings > 20000:
                    lm_head = lambda x: torch.matmul(x.to(module.weight.dtype), module.weight.T)
                    break
                    
    if not lm_head:
        return "Error: Language head not found."

    generated_ids = input_ids[0].tolist()
    start_len = len(generated_ids)
    
    # Generate tokens one by one
    for _ in range(MAX_NEW_TOKENS):
        curr_tensor = torch.tensor([generated_ids]).to(model.device)
        with torch.no_grad():
            out = model(curr_tensor)
            h = out.last_hidden_state if hasattr(out, "last_hidden_state") else out[0]
            logits = lm_head(h[:, -1, :])
            
            # Greedy search for maximum accuracy at low temperature
            token = torch.argmax(logits, dim=-1).item()
            
            generated_ids.append(token)
            # Stop if the model generates the End of String token
            if token == tokenizer.eos_token_id:
                break
                
    return tokenizer.decode(generated_ids[start_len:], skip_special_tokens=True)

def start_chat():
    """Main terminal interface"""
    tokenizer, model = load_bol_ai()
    
    print("\n" + "="*40)
    print("BOL-AI v1.0 PRO IS ONLINE")
    print("Developer: Vivek Vijay Dalvi")
    print("Company: MAHAVEER AI")
    print("="*40)
    print("Type 'exit' to quit.\n")
    
    while True:
        query = input("You: ")
        if query.lower() in ["exit", "quit"]:
            break
        
        print("Bol-AI: Thinking...", end="\r")
        response = custom_generate(tokenizer, model, query)
        
        # Clean the output to remove any trailing 'User:' tags
        final_text = response.split("User:")[0].strip()
        print(f"Bol-AI: {final_text}\n")

if __name__ == "__main__":
    start_chat()

🔥 Why Bol-AI?

Bol-AI was designed to provide:

Better conversational intelligence
Smart assistant interaction
Enhanced communication quality
Human-like AI responses
Optimized assistant behavior
Lightweight AI deployment
Personalized AI interaction
Fast and intelligent responses

The project combines conversational optimization, assistant engineering, and AI response tuning into a single intelligent assistant system.

🧾 Additional Information

Information	Details
AI Project	Bol-AI
Developer Alias	MAHAVEER AI
Model Format	SafeTensors
Response Style	Conversational
Deployment Support	Local / Cloud
AI Category	Assistant AI
Optimization	Fine-tuned
Main Purpose	Intelligent Conversations
Assistant Type	Conversational Assistant
AI Identity	Bol-AI
AI Communication	Optimized

🔒 License

Bol-AI includes custom conversational tuning, assistant optimization, response engineering, and fine-tuning developed by Vivek Vijay Dalvi.

Base Model Credit:

MiniCPM-V-4.6 by OpenBMB — Apache-2.0 License.

👨‍💻 Developer

Vivek Vijay Dalvi
Founder & Developer of MAHAVEER AI

Bol-AI is a custom conversational AI assistant developed, engineered, optimized, and enhanced by Vivek Vijay Dalvi.

mahaveerai/bol-ai

Bol-AI v1.0

Bol-AI

A Custom, Lightweight Conversational AI Assistant

ï¿½MAHAVEER_AI :: VIVEK-X ï¿½ Ø§Ù„Ø°ÙƒØ§Ø¡ Ø§Ø³ØªÙŠÙ‚Ø¸... Ø§Ù„Ù…ØØ±Ø­Ù„Ø© Ø§Ù„Ø£Ø®Ø·Ø± Ù‚Ø§Ø¯Ù…Ø©ï¿½

📌 About Bol-AI