Skip to main content
Glama
Bluezeamer

PrecisionContextEngine

by Bluezeamer

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
PCE_MODELYesModel name under the provider
PCE_API_KEYYesAPI key for the model
PCE_API_BASENoCustom compatible endpoint (alternative: PCE_BASE_URL)
PCE_PROVIDERYesLiteLLM provider, e.g., openrouter/openai/anthropic
PCE_TEMPERATURENoGlobal temperature, default 1.0
PCE_AGENT_TIMEOUTNoAgent total timeout in seconds, default 600
PCE_MODEL_FALLBACKSNoFallback model chain, comma-separated
PCE_COMPLETION_RETRIES_PER_MODELNoCompletion retries per model, default 3

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
}
experimental
{}

Tools

Functions exposed to the LLM to take actions

NameDescription
pce_initA

Purpose: Bind a target project and initialize the PCE runtime, building the index and navigation context required by query / impact / sync. When to use: Call this when entering a new project or the first time PCE is needed in a session. Do NOT call pce_query, pce_impact, pce_sync, or edit tools before pce_init succeeds. Best practice: Typically called once per session and awaited until success. Only call again when switching projects or retrying after a failure. Avoid: Do not use this as a code query tool; it establishes context but does not directly answer code questions.

pce_statusA

Purpose: Return current service and project status, including initialization phase, index statistics, staging area, and warnings. When to use: Use when you need to confirm whether PCE is available, whether the index has been built, or to diagnose init / query / impact / sync issues. Best practice: Treat this as a diagnostic tool. When unsure whether to call init or sync first, check status. Avoid: Do not use this as a code understanding tool; it does not locate entry points, call chains, or impact boundaries.

pce_queryA

Purpose: The primary tool for codebase navigation and understanding. Best suited for project-level understanding, architecture overviews, major module responsibilities, entry points, main call chains, candidate file scopes, and overall project/module comprehension. When to use: Use when the target location is unclear. When you do not know which file contains the information, need to understand what the project or a subsystem does, need a rough architecture or module-level picture, want to find entry points / main call chains / module responsibilities, or need to narrow down the search scope — use this tool first. Do NOT manually traverse directories, broadly inspect the repo, or batch-read files before trying pce_query. Best practice: Prefer describing your question in natural language rather than just giving exact identifiers. This tool is especially appropriate for questions like what the project does, how a subsystem is organized, where a feature lives, or which modules participate in a workflow. You can request file:line references, name_path, candidate file lists, call chain summaries, or results grouped by module. Avoid: When you already know the exact file or exact identifier and only need to view local implementation or do exact string matching, pce_query is not necessary. If the target is already clear and the task becomes 'what will be affected by changing it', switch to pce_impact instead.

pce_impactA

Purpose: The primary tool for analyzing the impact boundary of a known change target. Outputs direct call sites, direct consumers, main propagation chains, risks, and suggested modification order. When to use: Use when you already know which symbol, field, interface contract, or file to change, and want to understand what will be affected before making the change. Best practice: Provide an explicit target; if you know the file containing the symbol, also provide the file parameter to speed up resolution. Frame the question as a concrete change, e.g. 'modify field X', 'change function signature of Y', 'what breaks if file Z is deleted'. Avoid: If the target is still ambiguous or you are choosing between multiple candidates, do not use impact as a substitute for the discovery step — use pce_query first to converge on the target. If you only want to view local implementation or exact definitions, impact is not necessary.

pce_syncA

Purpose: Synchronize Serena and PCE index state after codebase modifications, so subsequent query / impact calls work against the latest code. When to use: Use after completing a batch of code modifications, file deletions, renames, or structural changes. Best practice: Use this as a batch synchronization step; typically call once after completing a round of changes, rather than after every small edit. Avoid: Do not use this as a code understanding tool; it refreshes index state but does not explain code.

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A4.7/5.0

Scored across 5 tools

Disambiguation5/5

Each tool occupies a distinct lifecycle role: init sets up, status diagnoses, query discovers, impact analyzes changes, and sync refreshes. The descriptions explicitly warn against cross-use, particularly between query and impact, so an agent can reliably select the right tool.

Naming Consistency5/5

All tools share a consistent pce_ prefix and a single lowercase keyword, making the pattern immediately predictable. Although the second words mix verbs and nouns, the convention is uniform and readable.

Tool Count5/5

Five tools is well-scoped for a context engine: setup, status, discovery, impact analysis, and synchronization cover the core workflow without redundancy. No tool feels decorative or missing from the set.

Completeness5/5

The lifecycle is complete: init builds context, status verifies it, query consumes it for exploration, impact consumes it for change analysis, and sync brings it up to date after edits. There are no obvious dead ends for the stated purpose.

Maintenance

ActivityInactive
ResponsivenessUnresponsive