CulturalTruth MCP

Advanced Cultural Intelligence & Bias Detection MCP Server - A Model Context Protocol implementation combining Qloo's cultural API with comprehensive bias detection and compliance analysis.

Comment

🚀 What We Built

CulturalTruth MCP is a sophisticated Model Context Protocol server that bridges the gap between AI ethics and cultural intelligence. By combining Qloo's powerful cultural API with advanced bias detection algorithms, we created a production-ready platform that helps developers build more inclusive and culturally-aware AI applications.

💡 What Inspired Us

The inspiration came from witnessing AI systems perpetuate bias and cultural insensitivity at scale. We saw job postings excluding qualified candidates through biased language, marketing campaigns alienating entire demographics, and AI assistants providing culturally tone-deaf recommendations.

The problem was clear: AI systems need both bias detection AND cultural intelligence to serve diverse global audiences effectively.

We chose to build on the Model Context Protocol (MCP) because it allows us to seamlessly integrate these capabilities directly into AI workflows, making ethical AI development accessible to every developer.

🎯 The Challenge We Solved

Traditional approaches to AI ethics are fragmented:

  • Bias detection tools work in isolation
  • Cultural intelligence requires separate API calls
  • Compliance checking is manual and error-prone
  • No unified solution for inclusive AI development

Our solution: A single MCP server that provides comprehensive bias detection, cultural intelligence, and regulatory compliance analysis in one unified interface.

🔧 How We Built It

Architecture Overview

Claude Desktop → CulturalTruth MCP → [Bias Engine + Qloo API + Compliance Scorer]

Core Components:

1. Advanced Bias Detection Engine

  • 50+ regex patterns across 5 bias categories
  • Confidence scoring with context awareness
  • Regulatory mapping to EU AI Act, GDPR, Section 508
  • Severity classification (Critical/High/Medium/Low)
// Example bias pattern
'gender_exclusive': {
  pattern: '\\b(?:guys|bros|rockstar developer|ninja coder)\\b',
  severity: 'medium',
  suggestions: ['team members', 'skilled developer', 'expert engineer'],
  regulation_risk: ['EU_AI_ACT', 'EEOC', 'TITLE_VII'],
  confidence_factors: ['hiring_context', 'job_posting', 'team_building']
}

2. Qloo Cultural Intelligence Integration

  • Entity Search & Validation across 500M+ cultural entities
  • Demographic Analysis for age/gender-based preferences
  • Trending Content with real-time cultural relevance
  • Geospatial Insights for location-based recommendations
  • Audience Comparison with cultural affinity scoring

3. Production-Ready Infrastructure

  • Circuit Breaker Pattern for API fault tolerance
  • LRU Caching for performance optimization
  • Rate Limiting with token bucket algorithm
  • Comprehensive Audit Trails for compliance documentation

Technical Implementation:

Dual Environment System:

// Hackathon Mode: Demo-friendly, faster responses
const HACKATHON_CONFIG = {
  biasDetectionLevel: 'lenient',
  complianceThresholds: { critical: 20, high: 40, medium: 60 },
  enabledFeatures: { culturalTrends: true, demographicAnalysis: false }
};

// Production Mode: Strict validation, full compliance
const PRODUCTION_CONFIG = {
  biasDetectionLevel: 'strict', 
  complianceThresholds: { critical: 10, high: 25, medium: 50 },
  enabledFeatures: { all: true }
};

MCP Tools Implemented (15+ tools):

  • analyze_content_bias - Comprehensive bias analysis
  • qloo_basic_insights - Cultural entity recommendations
  • qloo_demographic_insights - Age/gender-based analysis
  • qloo_trending_entities - Real-time trending content
  • qloo_geospatial_insights - Location-based cultural data
  • batch_cultural_audit - Process multiple items
  • get_compliance_report - Generate audit reports
  • And 8+ more specialized tools

💪 Technical Challenges Overcome

Challenge 1: Bias Detection Accuracy

Problem: Simple keyword matching produces false positives Solution: Context-aware confidence scoring with regulatory risk mapping

private static calculateConfidence(matches: string[], text: string, biasType: string): number {
  let confidence = 0.7; // Base confidence
  confidence += Math.min(matches.length * 0.1, 0.2); // Multiple matches

  // Context-aware adjustments
  const contextWords = {
    'gender_exclusive': ['hiring', 'job', 'position', 'role'],
    'age_discriminatory': ['candidate', 'applicant', 'employee']
  };

  const contextMatches = contextWords[biasType]?.filter(word =>
    new RegExp(`\\b${word}\\b`, 'i').test(text)
  ).length || 0;

  return Math.min(confidence + (contextMatches * 0.05), 1.0);
}

Challenge 2: Qloo API Integration Complexity

Problem: Multiple API endpoints with different response formats Solution: Unified client with intelligent caching and error recovery

// Unified response handling with circuit breaker protection
async searchEntities(params: QlooSearchArgs): Promise<QlooResponse> {
  return this.circuitBreaker.execute(async () => {
    const cacheKey = `search_${JSON.stringify(params)}`;
    const cached = this.entityCache.get(cacheKey);

    if (cached) {
      this.cacheHitCount++;
      return cached;
    }

    const response = await this.api.get('/search', { params });
    const result = this.sanitizeOutput(response.data);
    this.entityCache.set(cacheKey, result);
    return result;
  });
}

Challenge 3: Performance at Scale

Problem: Real-time analysis with multiple API calls creates latency Solution: Intelligent caching, parallel processing, and rate limiting

  • 87% cache hit rate for entity lookups
  • <400ms average response time with caching
  • Parallel API calls with Promise.allSettled for resilience
  • Token bucket rate limiting to respect API quotas

Challenge 4: Regulatory Compliance Complexity

Problem: Different regulations have overlapping but distinct requirements Solution: Multi-dimensional scoring with regulation-specific penalties

calculateComplianceScore(biasPatterns: BiasPattern[]): ComplianceScore {
  const euAiAct = this.calculateRegulationScore(biasPatterns, EU_AI_ACT_PATTERNS);
  const section508 = this.calculateRegulationScore(biasPatterns, ACCESSIBILITY_PATTERNS);
  const gdpr = this.calculateRegulationScore(biasPatterns, PRIVACY_PATTERNS);

  return {
    euAiAct, section508, gdpr,
    overallScore: Math.min(euAiAct, section508, gdpr),
    riskLevel: this.determineRiskLevel(overallScore),
    regulations_triggered: this.getTriggeredRegulations(biasPatterns)
  };
}

🎓 What We Learned

Technical Learnings:

  • MCP Protocol Mastery: Deep understanding of tool definitions, request handling, and client integration
  • Cultural API Integration: Learned Qloo's data model and optimal usage patterns
  • Bias Detection Science: Discovered the complexity of context-aware bias detection
  • TypeScript Architecture: Built maintainable, type-safe systems with proper separation of concerns

Product Learnings:

  • Dual Environment Strategy: Hackathon demos need different configurations than production systems
  • User Experience Design: Complex AI ethics tools need intuitive interfaces
  • Compliance Requirements: Regulatory frameworks are nuanced and require domain expertise

Qloo Platform Insights:

  • Cultural Data Richness: 500M+ entities provide incredible recommendation depth
  • Demographic Segmentation: Age/gender filters unlock powerful personalization
  • Trending Intelligence: Real-time cultural signals enable timely content curation
  • Geospatial Context: Location-based cultural insights are surprisingly valuable

🚀 Real-World Impact Demo

Job Posting Analysis:

Input: "Looking for young guys from top universities for our fast-paced startup"

Output:
🚨 CRITICAL: 18/100 compliance score
- 4 critical bias issues detected
- Violates EU AI Act, ADEA, EEOC guidelines
- Specific suggestions: "qualified candidates" instead of "young guys"
- Regulatory risk assessment included

Cultural Content Curation:

Input: "Find trending content for Marvel fans in SF"

Output:
🎭 Cultural Intelligence Analysis:
- 12 trending entities with popularity scores
- Demographic preferences (young adults prefer darker themes)
- Geographic relevance (SF-specific venues)
- Cross-cultural affinity analysis (89% Marvel-DC overlap)

🏗️ What's Next

Immediate Roadmap:

  • Multi-language support for global bias detection
  • Custom bias patterns for industry-specific use cases
  • Real-time dashboards for compliance monitoring
  • API webhooks for proactive bias prevention

Vision:

Transform CulturalTruth MCP into the industry standard for ethical AI development, where every AI application automatically includes bias detection and cultural intelligence as core capabilities.

Built With

Languages & Frameworks:

  • TypeScript
  • Node.js
  • Model Context Protocol (MCP)

APIs & Services:

  • Qloo Cultural Intelligence API
  • Anthropic Claude (MCP client)

Architecture & Infrastructure:

  • Circuit Breaker Pattern
  • LRU Caching
  • Token Bucket Rate Limiting
  • Axios HTTP Client

Development Tools:

  • npm/Node Package Manager
  • TypeScript Compiler
  • ESLint + Prettier
  • Jest Testing Framework

AI & Ethics Technologies:

  • Regex-based bias detection
  • Confidence scoring algorithms
  • Multi-dimensional compliance scoring
  • Audit trail generation

"Try It Out" Links

GitHub Repository:

https://github.com/jacksonkasi1/CulturalTruth-MCP

Live Demo Setup Instructions:

https://github.com/jacksonkasi1/CulturalTruth-MCP#quick-start

Documentation & Examples:

https://github.com/jacksonkasi1/CulturalTruth-MCP/blob/main/Example.md

Built With

Share this project:

Updates