Nextcloud ChatGPT Bridge

by v4t0r

Overview Schema Related Servers Score Discussions

Python

Hybrid

Server Quality Checklist

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

Latest release: v0.3.0
Disambiguation4/5
Tools address distinct resources/actions (capabilities, app access, file ops, shares), but get_nextcloud_capabilities, get_nextcloud_app_accesses, and probe_native_nextcloud_mcp all concern bridge/native capability discovery and could be confused if descriptions are skimmed. The file tools are clearly distinct: list/search/get/read/write/upload/create/move/delete.
Naming Consistency4/5
Most names follow a verb_noun snake_case pattern (list_files, create_folder, delete_file), but there is minor inconsistency between get_ prefixed tools (get_nextcloud_capabilities), bare verbs (read_text_file, write_text_file), and descriptive verbs (probe_native_nextcloud_mcp, download_file_base64). Still predictable and readable overall.
Tool Count5/5
14 tools is well within the ideal range for a file-management bridge with additional introspection. Each tool covers a concrete, non-redundant operation; none feel like padding.
Completeness4/5
File lifecycle is well covered: list, search, read, write, upload, download, create, move, delete, and metadata. Missing share management (only listing) and lack of a direct 'exists' endpoint (though get_file_info covers it), but these are minor gaps for the bridge's apparent scope.
Average 3.9/5 across 14 of 14 tools scored. Lowest: 3.1/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 110 commits in the last 12 weeks
- Last stable release on August 20, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under Apache 2.0.
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description notes the transfer size limit, adding context. Annotations already indicate destructiveHint true and readOnlyHint false, but description doesn't contradict. It doesn't detail overwrite behavior or permissions.
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?
One sentence, efficient and front-loaded. No wasted words, but could benefit from more structuring.
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?
Despite having an output schema, the description is under-specified for a mutation tool. It doesn't mention overwrite behavior, error cases, or how the path should be specified. Limited compared to sibling tools.
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%, so description should compensate. The description only mentions base64 data and size limit, but does not explain 'path', 'overwrite', or 'content_base64' semantics. The title mentions base64, but the description is thin.
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 uploads a file from base64 data, and distinguishes from siblings like download_file_base64 and write_text_file. However, it doesn't mention the specific resource (Nextcloud) explicitly, though the title does.
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 mentions 'small binary file' and 'transfer size limit', indicating when to use but not explicitly when not to use or alternatives. No sibling differentiation or exclusions.
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?
Annotations already establish this as a safe, read-only operation. The description adds meaningful behavioral constraints: it searches names only, operates below one workspace folder, and never crosses the configured root. This goes beyond the annotations and clarifies scope, though it omits output/pagination details, which are partially covered by the output 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?
The description is a single, focused sentence that front-loads the action and scope. Every word contributes to the core semantics, and there is no filler or redundant restatement of the tool name.
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 relatively simple search tool with annotations and an output schema, the one-sentence description is mostly adequate. However, it lacks parameter-level context and does not address when to choose this tool over list_files or other siblings, leaving some selection ambiguity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%; the description does not mention query, path, max_depth, or max_results. The parameter names and defaults in the schema are self-explanatory, but the description itself adds no semantic value or guidance for how these parameters interact with the search behavior.
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 searches names below a workspace folder and respects the configured root, giving a specific verb, resource, and scope. It distinguishes itself from list_files via the searching-vs-listing focus, though it does not explicitly name a sibling alternative.
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 when searching file/directory names within a bounded workspace area, but it does not explicitly state when to prefer this over list_files or provide when-not-to-use guidance. The root constraint supplies some context but no direct alternative comparison.
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?
Annotations already indicate it is not read-only, and the description adds that it creates a folder inside the configured root, which clarifies path scoping. However, it does not disclose behaviors like whether intermediate directories are created, error handling if the folder already exists, or permission requirements. Given annotations cover the mutation nature, the description adds minimal extra 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?
A single clear sentence with no unnecessary words. It is front-loaded with the verb and resource, and every word adds value.
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 one-parameter creation tool, the description covers the core purpose. However, it omits behavioral details like whether it fails if the parent path doesn't exist, if it is recursive, or what it returns. The output schema exists but is not described, and annotations don't clarify side effects. Balanced but with gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the single 'path' parameter. It only states 'inside the configured Nextcloud root', implying a relative path, but does not clarify format (slashes), whether recursion is supported, or error conditions. This is minimal added meaning.
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 'Create a folder inside the configured Nextcloud root' clearly states the verb (create) and resource (folder inside a specific location), which distinguishes it from sibling file operations like write_text_file or upload_file_base64.
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 creating folders but does not explicitly state when to use it versus other tools (e.g., when not to use it, or that it should be preferred over other creation methods). It lacks exclusions or explicit context about alternatives.
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?
Annotations already provide readOnlyHint=true, and the description's 'Get metadata' is consistent with a read operation. The description adds scope context ('inside the configured Nextcloud root') but does not disclose potential errors, path limitations, or other behavioral nuances. It neither contradicts annotations nor adds substantial extra transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, tightly worded sentence with no filler. It front-loads the core action and scope, making it easy to parse.
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 tool with one parameter and an output schema present, the description is functional but incomplete. It lacks parameter guidance and explicit usage advice, yet the output schema may compensate for return-value details. Overall, it is adequate but not thorough.
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% for the 'path' parameter, and the description only names the parameter without explaining expected format (absolute vs. relative, file vs. folder, trailing slashes). The description does not compensate for the schema's lack of detail, leaving significant ambiguity about how to specify the path.
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 retrieves metadata for a single file or folder within the Nextcloud root. It uses a specific verb ('Get') and resource ('file info'), and distinguishes itself from siblings like list_files (multiple items) and read_text_file (content) by focusing on 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 use for individual file/folder metadata but does not explicitly state when to prefer it over alternatives (e.g., list_files for multiple items, download_file_base64 for content). No when-not-to-use guidance is provided, leaving the agent to infer from sibling names.
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?
Annotations already indicate destructiveHint=true, so the description doesn't need to restate that. However, it adds the constraint 'inside the configured root,' which is useful context. It does not disclose other behavioral traits like overwrite semantics or conflict handling, but given the annotation coverage, this is acceptable.
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 sentence, front-loaded with the verb and object. It is concise with zero wasted words, fully fitting the tool's simple purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description need not explain return values. The tool is straightforward, and the root constraint is mentioned. However, the lack of parameter semantics and overwrite behavior leaves some gaps. It is adequate but not comprehensive.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for parameter meaning. It does not mention source, destination, or overwrite at all. The action implies that source and destination are paths, but no details are given about format, overwrite behavior, or defaults, leaving the agent to infer from schema field names alone.
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 states a clear action: 'Move or rename a file/folder inside the configured root.' It specifies the resource (file/folder) and the operation (move/rename), and distinguishes from sibling tools like delete_file or write_text_file by indicating relocation/rename rather than creation, deletion, or modification.
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 moving or renaming files/folders but does not explicitly state when to use it over alternatives (e.g., copying via upload/download) or when not to use it. There are no exclusions or alternatives mentioned, so the guidance is only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds a behavioral detail (size limit) beyond the readOnlyHint annotation, but nothing else about error handling or return behavior. It is consistent with annotations and adds a small extra 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 a single, clear sentence with no fluff, perfectly sized for the tool's simplicity.
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 simplicity of the tool and the existence of an output schema (not shown but indicated), the description adequately covers the core operation. It does not mention distinguishing from binary downloads, but the name and sibling context fill that gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter 'path' is not described in the schema (coverage 0%) and the tool description does not elaborate on what path means or its expected format. This leaves the parameter semantics ambiguous.
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 ('Read a UTF-8 text file') and distinguishes it from sibling tools like write_text_file or download_file_base64 by specifying the file type.
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?
It mentions a size limit constraint but does not explicitly explain when to use this tool over alternatives (e.g., download_file_base64 for binary files). Usage context is implied but not stated.
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?
The annotation already declares readOnlyHint=true and destructiveHint=false, but the description adds value by noting that the operation is 'credential-free' and returns metadata rather than raw content. It also clarifies that results are restricted to the configured workspace root, which is not expressed in the annotations.
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 sentence, front-loaded with the primary verb and resource. Every word contributes meaning, with no redundant content or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is low-complexity with only two optional params, and the output schema removes the need to describe return values. However, the description still leaves parameter semantics unexplained and does not mention how many shares are returned or any filtering behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has zero description coverage and the description never mentions the 'path' or 'include_subfiles' parameters. With no parameter explanations anywhere, an agent must guess at the meaning and expected format for these optional inputs.
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 names a specific verb ('List'), a clear resource ('credential-free share metadata'), and a scope ('constrained to the configured workspace root'). This distinguishes it from sibling tools like list_files, which lists files, and the various Nextcloud capability/access tools.
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 gives context ('credential-free', 'constrained to the configured workspace root') but does not explicitly state when to prefer this tool over alternatives like list_files or search_files. No alternatives or exclusions are mentioned, so guidance is 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.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds useful behavioral context beyond the annotations: existing files are protected by default and only overwritten when overwrite is explicitly true. This clarifies the destructiveHint=true annotation by specifying the exact condition under which destruction occurs.
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 short sentences with no filler. The main action is front-loaded, and the critical overwrite safeguard is stated separately and clearly.
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 three-parameter write tool with an output schema and annotations, the description is largely sufficient. It covers the key safety behavior (overwrite protection) and encoding, though it does not mention path conventions or failure behavior when an existing file is not overwritten.
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?
With 0% schema description coverage, the description must compensate for parameter meaning. It clarifies the overwrite parameter ('unless overwrite is explicitly true') and content type (UTF-8), but does not explain path semantics or required path format, leaving some 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 a specific verb and resource: 'Write a UTF-8 text file.' It clearly identifies the tool's core action and distinguishes it from sibling tools like read_text_file or upload_file_base64 by emphasizing UTF-8 text content.
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?
There is no guidance on when to use this tool versus alternatives such as upload_file_base64 or create_folder. The description states what the tool does but does not provide use cases, exclusions, or references to sibling tools.
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?
Annotations already declare destructiveHint=true and idempotentHint=true, which covers mutability. The description adds a behavioral caveat: 'Deleting the configured root itself is always refused.' This is useful context not present in annotations. However, it does not disclose whether folder deletion is recursive or if there are other side effects.
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: two short sentences. It front-loads the primary action in the first sentence and adds a critical safety note in the second. No unnecessary words or fluff; every word 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 tool is simple (one parameter, no nested objects, output schema exists). The description covers the core action and the root-refusal safeguard. It does not mention recursive deletion for folders or error behavior, but these are likely captured by the output schema. Overall, it is adequate for a simple delete operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has a single 'path' parameter with 0% description coverage. The tool description does not explain what 'path' means, its format, relative vs absolute, or any constraints. The description fails to compensate for the lack of schema documentation, leaving the agent to infer path semantics from the parameter name alone.
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 action: 'Delete one file or folder.' It uses a specific verb and resource, and adds a safety note about refusing to delete the configured root. This distinguishes it from sibling tools like move_file or create_folder.
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 does not explicitly state when to use this tool versus alternatives. Usage is implied from the purpose (deleting files/folders), but no guidance is given on when deletion is appropriate versus moving or trash, or when not to use it. No alternatives are mentioned.
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?
Annotations already declare readOnlyHint=true, and the description adds meaningful behavioral context: the file must be small and output is subject to the MCP transfer size limit. This goes beyond the structured safety hints and helps set expectations around limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no wasted words. Every element adds useful information about the tool's purpose and constraints.
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 simple one-parameter tool, the readOnly annotation, and the presence of an output schema, the description covers the key operational constraint (size limit) and file type. It is sufficient 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.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description does not elaborate on the 'path' parameter—such as whether it is relative to a Nextcloud root or how to format it. With low schema coverage, the description should compensate but does not.
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 action ('Download'), the resource ('Nextcloud file'), the output format ('base64'), and a key scope ('small binary file'). This distinguishes it from sibling tools like read_text_file (text) and upload_file_base64 (upload direction).
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 conveys a clear usage context: small binary files, output as base64, with a transfer size limit. It does not explicitly name alternatives or state when not to use the tool, but the size and file-type qualifiers imply appropriate selection criteria.
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?
The annotations already declare readOnlyHint=true and openWorldHint=false, so the agent knows this is a safe, deterministic read operation. The description adds meaningful behavioral context beyond the annotations: it limits results to direct children and constrains paths to within the configured root.
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, focused sentence with no filler or redundant information. It conveys the core action, scope, and location in a compact way.
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 operation with one optional parameter, read-only annotations, and an output schema, the description covers the essential behavioral context: non-recursive listing within a root-relative folder. It does not mention pagination or hidden files, but the output schema likely covers return structure, and the tool is simple enough that this is not a major gap.
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 0% for the single 'path' parameter, so the description must compensate. It implies the path refers to a folder and is root-relative, but it does not clarify the default behavior of an empty path, whether leading slashes are accepted, or that the path must identify a folder rather than a file.
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 a specific verb and resource: 'List direct children of a folder inside the configured Nextcloud root.' It distinguishes itself from siblings like search_files and get_file_info by emphasizing 'direct children' and the root-relative 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 phrase 'direct children' provides clear context that this is non-recursive, and 'inside the configured Nextcloud root' sets a scope boundary. It does not explicitly name alternatives or when-not-to-use cases, but the context is strong enough for an agent to differentiate from recursive search or file-reading tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=false, so the read-only behavior is covered structurally. The description adds the context that this inspects capability hints but does not disclose additional behavior, return shape, or any potential caveats, which is acceptable for a simple zero-parameter inspect 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?
A single sentence that is front-loaded and immediately communicates the tool's purpose and value. No filler or repetition of the title or schema.
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 read-only, zero-parameter tool with an output schema and appropriate annotations, the description fully covers what the tool does and why it is useful. No additional behavioral or return-value detail is necessary.
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 zero parameters, so the schema is trivially complete at 100% coverage. The description adds no parameter details, but none are needed; the baseline for zero-parameter tools is 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 uses a specific verb ('Inspect') and resource ('server/app capability hints'), and clearly states its purpose: to choose native Nextcloud or fallback providers. This differentiates it from sibling tools, which focus on file operations or app accesses.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes clear the tool is useful for capability discovery when deciding between native and fallback providers. It does not explicitly name alternatives or state when not to use it, but the context of provider selection is implied strongly enough.
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?
Annotations already declare readOnlyHint=true, but the description adds meaningful context by guaranteeing the tool 'never invokes a native tool.' This clarifies that the probe has no side effects on the Nextcloud instance, going beyond the generic read-only hint and providing a concrete behavioral guarantee.
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 short sentences, front-loaded with the core purpose and an important safety qualifier. Every word contributes value; there is 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 zero-parameter health-check tool with an output schema, the description is fully sufficient. It explains what the tool does and its side-effect-free nature; the output schema covers return format, so no additional description is necessary.
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 zero parameters, so the description does not need to explain parameter semantics. Per the baseline for no parameters, a score of 4 is appropriate; the description adds no extraneous parameter details and relies on the schema's empty property list.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: to check reachability of the Nextcloud Context Agent MCP. It uses a specific verb ('Check') and a clear resource, and explicitly notes it 'never invokes a native tool,' distinguishing it from sibling tools that perform native actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this is a safe, non-invasive probe, but it does not explicitly state when to use it versus alternatives or provide criteria for when it should be preferred. The 'never invokes a native tool' note is a constraint rather than direct usage guidance, leaving room for the agent to infer applicability.
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?
The description adds value beyond annotations by specifying that access levels are 'safe' and that it works without admin APIs, which is not implied by readOnlyHint. It does not describe return format, but the output schema handles that; no contradictions with annotations.
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, focused sentence that conveys purpose and key constraints without redundancy. Every word earns its place, and the lack of parameters makes it appropriately concise.
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 that there are no parameters, the description is sufficient for an agent to understand the tool's purpose. The presence of an output schema likely covers return values, and the tool's simplicity (zero params) means the description is complete.
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?
With zero parameters, the description adds meaning by clarifying the scope (user-visible apps and safe bridge access levels), which is essential since the schema is empty. This exceeds the baseline of 4 for parameter-less tools.
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 inventories user-visible apps and bridge access levels, specifying the resource (Nextcloud apps) and the action (inspect). It distinguishes itself from siblings such as get_nextcloud_capabilities and probe_native_nextcloud_mcp by emphasizing 'user-visible' and 'safe bridge access levels without administrator APIs'.
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 use for checking accessible apps and safe access, distinguishing from admin-API-based tools. However, it does not explicitly state when not to use it or mention alternatives, though the sibling context provides some contrast.
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:

[![nextcloud-chatgpt-bridge MCP server](https://glama.ai/mcp/servers/v4t0r/nextcloud-chatgpt-bridge/badges/card.svg)](https://glama.ai/mcp/servers/v4t0r/nextcloud-chatgpt-bridge)

Score Badge

Copy to your README.md:

[![nextcloud-chatgpt-bridge MCP server](https://glama.ai/mcp/servers/v4t0r/nextcloud-chatgpt-bridge/badges/score.svg)](https://glama.ai/mcp/servers/v4t0r/nextcloud-chatgpt-bridge)

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/v4t0r/nextcloud-chatgpt-bridge'

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