What can you do with this server?

The ZeroTrue MCP Server integrates the ZeroTrue AI Detection API to detect AI-generated content across text, images, video, and audio. * Analyze text (zerotrue_analyze_text): Submit plain text (up to 200,000 characters) to detect AI-generated content. * Analyze a URL (zerotrue_analyze_url): Point the server at any direct HTTP(S) URL (image, video, audio, or text file) for analysis. * Analyze a local file (zerotrue_analyze_local_file): Provide an absolute local file path; the server auto-detects the MIME type and uploads it — no manual encoding required. * Analyze a Base64-encoded file (zerotrue_analyze_file): Submit a Base64-encoded file (up to ~70 MB) with its filename and optional MIME type. * Retrieve a previous result (zerotrue_get_result): Look up any past analysis by its UUID without re-running the scan. * Get API metadata (zerotrue_get_api_info): Fetch supported file formats and API capabilities. Optional flags (available on all analysis tools): * isDeepScan — enables more thorough analysis (may consume paid credits). * isPrivateScan — keeps results private and not stored publicly (may consume paid credits).

Which integrations are available for this server?

Enables GitHub Copilot to analyze files, URLs, and text for AI-generated content. Enables JetBrains IDEs to analyze local files and text for AI-generated content via ZeroTrue.

How do I use ZeroTrue MCP Server?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ZeroTrue MCP Server analyze this text for AI-generated content" 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.

ZeroTrue MCP Server

Official

by ZeroTrueLCC

Overview Schema Source Related Servers Discussions Admin

TypeScript

Hybrid

ZeroTrue MCP Server

npm version License: MIT Node.js

Official Model Context Protocol server for the ZeroTrue AI Detection API. Detect AI-generated text, images, video, and audio from any MCP-compatible agent or IDE.

Quick Start

Requires a ZeroTrue API key. Get one at zerotrue.app.

ZEROTRUE_API_KEY=zt_your_key npx -y @zerotrue/mcp stdio

Related MCP server: MidjourneyMCP

Tools

Tool	Description
`zerotrue_analyze_text`	Detect AI-generated content in plain text
`zerotrue_analyze_url`	Analyze media or text at a direct HTTP(S) URL
`zerotrue_analyze_local_file`	Analyze a local file by path (preferred for desktop/CLI clients)
`zerotrue_analyze_file`	Analyze a Base64-encoded file
`zerotrue_get_result`	Retrieve a previous analysis result by ID
`zerotrue_get_api_info`	Return API metadata and supported formats

All tools accept optional isDeepScan and isPrivateScan flags where applicable.

`zerotrue_analyze_local_file`

The recommended tool for local MCP clients. Pass an absolute path: the server validates the file, detects its MIME type, and uploads it as a multipart form to ZeroTrue. No manual Base64 encoding needed.

{ "path": "/Users/alex/Downloads/photo.png", "isPrivateScan": true }

`zerotrue_analyze_text`

{ "text": "Paste the content here...", "isDeepScan": false }

`zerotrue_analyze_url`

{ "url": "https://example.com/video.mp4", "isPrivateScan": true }

`zerotrue_get_result`

{ "id": "246c6522-195d-45d3-af96-0f2360d2e0bc" }

Response Format

Every tool returns a consistent JSON envelope:

{
  "ok": true,
  "data": {
    "id": "246c6522-195d-45d3-af96-0f2360d2e0bc",
    "status": "completed",
    "result": {
      "ai_probability": 0.998,
      "human_probability": 0.002,
      "result_type": "ai_generated",
      "feedback": "High probability of AI generation detected"
    }
  }
}

Errors use the same shape with ok: false:

{
  "ok": false,
  "error": {
    "statusCode": 401,
    "message": "ZeroTrue API key is required.",
    "code": "ZEROTRUE_API_ERROR"
  }
}

Client Setup

[mcp_servers.zerotrue]
command = "npx"
args = ["-y", "@zerotrue/mcp", "stdio"]

[mcp_servers.zerotrue.env]
ZEROTRUE_API_KEY = "zt_your_key"

Add to claude_desktop_config.json:

{
  "mcpServers": {
    "zerotrue": {
      "command": "npx",
      "args": ["-y", "@zerotrue/mcp", "stdio"],
      "env": {
        "ZEROTRUE_API_KEY": "zt_your_key"
      }
    }
  }
}

copilot mcp add zerotrue \
  --transport stdio \
  --env ZEROTRUE_API_KEY=zt_your_key \
  --tools '*' \
  --timeout 310000 \
  -- npx -y @zerotrue/mcp stdio

Install in VS Code Install in VS Code Insiders

Or add manually to your workspace .vscode/mcp.json:

{
  "inputs": [
    {
      "id": "zerotrue-api-key",
      "type": "promptString",
      "description": "ZeroTrue API key",
      "password": true
    }
  ],
  "servers": {
    "zerotrue": {
      "command": "npx",
      "args": ["-y", "@zerotrue/mcp", "stdio"],
      "env": {
        "ZEROTRUE_API_KEY": "${input:zerotrue-api-key}"
      }
    }
  }
}

Add to your Cursor MCP settings:

{
  "mcpServers": {
    "zerotrue": {
      "command": "npx",
      "args": ["-y", "@zerotrue/mcp", "stdio"],
      "env": {
        "ZEROTRUE_API_KEY": "zt_your_key"
      }
    }
  }
}

Use the IDE MCP settings panel with a local stdio server:

{
  "mcpServers": {
    "zerotrue": {
      "command": "npx",
      "args": ["-y", "@zerotrue/mcp", "stdio"],
      "env": {
        "ZEROTRUE_API_KEY": "zt_your_key"
      }
    }
  }
}

Run the HTTP server:

ZEROTRUE_API_KEY=zt_your_key \
ZEROTRUE_MCP_PORT=8787 \
npx -y @zerotrue/mcp http

Or with Docker:

docker run -p 8787:8787 \
  -e ZEROTRUE_API_KEY=zt_your_key \
  zerotrue/mcp

MCP endpoint: http://localhost:8787/mcp Health check: http://localhost:8787/healthz

Point your MCP client to the endpoint above. For production, place the server behind HTTPS and add authentication.

Configuration

Variable	Default	Description
`ZEROTRUE_API_KEY`	(required)	ZeroTrue API key (`zt_...`). Required for all analysis tools.
`ZEROTRUE_API_BASE_URL`	`https://api.zerotrue.app`	ZeroTrue API base URL
`ZEROTRUE_API_TIMEOUT_MS`	`310000`	Request timeout in milliseconds
`ZEROTRUE_MAX_FILE_BYTES`	`104857600`	Max local file size (default 100 MB)
`ZEROTRUE_MCP_TRANSPORT`	`stdio`	Transport mode: `stdio` or `http`
`ZEROTRUE_MCP_HOST`	`0.0.0.0`	HTTP bind host
`ZEROTRUE_MCP_PORT`	`8787`	HTTP bind port
`ZEROTRUE_MCP_ENDPOINT`	`/mcp`	HTTP MCP path

Example Prompts

Is this text AI-generated? "The quantum entanglement of..."

Analyze https://example.com/profile.jpg with ZeroTrue and summarize the result.

Use ZeroTrue to check /Downloads/video.mp4. Keep the scan private.

Get ZeroTrue result 246c6522-195d-45d3-af96-0f2360d2e0bc and explain the verdict.

Security

Store ZEROTRUE_API_KEY in your MCP client config, never in source control.
Prefer stdio mode for personal use: your key never leaves your machine.
zerotrue_analyze_local_file can only access files readable by the MCP server process.
For HTTP deployments, do not expose the /mcp endpoint publicly without authentication and rate limiting.

Troubleshooting

ZeroTrue API key is required - Set ZEROTRUE_API_KEY in the environment where the MCP server starts.

File is not readable or does not exist - Use an absolute path and confirm the MCP server process has read access.

fetch failed - Check connectivity: curl https://api.zerotrue.app/api/v1/info. If details.cause.code is present, use it to diagnose DNS, TLS, or proxy issues.

Stale tool behavior after an update - Restart the MCP client. Most clients keep MCP subprocesses alive between tool calls.

Requirements

Node.js >= 20.11

License

MIT

Available Tools

6 tools

zerotrue_analyze_fileAnalyze FileA

Analyze a base64-encoded file using ZeroTrue. Prefer zerotrue_analyze_local_file for local files and zerotrue_analyze_url for remote files.

ParametersJSON Schema

Name	Required	Description
`filename`	Yes	Original filename including extension.
`mimeType`	No	MIME type, if known.
`base64`	Yes	Base64-encoded file bytes. Prefer zerotrue_analyze_url for large remote files.
`isDeepScan`	No	Enable deeper analysis when supported. This can consume paid credits.
`isPrivateScan`	No	Keep the result private. Defaults to true and can consume paid credits.

TDQS

A4/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It states 'analyze' but does not explain what the tool does beyond that (e.g., returns a result ID, scans for threats, etc.). The schema hints at credit consumption for deep/private scans, but the description does not explicitly mention behavioral outcomes or 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?

Two sentences, front-loaded with purpose and immediate usage guidance. No unnecessary words.

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?

No output schema and absence of any description about what the analysis returns (e.g., a result ID, a report). Given the complexity (5 parameters, including optional booleans for paid credits), the description should at least hint at the workflow (e.g., 'use zerotrue_get_result to retrieve analysis').

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline is 3. The description adds no new parameter information beyond what the schema provides, except a mention of preferring URL for large files which is already in the schema.

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 analyzes base64-encoded files using ZeroTrue, and distinguishes it from siblings by advising to prefer other tools for local and remote files.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicit guidance is given: prefer zerotrue_analyze_local_file for local files and zerotrue_analyze_url for remote files. This helps the agent choose correctly.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

zerotrue_analyze_local_fileAnalyze Local FileA

Analyze a local file path readable by the MCP server. Best option for local desktop/CLI MCP clients.

ParametersJSON Schema

Name	Required	Description
`path`	Yes	Path to a local file readable by the MCP server process. Use zerotrue_analyze_url for remote files.
`isDeepScan`	No	Enable deeper analysis when supported. This can consume paid credits.
`isPrivateScan`	No	Keep the result private. Defaults to true and can consume paid credits.

TDQS

A4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, but description fails to mention that isDeepScan and isPrivateScan consume paid credits (only noted in schema). Behavior traits like read-only or side effects are not disclosed, leaving gaps for the agent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Single sentence that is concise and front-loaded with the main purpose, no wasted words.

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 3 parameters (1 required) and no output schema, the description provides enough context for the tool's purpose and usage. However, it lacks details on behavioral aspects like credit consumption, which are in schema but not in description.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% with good parameter descriptions, so baseline 3. Description does not add extra meaning beyond the schema, but also does not miss key details.

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?

Description clearly states the verb 'Analyze' and resource 'local file path', and distinguishes from sibling tool zerotrue_analyze_url by specifying local vs remote.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says 'Best option for local desktop/CLI MCP clients' and the path parameter description mentions to use zerotrue_analyze_url for remote files, providing clear usage context and alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

zerotrue_analyze_textAnalyze TextC

Analyze plain text for AI-generated content using ZeroTrue.

ParametersJSON Schema

Name	Required	Description
`text`	Yes	Plain text to analyze for AI-generated content.
`isDeepScan`	No	Enable deeper analysis when supported. This can consume paid credits.
`isPrivateScan`	No	Keep the result private. Defaults to true and can consume paid credits.

TDQS

C2.8/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, putting the full burden on the description. The description does not disclose key behavioral traits such as whether the tool is read-only, requires authentication, has rate limits, or consumes credits beyond what is stated in parameter descriptions. It merely states the action without context.

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 a single sentence, which is concise but too brief given the lack of annotations. It is front-loaded but omits important details; the sentence is not wasted but could be expanded without losing conciseness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is incomplete for a tool with 3 parameters and no output schema or annotations. It does not explain the return value, how to retrieve results (especially given sibling zerotrue_get_result), or any behavioral requirements. The agent lacks sufficient context to invoke the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters. The description adds minimal extra meaning beyond the schema, such as noting that isDeepScan and isPrivateScan 'can consume paid credits,' which is useful but not extensive. The text parameter is essentially repeated.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the tool 'analyze[s] plain text for AI-generated content using ZeroTrue,' which clearly indicates the verb (analyze), resource (plain text), and purpose (detecting AI-generated content). It is specific enough to distinguish from sibling tools like zerotrue_analyze_file, but lacks explicit differentiation details.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives such as zerotrue_analyze_file or zerotrue_analyze_url. There are no prerequisites, exclusions, or context-specific recommendations, leaving the agent to infer usage from names alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

zerotrue_analyze_urlAnalyze URLB

Analyze content at a direct HTTP(S) URL using ZeroTrue.

ParametersJSON Schema

Name	Required	Description
`url`	Yes	Direct HTTP(S) URL to content that ZeroTrue should download and analyze.
`isDeepScan`	No	Enable deeper analysis when supported. This can consume paid credits.
`isPrivateScan`	No	Keep the result private. Defaults to true and can consume paid credits.

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, and the description lacks behavioral details such as whether analysis is synchronous or asynchronous, what happens to downloaded content, or cost implications for deep/private scans. The description merely states what the tool does without disclosing side effects or constraints.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that efficiently conveys the core action and input type. It is front-loaded with the verb and resource. However, it omits potentially useful context, preventing a perfect score.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's three parameters, high sibling count, and lack of annotations or output schema, the description is insufficiently complete. It does not differentiate from siblings, explain return values, or warn about cost/credits, leaving significant gaps for an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema covers all parameters with descriptions (100% coverage). The description adds no additional meaning beyond the schema. Given high schema coverage, baseline is 3; the description does not elevate it further.

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: 'Analyze content at a direct HTTP(S) URL using ZeroTrue.' It specifies the verb (analyze), the resource (content at a URL), and the system (ZeroTrue). This distinguishes it from sibling tools like zerotrue_analyze_file and zerotrue_analyze_text, which handle different input types.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus its siblings. It does not mention scenarios for which it is appropriate or inappropriate, nor does it direct users to alternative tools for file or text input.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

zerotrue_get_api_infoGet API InfoA

Return ZeroTrue public API metadata and supported formats.

ParametersJSON Schema

Name	Required	Description	Default
No parameters

TDQS

A3.6/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries the full burden. It identifies the tool as a read operation returning metadata, but does not disclose idempotency, authentication needs, or rate limits. It is accurate but lacks depth.

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 with no wasted words. It is front-loaded and efficiently conveys the tool's purpose.

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 parameterless, read-only metadata tool without an output schema, the description is nearly complete. It tells the agent what is returned (metadata and formats), though it could mention that no arguments are required and that it is safe to call frequently.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has no properties and schema coverage is 100%, so the baseline is 3. The description adds no parameter information beyond what the schema provides, which is acceptable given the absence of parameters.

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 explicitly states it returns 'ZeroTrue public API metadata and supported formats,' clearly specifying the verb and resource. It distinguishes from sibling tools that perform analysis or result retrieval.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is provided on when to use this tool versus alternatives. The description does not include scenarios, prerequisites, or exclusions, leaving the agent to infer usage from the tool name alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

zerotrue_get_resultGet Analysis ResultA

Retrieve a ZeroTrue analysis result by ID.

ParametersJSON Schema

Name	Required	Description	Default
`id`	Yes	Analysis/result identifier returned by an analyze tool.

TDQS

A3.5/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only states the basic function without mentioning idempotency, blocking behavior, prerequisites (e.g., analysis completion), or error handling. This is minimal disclosure.

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 of eight words, front-loaded with the verb and resource. No redundant information; every word serves a 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?

For a simple 1-parameter retrieval tool with no output schema, the description states core functionality and parameter source. However, it lacks return value context or error conditions, making it merely adequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% (one parameter fully described in the schema as a UUID from an analyze tool). The description adds no additional meaning beyond 'by ID', so it meets the baseline but does not enrich.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses the specific verb 'Retrieve' and identifies the resource as 'ZeroTrue analysis result by ID'. It clearly distinguishes from sibling analyze tools (zerotrue_analyze_*) which create analyses, and from get_api_info.

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 the tool should be used after an analyze tool to retrieve the result, but does not explicitly state when to use it, when not to, or provide alternatives. Usage context is implied but not elaborated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

6 tool updatesv0.1.2May 28, 2026
- First observedzerotrue_analyze_file
- First observedzerotrue_analyze_local_file
- First observedzerotrue_analyze_text
- First observedzerotrue_analyze_url
- First observedzerotrue_get_api_info
- First observedzerotrue_get_result

Deploy Server

One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A3.7/5.0

Scored 2026-05-28 09:01 across 6 tools

Disambiguation5/5

Each tool has a distinct purpose: analyzing files from different sources (local, URL, base64), analyzing text, retrieving API info, and getting results. Descriptions clearly differentiate them, reducing ambiguity.

Naming Consistency5/5

All tools follow a consistent pattern: 'zerotrue_' prefix + verb_noun in snake_case (e.g., zerotrue_analyze_file, zerotrue_get_result). No mixing of conventions.

Tool Count5/5

With 6 tools, the server is well-scoped for its purpose of analyzing content for AI-generated material. Each tool provides necessary functionality without redundancy.

Completeness5/5

The toolset covers the full workflow: analyzing files (local, URL, base64), analyzing text, retrieving results, and accessing API metadata. No obvious gaps exist for the stated domain.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Related MCP Connectors

Writingmate MCPOAuth
ai.writingmate
Use AI models for chat, image, and video generation from Claude Code and other MCP hosts.
AI & Machine Learning Image & Video Processing
1
Claude Imagine AOAuth
com.claudeimagine
Generate AI images and videos from any compatible MCP client.
AI & Machine Learning Image & Video Processing
102
Frenchie A
io.github.Lab94
OCR, transcription, file extraction, and image generation for AI agents via MCP.
AI & Machine Learning Image & Video Processing Speech Processing
72
zerolangcompiler-mcp
com.clauxel.zerolangcompiler
A paid remote MCP for ZeroLang, built to return verdicts, receipts, usage logs, and audit-ready JSON
Developer Tools Code Analysis Monitoring
2

Related MCP Servers

GPTZero MCP Server
Text Summarization Research & Data
louis030195
A
license
B
quality
D
maintenance
Enables AI-generated text detection using the GPTZero API. Provides confidence scores and detailed analysis to identify whether text was written by humans or AI, with multilingual support.
Updated a year ago (2025-10-06 20:20 UTC)
2
7 npm
1
MIT
MidjourneyMCP
Image & Video Processing Multimedia Processing
AceDataCloud
A
license
A
quality
A
maintenance
Enables AI image and video generation using Midjourney through the AceDataCloud API. It supports comprehensive features including image creation, transformation, blending, editing, and video generation directly within MCP-compatible clients.
Updated 25 days ago (2026-09-04 10:01 UTC)
16
64 PyPI
9
MIT
Reality Defender MCP Serverofficial
AI & Machine Learning Image & Video Processing
Reality-Defender
A
license
Not graded
quality
D
maintenance
Enables LLMs to analyze images, videos, audio, and text files for AI-generated content using the Reality Defender API, with support for user file uploads and direct URL analysis.
Updated 6 months ago (2026-03-29 04:28 UTC)
1
Apache 2.0
image-forensics-mcp
Image & Video Processing AI & Machine Learning
surewht
A
license
A
quality
D
maintenance
An MCP server that enables AI assistants to analyze images for AI-generated content using noise maps, error level analysis, frequency analysis, spectral decay, color analysis, and metadata inspection.
Updated 8 months ago (2026-02-10 22:04 UTC)
7
MIT

ZeroTrue MCP Server

Quick Start

Tools

zerotrue_analyze_local_file

zerotrue_analyze_text

zerotrue_analyze_url

zerotrue_get_result

Response Format

Client Setup

Configuration

Example Prompts

Security

Troubleshooting

Requirements

License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Reality Defender MCP Serverofficial

`zerotrue_analyze_local_file`

`zerotrue_analyze_text`

`zerotrue_analyze_url`

`zerotrue_get_result`