Pure Liquid Local
AI Client

Overview

This Nx monorepo hosts two applications that act as a single product: an authenticated proxy in front of your local inference server, and the Angular chat interface on top of it. Every chat session is persisted in MongoDB, token usage is tracked per user, and the backend runs its own MCP client that calls tools on-demand as the model requests them — rather than relying on the inference server to orchestrate tool calls itself.

Chat Completions API (current default)

LM Studio disabled connecting to localhost MCP servers, which broke this project's original architecture: the Responses API worked by handing LM Studio a type: 'mcp' tool pointing at this backend's MCP server, relying on LM Studio itself to connect, list tools, call them, and feed results back to the model. With per-request localhost MCP connections disabled, that flow no longer works — and it was never portable to other backends anyway, since MCP tool passthrough is a Responses-API-only convenience.

The fix: stop depending on the inference server for MCP orchestration entirely, and do it ourselves. The backend now runs its own MCP client (apps/api/src/modules/mcp-client) that connects directly to the MCP tool server, lists available tools, and translates them into plain OpenAI function-tool definitions. Chat requests go out over the standard Chat Completions API (/v1/chat/completions) with those function tools attached. When the model returns tool_calls, the backend executes them itself via the MCP client and loops back into the model until it produces a final answer.

Known limitation: file attachments are text-only-friendly (images are inlined as vision content; other file types are referenced by ID and fetched on demand via get-content-from-file-ids). Reasoning-effort and AI-decided chat naming are still supported, matching the old Responses-API experience.

Resilient Background Generation

A chat generation isn't tied to the HTTP connection that started it. Refreshing the page, closing the tab, or switching to another chat while the AI is still responding doesn't lose or corrupt anything — the backend keeps generating in the background, and the frontend reattaches to it automatically.

Architecture

Unlike the old Responses-API flow — where LM Studio itself connected to the MCP server mid-inference — the NestJS backend now acts as the MCP client itself: it lists tools from its own MCP server, attaches them to the Chat Completions request as plain function tools, and executes any tool_calls the model returns before looping back into the model. The inference server never talks to MCP directly, so this works with any backend that supports standard OpenAI function calling.

Angular UI (4200) ──SSE──▶ NestJS API (8888) ──/v1/chat/completions──▶ Inference server
                                    │        ▲
                          tool_calls loop    │ generate-image-tool
                                    ▼        │
                             MCP Client ──▶ MCP Server (@rekog/mcp-nest, self)
                                    │
                                    ▼
                           InvokeAI (9090) — txt2img via REST + Socket.IO

Tech Stack

Features

Getting Started

Up and running in a few steps.

npm install

nx serve api          # → http://localhost:8888
nx serve ui           # → http://localhost:4200

# Or start both simultaneously:
npm start

curl -X POST http://localhost:8888/auth/register \
  -H "Content-Type: application/json" \
  -d '{"username":"alice","password":"s3cret"}'

Environment Variables

Create apps/api/.env with the following:

# MongoDB connection URI
MONGODB_URI=mongodb://localhost:27017/lmStudioWrapper

# OpenAI-compatible inference server (LM Studio, Ollama, llama.cpp, vLLM, ...)
LM_STUDIO_BASE_URL=http://localhost:1234
LM_STUDIO_API_TOKEN=            # optional

# JWT signing secret
JWT_SECRET=your-very-secret-key

# Backend's own MCP client connects here — safe as localhost/LAN IP
SELF_MCP_URL=http://192.168.0.34:8888/tools/mcp

# Additional external MCP servers, comma-separated (optional)
# MCP_SERVER_URLS=http://example.com/mcp,http://another-host:9000/mcp

# Public base URL of this backend — used to build asset URLs (must be browser-reachable)
SELF_URL=http://localhost:8888

PORT=8888
USE_SWAGGER=true       # enables /api Swagger UI

MCP Tool Integration

The NestJS backend plays both MCP roles at once: an MCP server (apps/api/src/tools/api.tools.ts, via @rekog/mcp-nest) exposing Streamable HTTP + SSE transports at /tools/mcp, and an MCP client that connects to that same server (and any others configured via MCP_SERVER_URLS), lists its tools, and calls them on the model's behalf — forwarding the authenticated user's JWT and current chatId so tools have full access to the user's context.

Custom MCP Servers

Beyond the built-in MCP server/client, each user can register their own external MCP servers on their account and control exactly which tools are available — account-wide or per chat. The account-level list, the New Chat dialog, and every chat's settings dialog all read/write the same data, so changes made from any one of them show up in the others immediately.

Tool Approval

Per-chat opt-in that pauses a tool call for your approval before it runs, instead of executing automatically the moment the model requests it — the same request/approve/deny loop as an agentic coding CLI, applied to this project's own MCP tool orchestration.

Custom MCP Progress Reporting

MCP's spec has a standard notifications/progress mechanism, but neither LM Studio nor llama.cpp forward it anywhere the browser can see. Since this backend is its own MCP client, there was no transport carrying a tool's progress back to the chat UI — apps/api/src/tools/tools-helper.service.ts is a custom workaround that fixes that using the same SSE connection already streaming the chat response.

Image Generation (InvokeAI)

The generate-image-tool MCP tool lets the model generate images on demand during a conversation via a locally running InvokeAI instance.

Image Upload

Users can attach one or more images to a chat message before sending. Attached files are listed below the textarea with filename and size, and can be removed before sending. On send, each image is uploaded to POST /assets/:chatId as multipart/form-data, validated for MIME type (max 10 MB), and stored as a binary blob in the image_blobs MongoDB collection, then forwarded to the model as vision content.

Voice Input

A mode toggle next to the chat input swaps the whole composer between typing and recording. By default, no separate speech-to-text step happens in this codebase — the inference server itself (llama.cpp, etc.) handles transcription/understanding via its own audio input support. A text message is optional whenever a recording is attached — you can send audio-only. For models without audio support, see Voice Transcription below.

Voice Transcription

Per-chat opt-in (ChatMetadata.transcribeAudio) that turns a recorded voice message into an ordinary typed message before the model ever sees audio — useful for models without audio support, or simply to get more reliable tool-calling/reasoning out of a model that technically accepts input_audio but doesn't handle it as well as text.

Any input_audio part that isn't userRecorded (or transcription is off for the chat) still falls back to the plain "listen to this audio" system prompt from Voice Input — nothing about that path changes.

Message Encryption

Per-chat AES-256 encryption can be opted into when creating a new chat session. Only ciphertext ever reaches the inference server's own message store/logs — plaintext never leaves the NestJS trust boundary.

Key Storage & Security Boundaries

Authentication & Authorization

Token Usage & Rate Limiting

Token consumption is tracked per user and enforced against subscription-tier limits configured in the token_limit_configs MongoDB collection.

After each completed inference, TokenLimitService.updateUsedTokens() increments the user's usedTokens counter. If the limit is reached, an api.info SSE event is emitted with the reset timestamp. Limits reset automatically when tokenCountResetDate elapses. Token limits are managed exclusively through the Admin CMS — the TokenLimitModule controller is gated behind @Roles(Role.Admin).

Admin CMS

A role-gated /admin route (Angular reactive forms throughout — no ngModel) for managing users and token-limit configs without touching MongoDB by hand. Only visible/reachable for users with role: 'admin' — the link appears in the account info panel only for admins, and is enforced twice: an Angular adminGuard route guard, and @Roles(Role.Admin) on every backend endpoint.

User Management

List every user with role, subscription, activation status, and current token usage. Create a user directly (bypassing the normal registration/activation-email flow), edit an existing user's role, subscription, activation status, or password, reset their token-usage counter on demand, or delete them (an admin cannot delete their own account, to avoid accidental lockout).

Token Limit Config Management

List, create, edit, and delete token_limit_configs documents. Creating a config with a brand-new tier name is how a new subscription type is defined — there's no separate "add subscription type" step. The tier-name field is free text when creating a config (validated against ^[a-z0-9_-]{2,32}$), and locked once a config exists (one config per tier, enforced by a unique index). The "assign subscription" dropdown in the user-edit dialog is populated from GET /admin/users/subscription-types, which unions the built-in defaults (free, basic), every tier with a config, and any tier already assigned to a user — so a user's tier stays selectable even if its config was later deleted.

All admin routes require both a valid JWT and role: 'admin'.

API Overview

Full interactive docs at http://localhost:8888/api when USE_SWAGGER=true.