project-advisors-mcp

by ragubaran

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v1.0.0
Disambiguation4/5
Each tool targets a distinct concern (dependencies, endpoints, runtime telemetry, MCP design, architecture, REST APIs, security config), but some overlap exists between security scan, vulnerability scan, and pentest scan. Descriptions clarify boundaries, so misselection is unlikely but possible.
Naming Consistency4/5
Six of seven tools follow the 'run_*_scan' pattern, which is predictable and consistent. The outlier 'get_telemetry_stream' uses a different verb and noun style, creating a minor deviation but not causing confusion.
Tool Count5/5
Seven tools is well within the ideal range for a specialized scanning server. Each tool covers a distinct aspect of project advisory, and the count feels neither sparse nor bloated.
Completeness4/5
The tool surface covers the main advisory domains: dependencies, security config, architecture, REST APIs, and runtime telemetry. Minor gaps like container scanning or infrastructure checks exist, but the core workflows are well covered.
Average 3.5/5 across 7 of 7 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 2 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of explaining behavioral traits. It lists what is evaluated but does not disclose whether the tool modifies anything, what output format to expect, if it's read-only, or any side effects. This is a significant gap for a scanning tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that enumerates the specific compliance checks without any filler. It is efficient and well-structured for a tool that only needs to state its purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is moderately complex with two undocumented parameters, no output schema, and no annotations. The description only covers the checks performed, leaving out parameter guidance, result semantics, and operational context, so it is incomplete for an agent to invoke confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters1/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 0%, and the description makes no mention of the two parameters (strictMode and includeRoutes). The agent has no explanation of how these parameters affect the scan, making it impossible to reason about their usage or values.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's function: evaluating REST endpoints for specific compliance issues like pagination, state-mutating GETs, and raw stack traces. It distinguishes itself from sibling tools by focusing on HTTP compliance and REST-specific concerns, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this tool is for REST API scanning based on the name and the listed checks, but it does not explicitly state when to choose it over alternatives like run_security_scan or run_vulnerability_scan. No exclusions or alternative usage scenarios are mentioned, so guidance is implied rather than stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the scan's purpose and supported languages, but does not mention whether the tool is read-only, what it returns, whether it modifies anything, or any performance/error behavior. This is a significant gap for a scan tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded, using two sentences to cover purpose and supported languages without redundant or promotional language. Every word earns its place, making it highly scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no output schema and no annotations, so the description must alone provide enough context for correct usage. It explains what the tool does but omits crucial details such as output format, how to interpret results, and the semantics of the 'pattern' parameter. This makes the description incomplete for a tool with this complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 50%: 'projectRoot' is described, but 'pattern' has no description. The tool description does not compensate for the undocumented parameter; it does not explain what patterns like 'layered' or 'hexagonal' mean or how they affect the scan. It adds no value beyond the existing schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function with a specific verb ('scans'), a target resource ('workspace source files'), and concrete outcomes ('layer boundary violations, circular dependencies, and improper coupling'). It also lists supported languages, which distinguishes it from sibling security-focused scan tools like run_vulnerability_scan or run_security_scan.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool (whenever architectural quality checks are needed) but provides no explicit guidance on when not to use it or how it compares to alternatives like run_mcp_design_scan. It gives clear context but lacks exclusionary or alternative usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description clearly indicates this is an 'audit' action, which implies a non-destructive review, and lists the specific areas checked. However, it does not disclose behavioral details beyond the audit scope, such as whether it modifies anything, requires special permissions, or produces a report. With no annotations to rely on, this is a moderate gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that starts with the action verb and lists items efficiently without fluff. It is concise and easy to parse, though the list feels somewhat run-on and could be broken into clearer categories. Still, it earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the purpose but lacks critical context: no usage guidelines, no explanation of the boolean parameters, and no mention of what the audit returns or any side effects. With no output schema or annotations to fill these gaps, the description is incomplete for an agent to invoke the tool confidently.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, and the tool description does not mention the parameters scanConfig and scanSecrets at all. The audit list implicitly maps to these booleans (configurations and secrets), but the agent is left to infer the exact meaning and effect of each flag. The description fails to compensate for the lack of schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Audits') and clearly enumerates the exact security concerns it checks: configurations, hardcoded secrets/API keys, exposed endpoints, CSRF tokens, and permissions. This distinguishes it from sibling tools like run_vulnerability_scan or run_pentest_scan, which target different aspects of security.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool based on the listed audit items (e.g., if you need to check for hardcoded secrets), but it does not explicitly state usage context or mention alternatives. There is no 'use this when...' or comparison to sibling scans, so guidance is only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It states the core action (checks against CVE databases) and implies a read-only operation, but it does not clarify whether files are uploaded, if network access is required, or whether the operation is non-destructive. Lack of detail on side effects or return behavior leaves the agent under-informed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, grammatically complete sentence that immediately identifies the tool's scope. It uses concrete file examples without excess wording, earning a high score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's low complexity (one parameter, no output schema) and absence of annotations, the description covers the primary purpose but omits key details about the parameter format and the result format of the scan. It is complete enough for a basic understanding but lacks nuance for correct invocation and interpretation of results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema defines a single 'manifestPath' string with no description, and schema description coverage is 0%. The description lists example dependency files, which helps infer that manifestPath likely points to one such file, but it does not specify whether a directory or glob is accepted, requiredness is unknown (required params: 0), or how multiple manifests are handled. This insufficiently compensates for the missing schema documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool checks build dependency files (with specific examples) against known CVE databases, using a specific verb and resource. This distinguishes it from sibling scan tools like run_architecture_scan or run_pentest_scan, which target different concerns.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the use case of scanning dependency manifests for vulnerabilities, but it does not explicitly state when to prefer this tool over alternatives like run_security_scan or how it relates to them. No exclusion or alternative guidance is provided, leaving the agent to infer usage from the dependency-file focus.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must convey behavioral traits. It says 'Verifies' and 'Checks for...' suggesting a read-only analysis, but it does not disclose whether it modifies anything, what output it produces, prerequisites (like a running server), or side effects. This partial disclosure is insufficient for a scanning tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, tightly packed sentence that begins with the main verb and resource, then enumerates key checks. Every clause contributes value without unnecessary fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool complexity (2 parameters, no output schema, no annotations), the description is incomplete. It does not describe the return format, expected prerequisites (e.g., projectRoot path requirements), or how strictMode changes behavior, leaving users without enough information to predict tool output or side effects.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 50% (projectRoot has a description, strictMode does not). The tool description does not explain either parameter, especially 'strictMode,' leaving its effect ambiguous. The description fails to compensate for the schema gaps.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's verb ('Verifies') and resource ('design and implementation of MCP servers'), and it lists specific checks (tool definitions, schema validation, transport security, error handling). This distinguishes it from sibling scan tools like run_rest_api_scan or run_architecture_scan by focusing on MCP-specific aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool: when analyzing MCP server design and implementation. It does not explicitly list alternatives or exclusion criteria, but the focus on MCP servers gives clear context relative to siblings, so it earns a 4.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must carry the full burden of behavioral disclosure. It conveys a read-only operation ('Retrieves') and lists data types, but does not mention authentication requirements, whether the stream is continuous, potential rate limits, or how the data is delivered (e.g., polling vs streaming). This is a moderate gap for a telemetry tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence with no redundant words. It front-loads the action and resource, then provides concrete examples of the telemetry data. Every part contributes to understanding the tool's purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (2 optional params, no output schema), but the description omits important contextual details such as the time window of live activity, whether data is returned as a snapshot or continuous stream, and any access constraints. Given no annotations and no output schema, a bit more detail would help the agent fully understand the tool's behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage; the description adds no explanation of the 'limit' or 'severity' parameters. While the schema defines them clearly (e.g., severity enum), the description could have noted that severity filters the telemetry levels, but it does not. This leaves the parameters underspecified relative to the tool's purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Retrieves' and identifies the resource as 'live runtime activity' with concrete examples (memory usage, exceptions, slow queries, leak traces). It also distinguishes itself from sibling scan tools by focusing on runtime telemetry rather than security or architecture scanning.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes clear this is for retrieving live runtime activity, which immediately sets it apart from the sibling scan tools. While it doesn't explicitly state exclusions or alternatives, the context is unambiguous given the sibling set are all scan-oriented tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full behavioral disclosure responsibility. It does mention 'non-destructive', indicating safety, and scopes to dev endpoints. However, it does not clarify whether payloads are actually sent or just generated, nor mention permissions, rate limits, or potential side effects, leaving gaps in transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence that front-loads the core action ('Generates non-destructive exploit payloads') and provides necessary details without unnecessary verbosity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has moderate complexity with two parameters and no output schema. The description explains the tool's purpose and scoping but fails to describe expected return values, whether requests are sent, or any post-scan behavior, leaving the agent without a full picture of what happens when the tool is invoked.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers targetUrl with a description, but payloadTypes lacks a description. The description adds examples of payload types (SQLi, XSS, JWT tampering) but omits path_traversal from the enum, providing incomplete compensation for the 50% schema coverage gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: generating non-destructive exploit payloads (SQLi, XSS, JWT tampering) to test input sanitization on dev endpoints. It uses specific verbs and resources, and distinguishes itself from sibling tools like run_vulnerability_scan by focusing on payload generation for pentest purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for use: it targets 'configured dev environment endpoints' and tests input sanitization, implying it is suitable for development environments. It lacks explicit exclusions or alternative tool comparisons, but the context is clear enough to guide appropriate use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![project-advisors-mcp MCP server](https://glama.ai/mcp/servers/ragubaran/project-advisors-mcp/badges/card.svg)](https://glama.ai/mcp/servers/ragubaran/project-advisors-mcp)

Score Badge

Copy to your README.md:

[![project-advisors-mcp MCP server](https://glama.ai/mcp/servers/ragubaran/project-advisors-mcp/badges/score.svg)](https://glama.ai/mcp/servers/ragubaran/project-advisors-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/ragubaran/project-advisors-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server