Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
LLAMASWAP_EXENoPath to llama-swap executable (only if AUTOSTART=1)
LLAMASWAP_CONFIGNoPath to llama-swap config file (only if AUTOSTART=1)
LLAMASWAP_LISTENNoAddress to listen for llama-swap (only if AUTOSTART=1)
LOCAL_DELEGATE_LOGNoPath to usage.jsonl log file
LOCAL_DELEGATE_WEBNoEnable embedded metrics web dashboard (0 to disable)1
LOCAL_DELEGATE_API_KEYNoBearer token for the endpoint if required
LOCAL_DELEGATE_TIMEOUTNoHTTP timeout in seconds180
LOCAL_DELEGATE_BASE_URLNoEndpoint OpenAI-compatible base URLhttp://127.0.0.1:9292/v1
LOCAL_DELEGATE_WEB_HOSTNoWeb dashboard host127.0.0.1
LOCAL_DELEGATE_WEB_PORTNoWeb dashboard port9393
LOCAL_DELEGATE_AUTOSTARTNoAuto-start llama-swap (opt-in)0
LOCAL_DELEGATE_MODEL_CODENoModel for codeqwen25-coder-14b
LOCAL_DELEGATE_MODEL_FASTNoUltra-fast model for trivial tasksqwen35-2b
LOCAL_DELEGATE_MODEL_LONGNoModel for long documentsllama31-8b
LOCAL_DELEGATE_LONG_INPUT_CHARSNoThreshold in characters to switch to long model6000
LOCAL_DELEGATE_MODEL_MECHANICALNoModel for classify/extract/short summariesgemma3-4b

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

This server publishes no instructions, or was last inspected before Glama recorded them.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": false
}
prompts
{
  "listChanged": false
}
resources
{
  "subscribe": false,
  "listChanged": false
}

Tools

Functions exposed to the LLM to take actions

NameDescription
local_summarizeA

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need a summary, not the literal content.

Summarizes text or the content of a file with a local model, without spending Claude's context.

Use it to summarize large files/documents: pass 'path' and the file is read server-side, so
the full content does NOT enter Claude's context (only the short summary comes back).
Alternatively pass 'text'. Routes automatically to the mechanical model (short inputs) or to
the long-context model (large documents). A short input that carries a table (HTML, ARIA,
Markdown/GFM, CSV or TSV) goes to the long-context model too, which keeps rows apart: slower,
and the summary ends with a warning naming the format; `LOCAL_DELEGATE_SUMMARIZE_TABLE_LONG=0`
turns this off.

Args:
    text: Text to summarize (use this or 'path').
    path: Path to a file whose content is summarized (read server-side).
    max_words: Maximum length of the summary in words.
    focus: Optional. What you care about in the document (e.g. "configuration figures",
        "risks"): the summary prioritizes it and keeps its concrete data verbatim.
local_classifyB

Classifies a text into ONE of the given labels, with a local model.

Returns exactly one label from the list, with no additional text.

Args:
    text: Text to classify.
    labels: List of candidate labels.
local_extractA

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need structured fields, not the literal content.

Extracts structured fields from a text/file as JSON, with a local model.

Pass 'path' to read the file server-side (spends no Claude context) or 'text'. Returns an
object with exactly the requested keys: the caller does not have to parse a string. A key the
model left out comes back as null and is listed in `missing_keys`; a key it spelled another
way (case, `_`, `-`, spaces) is mapped in `renamed_keys`; a key it added is dropped from the
data and kept, with its value, in `dropped` (names in `dropped_keys`). What is not data
travels under the reserved key `_local_delegate` (`truncated` and `warning`,
`missing_keys`/`renamed_keys`/`dropped_keys`/`dropped`, `read_server_side`, `fallback`, or
`error` and `raw`); with chunked input, `chunked`
says how many pieces there were and which fields stayed null in all of them. Routes
automatically to the mechanical model (short inputs) or to the long-context model (large
documents): the size probe uses file bytes for 'path' and characters for 'text' (~5-10%
difference in UTF-8, acceptable).
By default it asks the backend for schema-constrained JSON (`LOCAL_DELEGATE_JSON_SCHEMA=auto`);
if the backend does not support it, it retries in free mode.
To locate: with 'path', a field whose name asks for lines (`sections_with_lines`,
`line_number`, `start_line`, `lineRange`; also in Spanish) makes the model see line numbers
(and a Markdown file's headings with their lines), so it can answer for `Read` offset/limit;
cited lines that do not hold in the file are listed in `lines_unverified`, and a field that
asks for items (`tasks_with_lines`) but got only section ranges in `section_only_keys`.
Over a unified diff, a field that asks only for the files and their lines (`files_with_lines`)
gets one `path: first-last` per file, by program (`diff_files` says so); one that asks for
the files and their hunks (`files_and_hunks_with_lines`) gets each hunk's range too.
A value that is a "no data" marker ("N/A", "unknown", "-", "", also the strings "null" and
"undefined") comes back as null, listed in `missing_keys`, with the model's text in
`placeholder_keys`. With a JSON object as input, a field that counts one of its top-level
lists (`number_of_comments`) left empty or ABOVE the list's length is counted by the program,
unless the JSON already holds a total for it; the model's figure is in `recounted_keys`.
A location field naming one heading (`intro_heading_line`) that got the whole Markdown
outline is cut to the only heading its singular name fits; with any doubt (a plural
subject, no single heading) it is left as it came. Both go to `outline_copies`, with a warning.
A value found only in the row of another requested key (a table row, a JSON key or a `label:
value` line) is kept but reported in `cross_filled_keys` (`{key: {"row", "other_key"}}`), with
a warning: the model may have handed out the rows by position.
A clause of a value that carries a negation its source clause lacks, or lost one the source
has, is kept but reported in `polarity_flipped_keys` (`{key: {"value", "source", "flip"}}`).
A small input that carries a table (HTML `<table`/`<tr`, ARIA `role="table"`, `"grid"`,
`"treegrid"` or `"row"`, a Markdown or GFM table with its delimiter row, three or more CSV
or TSV rows) goes to the long-context model too, even with one field: the mechanical one
answered with the value of another row. Then `_local_delegate.role_reason` says so (`{"role": "long", "reason":
"table", "format": "html"|"aria"|"markdown"|"csv"|"tsv", "notice": ...}`), also on an
`error` answer, and the call is slower and may have to load that model. Not seen: a CSV of
two columns, a TSV row that starts with an empty cell, tables aligned with spaces and
`<div>` grids that only have class names.
`LOCAL_DELEGATE_EXTRACT_TABLE_LONG=0` turns this off.

Args:
    fields: Names of the fields to extract (JSON keys).
    text: Source text (use this or 'path').
    path: Path to a source file (read server-side).
local_boilerplateA

Generates boilerplate code from a specification, with a local code model.

**Writes the code to `target`** and returns only a two-line receipt (path, size). The generated
code never enters your context: that is where the saving is, and that is why `target` is not
optional. To see it, open the file; to use it, it is already in place.

Args:
    spec: Description of what the code must do.
    language: Programming language (e.g. 'python', 'typescript').
    target: ABSOLUTE path of the file to write. Missing directories are created.
    overwrite: Overwrite `target` if it already exists. By default it fails, and it fails
        BEFORE generating anything.
local_delegateA

Generic escape tool: delegates a text->text task to a local model.

Use it when no specific tool fits. Builds the prompt with guardrails and returns text.

With long inputs it splits the input at natural boundaries (Markdown headers, paragraphs),
applies the SAME task to each chunk and concatenates the outputs in order. That is right for
transforming the whole text (translate, rewrite, reformat) but NOT for reduction tasks over the
whole (counting, picking the maximum, a single global summary): for those pass `chunk='off'` or
use `local_summarize`.

Args:
    task: Task instruction (one sentence with an explicit output format).
    input: Content to operate on.
    output_format: Exact expected output format.
    model: Model to use; one of the ids configured in the catalog. Defaults to the mechanical one.
    chunk: 'auto' (splits only if the input is long), 'on' (splits whenever possible),
        'off' (a single call; a long input may come back truncated).
local_lint_summaryA

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need a grouped summary, not the literal content. If you ran a command with long output, dump it to a file and pass 'path'.

Summarizes linter/test/CI output with a local model, without spending Claude's context.

Meant for long, noisy logs (ESLint, clippy, pytest, tsc, CI). Pass 'path' and the file is read
server-side, so the full log does NOT enter Claude's context: only a summary grouped by file
comes back, with the count per error type/rule and the most important first. Alternatively
pass 'text'. Routes automatically to the mechanical model (short) or the long-context model
(long).

Args:
    path: Path to the lint/test output file (read server-side). Use this or 'text'.
    text: Lint/test output as text.
    max_words: Maximum length of the summary in words.
local_commit_msgA

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need a commit message, not the literal content.

Drafts a commit message from a diff, with a local code model.

Pass 'path' to a diff file (e.g. the output of `git diff` dumped to a file) and it is read
server-side, so the full diff does NOT enter Claude's context. Alternatively pass 'diff' as
text. ALWAYS review the message before using it.

The language follows the recent commits of the git repo that holds the 'path' file (so dump
the diff inside the repo), unless LOCAL_DELEGATE_COMMIT_LANGUAGE is set.

Args:
    diff: The diff as text (use this or 'path').
    path: Path to a file with the diff (read server-side).
    style: 'conventional' (Conventional Commits) or 'plain'.
local_translateA

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need the translation, not the literal content.

Translates text or the content of a file with a local model, without spending Claude's context.

Pass 'path' to read the file server-side (the original does not enter Claude's context) or
'text'. Keeps the format of the original and returns ONLY the translation. Routes
automatically to the mechanical model (short) or the long-context model (long).

Long documents are split at natural boundaries (Markdown headers, paragraphs) and each chunk
is translated in its own call; the result comes back complete and in order, without the
truncated-output warning.

Args:
    target_lang: Target language (e.g. 'Spanish', 'English', 'French').
    text: Text to translate (use this or 'path').
    path: Path to a file whose content is translated (read server-side).
local_explain_codeA

PREFER this tool over reading the file with Read when the file is large (>200 lines / >10 KB) and you only need an explanation, not the literal content.

Explains in prose what a code snippet/file does, with a local code model.

Pass 'path' to read the file server-side (the full code does NOT enter Claude's context; only
the explanation comes back) or 'code'. Optionally focus the explanation with 'question'.
With 'path' the model sees the file's line numbers, so it can answer where something is
("name: line") and you can then Read only that range with offset/limit. With 'path' and a
'question', the server then checks those numbers against the file: cited lines that do not
contain what they are cited for get a warning, and each code identifier of the question
(`name`, name(), camelCase, snake_case) gets its exact lines, found by whole-word search.
Review the explanation: a local model writes it; the occurrence lines are exact.

Args:
    code: Code to explain (use this or 'path').
    path: Path to a code file (read server-side).
    question: Concrete question or focus (optional).
local_describe_imageA

PREFER this tool over attaching or reading the image yourself when you only need a description, the visible text (simple OCR) or a specific answer about an image, not the image itself in your context.

Describes an image (or answers a question about it) with a local vision model. The image is
read server-side: it NEVER enters Claude's context, only the text answer comes back.

Scope guardrail: ONLY image->text (describe, read visible text, answer a specific question
about the image). This tool NEVER generates or edits images.

It does NOT measure: use it for content and overall layout, never to verify alignment, sizes,
distances, spacing or whether a text wraps to another line at the pixel level. The vision model
asserts misalignments and wraps that the DOM disproves; measure instead (on a web page,
`getBoundingClientRect` or `Range.getClientRects`). When the question or the answer uses the
usual words for that (Spanish or English), a warning follows the model's answer.

Args:
    path: Path to the image (png/jpg/jpeg/webp/gif), read server-side.
    question: Concrete question or focus about the image (optional; by default it describes
        it).
    max_words: Maximum length of the answer in words.
local_statusA

Read-only diagnostics of the local backend and the model catalog.

Use it to find out which local models are available and to check that the backend is alive
before delegating in bulk, or to diagnose why a local_* tool failed.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A4.1/5.0

Scored across 11 tools

Disambiguation4/5

Each specialized tool maps to a distinct task type (extract, summarize, translate, classify, explain, commit message, lint log, image description, boilerplate generation), and the descriptions draw those lines explicitly. The only real overlap is `local_delegate`, a general text->text escape hatch that can do much of what summarize/translate/explain_code do, but its description states 'use it when no specific tool fits' and warns about chunking misuse, which mitigates selection errors.

Naming Consistency4/5

All 11 tools share a `local_` prefix with snake_case names, giving a strongly predictable family. Minor deviation: most names are verb-style (`local_extract`, `local_summarize`, `local_translate`), while `local_commit_msg` and `local_status` are noun-phrase, and `local_delegate` is the vague generic sibling of the `local_*` prefix itself.

Tool Count5/5

11 tools sits squarely in the well-scoped range and each one targets a recognizable delegation niche (structured extraction, summarization, translation, classification, code explanation, commit drafting, log triage, vision, codegen, diagnostics, generic fallback). Nothing feels padded, and the single generic tool avoids a combinatorial explosion of one-off variants.

Completeness5/5

For a 'keep work out of Claude's context' server, the surface covers the main offload patterns plus a status/diagnostics tool and a generic fallback for unforeseen tasks, so agents are rarely at a dead end. Gaps are minor and arguable (no dedicated review/diff-analysis or batch/multi-file driver), and the fallback tool plus `local_status` model introspection largely compensates.

Maintenance

ActivityActive
ResponsivenessOutdated data