Content
# CopliteSuite / DocClaw
## DGX Spark Local Multi-Agent Medical Workbench
> A doctor's workflow intelligent agent for hospital intranet: Deploy a local large model on DGX Spark, with a main agent coordinating clinical assistance, evidence retrieval, evidence screening, citation verification, medical safety review, and follow-up execution, and connecting patients, HIS, knowledge base, medical records, follow-up, and desktop tools through MCP. Before writing medical records and creating follow-ups, doctor confirmation (Human-in-the-Loop, HITL) is required.
This README is organized based on the following materials:
- NVIDIA event page local-first Workshop ideas: model, agent, skill, and runtime environment centralized deployment, with clear local ports and direct browser demonstration.
- Verified DGX Spark, Docker, tmux, NVIDIA vLLM, and local Qwen model deployment process in `DGX_Spark_Docker_tmux_vLLM_deployment_SOP.md`.
- Real code, model registry, sub-agent YAML, MCP tool list, launcher, and end-to-end acceptance script in the current repository.
### Status Mark
| Mark | Meaning |
|---|---|
| ✅ Implemented | Corresponding code or configuration exists in the current repository |
| 🟩 Competition configuration | Can be enabled using existing interfaces, but configuration and verification must be completed on the demonstration machine |
| 🧪 Optional extension | Technical route is clear, but not enabled by default in the current offline package, and cannot be described as completed in the demonstration |
## 1. What problems does the project solve
AI in hospitals not only needs to "answer questions" but also complete an auditable, confirmable, and reversible business chain: read patient context, retrieve and screen evidence, generate draft with basis, complete safety review, and submit for doctor confirmation before writing into medical records or creating follow-up tasks.
CopliteSuite / DocClaw splits this chain into multiple single-responsibility agents and keeps patient data, medical evidence, and tool execution within the hospital intranet. DGX Spark is responsible for local model inference, and the Windows doctor workstation is responsible for interaction, desktop collaboration, and front-end and back-end services.
Core value:
- **Clear privacy boundary**: Patient original data, medical records, and tool execution do not leave the hospital intranet by default.
- **Not a chat shell**: Form a closed loop from patient queue, inquiry, evidence-based medicine, medical records, to follow-up.
- **Key actions are reviewed by humans**: Medical records writing and follow-up creation must be confirmed by doctors before execution.
- **Evidence is traceable**: Medical conclusions are bound to `evidence_id`, and citation verification results are written back to the evidence ledger.
- **Model is replaceable**: The business layer is decoupled from the inference layer through the OpenAI-compatible interface, and can be switched to local Qwen, NVIDIA Nemotron, or StepFun models that have passed privacy gate control.
## 2. Implemented complete capabilities
### Doctor side and business closed loop
- ✅ React + Vite doctor workstation front-end.
- ✅ Patient queue, patient summary, laboratory results, and medical history reading.
- ✅ Doctor inquiry session and streaming agent response.
- ✅ Medical skill viewing, installation, editing, and running.
- ✅ Structured outpatient medical record draft, field difference, and doctor confirmation.
- ✅ Follow-up plan, task scheduling, execution result, and notification.
- ✅ Tool execution and agent running audit.
- ✅ Coplite floating ball, text input, local voice input, desktop, and Office tools.
### Multi-agent collaboration
| Agent | Responsibility boundary | Key tool or constraint |
|---|---|---|
| Main agent | Understand doctor's goal, inject patient context, assign tasks, and summarize results | DeepAgents, MCP, context, and memory middleware |
| `clinical-assistant` | Inquiry analysis, examination interpretation, and medical record draft | `patient_get`, `his_get_labs`, `his_get_history`; request confirmation before writing |
| `evidence-retriever` | Analyze clinical problems and retrieve candidate evidence | `search_guidelines`, `fetch_evidence`; do not provide treatment suggestions directly |
| `evidence-ranker` | Screen by authority, timeliness, population, and evidence level | Output available and inapplicable evidence |
| `evidence-answer-composer` | Generate evidence-based draft only based on ledger | Each key judgment must be bound to `evidence_id` |
| `citation-verifier` | Verify if claim matches evidence | `verify_citation`; unsupported conclusions must be deleted or rewritten |
| `medical-safety-reviewer` | Check diagnosis commitment, prescription authority, acute and contraindication omission | Output `pass` or `revise_required` |
| `followup-executor` | Create, query, and execute follow-up tasks | Dual HITL: draft confirmation + tool execution approval |
### Differences from ordinary single-agent solutions
1. **Retrieval, screening, generation, citation verification, and safety review are isolated**, reducing the circular deviation of the same model "finding evidence and proving itself".
2. **Tools are authorized by role with minimal permission**, e.g., citation verification agent cannot write medical records, and safety review agent cannot create follow-ups.
3. **Degradation path is clear**: When MCP loading fails, it can fall back to FastAPI direct connection; when the model does not support tool calls, Hermes automatically switches to `no_mcp` to avoid pseudo-tool calls.
4. **Middleware controls running cost and risk**: The main agent and clinical sub-agents set model call times, tool call times, summary, memory, and context injection limits.
## 3. System architecture
```mermaid
flowchart LR
Doctor["Doctor / Browser / Coplite Floating Ball"] --> FE["Skill Hub Front-end :5173"]
Doctor --> Coplite["Coplite Desktop"]
FE --> API["Medical Business API :8000"]
FE --> AgentAPI["Agent API :8090"]
AgentAPI --> Main["Main Agent"]
Main --> Clinical["Clinical Assistance"]
Main --> Evidence["Retrieval → Ranking → Generation → Citation Verification"]
Main --> Safety["Medical Safety Review"]
Main --> Followup["Follow-up Execution"]
Main --> MedicalMCP["Medical MCP :8001"]
Coplite --> CopliteMCP["Coplite MCP :9000"]
Coplite --> Hermes["Hermes Runtime"]
Hermes --> MedicalMCP
Hermes --> CopliteMCP
MedicalMCP --> Data["Patient / HIS / Evidence Library / Medical Records / Follow-up / Audit"]
Main --> ModelAdapter["OpenAI-compatible Model Adapter Layer"]
Hermes --> ModelAdapter
ModelAdapter --> VLLM["DGX Spark · NVIDIA vLLM :8000"]
VLLM --> Qwen["Qwen3.6-35B-A3B Local Weights"]
```
### Port convention
| Service | Address | Description |
|---|---|---|
| Skill Hub Front-end | `http://127.0.0.1:5173` | Doctor demonstration entrance |
| Medical Business API | `http://127.0.0.1:8000` | Patient, HIS, follow-up, audit, and other business APIs |
| Medical MCP | `http://127.0.0.1:8001/mcp` | Medical tool service for agents |
| Agent API | `http://127.0.0.1:8090` | DeepAgents session, streaming output, and interrupt recovery |
| Coplite MCP | `http://127.0.0.1:9000/mcp` | Desktop, file, Office, visual, and other tools |
| DGX Spark vLLM | `http://192.168.110.60:8000/v1` | LAN model interface in SOP |
> `8000` appears on two machines: Windows workstation `127.0.0.1:8000` is the medical business API; DGX Spark `192.168.110.60:8000` is the model API, which does not constitute a local port conflict.
## 4. Why use DGX Spark
The GB10 Grace Blackwell Superchip, 128 GB consistent unified memory, and local NVMe of DGX Spark are suitable for completing large model inference and agent development on desktop-level devices. For this project, the platform advantage is not just "running a large model", but:
- **Model weights do not cross the public network**: Qwen weights are mounted read-only from the local machine to the container, and patient requests only go through the hospital LAN.
- **Unified memory bears large models and long context**: Suitable for 35B MoE models and 64K agent context, but concurrency and KV Cache must be controlled.
- **NVIDIA full-stack reproducible**: DGX OS, GPU Driver, NVIDIA Container Toolkit, NGC vLLM container, and CUDA acceleration library form a migratable deployment unit.
- **Path from prototype to production is consistent**: The application layer always uses the OpenAI-compatible API, which can be migrated to NVIDIA NIM, data center GPU, or dual Spark solutions later.
## 5. DGX Spark local model deployment
The following process is for the SOP confirmed environment:
| Item | Value |
|---|---|
| Login user | `Developer` |
| DGX Spark host | `spark-9408` |
| LAN IP | `192.168.110.60` |
| Model directory | `/home/xsuper/models/Qwen3.6-35B-A3B` |
| Model weights | About 67 GB, 26 `safetensors` slices |
| NGC image | `nvcr.io/nvidia/vllm:26.05.post1-py3` |
| External service name | `qwen35-64k` |
| Service port | `8000` |
### 5.1 Environment check
Execute the following complete command on DGX Spark:
```bash
nvidia-smi -L
nvidia-smi
sudo docker --version
sudo docker run --rm --gpus all ubuntu nvidia-smi
sudo test -f /home/xsuper/models/Qwen3.6-35B-A3B/config.json && echo "Model directory check passed"
sudo find /home/xsuper/models/Qwen3.6-35B-A3B -maxdepth 1 -type f -name 'model-*.safetensors' | wc -l
sudo docker pull nvcr.io/nvidia/vllm:26.05.post1-py3
sudo docker image inspect nvcr.io/nvidia/vllm:26.05.post1-py3 >/dev/null && echo "vLLM image check passed"
```
The model is located in another user's Home directory, so directory check, weight statistics, and Docker mounting all retain `sudo`, and cannot use ordinary user permissions to check results to infer that the model does not exist.
### 5.2 Create 64K multi-agent deployment script
The current Hermes integration code requires the model context to be at least 64,000 tokens; the original SOP `16384` only suitable for basic chat verification, not as the complete multi-agent demonstration configuration for this project. Therefore, the competition demonstration uses `65536` and limits concurrency to 1 to prioritize stability.
```bash
cat > /home/Developer/start_coplite_qwen36_vllm.sh <<'BASH'
#!/usr/bin/env bash
set -Eeuo pipefail
MODEL_DIR="/home/xsuper/models/Qwen3.6-35B-A3B"
IMAGE="nvcr.io/nvidia/vllm:26.05.post1-py3"
CONTAINER="coplite_qwen36_vllm"
MODEL_NAME="qwen35-64k"
PORT="8000"
LOG_DIR="/home/Developer/vllm_logs"
LOG_FILE="$LOG_DIR/coplite_qwen36_vllm.log"
mkdir -p "$LOG_DIR"
sudo test -d "$MODEL_DIR" || { echo "Model directory does not exist or no access: $MODEL_DIR"; exit 1; }
sudo test -f "$MODEL_DIR/config.json" || { echo "Model directory missing config.json"; exit 2; }
WEIGHT_COUNT="$(sudo find "$MODEL_DIR" -maxdepth 1 -type f -name 'model-*.safetensors' | wc -l)"
test "$WEIGHT_COUNT" -gt 0 || { echo "No safetensors weights detected"; exit 3; }
sudo docker image inspect "$IMAGE" >/dev/null 2>&1 || {
echo "Missing image: $IMAGE"
exit 4
}
sudo docker rm -f "$CONTAINER" >/dev/null 2>&1 || true
sudo docker run --rm \
--name "$CONTAINER" \
--gpus all \
--network host \
--ipc host \
-v "$MODEL_DIR:/model:ro" \
"$IMAGE" \
vllm serve /model \
--host 0.0.0.0 \
--port "$PORT" \
--served-model-name "$MODEL_NAME" \
--tensor-parallel-size 1 \
--dtype auto \
--gpu-memory-utilization 0.70 \
--max-model-len 65536 \
--max-num-seqs 1 \
--trust-remote-code \
2>&1 | tee -a "$LOG_FILE"
BASH
chmod +x /home/Developer/start_coplite_qwen36_vllm.sh
```
### 5.3 Use tmux to keep the service running
```bash
sudo apt update
sudo apt install -y tmux
tmux new-session -d -s coplite-qwen36 '/home/Developer/start_coplite_qwen36_vllm.sh'
tmux ls
```
View real-time logs:
```bash
tmux attach -t coplite-qwen36
```
Exit to view but keep the service running: press `Ctrl+B`, release and press `D`.
### 5.4 Model service acceptance
```bash
sudo docker ps --filter name=coplite_qwen36_vllm
sudo ss -lntp | grep ':8000'
curl -s http://127.0.0.1:8000/v1/models | python3 -m json.tool
curl -s http://127.0.0.1:8000/v1/chat/completions -H 'Content-Type: application/json' -d '{"model":"qwen35-64k","messages":[{"role":"user","content":"Hello, please only reply: CopliteSuite DGX Spark model service is normal."],"max_tokens":64,"temperature":0.1}' | python3 -m json.tool
```
Verify LAN access on the Windows doctor workstation:
```powershell
Invoke-RestMethod -Uri "http://192.168.110.60:8000/v1/models" -Method Get
```
### 5.5 Model configuration must be consistent
The model registration item in the competition environment should be consistent with the vLLM service name and address:
```json
{
"key": "qwen35-64k",
"label": "Qwen3.6-35B 64K",
"base_url": "http://192.168.110.60:8000/v1",
"model": "qwen35-64k",
"supports_tool_calls": false,
"max_tokens": 1024,
"extra_body": {
"chat_template_kwargs": {
"enable_thinking": false
}
}
}
```
The `skill-hub/backend/agent_models_config.json` in the current repository and the old installation instructions in the root directory have port differences. Before demonstration, the Base URL, model name, and tool call capability must be uniformly set through the model setting page based on the actual return result of `/v1/models`, and cannot be changed only in the README.
## 6. Large model optimization strategy
### Implemented inference optimization
| Optimization item | Current strategy | Purpose |
|---|---|---|
| NVIDIA optimized container | NGC `nvcr.io/nvidia/vllm:26.05.post1-py3` | Avoid on-site compilation of complete inference stack on ARM64 DGX Spark |
| Unified memory protection | `--gpu-memory-utilization 0.70` | NVIDIA documentation clearly prompts to reduce default occupancy to avoid OOM |
| Single-machine parallelism | `--tensor-parallel-size 1` | Run on a single DGX Spark, single GPU |
| Demonstration concurrency | `--max-num-seqs 1` | Reduce KV Cache fluctuation, prioritize on-site stability |
| Long context | `--max-model-len 65536` | Meet the minimum context requirements of Hermes multi-agent operation |
| Thinking switch | `enable_thinking=false` | Reduce the first token delay and invalid inference overhead of regular tool routing |
| Read-only weights | `-v /model:ro` | Reduce mis-write, pollution, and demonstration environment drift risk |
| API decoupling | OpenAI-compatible | Model switching does not invade medical business and front-end code |
### Tool call optimization safety threshold
The SOP omits `--reasoning-parser`, `--tool-calls-parser`, and other image version-sensitive parameters to ensure basic service startup; the current model registry also explicitly sets `supports_tool_calls=false`. This means:
- Basic Q&A, summary, and explicitly arranged processes can run.
- Hermes will automatically disable MCP toolset to avoid model outputting unresolvable pseudo-tool calls.
- To demonstrate "model native autonomous tool calls", a verified parser must be selected for the current model and vLLM image, complete tool call smoke test, and then change `supports_tool_calls` to `true`.
Cannot just modify the boolean switch. The minimum acceptance criteria are: complete patient reading, evidence retrieval, citation verification, and HITL interrupt recovery, and no parser error or tool parameter JSON corruption in the log.
### Tuning sequence
1. Verify `/v1/models` and minimum Chat Completions.
2. Verify if 64K context can complete a complete multi-agent trajectory.
3. Enable tool calls parser verified by the model.
4. Gradually increase `max-num-seqs`, record first token delay, output speed, peak unified memory, and success rate.
5. When OOM occurs, do not reduce the context to below 64K in complete multi-agent mode; prioritize compatible quantized weights or smaller models. If reduced to 16K, can only be marked as "basic chat mode".
### Recommended Metrics for Recording
| Metric | Recording Method |
|---|---|
| Time to First Token (TTFT) | From request sent to first SSE token |
| Output Throughput (tokens/s) | vLLM request statistics or service logs |
| Complete Task Time | From doctor's question to safety review completion |
| Tool Call Success Rate | Successful calls / Total calls |
| Reference Verification Pass Rate | `supported` count / Total claims |
| HITL Interception Rate | Proportion of high-risk actions correctly intercepted that require confirmation |
| Peak Unified Memory | `nvidia-smi` and system monitoring synchronous recording |
## 7. NVIDIA SDK, Software Stack, and Models
### NVIDIA Software Stack
| Component | Role in the Project | Status |
|---|---|---|
| DGX OS + NVIDIA GPU Driver | Provides GB10 driver, GPU management, and local operation base | 🟩 Required for DGX Spark environment |
| NVIDIA Container Toolkit | Allows Docker to use GPU with `--gpus all` | 🟩 Deployment prerequisite |
| NVIDIA NGC vLLM Container 26.05 | Provides vLLM optimized for NVIDIA GPU, CUDA acceleration library, PyTorch, FlashInfer, FlashAttention, etc. | 🟩 SOP usage |
| CUDA / Tensor Cores | Performs large model matrix calculations and low-precision inference | 🟩 Used indirectly by containers and drivers |
| NVIDIA NIM for LLMs | Encapsulates NVIDIA models as standard inference microservices | 🧪 Recommended access path for Nemotron reference models |
| NVIDIA Nemotron | NVIDIA's open model family for Agentic AI | 🧪 Reference model for the competition and subsequent local safety review |
| NVIDIA NeMo / ModelOpt | Domain fine-tuning, quantization, and model optimization route | 🧪 Current repository does not include training products, no claim of completion of fine-tuning |
### Model Matrix
| Model | Vendor | Role | Deployment Method | Current Status |
|---|---|---|---|---|
| Qwen3.6-35B-A3B | Qwen | Main inference model for hospital, processing Chinese clinical context, summary, and business orchestration | DGX Spark + NVIDIA vLLM, service name `qwen35-64k` | ✅ Current main model |
| NVIDIA Nemotron 3 Nano 30B-A3B NVFP4 | NVIDIA | Agentic tool calling / Safety review reference model | Single DGX Spark can use NVIDIA NIM or compatible vLLM configuration | 🧪 Not enabled in current registry |
| StepFun Step-3.7-Flash | StepFun | Reference model for competition for long context, visual understanding, and complex intelligent agent trajectory | StepFun OpenAI-compatible API; or local deployment on 128 GB high memory device | 🧪 Not enabled in current offline package |
#### StepFun Usage Boundary
Step-3.7-Flash provides OpenAI-compatible API and local deployment routes such as vLLM, SGLang, and llama.cpp. Its GGUF local solution requires about 120 GB unified memory/video memory, and a single 128 GB DGX Spark can be used for single-model verification, but there is insufficient space to coexist with 67 GB Qwen service, so it is not recommended as a co-located dual-model on-site solution.
Hospital edition defaults to pure intranet. If using StepFun cloud API during the competition, only allow sending de-identified and no patient identity information evaluation questions, and clearly mark "external model reference channel" on the interface and log; real patient data must not enter this channel. If unable to prove effective de-identification gate control, disable the cloud channel.
## 8. Windows Doctor Workstation Startup
The portable package includes Python, Node.js, Hermes, and related dependencies. Please open PowerShell in the project root directory and execute the entire script:
```powershell
$projectRoot = (Get-Location).Path
$python = Join-Path $projectRoot "coplite\.venv\Scripts\python.exe"
$launcher = Join-Path $projectRoot "coplite\start_suite.py"
& $python $launcher start
```
View status:
```powershell
$projectRoot = (Get-Location).Path
$python = Join-Path $projectRoot "coplite\.venv\Scripts\python.exe"
$launcher = Join-Path $projectRoot "coplite\start_suite.py"
& $python $launcher status
```
Stop service:
```powershell
$projectRoot = (Get-Location).Path
$python = Join-Path $projectRoot "coplite\.venv\Scripts\python.exe"
$launcher = Join-Path $projectRoot "coplite\start_suite.py"
& $python $launcher stop
```
The launcher will complete dependency pre-check, model configuration synchronization, model endpoint detection, Hermes MCP configuration synchronization, gateway startup, Coplite entrance startup, desktop shortcut creation, and port status summary.
## 9. Demo Script (Recommended 5–7 minutes)
### Scenario: Outpatient Patient Assessment, Evidence Verification, and Follow-up Closed Loop
1. **30 seconds｜Explain privacy boundary**
Show `nvidia-smi`, vLLM container, and `/v1/models` on DGX Spark, emphasizing that model weights and patient data are within the hospital.
2. **45 seconds｜Open patient queue**
Select demonstration patients from Skill Hub, show patient summary, test results, medical history, and inquiry messages.
3. **90 seconds｜Start multi-agent evidence-based task**
Doctor raises clinical questions; main agent calls evidence retrieval, evidence sorting, answer generation, reference verification, and medical safety review sub-agents. Interface shows Agent Trace, not just the final answer.
4. **60 seconds｜Show traceable results**
Show `evidence_id`, applicable boundary, missing information, and safety reminders after each medical judgment; actively show how a non-applicable piece of evidence is excluded.
5. **60 seconds｜HITL medical record**
Clinical auxiliary intelligent agent generates structured medical record draft, doctor views field differences and confirms before writing.
6. **60 seconds｜Follow-up dual confirmation**
Create review plan, first show plan draft, then trigger tool execution approval; generate task and notification after approval.
7. **30 seconds｜Stability and audit**
Show tool logs, model information, port health status, and fallback path.
The demonstration focuses on "complete trajectory and safety boundary," not just playing a natural language Q&A once.
## 10. Review Criteria Correspondence
The following items are sorted according to the five review criteria provided, with a total weight of 95%.
| Review Item | Weight | Project Highlights | Demo Evidence |
|---|---:|---|---|
| Practicality, Industry Landing Value, and Technical Innovation | 25% | Faces real outpatient links; local privacy, evidence-based ledger, HITL, desktop collaboration; upgrades "generated answer" to "executable but controlled doctor workflow" | Patient queue → Evidence-based → Medical record confirmation → Follow-up task complete closed loop |
| Intelligent Agent Fusion and Model Optimization Technology Depth | 25% | Main agent + 7 specialized sub-agents; responsibility isolation, minimum tool permissions, call limit, failure degradation; long context on DGX Spark, unified memory, and concurrent optimization | Agent Trace, tool call log, 64K configuration, performance indicators |
| Project Completeness | 20% | React front-end, FastAPI back-end, Agent API, dual MCP, Hermes, model registry, scheduler, audit, and existing E2E acceptance script | Five service health checks, front-end process, acceptance results |
| Platform Adaptability | 15% | DGX Spark + NGC vLLM + NVIDIA Container Toolkit + CUDA; NVIDIA Nemotron/NIM extension route; StepFun reference model and privacy gate control | `nvidia-smi`, container, model list, model matrix, and measured data |
| Demo Effect | 10% | 5–7 minute fixed script, interface, trajectory, evidence, approval, and audit unfolding layer by layer | No manual configuration change, no on-site package pulling, complete closed loop at once |
## 11. Acceptance Checklist
### Service Health Check
```powershell
Invoke-RestMethod -Uri "http://127.0.0.1:8000/api/health" -Method Get
Invoke-RestMethod -Uri "http://127.0.0.1:8090/health" -Method Get
Invoke-WebRequest -Uri "http://127.0.0.1:5173" -Method Get -UseBasicParsing
Invoke-RestMethod -Uri "http://192.168.110.60:8000/v1/models" -Method Get
```
### Code Acceptance Script
Execute in the project root directory:
```powershell
$projectRoot = (Get-Location).Path
$python = Join-Path $projectRoot "skill-hub\backend\.venv\Scripts\python.exe"
$acceptance = Join-Path $projectRoot "skill-hub\backend\scripts\e2e_acceptance.py"
& $python $acceptance
```
The acceptance script covers patient summary, patient details, Skill streaming operation, follow-up plan, scheduling notification, to-do task, Agent smoke test, and evidence-based intelligent agent test.
### Must Be Satisfied Before Demo
- [ ] DGX Spark's `/v1/models` returns `qwen35-64k`.
- [ ] 64K model configuration can complete a complete task without OOM.
- [ ] Windows workstation can access `192.168.110.60:8000`.
- [ ] Services corresponding to `5173 / 8000 / 8001 / 8090 / 9000` are all normal.
- [ ] Model Base URL, served model name, and model registry are completely consistent.
- [ ] If tool call are enabled, parser and tool parameter JSON verification are completed.
- [ ] Medical record writing and follow-up creation can trigger HITL.
- [ ] Demo patients are simulated or de-identified data.
- [ ] All models and dependencies are downloaded in advance, and no public network installation is relied on during the on-site demo.
- [ ] Screen recording simultaneously shows interface, Agent Trace, evidence reference, and final business results.
## 12. Directory Navigation
```text
CopliteSuite/
├─ coplite/ # Windows desktop, floating ball, Hermes bridge, Coplite MCP
│ ├─ src/coplite/agent/ # Hermes runtime and message processing
│ ├─ src/coplite/mcp/ # Desktop, file, Office, medical and other MCP tools
│ ├─ src/coplite/services/ # Model settings, diagnosis, MCP configuration synchronization
│ └─ start_suite.py # Full service start and stop entrance
├─ skill-hub/
│ ├─ frontend/ # React + TypeScript + Vite doctor workstation
│ └─ backend/
│ ├─ app/ # FastAPI medical business, scheduling, audit, and knowledge base
│ ├─ agent/ # DeepAgents main agent, middleware, and sub-agents
│ ├─ mcp_server/ # Medical MCP Server
│ ├─ skills/ # Medical Skills and output contracts
│ └─ scripts/e2e_acceptance.py
├─ hermes/ # Portable Hermes Runtime
├─ runtime/ # Packaged Python / Node.js runtime environment
└─ INFO_Reference/ # Deployment reference materials
```
## 13. References
- [NVIDIA DGX Spark Hackathon Event Page](https://scrm.nvidia.cn/assets/download-dgx-spark-hackathon-multi-agents-20260712-04?pushId=RWBUbc4eS9D8Kg8PtRHWVW)
- [NVIDIA DGX Spark Product and Specifications](https://www.nvidia.com/en-gb/products/workstations/dgx-spark/)
- [NVIDIA vLLM 26.05 Release Notes](https://docs.nvidia.com/deeplearning/frameworks/vllm-release-notes/rel-26-05.html)
- [NVIDIA vLLM Container Operation Instructions](https://docs.nvidia.com/deeplearning/frameworks/vllm-release-notes/running.html)
- [NVIDIA Nemotron](https://developer.nvidia.com/topics/ai/nemotron)
- [NVIDIA NIM Supported Models](https://docs.nvidia.com/nim/large-language-models/1.15.0/supported-models.html)
- [StepFun Step-3.7-Flash Official Repository](https://github.com/stepfun-ai/Step-3.7-Flash)
- [StepFun Open Platform Documentation](https://platform.stepfun.com/docs/zh/step-plan/quick-start)
## 14. Security Statement
This project is a doctor assistance system and does not replace doctor diagnosis, prescription, or emergency treatment. Any action that writes into a formal medical record, creates a follow-up plan, or affects patient management must retain identity authentication, permission control, doctor confirmation, and audit records. The competition demo uses simulated or fully de-identified data.
MCP Config
Below is the configuration for this MCP Server. You can copy it directly to Cursor or other MCP clients.
mcp.json
Connection Info
You Might Also Like
No recommendations available