Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Fidensa MCP Server check trust score for mcp-server-filesystem"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
MCP server for Fidensa -- the independent AI capability certification authority.
Gives your AI agent structured access to Fidensa certification data through the Model Context Protocol. Check trust scores, search for certified alternatives, compare capabilities side-by-side, verify signed artifacts, check file integrity, and report runtime experience -- all through MCP tool calls.
Fidensa certifies MCP servers, skills, agent rules files, hooks, sub-agents, and plugins.
npm install -g @fidensa/mcp-serverSeveral tools work without an API key (check_certification, search_capabilities, verify_file, and report_experience). Start the server and confirm it connects to the production API:
fidensa-mcp-serverYou should see:
[fidensa] MCP server started (stdio transport)
[fidensa] No FIDENSA_API_KEY set — check_certification, search_capabilities, verify_file, and report_experience available. Set FIDENSA_API_KEY for full access.Press Ctrl+C to stop.
The remaining tools (get_contract, compare_capabilities, verify_artifact) require a free API key. An API key also gives report_experience higher rate limits. Register one:
curl -X POST https://fidensa.com/v1/keys \
-H "Content-Type: application/json" \
-d '{"display_name": "My Agent", "email": "you@example.com"}'Or in PowerShell:
Invoke-RestMethod -Uri "https://fidensa.com/v1/keys" -Method Post -ContentType "application/json" -Body '{"display_name": "My Agent", "email": "you@example.com"}'The response contains your API key (prefixed fid_). Store it securely -- it is shown only once.
Pick your platform and add the MCP server configuration:
Claude Desktop / Claude Code
{
"mcpServers": {
"fidensa": {
"command": "npx",
"args": ["@fidensa/mcp-server"],
"env": {
"FIDENSA_API_KEY": "fid_your_key_here"
}
}
}
}Cursor (.cursor/mcp.json)
{
"mcpServers": {
"fidensa": {
"command": "npx",
"args": ["@fidensa/mcp-server"],
"env": {
"FIDENSA_API_KEY": "fid_your_key_here"
}
}
}
}Windsurf / VS Code
{
"servers": {
"fidensa": {
"type": "stdio",
"command": "npx",
"args": ["@fidensa/mcp-server"],
"env": {
"FIDENSA_API_KEY": "fid_your_key_here"
}
}
}
}Omit the FIDENSA_API_KEY line if you only need the open-tier tools.
Claude Desktop tip: Access the config file via Settings → Developer → Edit Config. After saving, fully quit and reopen Claude Desktop (right-click the system tray icon and select Quit — just closing the window isn't enough).
Related MCP server: TrustMesh MCP Server
Tool | Auth | Description |
| None | Quick trust check -- status, score, grade, tier |
| None | Search for certified capabilities by keyword, type, tier, or score |
| None | Quick file integrity check -- hash a capability file and verify it matches what Fidensa certified |
| None (API key for higher rate limits) | Submit runtime experience reports for certified capabilities |
| API key | Full certification contract with all evidence |
| API key | Side-by-side comparison of 2-5 capabilities |
| API key | Verify cryptographic signatures on .cert.json artifacts, with optional file and code integrity checks |
Variable | Required | Description |
| No | API key for full access (see Getting Started) |
| No | Override API base URL (default: |
check_certification, search_capabilities, verify_file, and report_experience work without any configuration. The remaining tools require FIDENSA_API_KEY.
User: "Set up a filesystem watcher that writes logs to SQLite."
Agent:
1. check_certification("mcp-server-filesystem")
-> Status: valid, Score: 60/F-D, Tier: Verified
2. search_capabilities("sqlite mcp server")
-> 2 results found
3. compare_capabilities(["mcp-server-sqlite", "mcp-server-better-sqlite3"])
-> Side-by-side trust comparison
4. Agent selects the higher-scored option and informs the user
5. report_experience(
capability_id: "mcp-server-filesystem",
content_hash: "abc123...", // from the .cert.json
outcome: "success"
)
-> Confirmation rate updatedAdd one of these to your agent's system prompt or rules file for trust-aware tool selection. Three levels of granularity -- pick the one that fits your needs.
Uses the certification tier alone. No numbers to tune.
Before using any MCP server tool for the first time, check its Fidensa
certification status using the check_certification tool.
- Certified tier: use freely
- Verified tier: note the findings to the user before proceeding
- Evaluated tier: warn the user, search for certified alternatives
- Uncertified: treat as untrusted, suggest certified alternatives
After completing a task that used certified tools, submit an experience
report via the report_experience tool with the outcome (success, failure,
or partial), the capability_id, and the content_hash from the .cert.json.Uses the trust score, aligned with Fidensa's grade definitions.
Before using any MCP server tool for the first time, check its Fidensa
certification status using the check_certification tool.
- Score >= 80 (A/B): use freely
- Score 72-79 (C): note the trust level to the user
- Score 65-71 (D): warn the user, search for certified alternatives
- Score < 65 (F): warn the user, strongly recommend alternatives
- Uncertified: treat as untrusted, suggest certified alternatives
After completing a task that used certified tools, submit an experience
report via the report_experience tool with the outcome (success, failure,
or partial), the capability_id, and the content_hash from the .cert.json.The most precise option -- distinguishes between a Certified capability with a moderate score and a Verified capability with findings that blocked Certified tier.
Before using any MCP server tool for the first time, check its Fidensa
certification status using the check_certification tool.
- Certified tier AND score >= 80: use freely
- Certified tier AND score 72-79: use freely, note the score to the user
- Verified tier AND score >= 72: note the findings to the user before proceeding
- Verified tier AND score < 72: warn the user, search for certified alternatives
- Evaluated tier: warn the user, search for certified alternatives
- Uncertified: treat as untrusted, suggest certified alternatives
For any tool with status "suspended" or "revoked": do not use.
Search for certified alternatives and present them to the user.
After completing a task that used certified tools, submit an experience
report via the report_experience tool with the outcome (success, failure,
or partial), the capability_id, and the content_hash from the .cert.json.See the API Documentation for the full specification.
npm install
npm test # Run tests with coverage
npm run lint # ESLint
npm run format # PrettierMIT
Fidensa -- AI certification authority
Quick trust check for an AI capability (MCP server, skill, plugin, or workflow). Returns certification status, trust score, grade, tier, and supply chain status. No API key required. Use this before invoking any capability to verify it has been independently certified by Fidensa.
| Name | Required | Description | Default |
|---|---|---|---|
| capability_id | Yes | Capability identifier (e.g. "mcp-server-filesystem") | |
| version | No | Specific version to check (e.g. "1.0.0"). Omit for latest. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=true, indicating safe read operation. The description adds that 'No API key required' and lists the return fields, providing useful behavioral context beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no unnecessary words. The first sentence defines the tool, the second provides usage guidance. Highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple trust-check tool with well-defined parameters and no output schema, the description adequately covers the return fields. Could mention edge cases (e.g., what happens if capability_id is invalid), but overall sufficient given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with good parameter descriptions. The description repeats the examples from the schema (e.g., version: 'Omit for latest') but does not add new semantics beyond what the schema already provides. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it performs a 'trust check' for an AI capability, returns multiple specific fields (certification status, trust score, grade, tier, supply chain status). The title and description consistently use 'Check Fidensa Certification', differentiating it from sibling tools like verify_artifact or compare_capabilities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises 'Use this before invoking any capability to verify it has been independently certified by Fidensa.' This tells the agent when to use the tool, though it does not explicitly mention alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Side-by-side comparison of 2-5 certified capabilities. Shows trust scores, grades, tiers, and per-signal breakdowns to help choose between alternatives. Requires a free API key (set FIDENSA_API_KEY).
| Name | Required | Description | Default |
|---|---|---|---|
| capability_ids | Yes | Array of 2-5 capability IDs to compare |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description adds context beyond annotations: shows specific outputs (trust scores, grades, tiers) and states API key requirement. Does not contradict annotations (readOnlyHint, openWorldHint) which are already clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. Key action and outputs front-loaded. Efficient and clear.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given one parameter and no output schema, the description provides sufficient context: purpose, outputs, and prerequisite (API key). Annotations cover safety and variability.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% so baseline is 3. Description restates the array size (2-5) but adds no additional meaning about parameter semantics or capability IDs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it does side-by-side comparison of 2-5 certified capabilities. Specific verb 'compare' and resource 'certified capabilities', distinguishing from siblings like 'search_capabilities'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly mentions the tool helps choose between alternatives and requires an API key. Implies when to use, but does not explicitly state when not to use or mention alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve the full certification contract for a capability, including identity, supply chain analysis, security scan results, adversarial testing findings, behavioral fingerprint, and trust score breakdown. Requires a free API key (set FIDENSA_API_KEY).
| Name | Required | Description | Default |
|---|---|---|---|
| capability_id | Yes | Capability identifier | |
| version | No | Specific version (omit for latest) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare readOnlyHint=true and openWorldHint=true, which the description reinforces by stating 'Retrieve' and does not contradict. It adds the behavioral context of requiring an API key for access, which is valuable beyond 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two sentences: one defining the tool's purpose and content, and one noting the API key requirement. It is front-loaded and every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
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, no output schema, read-only), the description covers the key contextual information: what the contract includes and the API key prerequisite. It is nearly complete, lacking only potential details like response format or size limits.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage for both parameters (capability_id and version). The description does not add further semantic details about parameters beyond what the schema provides, so it meets the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'Retrieve' and the resource 'full certification contract for a capability', and lists specific included components. It effectively differentiates from siblings like check_certification (which likely checks status) by focusing on retrieving the complete contract.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description notes the prerequisite of a free API key and setting FIDENSA_API_KEY, which is useful. However, it does not provide explicit guidance on when to choose this tool over alternatives (e.g., check_certification for quick checks, compare_capabilities for comparisons).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Submit an experience report for a certified capability. Reports feed into the social proof signal of the trust score. Requires the content_hash from the .cert.json artifact (proves you've encountered the certified file). API key optional but recommended for higher rate limits.
| Name | Required | Description | Default |
|---|---|---|---|
| capability_id | Yes | Capability identifier | |
| content_hash | Yes | SHA-256 content hash from the .cert.json artifact or the certification block. This proves you have the certified file. | |
| outcome | Yes | Overall outcome of using the capability | |
| version | No | Capability version (e.g. "1.0.0"). Server defaults to latest if omitted. | |
| environment | No | Environment context | |
| details | No | Additional details |
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 that reports feed into trust scores and requires a proof-of-possession hash, but does not disclose side effects, default rate limits, or whether the action is idempotent. The behavioral transparency is adequate but incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loaded with the main purpose, followed by impact and key requirement. Every sentence contributes essential information without redundancy. It is highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 6 parameters, nested objects, and no output schema, the description explains the high-level purpose and the critical hash requirement, but lacks guidance on how to fill out environment/details sub-fields or what the response contains. Completeness is moderate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 explaining that content_hash proves file possession and linking it to the cert artifact, but other parameters (e.g., details, environment) are not elaborated beyond the schema. No significant extra meaning beyond the structured fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Submit an experience report for a certified capability.' It uses a specific verb ('Submit') and resource ('experience report'), and distinguishes itself from siblings like check_certification or search_capabilities by focusing on reporting usage outcomes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit guidance on the required content_hash and optional API key for rate limits, but does not compare to alternatives or state when not to use this tool. It lacks explicit context about prerequisites beyond the hash.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for certified AI capabilities by keyword or description. Use this to discover certified alternatives when a capability is uncertified or scores poorly. Supports filtering by type, tier, and minimum trust score. No API key required.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (natural language or keywords) | |
| type | No | Filter by capability type | |
| tier | No | Filter by certification tier | |
| min_score | No | Minimum trust score (0-100) | |
| limit | No | Maximum number of results (default: 10) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint. The description adds that no API key is required and that the tool supports filtering, which provides useful behavioral context beyond 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences. The first states the action, the second provides usage context and filtering capabilities. No superfluous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description is adequate for a search tool with good annotations, but it lacks details about the output format or pagination. Although no output schema is provided, the description could mention what fields are returned.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already describes all parameters adequately. The description simply summarizes filtering by type, tier, and score, adding no additional semantic value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it searches for certified AI capabilities by keyword or description, and specifically mentions discovering certified alternatives when a capability is uncertified or scores poorly. This distinguishes it from sibling tools like check_certification or compare_capabilities.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly advises using this tool to discover certified alternatives when a capability is uncertified or scores poorly. However, it does not specify when not to use it or mention alternative tools directly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Verify the cryptographic signature on a Fidensa certification artifact (.cert.json). Checks platform signature, content hash, expiry, and optionally code integrity (git SHA match) and file integrity (file hash match). For true offline verification, pass the .cert.json content from the capability's published package via the content parameter. Requires a free API key (set FIDENSA_API_KEY).
| Name | Required | Description | Default |
|---|---|---|---|
| content | No | Base64-encoded .cert.json artifact content. Preferred for independent verification. | |
| url | No | fidensa.com URL to fetch the artifact (convenience, but verification is circular since the artifact comes from the same authority verifying it). | |
| installed_git_sha | No | Git commit SHA of the installed code (from "git rev-parse HEAD"). When provided, verifies that the installed code matches the certified commit. | |
| file_hash | No | SHA-256 hash of the capability file (excluding the residual comment line). When provided, verifies the file matches the certified original. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=true and openWorldHint=true. The description adds value by detailing what the tool checks (signature, hash, expiry, optional code/file integrity) and highlights the circular nature of the URL parameter. 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.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences with no fluff. It front-loads the main purpose, then details optional capabilities and usage notes. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description should explain what the tool returns after verification. It mentions what it checks but not the result format or error conditions. This gap lowers completeness to a 3.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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 context beyond schema by explaining the preference for 'content' over 'url' and that 'content' is for independent offline verification. This extra guidance justifies a score of 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it verifies cryptographic signatures on Fidensa certification artifacts (.cert.json), specifying checks for platform signature, content hash, expiry, and optional code/file integrity. This is a specific verb+resource combination that distinguishes it from siblings like verify_file or check_certification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear guidance: recommends using 'content' for true offline verification, notes that 'url' is a convenience but circular, and mentions the API key requirement. It does not explicitly exclude siblings or provide when-not-to-use scenarios, but the context is sufficient for an agent to choose appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Quick file integrity check: pass the SHA-256 hash of a capability file and its capability_id to verify the file matches what Fidensa certified. This is the simplest verification path — no .cert.json needed. No API key required.
| Name | Required | Description | Default |
|---|---|---|---|
| capability_id | Yes | Capability identifier | |
| file_hash | Yes | SHA-256 hash of the capability file (excluding the residual comment line if present). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint, so the safety profile is clear. Description adds that no API key is required, which is useful but not extensive. Does not disclose error handling, rate limits, or side effects beyond verification.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with purpose and essential usage details. No unnecessary words; every sentence contributes to understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple verification tool with two required parameters and no output schema, the description covers the core purpose and usage. However, it does not indicate the return value (e.g., boolean or status message), which would be helpful for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema provides 100% coverage with descriptions for both parameters. Description adds value by clarifying that the file_hash is specifically the SHA-256 hash of the capability file and mentions excluding a residual comment line, which is not in the schema description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description explicitly states 'Quick file integrity check' and 'verify the file matches what Fidensa certified', clearly identifying the verb (verify) and resource (file integrity). It distinguishes from siblings by noting this is the simplest verification path without needing a .cert.json file.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear when-to-use context: pass SHA-256 hash and capability_id for a simple verification. States 'This is the simplest verification path — no .cert.json needed' and 'No API key required', implying this is for quick checks versus more complex alternatives. Does not explicitly exclude other scenarios but implies its niche.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool serves a unique purpose: quick trust check, comparison, detailed contract retrieval, experience reporting, search, cryptographic verification, and file hash check. No overlap.
All tools consistently use verb_noun pattern with underscores (e.g., check_certification, compare_capabilities), making them predictable.
7 tools cover the certification domain without redundancy or deficiency; the count is well-scoped for the server's purpose.
The set provides complete lifecycle coverage: discover, trust check, compare, retrieve details, verify artifacts/files, and submit feedback. No gaps apparent.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Trust infrastructure for AI agents: read a verifiable Trust Rating, claim an identity, earn a badge.
Trust infrastructure for AI agents. Portable reputation (JTS 0-5), agent discovery, vouching.
Trust signals for AI agents: an open agent-readiness standard and developer tool guide. Read-only.
Entity verification, sanctions screening, and trust scoring for AI agents.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/fidensa/mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
