Oracle MCP Server

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 with no ambiguity: describe_table focuses on table structure, execute_query runs queries, explain_query analyzes performance, export_query_results handles output formatting, generate_sample_queries creates examples, list_procedures lists procedures/functions/packages, list_tables lists tables, and list_views lists views. The descriptions make it easy for an agent to differentiate between them.
Naming Consistency5/5
All tools follow a consistent verb_noun pattern with snake_case throughout: describe_table, execute_query, explain_query, export_query_results, generate_sample_queries, list_procedures, list_tables, and list_views. This predictable naming scheme makes the tool set easy to navigate and understand.
Tool Count5/5
With 8 tools, the server is well-scoped for database interaction and exploration. Each tool earns its place by covering distinct aspects like query execution, metadata listing, analysis, and export, without being overly sparse or bloated. This count aligns well with the server's purpose of providing safe Oracle database access.
Completeness4/5
The tool set covers core database exploration and query tasks effectively, including listing resources, describing structures, executing and analyzing queries, and exporting results. A minor gap exists in the lack of tools for modifying data or schema (e.g., INSERT, UPDATE, CREATE TABLE), but this is likely intentional for safety, and agents can still perform read-only operations and analysis without dead ends.
Average 3.1/5 across 8 of 8 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- No commit activity data available
- 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?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns an execution plan for performance analysis, but lacks details on what the output includes (e.g., cost estimates, steps), whether it requires specific permissions, if it executes the query, or any rate limits. This leaves significant gaps in understanding how the tool behaves.
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, efficient sentence: 'Get the execution plan for a SQL query to analyze performance.' It is front-loaded with the core action and resource, with no wasted 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 the lack of annotations and output schema, the description is incomplete. It explains the basic purpose but fails to address key contextual aspects such as what the execution plan output entails, any prerequisites (e.g., database permissions), or how it differs from sibling tools. For a tool with no structured behavioral data, this leaves too many unknowns.
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 the 'sql' parameter clearly documented as 'SQL query to explain.' The description adds no additional meaning beyond this, as it only reiterates the general purpose without specifying parameter details like format or constraints. Given the high schema coverage, the baseline score of 3 is appropriate.
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 tool's purpose: 'Get the execution plan for a SQL query to analyze performance.' It specifies the verb ('Get'), resource ('execution plan'), and context ('SQL query'), making it easy to understand. However, it doesn't explicitly differentiate from siblings like 'execute_query' or 'describe_table', which might also involve query analysis, so it falls short of a perfect score.
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 mentions analyzing performance, but doesn't specify scenarios (e.g., debugging slow queries) or contrast with siblings like 'execute_query' (for running queries) or 'describe_table' (for schema details). Without such context, users may struggle to select the right tool.
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 the export action but lacks critical behavioral details: whether this executes the query (implying read/write operations), permission requirements, rate limits, output handling (e.g., file generation or direct return), or error conditions. The description is minimal and misses key operational context.
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 with zero waste. It is front-loaded with the core purpose and efficiently lists the formats. Every word earns its place, 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 the complexity (a tool that likely executes and exports queries), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what happens (e.g., does it return a file, trigger a download, or include results in response?), success/error behaviors, or integration with siblings. More context is needed for safe and 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 schema fully documents both parameters (sql and format). The description adds no additional meaning beyond stating 'various formats (JSON, CSV)', which is already covered by the enum in the schema. Baseline 3 is appropriate as the schema does the heavy lifting.
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 tool's purpose: 'Export query results in various formats (JSON, CSV)'. It specifies the verb ('Export') and resource ('query results'), and distinguishes it from siblings like execute_query by focusing on export functionality. However, it doesn't explicitly differentiate from all siblings (e.g., generate_sample_queries).
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 prerequisites (e.g., needing valid SQL), exclusions, or comparisons to siblings like execute_query (which might return results without export). Usage is implied but not explicitly 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 states the tool generates queries but doesn't describe key behaviors: what types of queries are generated (e.g., SELECT, JOIN), how many queries are produced, whether they include sample data or are template-based, or if there are any limitations (e.g., rate limits or permissions required). This leaves significant gaps for an agent to understand the tool's operation.
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, efficient sentence: 'Generate sample SQL queries for a given table to help with exploration.' It is front-loaded with the core purpose and wastes no words, making it highly concise and well-structured for quick understanding.
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 for a tool that generates queries. It doesn't explain what the output looks like (e.g., a list of query strings, formatted results), any behavioral constraints, or how it integrates with sibling tools. For a tool with 2 parameters and no structured output documentation, 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?
The input schema has 100% description coverage, with clear documentation for both parameters ('table_name' and 'owner'). The description adds no additional parameter semantics beyond what the schema provides, such as format examples or usage tips. According to the rules, with high schema coverage (>80%), the baseline is 3, which is appropriate here as the schema does the heavy lifting.
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 tool's purpose: 'Generate sample SQL queries for a given table to help with exploration.' It specifies the verb ('generate'), resource ('sample SQL queries'), and target ('given table'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'describe_table' or 'explain_query', which prevents a perfect score.
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 mentions 'to help with exploration,' but doesn't specify scenarios where this is preferred over tools like 'describe_table' for understanding table structure or 'execute_query' for running actual queries. There are no explicit when/when-not instructions or named alternatives.
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 full burden for behavioral disclosure. It states the action ('List all') but doesn't describe traits such as whether this is a read-only operation, potential performance impacts, pagination, or output format. This leaves significant gaps for a tool that likely returns a list of database objects.
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, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded with the core action and resource, making it easy to parse quickly, which is ideal for conciseness.
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 listing database objects, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits, usage context, and what the output entails (e.g., format, structure), making it inadequate for an agent to fully understand how 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 adds no parameter information beyond what the input schema provides, which has 100% coverage for the single optional parameter 'owner'. Since the schema fully documents the parameter, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.
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 verb ('List') and resource ('stored procedures, functions, and packages'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_tables' or 'list_views' beyond the resource type, which slightly reduces clarity in a context with multiple listing tools.
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 like 'list_tables' or 'list_views'. It lacks context about scenarios where listing procedures is preferred, prerequisites, or exclusions, leaving the agent to infer usage based on tool names 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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read operation but doesn't specify permissions required, pagination behavior, rate limits, or what 'views' entail in this context. This leaves significant gaps for an agent to understand how to interact with it effectively.
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, direct sentence with no wasted words, making it highly concise and front-loaded. It efficiently communicates the core action without 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 lack of annotations and output schema, the description is insufficiently complete. It doesn't address behavioral aspects like return format, error handling, or system constraints, which are critical for a tool with no structured metadata to compensate.
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 description coverage is 100%, so the input schema already documents the optional 'owner' parameter. The description adds no additional parameter semantics beyond what's in the schema, such as format examples or usage tips, resulting in the baseline score 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 verb ('List') and resource ('all views in the database'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'list_tables' or 'list_procedures' beyond the resource type, which prevents a perfect score.
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 like 'list_tables' or 'list_procedures', nor does it mention prerequisites or context for usage. It simply states what the tool does without indicating appropriate scenarios.
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 tool lists tables with metadata but doesn't describe what metadata is included, whether there are pagination limits, rate limits, or authentication requirements. This leaves significant behavioral gaps for an agent.
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, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized for a simple listing tool and front-loads the essential information.
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?
For a simple listing tool with one optional parameter and no output schema, the description is minimally adequate but lacks depth. It doesn't explain what 'metadata' includes or how results are structured, which would help an agent understand the tool's output despite the absence of an output schema.
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 description coverage is 100%, with the single parameter 'owner' clearly documented in the schema as an optional filter by schema owner. The description adds no additional parameter semantics beyond what's in the schema, so the baseline score of 3 is appropriate.
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 verb ('List') and resource ('all tables in the database'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'list_views' or 'list_procedures' beyond mentioning 'tables' specifically.
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 like 'list_views' or 'list_procedures'. It mentions metadata but doesn't specify what kind or how it differs from other listing tools, leaving usage context implied rather than explicit.
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. While 'Get' implies a read-only operation, it doesn't specify whether this requires specific permissions, how it handles non-existent tables, or what the return format looks like (e.g., structured data vs. text). For a tool with zero annotation coverage, this leaves significant behavioral gaps unaddressed.
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, efficient sentence that front-loads the purpose ('Get detailed information about a table') and specifies key details ('including columns, data types, and constraints'). Every word earns its place with no redundancy or unnecessary elaboration.
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 no annotations, no output schema, and a simple input schema with full coverage, the description provides adequate context for a basic read operation. However, it lacks details on behavioral aspects like error handling or return format, which would be helpful for an AI agent. It's minimally viable but could be more complete.
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 both parameters (table_name and owner) with descriptions. The description doesn't add any parameter-specific information beyond what the schema provides, such as format examples 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.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Get' and the resource 'detailed information about a table', specifying what information is included (columns, data types, constraints). It distinguishes from siblings like 'list_tables' (which would list table names) by focusing on detailed metadata. However, it doesn't explicitly differentiate from 'explain_query' which might provide execution details rather than structural metadata.
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 usage for obtaining table metadata, which suggests it should be used when structural details are needed rather than just listing names. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'list_tables' for basic enumeration or 'explain_query' for query execution details. No exclusions or prerequisites are mentioned.
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 the full burden of behavioral disclosure. It effectively communicates safety constraints by limiting allowed SQL types, implying read-only behavior, but lacks details on permissions, rate limits, error handling, or result format. This provides basic transparency but misses deeper operational context.
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 two sentences with zero waste: the first states the core purpose, and the second adds critical safety constraints. It is front-loaded and appropriately sized, with every sentence earning its place by providing essential information without redundancy.
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 complexity (executing SQL queries), lack of annotations, and no output schema, the description is moderately complete. It covers safety and basic usage but omits details on result format, error conditions, or performance implications, which are important for an agent to use it effectively in varied contexts.
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 both parameters (sql and params) thoroughly. The description adds no additional parameter semantics beyond what's in the schema, such as syntax examples or usage nuances. Baseline 3 is appropriate as the schema handles the heavy lifting.
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 specific action ('Execute a SQL query') and target resource ('against the Oracle database'), distinguishing it from siblings like list_tables or describe_table by focusing on query execution rather than metadata retrieval. It explicitly mentions the allowed SQL statement types (SELECT, DESCRIBE, EXPLAIN PLAN), which further clarifies its scope.
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 by specifying 'Only SELECT, DESCRIBE, and EXPLAIN PLAN statements are allowed for safety,' which implicitly guides when to use this tool (for read-only/safe queries) versus when not to (for DML/DDL operations). However, it does not explicitly name alternatives or detail when to choose siblings like export_query_results for output handling.
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:

[![oracle-mcp-server MCP server](https://glama.ai/mcp/servers/smith-nathanh/oracle-mcp-server/badges/card.svg)](https://glama.ai/mcp/servers/smith-nathanh/oracle-mcp-server)

Score Badge

Copy to your README.md:

[![oracle-mcp-server MCP server](https://glama.ai/mcp/servers/smith-nathanh/oracle-mcp-server/badges/score.svg)](https://glama.ai/mcp/servers/smith-nathanh/oracle-mcp-server)

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/smith-nathanh/oracle-mcp-server'

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