gitee-mcp

Server Quality Checklist

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

Latest release: v0.1.0
Disambiguation4/5
Tools have distinct purposes overall: status, explore, help, repo intel, search, translation, webhooks. Minor overlap between gitee_explore and show_gitee_humming_card (both deal with trending data) but one is data retrieval and the other is a display card, so ambiguity is low.
Naming Consistency3/5
Most tools use the 'gitee_' prefix followed by a verb (explore, repo, search, translate, webhook, help), but two tools use 'show_..._card' pattern, creating a mix. The inconsistency is noticeable though the pattern is still readable.
Tool Count4/5
8 tools is a reasonable number for a domain-specific MCP server focused on exploring Gitee. It covers key areas without being overwhelming or insufficient. Slightly on the lower side, but appropriate for the read-only scope.
Completeness4/5
The tool set covers discovery (explore, search, repo details), translation, webhook inspection, and status/help. It is read-only, which is clearly intentional. Missing operations like issue/PR listing or creating are not crucial given the stated purpose of non-Chinese speaker exploration.
Average 4/5 across 8 of 8 tools scored. Lowest: 3.3/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 10 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
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 must disclose all behavioral traits. It only mentions the return format and an example call, but does not explicitly state that the tool is read-only, safe, or requires no special permissions. The lack of transparency on side effects or restrictions leaves the agent uncertain.
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: one sentence stating the purpose, a clear return format header, and an example. Every element earns its place, and the critical information is front-loaded. There is no wasted text.
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 has no parameters, no annotations, and the description already specifies the return format and provides an example, it covers the essential information. However, it lacks guidance on when to invoke it and could elaborate on the scope of help topics (e.g., list of covered tools or configuration keys). Still, for a simple help tool, it is largely adequate.
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 tool has 0 parameters with 100% schema coverage. Per baseline rules, a 4 is appropriate. The description adds no parameter-level meaning (none needed), but does include return format context that aids understanding of the tool's output, which adds modest value beyond the schema.
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 provides help on Gitee MCP, covering tools, tiers, configuration, and tips. It is a specific verb-resource pair (gitee_help → help), and its purpose is distinct from sibling tools like gitee_repo or gitee_search, though no explicit differentiation is provided.
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 does not provide any guidance on when to use this tool versus alternatives. It does not mention use cases, prerequisites, or situations where another tool would be more appropriate. This omission leaves the agent without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description explains that the tool returns a ToolResult with a plain text fallback and a structured PrefabApp card, which adds transparency about the return format. However, it does not mention any behavioral traits like rate limits, authentication needs, or side effects. Since no annotations are provided, the description bears the full burden, but it leaves gaps about behavior beyond output format.
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 uses a front-loaded purpose statement, but includes a rationale section that is overly verbose (e.g., 'Status/list tools MUST ship a Prefab surface per fleet SOTA') which detracts from clarity. The example and return format are useful, but the rationale could be condensed or moved to development notes.
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 has only 2 optional parameters and no output schema, the description covers the purpose and return format reasonably well. However, it lacks details on what 'humming' means (e.g., trending repos, popular topics) and does not explain the 'translate' parameter. For a simple tool, it is mostly adequate but leaves minor gaps.
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 two parameters with defaults but no descriptions, resulting in 0% schema coverage. The description includes an example showing the 'limit' parameter, adding meaning that 'limit' controls the number of items. It does not explain the 'translate' parameter, but the contextual signal of a sibling 'gitee_translate' suggests its purpose. The description partially compensates for the schema gaps.
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 shows 'what is humming on Gitee right now as a rich in-chat card', giving a specific verb (show) and resource (humming status). It distinguishes itself from siblings like 'show_gitee_status_card' by focusing on trending/humming content rather than general status.
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 a primary use case (display trending Gitee content) and provides an example call, but does not explicitly state when to use this vs alternatives like 'gitee_explore' or 'show_gitee_status_card'. No exclusion criteria or context for choosing between siblings is given.
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 bears full responsibility for behavioral disclosure. The description omits critical traits: it does not state that translation relies on a local LLM with fallback to a dictionary gloss (this detail only appears in the input schema), nor does it mention side effects, authentication needs, or rate limits. The return format hints at error handling ('translated' bool, 'note') but does not explicitly explain failure modes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: a clear purpose sentence, a brief rationale, a return format block, and examples. No redundant or vague wording. Every element serves to clarify the tool's operation.
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 2-parameter tool with a clear purpose, the description provides adequate context: purpose, rationale, return format, and examples. It integrates well with sibling tools (unique role). Minor omission: the description does not restate the 1200-character limit from the schema, but the examples cover primary usage. Could include a note about when 'note' is not null for full 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 already provides full descriptions for both parameters (100% coverage), but the tool description adds value by including a return format and three concrete examples that show valid parameter combinations and expected outputs. This helps an agent understand the parameter semantics beyond the schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's verb ('Translate') and resource ('Chinese text to English'), and narrows the context to specific Gitee content types ('repo descriptions, issues, commit messages'). It distinguishes itself from all sibling tools (none of which handle translation), leaving no ambiguity about the tool's purpose.
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 typical use cases ('repo descriptions, issues, commit messages') and gives three concrete examples covering all operations. It implicitly conveys when to use the tool (anytime Chinese text needs translation or detection within the Gitee bridge). However, it does not explicitly exclude situations or mention alternatives, hence a 4 rather than a 5.
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?
No annotations are provided, so the description carries the full burden. It discloses that 'humming' works anonymously, 'top_starred'/'top_forked' require GITEE_TOKEN, and 'refresh' drops dead seeds. It also includes the return format. However, it does not mention rate limits, failure modes, or whether the tool is read-only, which are important behavioral details.
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 well-structured with a clear purpose, rationale, return format, and examples. It is front-loaded with the main purpose. The RATIONALE section is informative but slightly verbose; however, every part adds value. Overall, it is efficient and organized.
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 complexity (4 parameters, multiple operations, token requirements), the description is fairly complete. It covers the return format, operation semantics, and token needs. Minor gaps exist: it does not explain error handling, what happens if a token is missing for token-required operations, or the 'dead_seeds' field in detail. Nonetheless, it provides sufficient context for correct 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?
Schema coverage is 100%, so baseline is 3. The description adds significant value beyond the schema by explaining the operation enum values in detail, specifying token requirements, and providing examples that illustrate parameter combinations. This helps the agent understand how to use the parameters effectively.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Explore what is humming on Gitee - live ranked activity radar, top-starred and top-forked discovery.' It uses specific verbs and resources, and the RATIONALE section distinguishes it from sibling tools by explaining it consolidates four discovery tools due to Gitee's lack of a public trending API.
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 usage guidance through the RATIONALE (explaining why the tool exists), token requirements for specific operations, and examples. However, it does not explicitly state when to use this tool versus siblings like gitee_search or gitee_repo, nor does it exclude 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?
No annotations are provided, so the description must carry the full burden. It mentions two operations ('list' and 'clear') but does not disclose that 'clear' is destructive (wipes events), nor does it mention authorization, rate limits, or side effects. This is a significant omission for a mutation 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 concise but complete: a one-line summary, a rationale section, return format, and examples. Every sentence adds value, and it is front-loaded with the purpose. No redundant text.
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 (2 parameters, enum operation, and output schema provided), the description covers the main functionality and return format. However, it lacks details on error handling, edge cases, or behavioral nuances like the destructive nature of 'clear', which would make it fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already describes parameters. The description adds value by providing examples (`gitee_webhook(operation="list", limit=10)` and `gitee_webhook(operation="clear")`) and specifying the return format (`{"success": bool, "operation": str, "events": [...], "count": int}`), which goes beyond what the schema provides.
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 it inspects inbound Gitee webhook events, listing specific event types (push, star, fork, pull_request). This distinguishes it from sibling tools like gitee_explore or gitee_repo 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 rationale explains the tool surfaces captured webhook feed for reacting to CI pushes, stars, and forks, providing clear context. However, it does not explicitly state when not to use this tool or direct users to alternatives, which is a minor gap.
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 fully carries the burden of behavioral disclosure. It clearly defines the return format (ToolResult with content + PrefabApp card), notes a plain text fallback, and lists the data fields displayed. This is comprehensive for a status tool.
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 reasonably concise but includes a RATIONALE section and an examples section that add some redundancy. A marginal trim (e.g., dropping the first sentence of the rationale) could tighten it without losing value.
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 zero parameters, no output schema, and limited annotations, the description covers the essential semantics: purpose, output format, fallback behavior, and a usage example. It is sufficiently complete for an agent to select and invoke the tool correctly.
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 zero parameters (100% schema description coverage by default). The description adds meaning by explaining what the tool shows and how the output is structured, satisfying the baseline for a param-free tool.
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 shows a 'gitee-mcp configuration status as a rich in-chat card' and explicitly lists what it displays: tier, token state, LLM provider health, and rate-limit headroom. It is distinct from sibling tools like gitee_explore or show_gitee_humming_card.
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 a rationale stating status tools 'must ship a Prefab surface' and implies it is the go-to for a quick overview. It does not explicitly exclude alternatives or provide when-not-to-use guidance, but the context makes its use case clear.
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?
No annotations are provided, so the description carries the full burden of disclosure. The description and schema do mention that 'repos' requires GITEE_TOKEN and returns an actionable error otherwise, which is good. However, it doesn't fully disclose all behavioral traits, such as rate limiting or idempotency, which would be beneficial for a search tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with one sentence for the purpose and a succinct rationale for the design. The examples section provides immediate, actionable examples without extra fluff. Every part of the description earns its place.
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?
The description, combined with the schema and output schema, provides a pretty complete picture. The rationale section adds helpful context. It could be slightly improved by mentioning if there are any rate limits or request limits for the operations. Also, the response format is documented in examples but not in the description text itself.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Since schema description coverage is 100%, the schema already documents all parameters. The description in the schema for 'operation' provides extra context not in the JSON schema itself, such as 'works anonymously', 'requires GITEE_TOKEN'. This adds value for the agent.
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 it searches Gitee users and repositories or lists a user's public repos. The operation discriminator helps distinguish between three distinct sub-purposes, effectively combining multiple related operations into one tool. This makes the purpose specific and well-differentiated.
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 and input schema together provide clear guidelines on when to use each operation. The operation parameter's enum values and descriptions clarify which operation fits which scenario. However, there is no explicit 'when not to use' guidance or alternatives mentioned, slightly reducing the score.
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 the return format (success/error with suggestions) and notes that the 'readme' operation returns None when absent. It does not mention authentication requirements, rate limits, or any side effects. For a read-only tool, this is good but could be improved by stating that all operations are read-only and safe.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured with a rationale, a clear return format section, and multiple examples. Every sentence adds value, and the information is front-loaded. The examples are effective and easy to parse. No wasted words.
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 complexity (5 parameters, 6 operations, output schema present), the description is complete. It covers the purpose, each operation, return format, and failure behavior. The output schema exists, so return values are not needed in the description. The only minor gap is authentication, but overall it provides sufficient context for an agent to use the tool correctly.
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 100%, so the baseline is 3. The description adds value by providing examples that show how parameters are used together (e.g., 'path' in contents operation, 'limit' in commits). The detailed enum descriptions for 'operation' in the schema are supplemented by the examples. The description contributes beyond the schema, hence a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose as 'Gitee repository intel' and lists the specific operations (metadata, README, languages, commits, file tree, branches). The rationale explains the design choice of a single portmanteau, and the examples and input schema reinforce the purpose. It effectively distinguishes from sibling tools like gitee_explore which are for broader exploration.
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 a rationale and examples showing typical usage scenarios (e.g., owner/repo contract). It implies when to use this tool (for reading repository data) but does not explicitly state when not to use it or how it compares to siblings like gitee_search or show_gitee_status_card. The examples are clear enough for an agent to infer usage, but formal guidance is missing.
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

gitee-mcp MCP server — quality and maintenance score on Glama

Copy to your README.md:

[![gitee-mcp MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/sandraschi/gitee-mcp/badges/card.svg)](https://glama.ai/mcp/servers/sandraschi/gitee-mcp)

Score Badge

Copy to your README.md:

[![gitee-mcp MCP server — quality and maintenance score on Glama](https://glama.ai/mcp/servers/sandraschi/gitee-mcp/badges/score.svg)](https://glama.ai/mcp/servers/sandraschi/gitee-mcp)

shields.io Endpoint

For READMEs with an existing badge row. Append &style=flat-square (or any other shields.io style) to match the rest, and &metric=tools, &metric=maintenance or &metric=claim to badge a different dimension.

[![gitee-mcp MCP server — quality and maintenance score on Glama](https://img.shields.io/endpoint?url=https%3A%2F%2Fglama.ai%2Fmcp%2Fservers%2Fsandraschi%2Fgitee-mcp%2Fbadges%2Fshields.json)](https://glama.ai/mcp/servers/sandraschi/gitee-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/sandraschi/gitee-mcp'

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