Update README.md

README.md

@@ -1,75 +1,92 @@
 # Introduction
 
-RoboBrain2.0-7B-FlagOS-Nvidia  provides an all-in-one deployment solution, enabling execution of RoboBrain2.0-7B on Nvidia GPUs. As the first-generation release for the <HARDWARE_PLATFORM_SERIES>, this package delivers three key features:
+**FlagOS** is a unified heterogeneous computing software stack for large models, co-developed with leading global chip manufacturers. With core technologies such as the **FlagScale** distributed training/inference framework, **FlagGems** universal operator library, **FlagCX** communication library, and **FlagTree** unified compiler, the **FlagRelease** platform leverages the FlagOS stack to automatically produce and release various combinations of <chip + open-source model>. This enables efficient and automated model migration across diverse chips, opening a new chapter for large model deployment and application.
 
-1. Comprehensive Integration:
-   - Integrated with FlagScale (https://github.com/FlagOpen/FlagScale).
-   - Open-source inference execution code, preconfigured with all necessary software and hardware settings.
-   - Pre-built Docker image for rapid deployment on <HARDWARE_PLATFORM_SERIES>.
-3. Consistency Validation:
-   - Evaluation tests verifying consistency of results between the official and ours.
+Based on this, the **RoboBrain2.0-7B-FlagOS-FP8Dynamic** model is adapted for the Metax chip using the FlagOS software stack, enabling:
 
-# Technical Summary
+### Integrated Deployment
 
-## Serving Engine
+- Deep integration with the open-source [FlagScale framework](https://github.com/FlagOpen/FlagScale)
+- Out-of-the-box inference scripts with pre-configured hardware and software parameters
+- Released **FlagOS** container image supporting deployment within minutes
 
-We use FlagScale as the serving engine to improve the portability of distributed inference.
+### Consistency Validation
 
-FlagScale is an end-to-end framework for large models across multiple chips, maximizing computational resource efficiency while ensuring model effectiveness. It ensures both ease of use and high performance for users when deploying models across different chip architectures:
+- Rigorously evaluated through benchmark testing: Performance and results from the FlagOS software stack are compared against native stacks on multiple public.
 
-- One-Click Service Deployment: FlagScale provides a unified and simple command execution mechanism, allowing users to fast deploy services seamlessly across various hardware platforms using the same command. This significantly reduces the entry barrier and enhances user experience.
-- Automated Deployment Optimization: FlagScale automatically optimizes distributed parallel strategies based on the computational capabilities of different AI chips, ensuring optimal resource allocation and efficient utilization, thereby improving overall deployment performance.
-- Automatic Operator Library Switching: Leveraging FlagScale's unified Runner mechanism and deep integration with FlagGems, users can seamlessly switch to the FlagGems operator library for inference by simply adding environment variables in the configuration file.
+# Technical Overview
 
-## Triton Support
+## **FlagScale Distributed Training and Inference Framework**
 
-We validate the execution of RoboBrain2.0-7B model with a Triton-based operator library as a PyTorch alternative.
+FlagScale is an end-to-end framework for large models across heterogeneous computing resources, maximizing computational efficiency and ensuring model validity through core technologies. Its key advantages include:
 
-We use a variety of Triton-implemented operation kernels  to run the RoboBrain2.0-7B model. These kernels come from two main sources:
+- **Unified Deployment Interface:** Standardized command-line tools support one-click service deployment across multiple hardware platforms, significantly reducing adaptation costs in heterogeneous environments.
+- **Intelligent Parallel Optimization:** Automatically generates optimal distributed parallel strategies based on chip computing characteristics, achieving dynamic load balancing of computation/communication resources.
+- **Seamless Operator Switching:** Deep integration with the FlagGems operator library allows high-performance operators to be invoked via environment variables without modifying model code.
 
-- Most Triton kernels are provided by FlagGems (https://github.com/FlagOpen/FlagGems). You can enable FlagGems kernels by setting the environment variable USE_FLAGGEMS. 
+## **FlagGems Universal Large-Model Operator Library**
 
-- Also included are Triton kernels from vLLM, such as fused MoE.
+FlagGems is a Triton-based, cross-architecture operator library collaboratively developed with industry partners. Its core strengths include:
 
-# Container Image Download
+- **Full-stack Coverage**: Over 100 operators, with a broader range of operator types than competing libraries.
+- **Ecosystem Compatibility**: Supports 7 accelerator backends. Ongoing optimizations have significantly improved performance.
+- **High Efficiency**: Employs unique code generation and runtime optimization techniques for faster secondary development and better runtime performance compared to alternatives.
+
+## **FlagEval Evaluation Framework**
+
+FlagEval (Libra)** is a comprehensive evaluation system and open platform for large models launched in 2023. It aims to establish scientific, fair, and open benchmarks, methodologies, and tools to help researchers assess model and training algorithm performance. It features:
+
+- **Multi-dimensional Evaluation**: Supports 800+ model evaluations across NLP, CV, Audio, and Multimodal fields, covering 20+ downstream tasks including language understanding and image-text generation.
+- **Industry-Grade Use Cases**: Has completed horizontal evaluations of mainstream large models, providing authoritative benchmarks for chip-model performance validation.
 
-|             | Usage                                                        | Nvidia |
-| ----------- | ------------------------------------------------------------ | ------------------- |
-| Basic Image | basic software environment that supports FlagOS model running |              |
 # Evaluation Results
 
-## Benchmark Result 
+## Benchmark Result
 
-| Metrics            | RoboBrain2.0-7B-H100-CUDA | RoboBrain2.0-7B-FlagOS-Nvidia |
-|:-------------------|--------------------------|-----------------------------|
-| livebench_new      | -                        | 0.504 |
-| aime               | -                        | 0.167 |
-| GPQA(0-shot)       | -                        | 0.395 |
-| MMLU              | -                        | 0.697 |
-| MUSR              | -                        | 0.570 |
-| TheoremQA         | -                        | 0.151 |
+| Metrics     | RoboBrain2.0-7B-H100-CUDA | RoboBrain2.0-7B-FlagOS-FP8Dynamic |
+| ----------- | ------------------------- | --------------------------------- |
+| coming soon | coming soon               | coming soon                       |
 
+# User Guide
 
-# How to Run Locally
-## 📌 Getting Started
-### Download open-source weights
+## General Information 
 
-```bash
+**Basic Information**
 
-pip install modelscope
-modelscope download --model <Model Name> --local_dir <Cache Path>
+| Type            | Location    |
+| --------------- | ----------- |
+| Model Weights   | coming soon |
+| Container Image | coming soon |
+
+**Environment Setup**
+
+| System Component                | Version Information                   |
+| ------------------------------- | ------------------------------------- |
+| Accelerator Card Driver Version | Driver Version: 535.183.06            |
+| Docker Version                  | Docker version 20.10.5, build 55c4c88 |
+| Operating System                | Description:     Ubuntu 22.04.4 LTS   |
+| FlagScale                       | Version: 0.6.0                        |
+| FlagGems                        | Version: 2.2                          |
+
+## Operation Steps
+
+### Download Open-source Model Weights
 
+```python
+pip install modelscope
+modelscope download --model <model path> --local_dir /share/RoboBrain2.0-7B
 ```
 
-### Download the FlagOS image
+### Download FlagOS Image
 
-```bash
-docker pull 
+```python
+docker pull <image>
 ```
 
 ### Start the inference service
 
-```bash
+```
+#Container Startup
 docker run --rm --init --detach \
   --net=host --uts=host --ipc=host \
   --security-opt=seccomp=unconfined \
@@ -81,33 +98,98 @@ docker run --rm --init --detach \
   -v /share:/share \
   --gpus all \
   --name flagos \
-   \
+  <image> \
   sleep infinity
-
+  
 docker exec -it flagos bash
 ```
 
 ### Serve
 
-```bash
-flagscale serve <Model>
+```python
+flagscale serve robobrain2
+
+#After the service starts, you will see output similar to the following:
+#INFO:     Started server process [392]
+#INFO:     Waiting for application startup.
+#INFO:     Application startup complete.
+```
+
+# Service Invocation
+
+## API-based Invocation Script
+
 ```
+import openai
+openai.api_key = "EMPTY"
+openai.base_url = "http://<server_ip>:9010/v1/"
+model = "RoboBrain2.0-7B-nv-flagos-FP8Dynamic"
+messages = [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": "What's the weather like today?"}
+]
+response = openai.chat.completions.create(
+    model=model,
+    messages=messages,
+    temperature=0.7,
+    top_p=0.95,
+    stream=False,
+)
+for item in response:
+    print(item)
+```
+
+## AnythingLLM Integration Guide
+
+#### 1. Download & Install
+
+- Visit the official site: https://anythingllm.com/
+- Choose the appropriate version for your OS (Windows/macOS/Linux)
+- Follow the installation wizard to complete the setup
+
+#### 2. Configuration
+
+- Launch AnythingLLM
+- Open settings (bottom left, fourth tab)
+- Configure core LLM parameters
+- Click "Save Settings" to apply changes
+
+#### 3. Model Interaction
+
+- After model loading is complete:
+  - Click **"New Conversation"**
+  - Enter your question (e.g., “Explain the basics of quantum computing”)
+  - Click the send button to get a response
+
+# Frequently Asked Questions
+
+### Q1: What should I do if the model fails to load?
+
+- Check if the model weight path is correct.
+- Ensure the Qwen3-4B model files are present in the `/share` directory inside the container.
+- Check the container logs: `docker logs flagos`.
+
+### Q2: API call returns a timeout error. What should I do?
+
+- Verify that the server IP address is correct.
+- Check the firewall settings to ensure port 9010 is open.
+- Confirm that the service is running properly: `docker exec flagos ps aux | grep flagscale`.
 
 # Contributing
 
 We warmly welcome global developers to join us:
+
 1. Submit Issues to report problems
 2. Create Pull Requests to contribute code
 3. Improve technical documentation
 4. Expand hardware adaptation support
 
-# 📞 Contact Us
+# Contact Us
 
-Scan the QR code below to add our WeChat group
-send "FlagRelease"
-
-![WeChat](image/group.png)
+![image](image_.jpeg)
 
 # License
 
 This project and related model weights are licensed under the MIT License.
+
+Release Date: 2025.07.12