MCP Basics

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation5/5
Each tool has a clearly distinct purpose targeting specific development tasks: bug fixing, documentation generation, code formatting, linting, security auditing, dependency checking, test generation, and code translation. There is no overlap or ambiguity between these functions.
Naming Consistency5/5
All tools follow a perfectly consistent 'mcp-' prefix + descriptive noun pattern (e.g., mcp-bugfix, mcp-docs, mcp-formatter). This creates a predictable and readable naming convention throughout the entire toolset.
Tool Count5/5
With 8 tools, this server provides a well-scoped set of essential development utilities. Each tool earns its place by covering distinct aspects of the development workflow without being overwhelming or insufficient.
Completeness4/5
The toolset covers most core development tasks including code quality (linting, formatting), security (audit), dependencies (outdated), testing (testgen), and migration (translator). Minor gaps might include build/compilation tools or deployment utilities, but the current coverage is quite comprehensive for basic development workflows.
Average 2.6/5 across 8 of 8 tools scored. Lowest: 1.7/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 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
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
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

Behavior1/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure but fails completely. It doesn't indicate whether this is a read-only or destructive operation, what permissions might be needed, whether it modifies files, what side effects to expect, or any rate limits. The description simply states how to execute it without explaining what happens during execution. This leaves the agent with no understanding of the tool's behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise ('Execute mcp-translator: npx ts-migrate') but this brevity comes at the cost of being under-specified rather than efficiently informative. While it's front-loaded with the execution command, it lacks any explanatory content that would help an agent understand the tool's purpose or usage. The single sentence doesn't waste words but also doesn't provide meaningful information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness1/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given that this is a tool with no annotations, no output schema, and a description that provides minimal information, the description is completely inadequate. For a tool that likely performs code migration operations (inferred from 'ts-migrate'), the description should explain what the tool does, when to use it, what behavior to expect, and what results it produces. The current description fails to provide the contextual information needed for an agent to use this tool effectively.
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 description provides no parameter information whatsoever. However, with 100% schema description coverage for the single parameter 'directory', the schema already fully documents that this is an optional directory parameter. Since the description adds zero value beyond what's in the schema, the baseline score of 3 is appropriate. The description doesn't compensate but doesn't need to given complete schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose2/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Execute mcp-translator: npx ts-migrate' is essentially a tautology that restates the tool name with a command prefix. It doesn't explain what the tool actually does (e.g., migrating TypeScript code, transforming JavaScript to TypeScript, or performing specific code migrations). While it mentions 'npx ts-migrate', this is just the execution method rather than the purpose. The description fails to distinguish this tool from its siblings like mcp-formatter or mcp-linter.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines1/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. There's no mention of appropriate contexts (e.g., when migrating TypeScript projects, during codebase upgrades), prerequisites, or when not to use it. It doesn't reference sibling tools like mcp-formatter or mcp-linter that might serve different purposes. The user is left with no information about when this tool is the right choice.
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 states the tool executes 'npm audit fix', which implies a mutation operation (fixing vulnerabilities), but doesn't describe side effects (e.g., modifies package-lock.json), permissions needed, error handling, or output format. This is a significant gap for a mutation tool with zero annotation coverage.
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, efficient sentence with no wasted words. It's front-loaded with the core action, though it could be more informative. The structure is clear but minimalistic.
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's complexity (executing a security fix command), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'npm audit fix' does, potential impacts, or what to expect upon execution. For a mutation tool with no structured safety information, this leaves critical gaps for an AI agent.
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?
Schema description coverage is 100%, with the single parameter 'directory' well-documented in the schema. The description adds no parameter information beyond what the schema provides, so it doesn't enhance understanding of parameter usage or constraints. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Execute mcp-npm-audit: npm audit fix' states the action (execute npm audit fix) but is vague about the specific purpose. It doesn't clearly distinguish this tool from sibling tools like 'mcp-npm-outdated' or explain what 'npm audit fix' actually does (e.g., security vulnerability fixes). The description partially restates the tool name without adding meaningful differentiation.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description doesn't mention sibling tools like 'mcp-npm-outdated' for checking outdated packages or other security tools, nor does it specify prerequisites (e.g., requires npm project) or appropriate contexts. Usage is implied but not explicitly defined.
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. It mentions execution but doesn't disclose behavioral traits such as whether it modifies files, requires specific permissions, has side effects, or outputs results. This leaves significant gaps for a tool that likely performs code analysis.
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 extremely concise with a single sentence that directly states the command. It's front-loaded and wastes no words, making it easy to parse quickly.
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 no annotations, no output schema, and a tool that likely performs code linting (a non-trivial operation), the description is incomplete. It lacks information on what the tool does beyond running a command, expected outputs, or error handling, leaving the agent with insufficient context.
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?
Schema description coverage is 100%, so the schema already documents the optional 'directory' parameter. The description doesn't add any meaning beyond what the schema provides, such as examples or usage context, but meets the baseline since the schema handles parameter documentation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool executes 'npx eslint .' which indicates it runs ESLint, but it's vague about what ESLint does (code linting) and doesn't distinguish it from siblings like mcp-formatter or mcp-bugfix. It provides a verb+command but lacks specificity about the resource or purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like mcp-formatter or mcp-bugfix. The description only gives the command to execute, with no context about appropriate scenarios or exclusions.
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 states 'Execute mcp-npm-outdated: npm outdated', which implies it runs a command, but doesn't disclose traits like whether it's read-only, destructive, requires network access, has rate limits, or what the output format is. For a tool with zero annotation coverage, this is a significant gap 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.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with a single sentence, but it's not front-loaded with critical information—it repeats the tool name and lacks elaboration. While efficient, it under-specifies by not explaining what 'npm outdated' does, making it less helpful than it could be with minimal additional detail.
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 no annotations, no output schema, and a simple input schema, the description is incomplete. It fails to explain the tool's behavior, output, or context, leaving gaps for an AI agent. For a command execution tool, more detail on what 'npm outdated' returns and how to interpret it would be necessary for adequate completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 1 parameter with 100% description coverage, documenting the 'directory' parameter clearly. The description adds no parameter information beyond the schema, but with high schema coverage and only one optional parameter, the baseline is high. Since the description doesn't compensate or add value, but the schema is sufficient, a score of 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Execute mcp-npm-outdated: npm outdated' states the action (execute) and command (npm outdated), which provides a basic purpose. However, it's vague about what 'npm outdated' actually does—it doesn't specify that it checks for outdated packages in a Node.js project. It distinguishes from siblings by naming the specific command, but lacks clarity on the resource or outcome.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention scenarios like checking for package updates, comparing with other npm commands (e.g., npm update), or how it relates to sibling tools like mcp-npm-audit. Without any context on usage, it leaves the agent to infer based on the command name alone.
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. It mentions executing a command but doesn't disclose behavioral traits such as whether it modifies files, requires specific permissions, has side effects, or what happens on success/failure. For a tool that likely creates or updates configuration files, this lack of transparency is a significant gap.
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 extremely concise—a single sentence that directly states the command to execute. It's front-loaded with the essential action, with no wasted words or unnecessary elaboration, making it efficient for quick comprehension.
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 lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool does beyond running a command, what outcomes to expect, or how it fits with sibling tools. For a tool that likely performs a setup operation, more context is needed to guide effective use.
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?
Schema description coverage is 100%, with the single parameter 'directory' documented in the schema. The description adds no parameter information beyond what the schema provides, so it doesn't enhance understanding. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't add value but doesn't detract either.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool executes 'npx jest --init', which implies initializing Jest configuration. However, it's vague about what 'mcp-testgen' does beyond running this command, and it doesn't differentiate from sibling tools like mcp-linter or mcp-formatter. The purpose is understandable but lacks specificity about the tool's role in the MCP context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description only gives the command to execute, with no context about scenarios where Jest initialization is needed, prerequisites, or comparisons to sibling tools. This leaves the agent without usage direction.
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 provided, the description carries the full burden of behavioral disclosure. It states the command but does not explain what the tool does beyond running ESLint (e.g., whether it modifies files, requires specific permissions, has side effects like installing dependencies, or handles errors). This leaves significant gaps in understanding its behavior.
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 extremely concise and front-loaded, consisting of a single sentence that directly states the tool's action and command. There is no wasted text, making it efficient and easy to parse.
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 complexity of a code-fixing tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits, error handling, prerequisites (e.g., ESLint installation), and how it fits with sibling tools, leaving the agent with insufficient context for effective use.
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?
Schema description coverage is 100%, so the input schema fully documents the optional 'directory' parameter. The description does not add any parameter-specific information beyond what the schema provides, such as examples or constraints, meeting the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Execute mcp-bugfix') and the specific command ('npx eslint . --fix'), which fixes ESLint issues in code. However, it does not explicitly differentiate this tool from its siblings like 'mcp-linter' or 'mcp-formatter', which might have overlapping functionality.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It lacks context such as whether this is for pre-commit fixes, CI/CD integration, or specific project types, and does not mention sibling tools like 'mcp-linter' that might be related.
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 command to execute ('npx typedoc'), without detailing traits like whether it modifies files, requires internet access, has side effects, or handles errors. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior and safety.
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 extremely concise with just one sentence ('Execute mcp-docs: npx typedoc'), which is front-loaded and wastes no words. Every part earns its place by directly stating the action, making it efficient and easy to parse, though this brevity contributes to gaps in other dimensions.
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 complexity of executing a documentation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'npx typedoc' does, what outputs to expect, or any dependencies. For a tool that likely generates documentation, more context is needed to understand its role and results, making it inadequate for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds no parameter information beyond what the input schema provides, but schema description coverage is 100%, documenting the single optional 'directory' parameter clearly. With only one parameter and high schema coverage, the baseline is strong, and the description doesn't need to compensate. However, it doesn't add extra meaning, such as examples or constraints, keeping it at a baseline level.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states the tool executes 'npx typedoc', which implies generating documentation, but it's vague about what 'mcp-docs' specifically does beyond that command. It doesn't distinguish from sibling tools like mcp-formatter or mcp-linter, which likely handle different code-related tasks. The purpose is understandable but lacks specificity about the resource or outcome (e.g., TypeScript documentation generation).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. It doesn't mention context, prerequisites, or exclusions, such as whether it requires TypeScript files or specific project setups. With siblings like mcp-testgen and mcp-translator, there's no indication of how this tool fits into a workflow or when it's preferred over others.
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 states the command but doesn't explain that this is a write operation (modifies files), potential side effects (overwrites existing formatting), permissions needed, or execution time. This is a significant gap for a tool that alters files.
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 extremely concise—a single sentence that directly states the tool's action and command. It's front-loaded with the essential information, with no wasted words or unnecessary elaboration.
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's complexity (executes a command that modifies files) and lack of annotations or output schema, the description is incomplete. It doesn't cover behavioral aspects like file changes, error handling, or output format, which are critical for safe and effective use by an AI agent.
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 input schema has 100% description coverage, with one optional parameter ('directory') clearly documented. The description adds no parameter information beyond what the schema provides, so it meets the baseline of 3 for high schema coverage without compensating value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Execute mcp-formatter') and the specific command to run ('npx prettier --write .'), which indicates it formats code using Prettier. However, it doesn't explicitly differentiate from sibling tools like mcp-linter or mcp-docs, which might also involve code processing.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention scenarios like code formatting before commits, after editing, or in CI/CD pipelines, nor does it reference sibling tools for comparison, leaving the agent to infer usage context.
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:

[![mcp-basics MCP server](https://glama.ai/mcp/servers/caroline-davis/mcp-basics/badges/card.svg)](https://glama.ai/mcp/servers/caroline-davis/mcp-basics)

Score Badge

Copy to your README.md:

[![mcp-basics MCP server](https://glama.ai/mcp/servers/caroline-davis/mcp-basics/badges/score.svg)](https://glama.ai/mcp/servers/caroline-davis/mcp-basics)

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/caroline-davis/mcp-basics'

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