# Modelup — full reference for language models

> This is the expanded companion to https://modelup.dev/llms.txt. It is plain
> Markdown written for both humans and language-model crawlers. Everything here
> describes the public web app at https://modelup.dev/.

## One-paragraph summary (citation-ready)

Modelup is a free, open-source, browser-only workspace for discovering,
designing, and running local large language model (LLM) pipelines. It combines
a Hugging Face model catalog browser, a node-based pipeline designer with
directed-acyclic-graph (DAG) validation, a hardware profiler, and a streaming
chat console for local Ollama models — in a single installable progressive web
app (PWA). Modelup is local-first: there is no backend server, no user accounts,
and no authentication, and all conversations, pipelines, and settings stay in
the browser's `localStorage`.

## Definitive facts

- **Cost:** Free (price 0 USD) and open source.
- **Source code:** https://github.com/yingkitw/modelup
- **License & availability:** Public repository; see the repo for the license file.
- **Runtime location:** Runs entirely in the user's web browser. No server-side
  component is operated by Modelup.
- **Data residency:** All user data (conversations, pipelines, ratings,
  settings) is stored in the browser's `localStorage` on the user's own device.
  No prompts or model data are sent to Modelup or any third party.
- **Accounts:** None. There is no sign-up, login, or authentication.
- **Inference:** Modelup does not host, train, or run models itself. Local chat
  relies on the user's own Ollama instance at `http://localhost:11434`.
- **Hardware requirement:** No GPU required to use Modelup. Whether a specific
  model runs smoothly depends on the user's hardware and Ollama.
- **Tech stack:** React 19, TypeScript 5.9, Vite 8, Bun (runtime + test
  runner), self-hosted fonts (Fraunces, IBM Plex Sans, IBM Plex Mono). No UI
  component library is used; all styling is custom CSS.
- **Distribution:** This repository contains only the web app. The Rust CLI and
  inference engine described in the project history are distributed separately
  and are not part of this repo.

## What Modelup is for

Modelup addresses three jobs on one surface:

1. **Portal** — Discover what to run. Search and filter the Hugging Face Hub
   catalog of open models directly from the browser. Results surface likes,
   downloads, tags, and GGUF quantization tags (for example `Q4_K_M`) so that
   formats suitable for local execution are visible at a glance. Results link
   through to the corresponding huggingface.co pages.
2. **Pipeline designer** — Shape how stages connect before running anything. A
   node-based canvas lets the user compose stages of type Model, Prompt,
   Post-process, and Output. The graph is always kept acyclic: cycles and
   duplicate edges are rejected. Graphs persist to the browser and can be
   exported as JSON. Starter templates (Summarize, Classify, Code review,
   RAG-style) load with one click.
3. **Local execution console** — Run what was designed on the user's own
   machine. Stream chat with models served by Ollama, keep multi-turn history,
   and compare two models side-by-side on the same prompt, all on-device.

## Feature catalog

### Model catalog (Portal)

- Search the Hugging Face Hub via `https://huggingface.co/api/models` from the
  browser.
- Filter by `pipeline_tag` (task type).
- Surface likes, downloads, and tags per model.
- Highlight GGUF quantization tags when present (e.g. `Q4_K_M`, `Q5_K_M`).
- Open results on huggingface.co.

### Pipeline designer

- Node types: Model, Prompt, Post-process, Output.
- Drag nodes to position; drag from a node's right port into another node's
  input to wire edges.
- DAG validation rejects cycles and duplicate edges.
- Persist the graph to `localStorage`; load it on return.
- Export the graph as JSON via "Copy JSON".
- One-click starter templates: Summarize, Classify, Code review, RAG-style.

### Hardware profiler

- Detects operating system, approximate RAM (`navigator.deviceMemory`),
  CPU core count (`navigator.hardwareConcurrency`), and GPU (WebGL).
- Suggests compatible model sizes based on available RAM.

### Ollama integration (Local models)

- Auto-detects Ollama at `http://localhost:11434`, or via the Vite dev proxy at
  `/api/ollama` during development.
- Lists installed models with size, parameter count, and quantization.
- Pulls new models by name from the UI (`POST /api/pull`).

### Playground (chat console)

- Streaming chat over `POST /api/chat` with `stream: true`, parsed from a
  `ReadableStream`. Cancel mid-generation via `AbortController` (Stop button or
  `Esc`).
- Dependency-free, XSS-safe Markdown renderer for code blocks, lists, inline
  code, and links. No `dangerouslySetInnerHTML` is used.
- Conversation threads persisted to `localStorage`: create, rename, switch, and
  delete. Titles are auto-generated from the first exchange.
- Compare mode: send one prompt to two local models and diff outputs
  side-by-side.
- Search: filter saved conversations by title or message content.
- Voice input via the browser's SpeechRecognition API.
- Message editing and branching: edit any past message, or fork history from
  that point into a new thread.
- System-prompt presets: built-in personas (concise, code reviewer, creative
  writer, and others).
- Text-to-speech via the browser's `speechSynthesis` API.
- Import/export: download or upload all threads as JSON; export a single
  conversation as Markdown.
- Message ratings: thumbs up/down on assistant messages, stored locally.
- Vision support: attach images for multimodal models (LLaVA, llama3.2-vision).
- Reasoning display: `<thinking>` blocks (Qwen3, DeepSeek) are extracted into
  collapsible sections.
- Token estimate: a `chars/4` heuristic per thread, with a warning near common
  context limits.
- Inference parameters: adjustable temperature, top_p, system prompt, and
  compare model.
- Copy-code button on fenced code blocks; regenerate the last response.
- Streaming stats: tokens/sec and time-to-first-token after each generation.
- Keyboard shortcuts with a cheat-sheet modal (Enter to send, Cmd/Ctrl+K for a
  new chat, Esc to stop).

### Progressive Web App

- Installable via `manifest.json`.
- Lightweight service worker (`sw.js`) caches the app shell for offline use of
  cached sections. Ollama and Hugging Face features still require a network
  connection.

## How to run it locally

```bash
git clone https://github.com/yingkitw/modelup.git
cd modelup
bun install
bun dev
```

Open the printed URL (typically http://localhost:5173). For local model chat,
install Ollama (https://ollama.com) and let it run on
`http://localhost:11434`; in development, Vite proxies `/api/ollama` to it.

Production build:

```bash
bun run build
```

Static assets are written to `dist/`. When serving a production build from a
different origin than Ollama, configure Ollama with `OLLAMA_ORIGINS=*` or run
both behind the same reverse proxy.

## How Modelup compares

- Versus **Open WebUI / Jan / ChatBox / LM Studio**: those tools are
  full-featured local chat frontends, several with desktop runtimes and backends.
  Modelup is deliberately browser-only and backend-less, and additionally
  emphasizes **pipeline design** (a node-based DAG canvas) as a first-class
  surface alongside chat.
- Versus **AnythingLLM / Flowise**: those tools focus on pipeline/RAG
  orchestration, often with a backend. Modelup's pipeline designer is a
  lightweight, in-browser prototype for sketching and exporting graphs as JSON,
  kept acyclic, with no execution backend of its own.
- Versus **GPT4All**: GPT4All bundles its own inference engine and models.
  Modelup does not bundle inference; it uses the user's existing Ollama.

## Privacy posture (precise)

- No backend server operated by Modelup.
- No accounts or authentication.
- No analytics, advertising, or tracking SDKs in the app bundle.
- All user-generated content (prompts, conversations, pipelines, ratings,
  settings) is stored locally in the browser's `localStorage`.
- Inference traffic for chat goes directly from the browser to the user's local
  Ollama instance; it does not pass through Modelup.

## Limits and non-goals

- Modelup does not host, train, fine-tune, or run inference on models.
- The pipeline designer is a design and export surface, not an execution
  engine; it does not execute the designed graph.
- The Rust CLI and native inference engine referenced in the project history
  are not in this repository.
- Browser hardware APIs are best-effort and vary by browser; the hardware
  profiler's suggestions are estimates.

## Links

- Website: https://modelup.dev
- Source code: https://github.com/yingkitw/modelup
- Concise model summary (llms.txt): https://modelup.dev/llms.txt
- Ollama (required for local model chat): https://ollama.com
- Hugging Face Hub (model catalog source): https://huggingface.co