Update README.md

README.md

@@ -1,187 +1,215 @@
 ---
 library_name: transformers
 license: apache-2.0
-license_link: https://huggingface.co/Qwen/Qwen3-Coder-Next/blob/main/LICENSE
+license_link: https://huggingface.co/aivedha/aicippy-Coder/blob/main/LICENSE
 pipeline_tag: text-generation
+base_model: aivedha/aicippy-Coder
+tags:
+  - aicippy
+  - aivedha
+  - aivibe
+  - coding-agent
+  - code-generation
+  - agentic-coding
 ---
 
-# Qwen3-Coder-Next
+<p align="center">
+  <img src="https://aivibe.cloud/assets/aivibe-logo.png" alt="AiVibe Logo" width="180"/>
+</p>
 
-## Highlights
+<h1 align="center">AiCIPPY-Coder</h1>
+
+<p align="center">
+  <b>The Agentic Coding Intelligence behind AiCIPPY</b><br/>
+  <i>by AiVedha · AiVibe Software Services Private Limited</i>
+</p>
+
+<p align="center">
+  <a href="https://aicippy.com">aicippy.com</a> ·
+  <a href="https://aivedha.ai">aivedha.ai</a> ·
+  <a href="https://aivibe.cloud">aivibe.cloud</a> ·
+  <a href="https://pypi.org/project/aicippy">PyPI</a>
+</p>
 
-Today, we're announcing **Qwen3-Coder-Next**, an open-weight language model designed specifically for coding agents and local development. It features the following key enhancements:  
+---
 
-- **Super Efficient with Significant Performance**: With only 3B activated parameters (80B total parameters), it achieves performance comparable to models with 10–20x more active parameters, making it highly cost-effective for agent deployment.
-- **Advanced Agentic Capabilities**: Through an elaborate training recipe, it excels at long-horizon reasoning, complex tool usage, and recovery from execution failures, ensuring robust performance in dynamic coding tasks.
-- **Versatile Integration with Real-World IDE**: Its 256k context length, combined with adaptability to various scaffold templates, enables seamless integration with different CLI/IDE platforms (e.g., Claude Code, Qwen Code, Qoder, Kilo, Trae, Cline, etc.), supporting diverse development environments.
+## Highlights
 
-![image/jpeg](https://qianwen-res.oss-accelerate-overseas.aliyuncs.com/Qwen3-Coder-Next/benchmarks.png)
+We are releasing **AiCIPPY-Coder** — the open-weight coding intelligence model powering the AiCIPPY agent platform. Built for real-world agentic software development, this model is the foundation of AiCIPPY's CLI and IDE-integrated coding workflows.
 
-![image/jpeg](https://qianwen-res.oss-accelerate-overseas.aliyuncs.com/Qwen3-Coder-Next/swebench_pro.png)
+- **Efficient Yet Powerful**: With only 3B activated parameters (80B total), AiCIPPY-Coder delivers performance comparable to models with 10–20x more active parameters — making it highly cost-effective for production agent deployment at scale.
+- **Advanced Agentic Capabilities**: Trained with an elaborate agentic recipe, the model excels at long-horizon reasoning, complex multi-step tool usage, and graceful recovery from execution failures — essential for robust real-world coding tasks.
+- **Seamless IDE and CLI Integration**: A native 256K context window, combined with full adaptability to diverse scaffold templates, enables plug-and-play integration with CLI agents (including AiCIPPY CLI), VS Code extensions, and platforms such as Cline, Kilo, Trae, and others.
+
+---
 
 ## Model Overview
 
-**Qwen3-Coder-Next** has the following features:
-- Type: Causal Language Models
-- Training Stage: Pretraining & Post-training
-- Number of Parameters: 80B in total and 3B activated
-- Number of Parameters (Non-Embedding): 79B
-- Hidden Dimension: 2048
-- Number of Layers: 48
-  - Hybrid Layout: 12 \* (3 \* (Gated DeltaNet -> MoE) -> 1 \* (Gated Attention -> MoE))
-- Gated Attention:
-  - Number of Attention Heads: 16 for Q and 2 for KV
-  - Head Dimension: 256
-  - Rotary Position Embedding Dimension: 64
-- Gated DeltaNet:
-  - Number of Linear Attention Heads: 32 for V and 16 for QK
-  - Head Dimension: 128
-- Mixture of Experts:
-  - Number of Experts: 512
-  - Number of Activated Experts: 10
-  - Number of Shared Experts: 1
-  - Expert Intermediate Dimension: 512
-- Context Length: 262,144 natively
-
-**NOTE: This model supports only non-thinking mode and does not generate ``<think></think>`` blocks in its output. Meanwhile, specifying `enable_thinking=False` is no longer required.**
-
-For more details, including benchmark evaluation, hardware requirements, and inference performance, please refer to our [blog](https://qwen.ai/blog?id=qwen3-coder-next), [GitHub](https://github.com/QwenLM/Qwen3-Coder), and [Documentation](https://qwen.readthedocs.io/en/latest/).
+**AiCIPPY-Coder** carries the following architecture:
+
+| Property | Value |
+|---|---|
+| Model Type | Causal Language Model |
+| Training Stage | Pretraining & Post-training |
+| Total Parameters | 80B |
+| Activated Parameters | 3B |
+| Non-Embedding Parameters | 79B |
+| Hidden Dimension | 2048 |
+| Number of Layers | 48 |
+| Context Length | 262,144 tokens (native) |
+| Thinking Mode | Non-thinking (no `<think>` blocks) |
+
+**Architecture Details:**
+- **Hybrid Layout:** 12 × (3 × Gated DeltaNet → MoE) → 1 × (Gated Attention → MoE)
+- **Gated Attention:** 16 heads for Q, 2 for KV, Head Dim 256, RoPE Dim 64
+- **Gated DeltaNet:** 32 heads for V, 16 for QK, Head Dim 128
+- **Mixture of Experts:** 512 total experts, 10 activated, 1 shared, Expert Intermediate Dim 512
 
+> **Note:** This model operates in non-thinking mode only. The `<think></think>` output blocks are not generated. Setting `enable_thinking=False` is not required.
+
+---
 
 ## Quickstart
 
-We advise you to use the latest version of `transformers`.
+Ensure you are using the latest version of `transformers` before proceeding.
 
-The following contains a code snippet illustrating how to use the model generate content based on given inputs. 
 ```python
 from transformers import AutoModelForCausalLM, AutoTokenizer
 
-model_name = "Qwen/Qwen3-Coder-Next"
+model_name = "aivedha/aicippy-Coder"
 
-# load the tokenizer and the model
+# Load tokenizer and model
 tokenizer = AutoTokenizer.from_pretrained(model_name)
 model = AutoModelForCausalLM.from_pretrained(
-  model_name,
-  torch_dtype="auto",
-  device_map="auto"
+    model_name,
+    torch_dtype="auto",
+    device_map="auto"
 )
 
-# prepare the model input
+# Prepare input
 prompt = "Write a quick sort algorithm."
 messages = [
-  {"role": "user", "content": prompt}
+    {"role": "user", "content": prompt}
 ]
 text = tokenizer.apply_chat_template(
-  messages,
-  tokenize=False,
-  add_generation_prompt=True,
+    messages,
+    tokenize=False,
+    add_generation_prompt=True,
 )
 model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
 
-# conduct text completion
+# Generate
 generated_ids = model.generate(
     **model_inputs,
     max_new_tokens=65536
 )
-output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist() 
+output_ids = generated_ids[0][len(model_inputs.input_ids[0]):].tolist()
 
 content = tokenizer.decode(output_ids, skip_special_tokens=True)
-
-print("content:", content)
+print("AiCIPPY-Coder:", content)
 ```
 
-**Note: If you encounter out-of-memory (OOM) issues, consider reducing the context length to a shorter value, such as `32,768`.**
+> **Note:** If you encounter out-of-memory (OOM) issues, reduce the context length — for example, to `32,768` tokens.
+
+For local use, AiCIPPY-Coder is compatible with **Ollama**, **LMStudio**, **MLX-LM**, **llama.cpp**, and **KTransformers**.
 
-For local use, applications such as Ollama, LMStudio, MLX-LM, llama.cpp, and KTransformers have also supported Qwen3.
+---
 
 ## Deployment
 
-For deployment, you can use the latest `sglang` or `vllm` to create an OpenAI-compatible API endpoint.
+AiCIPPY-Coder can be served via `sglang` or `vllm` as an OpenAI-compatible API endpoint — the same interface used by the AiCIPPY production platform.
 
 ### SGLang
 
-[SGLang](https://github.com/sgl-project/sglang) is a fast serving framework for large language models and vision language models.
-SGLang could be used to launch a server with OpenAI-compatible API service. 
+[SGLang](https://github.com/sgl-project/sglang) is a fast serving framework for large language and vision language models.
 
-`sglang>=v0.5.8` is required for Qwen3-Coder-Next, which can be installed using:
 ```shell
 pip install 'sglang[all]>=v0.5.8'
 ```
-See [its documentation](https://docs.sglang.ai/get_started/install.html) for more details.
 
-The following command can be used to create an API endpoint at `http://localhost:30000/v1` with maximum context length 256K tokens using tensor parallel on 4 GPUs.
+Launch the server with 256K context using tensor parallelism:
+
 ```shell
-python -m sglang.launch_server --model Qwen/Qwen3-Coder-Next --port 30000 --tp-size 2 --tool-call-parser qwen3_coder
+python -m sglang.launch_server \
+  --model aivedha/aicippy-Coder \
+  --port 30000 \
+  --tp-size 2 \
+  --tool-call-parser aicippy-coder
 ```
 
-> [!Note]
-> The default context length is 256K. Consider reducing the context length to a smaller value, e.g., `32768`, if the server fails to start.
+> **Note:** If the server fails to start, reduce context length with `--context-length 32768`.
+
+API endpoint available at: `http://localhost:30000/v1`
 
+---
 
 ### vLLM
 
-[vLLM](https://github.com/vllm-project/vllm) is a high-throughput and memory-efficient inference and serving engine for LLMs.
-vLLM could be used to launch a server with OpenAI-compatible API service. 
+[vLLM](https://github.com/vllm-project/vllm) is a high-throughput, memory-efficient inference and serving engine for LLMs.
 
-`vllm>=0.15.0` is required for Qwen3-Coder-Next, which can be installed using:
 ```shell
 pip install 'vllm>=0.15.0'
 ```
-See [its documentation](https://docs.vllm.ai/en/stable/getting_started/installation/index.html) for more details.
 
-The following command can be used to create an API endpoint at `http://localhost:8000/v1` with maximum context length 256K tokens using tensor parallel on 4 GPUs.
+Launch with 256K context:
+
 ```shell
-vllm serve Qwen/Qwen3-Coder-Next --port 8000 --tensor-parallel-size 2 --enable-auto-tool-choice --tool-call-parser qwen3_coder
+vllm serve aivedha/aicippy-Coder \
+  --port 8000 \
+  --tensor-parallel-size 2 \
+  --enable-auto-tool-choice \
+  --tool-call-parser aicippy-coder
 ```
 
-> [!Note]
-> The default context length is 256K. Consider reducing the context length to a smaller value, e.g., `32768`, if the server fails to start.
+> **Note:** Reduce context length to `32768` if startup fails.
 
+API endpoint available at: `http://localhost:8000/v1`
 
-## Agentic Coding
+---
 
-Qwen3-Coder-Next excels in tool calling capabilities. 
+## Agentic Coding with AiCIPPY-Coder
+
+AiCIPPY-Coder is purpose-built for tool-calling agentic workflows. Define tools and invoke them directly:
 
-You can simply define or use any tools as following example.
 ```python
-# Your tool implementation
-def square_the_number(num: float) -> dict:
+# Tool implementation
+def square_the_number(num: float) -> float:
     return num ** 2
 
-# Define Tools
-tools=[
+# Tool definition
+tools = [
     {
-        "type":"function",
-        "function":{
+        "type": "function",
+        "function": {
             "name": "square_the_number",
-            "description": "output the square of the number.",
+            "description": "Returns the square of the given number.",
             "parameters": {
                 "type": "object",
                 "required": ["input_num"],
                 "properties": {
-                    'input_num': {
-                        'type': 'number', 
-                        'description': 'input_num is a number that will be squared'
-                        }
-                },
+                    "input_num": {
+                        "type": "number",
+                        "description": "The number to be squared."
+                    }
+                }
             }
         }
     }
 ]
 
 from openai import OpenAI
-# Define LLM
+
+# Point to your AiCIPPY-Coder local endpoint
 client = OpenAI(
-    # Use a custom endpoint compatible with OpenAI API
-    base_url='http://localhost:8000/v1',  # api_base
+    base_url="http://localhost:8000/v1",
     api_key="EMPTY"
 )
- 
-messages = [{'role': 'user', 'content': 'square the number 1024'}]
+
+messages = [{"role": "user", "content": "Square the number 1024"}]
 
 completion = client.chat.completions.create(
     messages=messages,
-    model="Qwen3-Coder-Next",
+    model="aivedha/aicippy-Coder",
     max_tokens=65536,
     tools=tools,
 )
@@ -189,20 +217,52 @@ completion = client.chat.completions.create(
 print(completion.choices[0])
 ```
 
+---
+
 ## Best Practices
 
-To achieve optimal performance, we recommend the following sampling parameters: `temperature=1.0`, `top_p=0.95`, `top_k=40`.
+For optimal generation quality, use the following sampling parameters:
+
+| Parameter | Recommended Value |
+|---|---|
+| `temperature` | `1.0` |
+| `top_p` | `0.95` |
+| `top_k` | `40` |
+
+---
+
+## About AiCIPPY
+
+**AiCIPPY** is AiVibe's production-grade agentic coding platform — available as a CLI tool on PyPI and deployable on AWS Bedrock. It combines multi-LLM orchestration, persistent memory via DynamoDB, WebSocket streaming, and enterprise SSO via AWS Cognito.
+
+- **Platform:** [aicippy.com](https://aicippy.com)
+- **CLI:** `pip install aicippy`
+- **Organisation:** AiVibe Software Services Private Limited, Chennai, India
+
+---
+
+## About AiVedha
+
+**AiVedha** (aivedha.ai) is AiVibe's AI-powered cybersecurity audit and compliance platform — available on AWS Marketplace (`prod-kulys2bmix2nm`). AiVedha and AiCIPPY together form the core of AiVibe's enterprise AI product portfolio.
+
+---
 
+## License
+
+This model is released under the **Apache 2.0 License**. See [LICENSE](https://huggingface.co/aivedha/aicippy-Coder/blob/main/LICENSE) for full terms.
+
+The underlying architecture is derived from Qwen3-Coder-Next (Qwen Team, Alibaba Cloud), used in accordance with its Apache 2.0 license terms.
+
+---
 
 ## Citation
 
-If you find our work helpful, feel free to give us a cite.
+If you use AiCIPPY-Coder in your research or products, please cite:
 
-```
-@techreport{qwen_qwen3_coder_next_tech_report,
-  title        = {Qwen3-Coder-Next Technical Report},
-  author       = {{Qwen Team}},
-  url          = {https://github.com/QwenLM/Qwen3-Coder/blob/main/qwen3_coder_next_tech_report.pdf},
-  note         = {Accessed: 2026-02-03}
-}
+```bibtex
+@misc{aivibe_aicippy_coder_2026,
+  title        = {AiCIPPY-Coder: Agentic Coding Intelligence by AiVedha},
+  author       = {{AiVibe Software Services Private Limited}},
+  year         = {2026},
+  url          = {https://huggingface.co/aivedha/aicippy-Coder}}
 ```