The Anti-Bullshit MCP Server provides tools for analyzing information by:
Analyze Claims: Evaluate claims using multiple epistemological frameworks (empirical, responsible, harmonic, pluralistic) to assess evidence, ethical implications, coherence, and practical outcomes.
Validate Sources: Cross-reference and validate the credibility, authority, and methodological soundness of cited sources.
Detect Manipulation: Identify tactics such as emotional manipulation, false authority, and urgency creation that undermine information integrity.
Click on "Deploy 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., "@Anti-Bullshit MCP Server analyze this claim: 'This supplement boosts immunity by 300% according to a recent study'"
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.
A Model Context Protocol server for analyzing claims, validating sources, and detecting manipulation using multiple epistemological frameworks.
The server provides three main tools for detecting and analyzing bullshit:
Analyzes claims using multiple epistemological frameworks:
Empirical Framework
Focuses on verifiable evidence
Evaluates reproducible results
Cross-references academic and scientific sources
Assesses methodological rigor
Responsible Framework
Evaluates ethical implications
Assesses community impact
Considers traditional knowledge
Validates source credibility
Harmonic Framework
Assesses coherence with established knowledge
Integrates multiple perspectives
Considers contextual appropriateness
Evaluates systemic implications
Pluralistic Framework
Combines all other frameworks
Considers multiple ways of knowing
Evaluates contextual appropriateness
Assesses practical outcomes
Checks alignment with community values
Extracts and analyzes cited sources
Validates credibility and authority
Cross-references across multiple platforms
Evaluates methodological soundness
Checks for conflicts of interest
Detects manipulation tactics including:
Emotional manipulation
Social pressure
False authority
Artificial scarcity
Urgency creation
Related MCP server: Kluster.ai Verify MCP
Node.js >= 18.0.0
npm or yarn
Install dependencies:
npm installBuild the server:
npm run buildAdd to Claude Desktop (MacOS):
{
"mcpServers": {
"anti-bullshit": {
"command": "node",
"args": ["/path/to/anti-bullshit-mcp-server/build/index.js"]
}
}
}Path: ~/Library/Application Support/Claude/claude_desktop_config.json
Or for VSCode extension:
Path: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json
// Analyze a claim
const result = await analyze_claim({
text: "Studies show that 87% of experts agree with this controversial claim",
framework: "empirical"
});
// Validate sources
const validation = await validate_sources({
text: "According to Dr. Smith's groundbreaking research...",
framework: "responsible"
});
// Check for manipulation
const check = await check_manipulation({
text: "Act now! This exclusive offer expires in the next 10 minutes!"
});For development with auto-rebuild:
npm run watchDebug with MCP Inspector:
npm run inspectorThe server uses 2025-01-01 as the reference date for temporal analysis of claims (particularly relevant for Goodman's "grue" paradox and similar philosophical puzzles).
MIT
Teglon Labs (teglon@vibes.lol)
Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -am 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request
Analyze a claim using multiple epistemological frameworks and suggest validation steps
| Name | Required | Description | Default |
|---|---|---|---|
| framework | No | Validation framework to use (empirical, responsible, harmonic, or pluralistic) | |
| text | Yes | Claim to analyze |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'analyze' and 'suggest validation steps' but doesn't specify what the analysis entails (e.g., output format, depth), whether it's read-only or has side effects, or any constraints like rate limits or authentication needs. This leaves significant gaps for a tool with no annotation coverage.
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 a single, efficient sentence that front-loads the core purpose ('analyze a claim') and adds key details ('using multiple epistemological frameworks and suggest validation steps'). Every word contributes meaning without redundancy or waste.
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 complexity of analyzing claims with frameworks and no annotations or output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., analysis results, validation steps list), how frameworks differ, or behavioral aspects like safety or performance. For a tool with 2 parameters and no structured output, more context is needed.
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 schema already documents both parameters ('framework' with enum values and 'text' as the claim). The description adds no additional semantic context beyond what's in the schema, such as explaining the frameworks or how they affect analysis. Baseline 3 is appropriate when the schema handles parameter documentation.
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 action ('analyze') and resource ('a claim'), specifying it uses 'multiple epistemological frameworks' and 'suggest validation steps'. This provides a specific verb+resource combination, though it doesn't explicitly differentiate from sibling tools like 'check_manipulation' or 'validate_sources' which might have overlapping domains.
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 no guidance on when to use this tool versus alternatives like 'check_manipulation' or 'validate_sources'. It mentions 'validation steps' but doesn't clarify if this is for preliminary analysis, in-depth validation, or specific contexts. No exclusions or prerequisites are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check for manipulation tactics across different cultural contexts
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | Text to analyze for manipulation |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions checking for manipulation tactics across cultural contexts, but doesn't describe what the tool actually does behaviorally—such as whether it returns a score, categories of manipulation, examples, or any limitations like accuracy, rate limits, or authentication needs. This leaves significant gaps in understanding the tool's operation.
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 a single, efficient sentence that directly states the tool's function. It's appropriately sized and front-loaded with the core purpose, though it could be slightly more structured by explicitly mentioning the input parameter or output expectations to improve clarity without adding unnecessary length.
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 complexity (analyzing manipulation across cultures) and lack of annotations or output schema, the description is incomplete. It doesn't explain what the tool returns, how results are formatted, any limitations in cultural coverage, or behavioral traits. This makes it inadequate for an agent to fully understand and use the tool effectively, especially without structured output information.
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, with the 'text' parameter clearly documented as 'Text to analyze for manipulation'. The description adds no additional meaning beyond this, as it doesn't elaborate on parameter usage, format expectations, or cultural context implications. With high schema coverage, the baseline score of 3 is appropriate, as the schema adequately handles parameter semantics without description enhancement.
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 states the tool's purpose as checking for manipulation tactics, which is clear but vague. It specifies 'across different cultural contexts' which adds some nuance, but doesn't clearly distinguish this from sibling tools like 'analyze_claim' or 'validate_sources' in terms of what specific manipulation tactics it detects or how it differs from general claim analysis or source validation.
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?
No explicit guidance on when to use this tool versus alternatives like 'analyze_claim' or 'validate_sources' is provided. The description implies usage for analyzing text for manipulation in cultural contexts, but lacks any context on prerequisites, exclusions, or comparative advantages over sibling tools, leaving the agent to infer when this specific tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Validate sources and evidence using configured framework
| Name | Required | Description | Default |
|---|---|---|---|
| framework | No | Validation framework to use | |
| text | Yes | Text containing claims and sources to validate |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden but provides minimal behavioral insight. It doesn't disclose whether this is a read-only operation, if it modifies data, authentication needs, rate limits, or output format. The phrase 'configured framework' hints at external configuration but lacks details.
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 a single, efficient sentence with no wasted words. It's front-loaded with the core action, though it could be more structured by elaborating on key aspects like output or context.
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 annotations and no output schema, the description is incomplete. It doesn't explain what validation results look like, error conditions, or behavioral traits. For a tool with two parameters and undefined output, more context is needed to guide effective use.
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 schema fully documents parameters. The description adds no additional meaning beyond implying validation uses a framework, which is already covered by the 'framework' parameter's enum. Baseline 3 is appropriate as the schema does the heavy lifting.
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 states the action ('validate') and target ('sources and evidence'), but lacks specificity about what validation entails or how it differs from sibling tools like 'analyze_claim' or 'check_manipulation'. It's vague about the scope and mechanism of validation.
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?
No guidance is provided on when to use this tool versus alternatives. The description mentions 'configured framework' but doesn't explain what contexts or scenarios warrant its use, nor does it reference sibling tools for comparison or exclusion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0analyze_claimcheck_manipulationvalidate_sourcesScored across 3 tools
Each tool has a clearly distinct purpose: analyze_claim focuses on epistemological frameworks and validation steps, check_manipulation targets manipulation tactics across cultures, and validate_sources deals with source and evidence validation. There is no overlap in functionality, making tool selection straightforward.
All tool names follow a consistent verb_noun pattern (analyze_claim, check_manipulation, validate_sources) with clear, descriptive verbs and nouns. The naming is uniform and predictable throughout the set.
With only 3 tools, the server feels thin for its broad domain of anti-bullshit analysis, which could include more operations like fact-checking, bias detection, or reporting. While each tool is distinct, the count is borderline low for comprehensive coverage.
The tools cover analysis, manipulation checking, and source validation, but there are notable gaps such as lack of fact-checking, bias assessment, or result summarization tools. Agents might encounter dead ends when needing broader anti-bullshit workflows.
Fact-check claims against independent sources — fast verdict or deep multi-step investigation.
49 deterministic tools for text integrity, agent control, and contextual quality evidence.
Verify claims with verdict, confidence & cited sources; batch verify, source checks, daily brief.
Fact-checks generated content against your sources of truth showing what to trust, change, & verify.
