wasmdashai

vivo-c-v1

README

License: apache-2.0

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

Table with columns: Property, Value
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

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

Table with columns: Capability, vivo-c-v1, General-purpose LLMs
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

Quick Start

Install the latest compatible libraries:

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

Load the model with Hugging Face Transformers:

python
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

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

SGLang

bash
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:

bash
--max-model-len 32768

or:

bash
--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:

text
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:

Table with columns: Workload, Suggested context
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:

python
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

bibtex
@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.

Available on FriendliAI

Dedicated Endpoints

Run this model inference on single tenant GPU with unmatched speed and reliability at scale.

Learn more

Container

Run this model inference with full control and performance in your environment.