Instructions to use wasmdashai/vivo-c-v1 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use wasmdashai/vivo-c-v1 with Transformers:

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

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

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("wasmdashai/vivo-c-v1")
model = AutoModelForCausalLM.from_pretrained("wasmdashai/vivo-c-v1")
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 wasmdashai/vivo-c-v1 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "wasmdashai/vivo-c-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": "wasmdashai/vivo-c-v1",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/wasmdashai/vivo-c-v1

SGLang

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

Docker Model Runner
How to use wasmdashai/vivo-c-v1 with Docker Model Runner:
```
docker model run hf.co/wasmdashai/vivo-c-v1
```

vivo-c-v1

Balanced Arabic Intelligence for Cloud and Enterprise Applications

🌐 VIVO AI • 🤗 Hugging Face • 🏢 Lahja AI

Overview

vivo-c-v1 is a large-scale conversational language model developed as part of the VIVO AI model family.

The model is built on Qwen3-235B-A22B-Instruct-2507, a Mixture-of-Experts causal language model with approximately 235 billion total parameters and 22 billion activated parameters per token.

vivo-c-v1 is being developed to provide a balanced foundation for Arabic conversational intelligence, enterprise assistants, AI agents, knowledge-based systems, cloud applications, and long-context workloads.

The model places particular emphasis on:

Modern Standard Arabic
Saudi and Gulf Arabic dialects
Natural conversational interaction
Long-context understanding
Enterprise knowledge integration
Tool and function calling
Cloud-native deployment
AI-agent workflows

Why vivo-c-v1?

Many general-purpose language models are optimized primarily for broad multilingual benchmarks. vivo-c-v1 is positioned around practical deployment scenarios where response quality, contextual continuity, scalability, and integration with external systems are essential.

The model is designed for applications that require:

Natural Arabic conversations
Regional dialect awareness
Persistent conversational context
Retrieval-Augmented Generation (RAG)
Enterprise knowledge bases
API and tool integration
Intelligent workflow automation
Scalable cloud inference

Model Architecture

Property	Value
Model type	Causal Language Model
Architecture	Qwen3 Mixture of Experts
Total parameters	Approximately 235B
Activated parameters	Approximately 22B per token
Non-embedding parameters	Approximately 234B
Number of layers	94
Attention heads	64 query heads and 4 key-value heads
Number of experts	128
Activated experts	8
Native context length	262,144 tokens
Extended context	Up to approximately 1,010,000 tokens
Tensor type	BF16
License	Apache 2.0

The parameter and architecture values above describe the underlying base architecture. They should not be interpreted as independently reproduced performance claims for vivo-c-v1.

Core Capabilities

Arabic and Regional Dialects

vivo-c-v1 is intended to improve interactions for Arabic-speaking users by focusing on:

Modern Standard Arabic
Saudi Arabic dialects
Gulf dialects
Context-aware Arabic responses
Reduced literal translation
Better regional language adaptation
Arabic instruction following

Long-Context Understanding

The underlying architecture supports a native context length of 262,144 tokens and can be extended to approximately 1 million tokens using supported long-context configurations.

This makes the model suitable for:

Long enterprise documents
Large knowledge bases
Extended conversations
Repository-level code analysis
Research and technical documents
Multi-step agent workflows

Enterprise and Agentic AI

vivo-c-v1 is designed for integration into:

AI customer-service platforms
Smart virtual assistants
Enterprise search
Knowledge management
AI agents
Tool-calling systems
RAG pipelines
Workflow automation
Government, education, and healthcare applications

Comparison with General Language Models

Capability	vivo-c-v1	General-purpose LLMs
Arabic-first deployment focus	High priority	General multilingual coverage
Saudi and Gulf dialect scenarios	Core target	Varies by model
Conversational applications	Primary use case	General text generation
Long-context workflows	Supported	Depends on model
Enterprise integration	APIs, RAG, tools, knowledge bases	Requires customization
AI-agent workflows	Designed for tool integration	Varies by implementation
Cloud deployment	Production-oriented	Depends on infrastructure
Resource balance	MoE with 22B active parameters	Architecture dependent

Quick Start

Install the latest compatible libraries:

pip install --upgrade "transformers>=4.51.0" accelerate torch

Load the model with Hugging Face Transformers:

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "wasmdashai/vivo-c-v1"

tokenizer = AutoTokenizer.from_pretrained(
    model_id,
    trust_remote_code=True,
)

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype="auto",
    device_map="auto",
    trust_remote_code=True,
)

messages = [
    {
        "role": "system",
        "content": (
            "You are an enterprise AI assistant specialized in Arabic "
            "and Saudi conversational applications."
        ),
    },
    {
        "role": "user",
        "content": "صمم معمارية لمنصة مساعد ذكي مؤسسية قابلة للتوسع.",
    },
]

text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
)

inputs = tokenizer(
    [text],
    return_tensors="pt",
).to(model.device)

with torch.inference_mode():
    generated_ids = model.generate(
        **inputs,
        max_new_tokens=2048,
        temperature=0.7,
        top_p=0.8,
        top_k=20,
        do_sample=True,
    )

output_ids = generated_ids[0][inputs.input_ids.shape[-1]:]

response = tokenizer.decode(
    output_ids,
    skip_special_tokens=True,
)

print(response)

Cloud Deployment

vLLM

vllm serve wasmdashai/vivo-c-v1 \
  --tensor-parallel-size 8 \
  --max-model-len 262144

SGLang

python -m sglang.launch_server \
  --model-path wasmdashai/vivo-c-v1 \
  --tp 8 \
  --context-length 262144

For environments with limited GPU memory, reduce the context length:

--max-model-len 32768

or:

--context-length 32768

Agentic Use

vivo-c-v1 can be integrated with:

Function calling
Model Context Protocol (MCP)
Code execution tools
Search and retrieval tools
RAG systems
Enterprise APIs
Workflow orchestration
Multi-agent applications

A typical production architecture may include:

User Interface
      │
      ▼
API Gateway
      │
      ▼
vivo-c-v1 Inference Service
      │
      ├── RAG and Vector Database
      ├── Enterprise Knowledge Bases
      ├── External APIs and Tools
      ├── Agent Orchestration
      └── Monitoring and Safety Layer

Long-Context Deployment

Processing contexts close to one million tokens requires substantial infrastructure for:

Model weights
KV cache
Activation memory
Tensor parallelism
High-bandwidth GPU communication

For production deployment, context size should be selected according to the actual workload rather than always enabling the maximum supported length.

Recommended starting values:

Workload	Suggested context
Standard assistant	16K–32K
Enterprise RAG	32K–128K
Long-document analysis	128K–256K
Specialized ultra-long context	Above 256K with dedicated infrastructure

Recommended Generation Settings

A practical starting configuration is:

generation_config = {
    "temperature": 0.7,
    "top_p": 0.8,
    "top_k": 20,
    "max_new_tokens": 2048,
    "do_sample": True,
}

These values should be adjusted according to the application, latency target, output length, and factuality requirements.

Intended Uses

vivo-c-v1 is intended for:

Arabic conversational assistants
Saudi and Gulf customer-service applications
Enterprise copilots
AI agents and automation
Knowledge-base assistants
RAG systems
Long-document analysis
Code and technical assistance
Government digital services
Education and healthcare platforms
Cloud-native AI applications

Limitations

The model may generate inaccurate or unsupported information.
Arabic dialect quality may vary by topic and prompt.
Long-context support does not guarantee perfect recall of every detail.
Large-scale inference requires substantial GPU infrastructure.
Generated code and business recommendations should be reviewed.
Sensitive or high-stakes outputs require human validation.
Performance results of the base model should not be presented as independently reproduced vivo-c-v1 results unless separate evaluations are published.

Responsible Use

Users are responsible for:

Reviewing generated content
Protecting personal and confidential information
Applying appropriate access controls
Monitoring production outputs
Testing integrations before deployment
Complying with applicable laws and organizational policies

Platform Links

Base Model and Attribution

vivo-c-v1 is based on:

Qwen3-235B-A22B-Instruct-2507

https://huggingface.co/Qwen/Qwen3-235B-A22B-Instruct-2507

Please follow the applicable base-model license and attribution requirements.

Citation

@misc{qwen3technicalreport,
    title        = {Qwen3 Technical Report},
    author       = {Qwen Team},
    year         = {2025},
    eprint       = {2505.09388},
    archivePrefix= {arXiv},
    primaryClass = {cs.CL}
}

License

This repository uses the Apache License 2.0, subject to the applicable terms of the base model and included dependencies.

Downloads last month: 415

Safetensors

Model size

235B params

Tensor type

BF16

Model tree for wasmdashai/vivo-c-v1

Base model

Qwen/Qwen3-235B-A22B-Instruct-2507

Finetuned

(19)

this model

Collection including wasmdashai/vivo-c-v1

VIVO AI

Collection

3 items • Updated 2 days ago

Paper for wasmdashai/vivo-c-v1

Qwen3 Technical Report

Paper • 2505.09388 • Published May 14, 2025 • 343

vivo-c-v1

Balanced Arabic Intelligence for Cloud and Enterprise Applications

Overview

Why vivo-c-v1?

Model Architecture

Core Capabilities

Arabic and Regional Dialects

Long-Context Understanding

Enterprise and Agentic AI

Comparison with General Language Models

Quick Start

Cloud Deployment

vLLM

SGLang

Agentic Use

Long-Context Deployment

Recommended Generation Settings

Intended Uses

Limitations

Responsible Use

Platform Links

vivo-c-v1 on Hugging Face

VIVO AI Platform

Lahja AI

Base Model and Attribution

Citation

License

Model tree for wasmdashai/vivo-c-v1

Collection including wasmdashai/vivo-c-v1

Paper for wasmdashai/vivo-c-v1