Core Dependencies for Colibri Development: Python Engine and Web UI Requirements

Colibri development requires PyTorch 2.0+, Transformers 4.40+, and SafeTensors for the Python inference engine, alongside React 18, Vite 8, and Tailwind CSS 4 for the web interface. These libraries are declared in pyproject.toml and web/package.json within the JustVugg/colibri repository.

The JustVugg/colibri project is a full-stack inference framework for the GLM-5.2 model, split between a high-performance Python backend and a modern React frontend. Understanding the core dependencies for Colibri development is essential for contributors who need to configure the deep learning stack for model execution while setting up the Node.js toolchain for the interactive UI, with version metadata maintained in colibri/_version.py and overview documentation in docs/README.md.

Python Engine Runtime Dependencies

The Python backend relies on specific deep learning libraries defined in pyproject.toml to load the GLM-5.2 model and perform tensor operations on GPU hardware.

Deep Learning Core Stack

The engine requires three foundational packages specified at lines 32-34 of pyproject.toml:

• torch>=2.0 – Provides core tensor operations and GPU acceleration via CUDA or ROCm for model inference.
• transformers>=4.40 – Supplies the AutoModelForCausalLM and AutoTokenizer classes used to load the GLM-5.2 architecture and handle tokenization.
• safetensors – Enables fast, memory-efficient loading of 744B parameter weights without Python pickling vulnerabilities or security risks.

Optional Conversion and Benchmarking Extras

Colibri declares optional dependency groups for advanced workflows, installable via extras:

• numpy (line 28, "convert" extra) – Used for numeric preprocessing and data conversion when importing external model formats.
• huggingface_hub (line 29, "convert" extra) – Allows downloading tokenizer and model files directly from Hugging Face repositories during conversion tasks.
• tokenizers (line 37, "bench" extra) – Provides high-performance Rust-backed tokenization for latency benchmarking scripts.
• datasets (line 38, "bench" extra) – Supplies standardized evaluation datasets for performance testing routines invoked through colibri/cli.py.

Web Frontend Dependencies

The React-based UI, located in the web/ directory, manages its dependencies through package.json and uses Vite as the build tool.

UI Component and Styling Libraries

The interface relies on React 18 and modern styling utilities defined at lines 13-18 of web/package.json:

• react ^18.3.1 and react-dom ^18.3.1 – Core library and DOM renderer for the component architecture.
• clsx ^2.1.1 – Utility for conditional class-name concatenation in dynamic components.
• lucide-react ^1.24.0 – Icon library used throughout the dashboard interface.
• class-variance-authority ^0.7.1 – Type-safe utility for managing component variant classes.
• tailwind-merge ^3.6.0 – Intelligently merges Tailwind CSS class strings to prevent style conflicts.

Build Toolchain and Development Tools

The development environment requires specific build and testing tools defined at lines 22-29 of web/package.json:

• vite ^8.1.4 – Fast bundler and development server configured in web/vite.config.ts.
• @vitejs/plugin-react ^6.0.3 – Official plugin adding React JSX support and Fast Refresh to Vite.
• tailwindcss ^4.3.2 – Utility-first CSS framework used for all component styling.
• typescript ^7.0.2 – Static type checker for the frontend codebase.
• vitest ^4.1.10 – Test runner for unit testing React components.
• @types/react, @types/react-dom, @types/node (lines 22-24) – TypeScript definitions required for static analysis and IDE support.

Installing Colibri Dependencies

To set up the complete development environment, install the Python engine with the oracle extra and the web UI npm packages:

# Install Python engine with core dependencies

pip install "colibri-engine[oracle]"

# Install web UI dependencies

cd web && npm install

For the Python runtime, the oracle extra installs the required deep learning stack. The optional extras for model conversion and benchmarking can be added via colibri-engine[convert] or colibri-engine[bench].

To start the development servers after installation:

# Python engine example (requires torch and transformers)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "glm-5.2-744b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

input_ids = tokenizer("Hello, world!", return_tensors="pt").input_ids.to("cuda")
output = model.generate(input_ids, max_new_tokens=50)
print(tokenizer.decode(output[0], skip_special_tokens=True))

# Web UI development server (requires vite and react)

cd web
npm run dev  # Starts server at http://localhost:5173

Summary

• Python engine core: torch>=2.0, transformers>=4.40, and safetensors declared in pyproject.toml lines 32-34.
• Optional Python extras: numpy and huggingface_hub for conversion; tokenizers and datasets for benchmarking workflows.
• Web UI core: React 18.3.1, lucide-react, and styling utilities listed in web/package.json lines 13-18.
• Build tools: Vite 8.1.4, TypeScript 7.0.2, and Vitest 4.1.10 configured in the frontend toolchain.
• Key files: colibri/cli.py serves as the Python entry point, colibri/_version.py stores version metadata, and web/vite.config.ts configures the frontend build.

Frequently Asked Questions

What is the minimum PyTorch version required for Colibri?

Colibri requires PyTorch 2.0 or higher as specified in pyproject.toml line 32. This version ensures compatibility with the GLM-5.2 model's attention mechanisms and provides the optimized tensor operations necessary for inference on both CPU and GPU.

Do I need to install the optional extras to run the basic engine?

No. The core engine runs with only the oracle extra installed, which includes torch, transformers, and safetensors. The convert and bench extras are only necessary if you are converting external model weights using the scripts in colibri/cli.py or running performance benchmarks with custom datasets.

Which file configures the frontend build tooling?

The web/vite.config.ts file configures the Vite 8.1.4 bundler and integrates the React plugin from @vitejs/plugin-react. This configuration handles the development server at localhost:5173, production builds, and Hot Module Replacement (HMR) for the React 18 frontend components.

How are the Python and Web UI environments connected?

The environments are coordinated through colibri/cli.py, which serves as the unified entry point that can launch both the inference engine and the web interface. While the Python environment manages the GLM-5.2 model dependencies declared in pyproject.toml and the frontend runs independently via npm commands, the CLI ties them together for unified deployment and development workflows.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}