Sezzlee Local LLM

io.github.sezzleePublished by GitHub account sezzleev0.1.3Updated Oct 24, 2026

Let a planning agent hand bounded language work to a local Ollama model.

VerifiedSTDIODesktop onlyDeveloper ToolsData & AnalyticsAI & ML

Overview

AI-generated overview

Lets a coding agent hand bounded language tasks — classify, extract, summarize, transform, CSV labelling — to a local Ollama model instead of its own context.

What you can do
  • Run one bounded language task on the local model: classify, extract, summarize, transform or free-form, optionally returning JSON that matches a supplied schema
  • Read text or up to eight workspace files for that task, with long inputs chunked and merged rather than truncated
  • Label every row of a CSV file with one of 2–50 labels, writing a new labelled CSV to the output directory and returning per-label counts and sample rows
  • Check whether the local model is reachable and loaded, its context window, the per-call input budget and the queue depth
When to use it
Useful when a planning agent should offload long or unstructured text work — summarising documents, extracting records, classifying rows — to a local model so the bulk content never enters the agent's own context. Less worthwhile for small tabular jobs with clear patterns, where the README's own measurements found the agent working alone faster.
Requirements
Runs locally over stdio via npx, so Node.js is needed, plus a reachable Ollama host (default with the chosen model pulled. SEZZLEE_LLM_MODEL is required and has no default; SEZZLEE_LLM_ROOT, SEZZLEE_LLM_OUTPUT_DIR, SEZZLEE_LLM_NUM_CTX, SEZZLEE_LLM_KEEP_ALIVE and SEZZLEE_LLM_TIMEOUT_MS are optional. Desktop only.
Before you install
local_map writes new CSV files into the output directory (SEZZLEE_LLM_OUTPUT_DIR, default .llm-mcp/out) inside the workspace root; it never overwrites or deletes, but it does create files. File arguments are read by the server and sent to the Ollama host, so point SEZZLEE_LLM_BASE_URL at a host you trust. Set SEZZLEE_LLM_NUM_CTX to what the GPU really delivers, since Ollama silently drops oversized prompts. In Codex with approval_policy "never", default_tools_approval_mode = "auto" is also…

Installation

In SourceWeft

  1. Open Sezzlee Local LLM in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Desktop only via STDIO. STDIO servers start a local process, so they need the SourceWeft desktop host.

Other MCP clients

Follow the launch instructions in the repository.

README

@sezzlee/llm-mcp

MCP server that lets a planning agent (Codex, Claude Code, Cursor) hand off bounded language work to a local model. It builds on @sezzlee/mcp-core and names no other @sezzlee/* package.

Quick start

json
{  "mcpServers": {    "local": {      "command": "npx",      "args": ["-y", "@sezzlee/llm-mcp"],      "env": {        "SEZZLEE_LLM_BASE_URL": "http://127.0.0.1:11434",        "SEZZLEE_LLM_MODEL": "qwen3:8b"      }    }  }}

In Codex, the same block goes under mcp_servers.local. If it runs with approval_policy = "never", default_tools_approval_mode = "auto" is also required, or Codex refuses the call.

Tools

Three tools. Two are read-only; local_map only adds new files to the server's own output directory.

ToolWhat it doesKey arguments
local_taskRuns one bounded language task on the local model: classify, extract, summarize, transform, or free. The server reads any file arguments itself — their contents never enter the calling agent's context. With jsonSchema the answer is JSON matching that schema (returned as result); otherwise it is text (returned as answer). summarize and extract split an oversized input into chunks and read all of it (up to 32 chunks, 1 MiB total); every other kind refuses an oversized input as input_too_large. Nothing is ever silently truncated.kind, instruction, text?, files? (up to 8, paths relative to the working directory), jsonSchema?
local_mapLabels every row of a CSV file with one of the given labels. The agent never sees the rows: it passes a path, and the server writes a new file (the original columns plus one label column) under the output directory, returning that file's path, the per-label counts, and up to 4 sample rows per label. Up to 2,000 rows.file, instruction, labels (2–50), labelColumn? (defaults to label)
local_statusReports whether the local model is reachable and loaded, its context window, one call's input budget, and how many calls are queued. Call it when unsure the local model is available before delegating to it.none

Configuration

text
SEZZLEE_LLM_MODEL=qwen3:8bSEZZLEE_LLM_ROOT=.                            # default: the working directorySEZZLEE_LLM_OUTPUT_DIR=.llm-mcp/out           # default; relative to root, must stay inside itSEZZLEE_LLM_BASE_URL=http://127.0.0.1:11434   # defaultSEZZLEE_LLM_NUM_CTX=16384                     # default; at least 4096SEZZLEE_LLM_KEEP_ALIVE=30m                    # defaultSEZZLEE_LLM_TIMEOUT_MS=300000                 # default; one request
npx -y @sezzlee/llm-mcp
VariableDefaultMeaning
SEZZLEE_LLM_MODELnone — requiredThe Ollama model name. There is no built-in default; it must be set explicitly (see Model choice).
SEZZLEE_LLM_ROOTworking directoryWorkspace root. Every file argument a tool accepts is resolved against it.
SEZZLEE_LLM_OUTPUT_DIR.llm-mcp/outWhere local_map writes its output. Relative to the root, and must stay inside it.
SEZZLEE_LLM_BASE_URLhttp://127.0.0.1:11434Base URL of the Ollama host.
SEZZLEE_LLM_NUM_CTX16384Context window in tokens. Must be an integer of at least 4096.
SEZZLEE_LLM_KEEP_ALIVE30mValue forwarded to Ollama's keep_alive.
SEZZLEE_LLM_TIMEOUT_MS300000Timeout for a single request to the model.

Only the model name is required. Parsing is fatal, reaching the host is not: the server still starts and answers tools/list with the host down, and local_status reports reachable: false. The model is warmed up right after the server starts serving.

Set SEZZLEE_LLM_NUM_CTX to what the GPU actually delivers. Ollama does not refuse an oversized input — it silently drops the head — and the input budget is derived from this value.

Limits

LimitValueWhy
Input budget45% of the context windowOllama silently drops the head of an oversized prompt instead of refusing it, so the server refuses first.
Output budget40% of the context windowCaps a runaway completion; without an id-bearing schema the model was measured looping into 12,600 tokens of garbage.
Chars-per-token estimate~1.8Measured on Turkish text; English runs closer to 4 characters per token, so the estimate errs toward refusing rather than truncating.
local_task filesup to 8Per-call file argument cap.
local_task long input (summarize/extract)up to 32 chunks, 1 MiB totalOther kinds refuse an over-budget input outright as input_too_large.
Chunk merge roundsup to 3A merge that still does not fit after 3 rounds fails as input_too_large.
local_map rowsup to 2,000Labelling was measured at ~270 ms per row — about nine minutes for 2,000 rows, inside the 900 s tool timeout Codex allows.
local_map file sizeup to 8 MiBRefused up front rather than timed out halfway with nothing written.

Rules

  • Three lint-enforced layers, three root entrypoints. src splits into platform/ (the mcp-core and Node boundary), backend/ (the model host), and tools/ (the MCP surface). tools/ sees the host only through backend/port.ts; the concrete backend is wired in cli.ts.
  • Only src/backend/ollama.ts reaches the network, and only through the global fetch. That global and the node:http/net/tls family are lint-banned everywhere else.
  • process.env is read only in cli.ts, each variable accessed by name.
  • File paths are resolved against the workspace. The requested path and its realpath are checked separately, so a symlink pointing outside the workspace is refused too. readText accepts only a WorkspacePath-branded path that has passed both checks. In error envelopes, the workspace's absolute path appears as ..
  • The server counts tokens, not the model. An input over num_ctx × 0.45 never reaches the host; an input that could not fit under any circumstances is refused before it is even read. The answer is capped at num_ctx × 0.4.
  • Only src/platform/workspace.ts touches the filesystem, lint-enforced. The single writer is createOutput: it re-checks the output directory's realpath, the server itself picks the file name, lowers it to a safe alphabet and fixes the extension to .csv, and opens it wx — so it never overwrites an existing file or a symlink, and nothing is ever deleted (mcp-core).
  • local_map carries the row number to the model and back. An id-less format lost the row order. A skipped row is asked again once; if it is still missing, it is left unlabeled and counted — never guessed.
  • A chunked input is not truncated either. Chunks split on paragraph, then line, boundaries; each chunk yields notes, the notes are merged and the instruction applied one last time. If the merged notes still do not fit the budget, the merge round repeats (up to 3); if that still fails, the call is refused as input_too_large.
  • One request per host at a time. createSerialBackend queues requests: the GPU does not run them in parallel, while Codex fires calls concurrently. probe bypasses the queue.
  • A new backend kind is just another implementation of the Backend interface. The rest of the server does not change.

Design notes

The measurements below are what the rules above are built on.

Why an MCP server instead of pointing Codex at Ollama directly

Four ways of getting Codex to a local model were tried; only the MCP server worked.

ApproachResult
Codex straight to OllamaOllama 0.34.2 serves /v1/responses and the connection succeeds, but the local model does not know Codex's tool protocol — it called a Read tool that does not exist, and Ollama answered the next request with no user query found. The real blocker: Codex starts every turn with a ~37k-token base cost, which does not fit a 16k context
Codex shell runs curlThe sandbox cuts network access; opening it means giving Codex network access everywhere, not just to the local model
Codex's spawn_agentAccepts OpenAI models only
MCP serverRuns outside the sandbox and reaches Ollama itself. Only the prompt reaches the local model (measured: 196 tokens) — Codex's ~37k-token turn overhead never leaves Codex

The server's working directory is Codex's workspace: every file argument the tools accept is resolved against it, and a path that resolves outside it is refused.

Model choice

gpt-oss:20b was measured scoring 0/100 on the id-bearing JSON schema local_map and structured local_task calls depend on — the model could not hold the schema. A qwen3 model (qwen3:8b in the examples above) is what the measurements in this repository were run with; SEZZLEE_LLM_MODEL has no built-in default, so it must be set explicitly.

Codex alone on tabular data

On a 400-row labelling task with clear cues, Codex working alone was as accurate as delegating (14/14 correct) and about 3.5x faster: 48 s versus 166 s through local_map. This is why DELEGATION_INSTRUCTIONS (products/chat/api/src/codex/delegation-instructions.ts) allows Codex to write a script instead of delegating when the data is tabular with clear patterns — delegating only pays off on long or unstructured text, not on rows a script can already parse.

Rejected alternatives

  • The name ollama-mcp. Too narrow once the backend became pluggable; llm-mcp follows the repo's convention of naming a server after the resource behind it, not the current backend.
  • A private worker inside a consumer product. The server has nothing chat-specific in it — tools take a file path and an instruction, schemas are plain JSON Schema on the MCP surface. Keeping it inside one product would close it to outside contribution and force reinventing the payload budget that @sezzlee/mcp-core already provides.
  • Using an existing open-source repo. Most of the ones reviewed are Python, and one carries a license that forbids modification; none of them know Codex's approval mode, its workspace boundary, or the payload budget. Ideas were borrowed where they held up: per-kind ready-made prompts (from ollama-handoff), file-path-taking tools and failover (from LocalTokens), and "the worker produces bounded output, the strong side accepts it" (from Shahriar/ollama-mcp-server).
  • One tool per job kind. Every extra tool schema is token cost on every Codex turn; one local_task tool with a kind enum covers the same ground for less.
  • Raising concurrency instead of queueing. Four parallel requests to one GPU were only 1.1x faster than four sequential ones — the GPU does not run requests in parallel, so a queue is the only thing that keeps a call inside its own timeout.

Out of scope (deliberately)

  • An agent loop on the local model. A reviewed repo's small model, run through a full agent harness, took 5–7 minutes on a simple task and once reported having done work it had not done. Agent work already has Codex's own spawn_agent.
  • Embedding. bge-m3 is available on the host but unused; add it if a search need appears.
  • Reading .xlsx directly. v1 reads CSV and plain text only. An .xlsx input goes through @sezzlee/excel-mcp from the calling side; teaching this server the format directly is out of scope for now.

Measured runs

All Codex runs below used gpt-5.6-luna at low reasoning effort, against Ollama 0.34.2 with num_ctx 16,384. "Cache-free" is input_tokens − cached_input_tokens.

RunDataSetupTimeCache-free inputOutputResult
S0400 rows, with cuesCodex alone53 s31.1k1.8k14/14 days
S1400 rows, with cueslocal_task only68 s32.5k2.4k14/14 (local call hit input_too_large, Codex fell back to Python)
S2400 rows, with cueslocal_map, auto-approved155 s41.4k1.5k14/14, Codex never read the rows
H0400 rows, no cuesCodex alone48 s25.8k1.9k14/14 (read 200 rows and wrote a rule)
H2400 rows, no cueslocal_map, blind instruction162 s18.4k1.7k2/14 (376/400 rows labelled)
H3400 rows, no cueslocal_map, sample + verify166 s24.5k2.2k14/14 (400/400 rows labelled)
D017 documentsCodex alone65 s34.1k2.9k17 records (read only the first 240 lines of each document)
D217 documentslocal_task + chunking226 s25.7k3.0k17 records, Codex read no document itself; 17 calls arrived at once, the queue cleared in 157 s, no timeout

Development

text
pnpm turbo run test --filter=@sezzlee/llm-mcp

No local model is needed for this — fetch is faked.

test/live.spec.ts runs against a real Ollama instance:

text
SEZZLEE_LLM_LIVE=1 SEZZLEE_LLM_BASE_URL=http://127.0.0.1:11434 SEZZLEE_LLM_MODEL=qwen3:8b \  pnpm turbo run test --filter=@sezzlee/llm-mcp -- test/live.spec.ts

Source: packages/servers/llm-mcp/README.md at commit 2614421

Tools

0
SourceWeft has not started this package in its sandbox yet, so its tools are not known.

Version history

1
  1. v0.1.3LatestOct 11, 2026

Score

50% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 days25 pts

    Keep the endpoint answering the MCP handshake; SourceWeft probes it every 30 days.

  • Auth declared10 pts

    Declare the credential headers in the registry entry, or keep the endpoint answering the probe so its auth can be classified.

  • Tools listed15 pts

    Answer tools/list without a credential, or ship a package that starts in a sandbox without one.

  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts