proxyllm-mcp

Server Quality Checklist

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

Latest release: v1.0.2
Disambiguation5/5
Each tool targets a distinct resource or action: savings calculation, model listing, key introspection, signup steps, account details, key creation/listing, and usage. There is no overlap; even the sequential signup tools are separated by stage.
Naming Consistency4/5
All tools share the 'proxyllm_' prefix and most follow a verb_noun pattern (list_models, create_routing_key, verify_signup). However, a few are noun-only (account, usage, signup) and savings_calculator is noun_noun, creating minor inconsistency.
Tool Count5/5
The 9 tools are well-scoped for a gateway management service, covering signup, key lifecycle, model discovery, usage, and savings estimation. It is neither too thin nor overloaded.
Completeness4/5
The set covers the core account and key lifecycle comprehensively, including signup, verification, key creation/listing, introspection, usage, and models. Minor gaps exist such as no delete or update routing key, but they can be worked around.
Average 4/5 across 9 of 9 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- 0 of 2 community issues answered or closed in the last 6 months
- 7 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.
This repository includes a glama.json configuration file.
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 must carry the full burden of disclosing behavior, but it only reveals that it is a GET request. It does not mention authentication requirements, response format, default behavior of the optional account_token, or any side effects. This leaves critical behavioral information undisclosed.
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, concise sentence that front-loads the HTTP method and endpoint, with no redundant words. It is efficient but perhaps too sparse, trading completeness for brevity. Still, the structure is clear and direct.
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?
The description is inadequate given the lack of annotations, output schema, and parameter explanations. It does not specify the time range (even though the title does), what data is included, or how the account_token alters behavior. An agent cannot reliably invoke this tool without additional information.
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 has 0% description coverage for the parameter 'account_token'. The description does not explain what this parameter means, what values it accepts, or how it affects the request. Given that the parameter is optional, the agent has no basis for deciding whether to include it or what to pass.
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 states a clear action ('GET') and resource ('/v1/organizations/usage'), making the tool's function explicit. The title '30-day usage summary' adds context that it returns usage data over a 30-day period. It does not explicitly differentiate itself from sibling tools, but the resource name itself is distinct enough for an agent to infer its 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. It does not mention any preconditions, exclusions, or related tools. The description only states the endpoint, leaving the agent without context for choosing this tool over siblings like proxyllm_savings_calculator or proxyllm_list_models.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It discloses the plan state machine (free plus payment block -> pro after operator activation) and implies polling is safe via 'poll'. It does not mention potential errors, rate limits, or token handling, but for a simple GET endpoint the provided context is meaningful.
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 no filler. It front-loads the exact HTTP endpoint and immediately follows with the key state logic and usage instruction. Every sentence adds value, and the structure is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (1 parameter, no output schema), the description covers the essential context: endpoint, expected state transitions, and when to invoke it. It does not specify response fields or error scenarios, but the stated plan values provide enough for basic invocation and interpretation.
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?
There is 1 parameter (account_token) with 0% schema description coverage, so the description must compensate. However, it does not mention the parameter at all, leaving its purpose, origin, and optionality unexplained. The name hints at meaning, but the absence of any elaboration makes it insufficient.
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 function: it GETs the organization account state and reports the plan status ('free' vs 'pro'). The title 'Account state (poll until paid)' further narrows its purpose. It does not explicitly reference sibling tools, but its unique focus on account polling makes it distinguishable.
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 explicit usage context: 'Poll this after handing over the checkout link.' It also explains the expected state changes while unpaid and after activation, which helps the agent decide when to call it. It does not name alternatives or exclusion criteria, but the guidance is clear and actionable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the HTTP method (GET), shows it is a read-only inspection, and states authentication is done via the routing key itself. It adds meaningful behavioral context beyond the bare parameter schema.
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?
Two sentences, front-loaded with the endpoint, and no wasted words. Each clause adds useful information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter introspection tool with no annotations or output schema, the description is fairly complete: it names the endpoint, lists the returned data categories, and explains authentication. It could mention response format or error cases, but it is adequate for the tool's simplicity.
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 only provides the parameter name with no description (0% coverage). The description adds that authentication is via the routing key, giving some semantic context, but does not explain the expected format or whether it is required beyond the implied use.
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 introspects a routing key and lists specific return details (provider lanes, reachable models, Codex subscription, monthly budget state). It distinguishes itself from sibling tools like create/list routing keys and usage.
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 explicit when-to-use or alternative guidance is provided. The description implies use when you need details about a specific key, but it does not contrast with sibling tools like list_routing_keys or usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 discloses key behavioral traits: the key is returned only once, and it optionally wires the provider chain in the same call. It omits potential costs or budget effects, but core behavior is transparent.
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?
Two sentences, front-loaded with the essential verb and resource, and no extraneous information. The sibling pointer is useful and compact.
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?
For a create tool with 5 parameters and no output schema, the description lacks explanation of most parameters and gives no indication of expected response or side effects beyond the one-time key return. The sibling reference helps only partially.
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 coverage is 0% and the description does not compensate. 'Provider chain' hints at the providers array, but mode, label, account_token, monthly_budget_usd, and provider sub-fields are left undefined, leaving the agent without enough to choose correct 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 uses a specific verb 'Mints' with a concrete resource ('pllm_ routing key') and clarifies its one-time return. It clearly differentiates from siblings like proxyllm_list_routing_keys and proxyllm_introspect_key by focusing on creation/issuance.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states the intended use ('for OPENAI_API_KEY-style use against the gateway') and explicitly points to a sibling for discovery ('discover wireable lane ids with proxyllm_list_routing_keys include_lanes'), providing both when-to-use and an alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It discloses that include_lanes adds wireable lanes (Codex sessions, bridges, saved provider keys) and that these provide ids used by provider chains, adding useful behavioral context beyond the schema.
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?
Two concise sentences front-load the main purpose and then clarify the optional parameter. No filler or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with no output schema, the description provides adequate scope and the optional behavior. It could mention the return format or account_token semantics, but the overall context is sufficiently complete for basic usage.
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 provides no descriptions (0% coverage). The description explains include_lanes meaningfully but leaves account_token undefined. It partially compensates for the schema gap but not fully.
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 lists the account's routing keys and optionally includes wireable lanes, using a specific verb+resource. It is easily distinguished from siblings like create_routing_key and introspect_key.
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 gives clear context: use it for listing routing keys, with optional lane expansion. It does not explicitly mention alternatives or exclusions, but the sibling tool names and the focus on routing keys imply the appropriate usage scenario.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the transparency burden. It discloses that the token is returned exactly once (a critical side effect) and that an unpaid account generates a checkout link. This goes beyond basic expectations, though details like code expiration or error handling are omitted.
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?
Two sentences, no filler, and all information is relevant. The description is front-loaded and structured logically: what exchange happens, what to do with the result, and a conditional note for unpaid accounts.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description should cover return values. It mentions the token and optional checkout link, which is sufficient for a simple verification endpoint. It does not cover errors, but the tool's simplicity and sibling context make this gap acceptable.
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 coverage is 0%, so the description must explain parameters. It clarifies 'code' as a 6-digit value, but does not add meaning for 'email' beyond the schema's email format. The token output is discussed, but this is output, not parameter. Partial compensation for the 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 uses the specific verb 'Exchanges' and identifies the resource ('6-digit code for an sk_ account token'). It clearly distinguishes the verification step from sibling tools like proxyllm_signup, which is the code-sending counterpart.
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 the tool is used after signup to convert the emailed code into an account token. It gives explicit post-usage instructions (store token, relay checkout link if unpaid), but does not explicitly name alternatives or state when-not-to-use scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/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 adds 'Free, no auth' and details the three outputs (subscription tier, flat total, monthly savings). This goes beyond a minimal statement, though it does not cover error handling or edge cases. For a non-mutating calculator, this is adequate 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 two sentences; the first packs essential functional info (input, output, fee), and the second adds 'Free, no auth.' No unnecessary words. It is front-loaded and immediately informative.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With one parameter and no output schema, the description lists the three output components (subscription tier, flat total, monthly savings) but does not specify the exact response structure (e.g., JSON field names). However, the tool is simple enough that an agent can infer the return contents. The description is complete enough for invocation and basic interpretation.
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?
Schema description coverage is 0%, but the description explicitly defines the parameter's meaning: 'monthly OpenAI API bill in USD' maps directly to monthly_openai_bill_usd. It also clarifies the computation context. With only one parameter, this is sufficient to understand what value to provide.
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 what the tool does: given a monthly OpenAI API bill in USD, it returns the appropriate subscription tier, the flat total with the $129 fee, and monthly savings. The specific verb 'returns' and the resource 'savings calculator' distinguish it from sibling tools like proxyllm_list_models or proxyllm_usage, which serve different 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 specifies the input condition ('Given a monthly OpenAI API bill in USD') and implies the use case: comparing API spend against subscription costs via ProxyLLM Codex Hosted. Although it does not explicitly mention when not to use it or alternative tools, the sibling list shows no similar calculator, so the context is sufficient for an agent to decide when to invoke it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the authentication requirement (none), explains the routing key's effect on lanes, and specifies the output shape as OpenAI-compatible. It lacks details on error handling or the meaning of 'lanes,' but for a simple read-only list, this is strong.
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, front-loaded with the main purpose ('OpenAI-shaped model list from the gateway'), and adds only essential details (auth, routing key behavior). No redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with one optional parameter and no output schema, the description covers the source, output format, auth, and parameter behavior. 'OpenAI-shaped' hints at the return structure, making the description sufficient 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 schema provides no description for routing_key (0% coverage), but the description says 'with a routing key it reflects that key's lanes,' which gives the parameter clear purpose. It could be more explicit about optionality, but the single parameter is adequately explained.
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 ('list') and resource ('models') with the qualifier 'OpenAI-shaped,' making it clear this returns a model catalog from the gateway. It distinguishes itself from siblings like proxyllm_list_routing_keys by focusing on models, not keys or usage.
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 states 'No auth required,' which is an explicit usage condition, and explains that supplying a routing key alters the output to reflect that key's lanes, including the live Codex catalog. It does not name alternative tools or provide when-not-to-use guidance, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does so excellently. It discloses that a code is emailed, that accounts are unpaid, and that they are removed after 48 hours without human activation. These are critical behavioral implications an agent must know.
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?
Three sentences, each earning its place: the first states the core action, the second adds key constraints (no captcha, unpaid, 48-hour loss), and the third directs the next step. No fluff, front-loaded, and highly scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (two params, no nested objects, no output schema), the description fully covers the flow, the outcome, and the required follow-up. An agent can confidently invoke this tool and know what to expect.
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 coverage is 100%: both email and source have descriptions. The tool description adds no parameter-specific detail beyond that, but the schema already documents each parameter adequately. Baseline 3 is appropriate because the description doesn't need to compensate.
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 opens with 'Starts autonomous account creation', clearly identifying the tool's verb (starts), resource (account creation), and method (email OTP). It distinguishes itself from siblings by naming the follow-up proxyllm_verify_signup, making the first step in a flow unmistakable.
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 gives strong context: when you need to create an account, use this to initiate, then verify. It mentions 'no captcha, no browser' and the follow-up step, but stops short of listing explicit exclusions or alternative tools. Still, the intended use is clear.
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:

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

Score Badge

Copy to your README.md:

[![proxyllm-mcp MCP server](https://glama.ai/mcp/servers/proxyllm-ai/proxyllm-mcp/badges/score.svg)](https://glama.ai/mcp/servers/proxyllm-ai/proxyllm-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/proxyllm-ai/proxyllm-mcp'

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