Update README.md

README.md

@@ -1,34 +1,47 @@
 ---
-title: Universal MCP Hub - Volkan
+title: Multi-LLM API Gateway
 emoji: 🛡️
 colorFrom: indigo
 colorTo: red
 sdk: docker
 pinned: false
 license: apache-2.0
-short_description: 'Sandboxed Universal MCP Server built on PyFundaments'
+short_description: 'Secure Multi-LLM Gateway — (Streamable HTTP / SSE)'
 ---
 
-# Universal MCP Hub (Sandboxed)
+# Multi-LLM API Gateway
 
-> A production-grade MCP server that actually thinks about security.  
-> Built on [PyFundaments](PyFundaments.md) — running on **simpleCity** and **paranoidMode**.
+— or Universal MCP Hub (Sandboxed)  
+— or secure AI wrapper with dual interface: REST + MCP
+
+aka: a clean, secure starting point for your own projects.  
+Pick the description that fits your use case. They're all correct.
+
+> A production-grade **the-thing** that actually thinks about security.  
+> Built on [PyFundaments](PyFundaments.md) — running on **simpleCity**.
 
 ```
 No key → no tool → no crash → no exposed secrets
 ```
 
-Most MCP servers are prompts dressed up as servers. This one has a real architecture.
+> [!WARNING]
+> Most MCP servers are prompts dressed up as servers. This one has a real architecture.
+
+---
+
+> [!IMPORTANT]
+> This project is under active development — always use the latest release from [Codey Lab](https://github.com/Codey-LAB/Multi-LLM-API-Gateway) *(more stable builds land here first)*.  
+> This repo ([DEV](https://github.com/VolkanSah/Multi-LLM-API-Gateway)) is where the chaos happens. 🔬 A ⭐ on the repos will be cool 😙
 
 ---
 
 ## Why this exists
 
-First have a look on this new project from BadTin & Me [Wall-of-Shames](https://github.com/Wall-of-Shames?view_as=public)
+The AI ecosystem is full of servers with hardcoded keys, `os.environ` scattered everywhere, zero sandboxing. One misconfigured fork and your API keys are gone.
 
-The MCP ecosystem is full of servers with hardcoded keys, zero sandboxing, and `os.environ` scattered everywhere. One misconfigured fork and your API keys are gone.
+This is exactly the kind of negligence (and worse — outright fraud) that [Wall of Shames](https://github.com/Wall-of-Shames) documents: fake "AI tools" exploiting non-technical users — API wrappers dressed up as custom models, Telegram payment funnels, bought stars. If you build on open source, you should know this exists.
 
-This hub was built as the antidote:
+This hub is the antidote:
 
 - **Structural sandboxing** — `app/*` can never touch `fundaments/` or `.env`. Not by convention. By design.
 - **Guardian pattern** — `main.py` is the only process that reads secrets. It injects validated services as a dict. `app/*` never sees the raw environment.
@@ -37,6 +50,47 @@ This hub was built as the antidote:
 
 ---
 
+## Two Interfaces — One Server
+
+This hub exposes **two completely independent interfaces** on the same hypercorn instance:
+
+```
+POST /api          → REST interface — for custom clients, desktop apps, CMS plugins
+GET+POST /mcp      → MCP interface — for Claude Desktop, Cursor, Windsurf, any MCP client
+GET /              → Health check — uptime, status
+```
+
+They share the same tool registry, provider config, and fallback chain. Adding a tool once makes it available on both interfaces automatically.
+
+### REST API (`/api`)
+
+Simple JSON POST — no protocol overhead, works with any HTTP client:
+
+```json
+POST /api
+{"tool": "llm_complete", "params": {"prompt": "Hello", "provider": "anthropic"}}
+```
+
+Used by: Desktop Client (`DESKTOP_CLIENT/hub.py`), WordPress plugin, any custom integration.
+
+### MCP Interface (`/mcp`)
+
+Full MCP protocol — tool discovery, structured calls, streaming responses.
+
+**Primary transport: Streamable HTTP** (MCP spec 2025-11-25)  
+**Fallback transport: SSE** (legacy, configurable via `.pyfun`)
+
+Configured via `HUB_TRANSPORT` in `app/.pyfun [HUB]`:
+
+```ini
+HUB_TRANSPORT = "streamable-http"   # default — MCP spec 2025-11-25
+# HUB_TRANSPORT = "sse"             # legacy fallback for older clients
+```
+
+Used by: Claude Desktop, Cursor, Windsurf, any MCP-compatible client.
+
+---
+
 ## Architecture
 
 ```
@@ -50,11 +104,11 @@ main.py (Guardian)
      │
      │  unpacks fundaments ONCE, at startup, never stores globally
      │  starts hypercorn (async ASGI)
-     │  routes: GET / | POST /api | GET+POST /mcp
+     │  routes: GET / | POST /api | /mcp (transport-dependent)
      │
-     ├── app/mcp.py         ← FastMCP + SSE handler
+     ├── app/mcp.py         ← FastMCP + transport handler (Streamable HTTP / SSE)
      ├── app/tools.py       ← Tool registry (key-gated)
-     ├── app/provider.py    ← LLM + Search execution + fallback chain
+     ├── app/providers.py   ← LLM + Search execution + fallback chain
      ├── app/models.py      ← Model limits, costs, capabilities
      ├── app/config.py      ← .pyfun parser (single source of truth)
      └── app/db_sync.py     ← Internal SQLite IPC (app/* state only)
@@ -64,7 +118,7 @@ main.py (Guardian)
 **The sandbox is structural:**
 
 ```python
-# app/app.py — fundaments are unpacked ONCE, NEVER stored globally
+# app/app.py — fundaments unpacked ONCE, NEVER stored globally
 async def start_application(fundaments: Dict[str, Any]) -> None:
     config_service         = fundaments["config"]
     db_service             = fundaments["db"]          # None if not configured
@@ -80,19 +134,16 @@ This isn't documentation. It's enforced by the import structure.
 
 ### Why Quart + hypercorn?
 
-MCP over SSE needs a proper async HTTP stack. The choice here is deliberate:
-
-**Quart** is async Flask — same API, same routing, but fully `async/await` native. This matters because FastMCP's SSE handler is async, and mixing sync Flask with async MCP would require thread hacks or `asyncio.run()` gymnastics. With Quart, the `/mcp` route hands off directly to `mcp.handle_sse(request)` — no bridging, no blocking.
+**Quart** is async Flask — fully `async/await` native. FastMCP's handlers are async; mixing sync Flask would require thread hacks. With Quart, `/mcp` hands off directly to FastMCP — no bridging, no blocking.
 
-**hypercorn** is an ASGI server (vs. waitress/gunicorn which are WSGI). WSGI servers handle one request per thread — fine for traditional web apps, wrong for SSE where a connection stays open for minutes. hypercorn handles SSE connections as long-lived async streams without tying up threads. It also runs natively on HuggingFace Spaces without extra config.
+**hypercorn** is an ASGI server (vs. waitress/gunicorn which are WSGI). WSGI servers handle one request per thread — wrong for long-lived MCP connections. hypercorn handles both Streamable HTTP and SSE natively, and runs without extra config on HuggingFace Spaces. HTTP/2 support (`config.h2 = True`) is built-in — relevant for Streamable HTTP performance at scale.
 
-The `/mcp` route in `app.py` is also the natural interception point — auth checks, rate limiting, payload logging can all be added there before the request ever reaches FastMCP. That's not possible when FastMCP runs standalone.
+The `/mcp` route in `app.py` remains the natural interception point regardless of transport — auth checks, rate limiting, and logging can all be added there before the request reaches FastMCP.
 
 ---
 
 ## Two Databases — One Architecture
 
-This hub runs **two completely separate databases** with distinct responsibilities. This is not redundancy — it's a deliberate performance and security decision.
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
@@ -100,14 +151,11 @@ This hub runs **two completely separate databases** with distinct responsibiliti
 │                                                             │
 │  postgresql.py   → Cloud DB (e.g. Neon, Supabase)          │
 │                    asyncpg pool, SSL enforced               │
-│                    Neon-specific quirks handled             │
-│                    (statement_timeout stripped, keepalives) │
 │                                                             │
 │  user_handler.py → SQLite (users + sessions tables)        │
 │                    PBKDF2-SHA256 password hashing           │
 │                    Session validation incl. IP + UserAgent  │
 │                    Account lockout after 5 failed attempts  │
-│                    Path: SQLITE_PATH env var or app/        │
 │                                                             │
 └──────────────────────┬──────────────────────────────────────┘
                        │ inject as fundaments dict
@@ -123,12 +171,6 @@ This hub runs **two completely separate databases** with distinct responsibiliti
 └─────────────────────────────────────────────────────────────┘
 ```
 
-**Why two SQLite databases?**
-
-`user_handler.py` (Guardian) owns `users` and `sessions` — authentication state that must be isolated from the app layer. `db_sync.py` (app/*) owns `hub_state` and `tool_cache` — fast, async IPC between tools that doesn't need to leave the process, let alone hit a cloud endpoint.
-
-A tool caching a previous LLM response or storing intermediate state between pipeline steps should never wait on a round-trip to Neon. Local SQLite is microseconds. Cloud PostgreSQL is 50-200ms per query. For tool-to-tool communication, that difference matters.
-
 **Table ownership — hard rule:**
 
 | Table | Owner | Access |
@@ -137,20 +179,13 @@ A tool caching a previous LLM response or storing intermediate state between pip
 | `sessions` | `fundaments/user_handler.py` | Guardian only |
 | `hub_state` | `app/db_sync.py` | app/* only |
 | `tool_cache` | `app/db_sync.py` | app/* only |
-
-`db_sync.py` uses the same SQLite path (`SQLITE_PATH`) as `user_handler.py` — same file, different tables, zero overlap. The `db_query` MCP tool exposes SELECT-only access to `hub_state` and `tool_cache`. It cannot reach `users` or `sessions`.
-
-**Cloud DB (postgresql.py):**
-
-Handles the heavy cases — persistent storage, workflow tool results that need to survive restarts, anything that benefits from a real relational DB. Neon-specific quirks are handled automatically: `statement_timeout` is stripped from the DSN (Neon doesn't support it), SSL is enforced at `require` minimum, keepalives are set, and terminated connections trigger an automatic pool restart.
-
-If no `DATABASE_URL` is set, the entire cloud DB layer is skipped cleanly. The app runs without it.
+| `hub_results` | PostgreSQL / Guardian | via `persist_result` tool |
 
 ---
 
 ## Tools
 
-Tools register themselves at startup — only if the required API key exists in the environment. No key, no tool. The server always starts.
+Tools register at startup — only if the required API key exists. No key, no tool. Server always starts.
 
 | ENV Secret | Tool | Notes |
 | :--- | :--- | :--- |
@@ -160,12 +195,15 @@ Tools register themselves at startup — only if the required API key exists in
 | `HF_TOKEN` | `llm_complete` | HuggingFace Inference API |
 | `BRAVE_API_KEY` | `web_search` | Independent web index |
 | `TAVILY_API_KEY` | `web_search` | AI-optimized search with synthesized answers |
-| `DATABASE_URL` | `db_query` | Read-only SELECT — enforced at app level |
+| `DATABASE_URL` | `cloud DB` | e.g. Neon, Supabase |
+| `DATABASE_URL` | `db_query`, `persist_result` | SQLite read + PostgreSQL write |
 | *(always)* | `list_active_tools` | Shows key names only — never values |
-| *(always)* | `health_check` | Status + uptime |
+| *(always)* | `health_check` | Status + uptime + active transport |
 | *(always)* | `get_model_info` | Limits, costs, capabilities per model |
 
-**Configured in `.pyfun` — not hardcoded:**
+For all key names see [`app/.pyfun`](app/.pyfun).
+
+**Tools are configured in `.pyfun` — including system prompts:**
 
 ```ini
 [TOOL.code_review]
@@ -179,20 +217,18 @@ system_prompt    = "You are an expert code reviewer. Analyze the given code for
 ```
 
 Current built-in tools: `llm_complete`, `code_review`, `summarize`, `translate`, `web_search`, `db_query`  
-Future hooks (commented, ready): `image_gen`, `code_exec`, `shellmaster`, Discord, GitHub webhooks
+Future hooks (commented, ready): `image_gen`, `code_exec`, `shellmaster_2.0`, Discord, GitHub webhooks
 
 ---
 
 ## LLM Fallback Chain
 
-All LLM providers share one `llm_complete` tool. If a provider fails, the hub automatically walks the fallback chain defined in `.pyfun`:
+All LLM providers share one `llm_complete` tool. If a provider fails, the hub walks the fallback chain from `.pyfun`:
 
 ```
-anthropic → gemini → openrouter → huggingface
+e.g. anthropic → gemini → openrouter → huggingface
 ```
 
-Fallbacks are configured per-provider, not hardcoded:
-
 ```ini
 [LLM_PROVIDER.anthropic]
 fallback_to = "gemini"
@@ -216,15 +252,13 @@ Same pattern applies to search providers (`brave → tavily`).
 3. Add the API keys you have (any subset works)
 4. Space starts automatically — only tools with valid keys register
 
-That's it. No config editing. No code changes.
-
-[→ Live Demo Space](https://huggingface.co/spaces/codey-lab/Universal-MCP-Hub-DEMO) (no LLM keys set!)
+[→ Live Demo Space](https://huggingface.co/spaces/codey-lab/Multi-LLM-API-Gateway) (no LLM keys set)
 
 ### Local / Docker
 
 ```bash
-git clone https://github.com/VolkanSah/Universal-MCP-Hub-sandboxed
-cd Universal-MCP-Hub-sandboxed
+git clone https://github.com/VolkanSah/Multi-LLM-API-Gateway
+cd Multi-LLM-API-Gateway
 cp example-mcp___.env .env
 # fill in your keys
 pip install -r requirements.txt
@@ -240,32 +274,33 @@ LOG_TO_TMP=""
 ENABLE_PUBLIC_LOGS="true"
 HF_TOKEN=""
 HUB_SPACE_URL=""
-MCP_TRANSPORT="sse"
 ```
 
+Transport is configured in `app/.pyfun [HUB]` — not via ENV.
+
 ---
 
 ## Connect an MCP Client
 
-### Claude Desktop / any SSE-compatible client
+### Streamable HTTP (default — MCP spec 2025-11-25)
 
 ```json
 {
   "mcpServers": {
     "universal-mcp-hub": {
-      "url": "https://YOUR_USERNAME-universal-mcp-hub.hf.space/sse"
+      "url": "https://YOUR_USERNAME-universal-mcp-hub.hf.space/mcp"
     }
   }
 }
 ```
 
-### Private Space (with HF token)
+### Streamable HTTP — Private Space (with HF token)
 
 ```json
 {
   "mcpServers": {
     "universal-mcp-hub": {
-      "url": "https://YOUR_USERNAME-universal-mcp-hub.hf.space/sse",
+      "url": "https://YOUR_USERNAME-universal-mcp-hub.hf.space/mcp",
       "headers": {
         "Authorization": "Bearer hf_..."
       }
@@ -274,11 +309,29 @@ MCP_TRANSPORT="sse"
 }
 ```
 
+### SSE legacy fallback (set `HUB_TRANSPORT = "sse"` in `.pyfun`)
+
+```json
+{
+  "mcpServers": {
+    "universal-mcp-hub": {
+      "url": "https://YOUR_USERNAME-universal-mcp-hub.hf.space/mcp"
+    }
+  }
+}
+```
+
+> Same URL (`/mcp`) for both transports — the protocol is negotiated automatically.  
+> SSE fallback is for older clients that don't support Streamable HTTP yet.
+
 ---
 
 ## Desktop Client
+###### (experimental — ~80% AI generated)
 
-A full PySide6 desktop client is included in `DESKTOP_CLIENT/hub.py` — ideal for private or non-public Spaces where you don't want to expose the SSE endpoint.
+A full PySide6 desktop client is included in `DESKTOP_CLIENT/hub.py`.  
+Communicates via the REST `/api` endpoint — no MCP protocol overhead.  
+Ideal for private or non-public Spaces.
 
 ```bash
 pip install PySide6 httpx
@@ -288,8 +341,8 @@ python DESKTOP_CLIENT/hub.py
 ```
 
 **Features:**
-- Multi-chat with persistent history (`~/.mcp_desktop.json`)
-- Tool/Provider/Model selector loaded live from your Hub
+- Multi-chat with persistent history
+- Tool / Provider / Model selector loaded live from your Hub
 - File attachments: images, PDF, CSV, Excel, ZIP, source code
 - Connect tab with health check + auto-load
 - Settings: HF Token + Hub URL saved locally, never sent anywhere except your own Hub
@@ -300,54 +353,60 @@ python DESKTOP_CLIENT/hub.py
 
 ---
 
+## CMS & Custom Clients
+
+| Client | Interface used | Notes |
+| :--- | :--- | :--- |
+| [Desktop Client](DESKTOP_CLIENT/hub.py) | REST `/api` | PySide6, local |
+| [WP AI Hub](https://github.com/VolkanSah/WP-AI-HUB/) | REST `/api` | WordPress plugin |
+| TYPO3 (soon) | REST `/api` | — |
+| Claude Desktop | MCP `/mcp` | Streamable HTTP |
+| Cursor / Windsurf | MCP `/mcp` | Streamable HTTP |
+
+---
+
 ## Configuration (.pyfun)
 
-`app/.pyfun` is the single source of truth for all app behavior. Three tiers — use what you need:
+`app/.pyfun` is the single source of truth for all app behavior. Three tiers:
 
 ```
 LAZY:       [HUB] + one [LLM_PROVIDER.*]                    → works
-NORMAL:     + [SEARCH_PROVIDER.*] + [MODELS.*]              → works better  
+NORMAL:     + [SEARCH_PROVIDER.*] + [MODELS.*]              → works better
 PRODUCTIVE: + [TOOLS] + [HUB_LIMITS] + [DB_SYNC]           → full power
 ```
 
-Adding a new LLM provider requires two steps — `.pyfun` + one line in `providers.py`:
+Key settings in `[HUB]`:
 
 ```ini
-# 1. app/.pyfun — add provider block
+[HUB]
+HUB_TRANSPORT   = "streamable-http"   # streamable-http | sse
+HUB_STATELESS   = "true"              # true = HF Spaces safe, no session state
+HUB_PORT        = "7860"
+[HUB_END]
+```
+
+Adding a new LLM provider — two steps:
+
+```ini
+# 1. app/.pyfun
 [LLM_PROVIDER.mistral]
 active        = "true"
 base_url      = "https://api.mistral.ai/v1"
 env_key       = "MISTRAL_API_KEY"
 default_model = "mistral-large-latest"
-models        = "mistral-large-latest, mistral-small-latest, codestral-latest"
+models        = "mistral-large-latest, mistral-small-latest"
 fallback_to   = ""
 [LLM_PROVIDER.mistral_END]
 ```
 
 ```python
-# 2. app/providers.py — uncomment the dummy + register it
+# 2. app/providers.py — uncomment the dummy
 _PROVIDER_CLASSES = {
     ...
     "mistral": MistralProvider,   # ← uncomment to activate
 }
 ```
 
-`providers.py` ships with ready-to-use commented dummy classes for OpenAI, Mistral, and xAI/Grok — each with the matching `.pyfun` block right above it. Most OpenAI-compatible APIs need zero changes to the class itself, just a different `base_url` and `env_key`. Search providers (Brave, Tavily) follow the same pattern and are next on the roadmap.
-
-Model limits, costs, and capabilities are also configured here — `get_model_info` reads directly from `.pyfun`:
-
-```ini
-[MODEL.claude-sonnet-4-6]
-provider           = "anthropic"
-context_tokens     = "200000"
-max_output_tokens  = "16000"
-requests_per_min   = "50"
-cost_input_per_1k  = "0.003"
-cost_output_per_1k = "0.015"
-capabilities       = "text, code, analysis, vision"
-[MODEL.claude-sonnet-4-6_END]
-```
-
 ---
 
 ## Dependencies
@@ -360,20 +419,21 @@ passlib          — PBKDF2 password hashing in user_handler.py
 cryptography     — encryption layer in fundaments/
 
 # MCP Hub
-fastmcp          — MCP protocol + tool registration
+mcp              — MCP protocol + FastMCP (Streamable HTTP + SSE)
 httpx            — async HTTP for all provider API calls
-quart            — async Flask (ASGI) — needed for SSE + hypercorn
-hypercorn        — ASGI server — long-lived SSE connections, HF Spaces native
+quart            — async Flask (ASGI) — needed for MCP + hypercorn
+hypercorn        — ASGI server — Streamable HTTP + SSE, HF Spaces native
 requests         — sync HTTP for tool workers
 
 # Optional (uncomment in requirements.txt as needed)
-# aiofiles       — async file ops (ML pipelines, file uploads)
-# discord.py     — Discord bot integration (app/discord_api.py, planned)
-# PyNaCl         — Discord signature verification
-# psycopg2-binary — alternative PostgreSQL driver
+# aiofiles         — async file ops (ML pipelines, file uploads)
+# discord.py       — Discord bot integration (planned)
+# PyNaCl           — Discord signature verification
+# psycopg2-binary  — alternative PostgreSQL driver
 ```
 
-The core stack is intentionally lean. `asyncpg` + `quart` + `hypercorn` + `fastmcp` + `httpx` covers the full MCP server. Everything else is opt-in.
+> **Note:** The package is `mcp` (not `fastmcp`) — `FastMCP` is imported from `mcp.server.fastmcp`.  
+> Streamable HTTP support requires `mcp >= 1.6.0`.
 
 ---
 
@@ -383,8 +443,9 @@ The core stack is intentionally lean. `asyncpg` + `quart` + `hypercorn` + `fastm
 - `list_active_tools` returns key **names** only — never values
 - `db_query` is SELECT-only, enforced at application level (not just docs)
 - `app/*` has zero import access to `fundaments/` internals
-- Direct execution of `app/app.py` is blocked by design — prints a warning and uses a null-fundaments dict
-- `fundaments/` is initialized conditionally — missing services degrade gracefully, they don't crash
+- Direct execution of `app/app.py` blocked by design — warning + null-fundaments fallback
+- `fundaments/` initialized conditionally — missing services degrade gracefully, never crash
+- Streamable HTTP uses standard Bearer headers — no token-in-URL (unlike SSE)
 
 > PyFundaments is not perfect. But it's more secure than most of what runs in production today.
 
@@ -394,25 +455,34 @@ The core stack is intentionally lean. `asyncpg` + `quart` + `hypercorn` + `fastm
 
 ## Foundation
 
-This hub is built on [PyFundaments](PyFundaments.md) — a security-first Python boilerplate providing:
+Built on [PyFundaments](PyFundaments.md) — a security-first Python boilerplate:
 
 - `config_handler.py` — env loading with validation
 - `postgresql.py` — async DB pool (Guardian-only)
 - `encryption.py` — key-based encryption layer
 - `access_control.py` — role/permission management
-- `user_handler.py` — user lifecycle management  
+- `user_handler.py` — user lifecycle management
 - `security.py` — unified security manager composing the above
 
-None of these are accessible from `app/*`. They are injected as a validated dict by `main.py`.
+None accessible from `app/*`. Injected as a validated dict by `main.py`.
 
 [→ PyFundaments Function Overview](PyFundaments%20–%20Function%20Overview.md)  
-[→ Module Docs](docs/app/)
+[→ Module Docs](docs/app/)  
+[→ Source Repo](https://github.com/VolkanSah/Multi-LLM-API-Gateway)
+
+---
+
+## Related Projects
+
+- [Customs LLMs for free — Build Your Own LLM Service](https://github.com/VolkanSah/SmolLM2-customs/)
+- [WP AI Hub (WordPress Client)](https://github.com/VolkanSah/WP-AI-HUB/)
+- [ShellMaster (2023 precursor)](https://github.com/VolkanSah/ChatGPT-ShellMaster)
 
 ---
 
 ## History
 
-[ShellMaster](https://github.com/VolkanSah/ChatGPT-ShellMaster) (2023, MIT) was the precursor — browser-accessible shell for ChatGPT with session memory via `/tmp/shellmaster_brain.log`, built before MCP was even a concept. Universal MCP Hub is its natural evolution.
+[ShellMaster](https://github.com/VolkanSah/ChatGPT-ShellMaster) (2023, MIT) was the precursor — browser-accessible shell for ChatGPT with session memory, built before MCP was a concept. Universal MCP Hub is its natural evolution: same idea, proper architecture, dual interface.
 
 ---
 
@@ -428,6 +498,6 @@ By using this software you agree to all ethical constraints defined in ESOL v1.1
 ---
 
 *Architecture, security decisions, and PyFundaments by Volkan Kücükbudak.*  
-*Built with Claude (Anthropic) as a typing assistant for docs & the occasional bug.*
+*Built with Claude (Anthropic) as a typing assistant for docs (and the occasional bug).*
 
 > crafted with passion — just wanted to understand how it works, don't actually need it, have a CLI 😄