Skip to main content
Glama
atsuki-sakai

Claude Code AI Collaboration MCP Server

by atsuki-sakai
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Remote

Claude Code AI Collaboration MCP Server

A powerful Model Context Protocol (MCP) server that enables AI collaboration through multiple providers with advanced strategies and comprehensive tooling.

Build Status TypeScript License: MIT Node.js

๐ŸŒŸ Features

๐Ÿค– Multi-Provider AI Integration

  • DeepSeek: Primary provider with optimized performance

  • OpenAI: GPT models integration

  • Anthropic: Claude models support

  • O3: Next-generation model support

๐Ÿš€ Advanced Collaboration Strategies

  • Parallel: Execute requests across multiple providers simultaneously

  • Sequential: Chain provider responses for iterative improvement

  • Consensus: Build agreement through multiple provider opinions

  • Iterative: Refine responses through multiple rounds

๐Ÿ› ๏ธ Comprehensive MCP Tools

  • collaborate: Multi-provider collaboration with strategy selection

  • review: Content analysis and quality assessment

  • compare: Side-by-side comparison of multiple items

  • refine: Iterative content improvement

๐Ÿ“Š Enterprise Features

  • Caching: Memory and Redis-compatible caching system

  • Metrics: OpenTelemetry-compatible performance monitoring

  • Search: Full-text search with inverted indexing

  • Synthesis: Intelligent response aggregation

Related MCP server: HydraMCP

๐Ÿš€ Quick Start

๐Ÿ“– New to MCP? Check out our Quick Start Guide for a 5-minute setup!

Prerequisites

  • Node.js 18.0.0 or higher

  • pnpm 8.0.0 or higher

  • TypeScript 5.3.0 or higher

Installation

# Clone the repository
git clone https://github.com/atsuki-sakai/ai_collaboration_mcp_server.git
cd ai_collaboration_mcp_server

# Install dependencies
pnpm install

# Build the project
pnpm run build

# Run tests
pnpm test

Configuration

  1. Environment Variables:

    # Required: Set your API keys
export DEEPSEEK_API_KEY="your-deepseek-api-key"
export OPENAI_API_KEY="your-openai-api-key"
export ANTHROPIC_API_KEY="your-anthropic-api-key"

# Optional: Configure other settings
export MCP_DEFAULT_PROVIDER="deepseek"
export MCP_PROTOCOL="stdio"

  2. Configuration Files:

    • config/default.yaml: Default configuration

    • config/development.yaml: Development settings

    • config/production.yaml: Production settings

Running the Server

# Start with default settings
pnpm start

# Start with specific protocol
node dist/index.js --protocol stdio

# Start with custom providers
node dist/index.js --providers deepseek,openai --default-provider deepseek

# Enable debug mode
NODE_ENV=development LOG_LEVEL=debug pnpm start

๐Ÿ”— Claude Code Integration

Connecting to Claude Code

To use this MCP server with Claude Code, you need to configure Claude Code to recognize and connect to your server.

1. Automated Setup (Recommended)

Use the automated setup script for easy configuration:

# Navigate to your project directory
cd /Users/atsukisakai/Desktop/ai_collaboration_mcp_server

# Run automated setup with your DeepSeek API key
./scripts/setup-claude-code.sh --api-key "your-deepseek-api-key"

# Or with multiple providers
./scripts/setup-claude-code.sh \
  --api-key "your-deepseek-key" \
  --openai-key "your-openai-key" \
  --anthropic-key "your-anthropic-key"

# Alternative using pnpm
pnpm run setup:claude-code -- --api-key "your-deepseek-key"

The setup script will:

  • โœ… Build the MCP server

  • โœ… Create Claude Code configuration file

  • โœ… Test the server connection

  • โœ… Provide next steps

1b. Manual Setup

If you prefer manual setup:

# Navigate to your project directory
cd /Users/atsukisakai/Desktop/ai_collaboration_mcp_server

# Install dependencies and build
pnpm install
pnpm run build

# Set your DeepSeek API key
export DEEPSEEK_API_KEY="your-deepseek-api-key"

# Test the server
pnpm run verify-deepseek

2. Configure Claude Code

Create or update the Claude Code configuration file:

Note: There are two server options:

  • simple-server.js - Simple implementation with DeepSeek only (recommended for testing)

  • index.js - Full implementation with all providers and features

macOS/Linux:

# Create config directory if it doesn't exist
mkdir -p ~/.config/claude-code

# Create configuration file (simple server - recommended for testing)
cat > ~/.config/claude-code/claude_desktop_config.json << 'EOF'
{
  "mcpServers": {
    "ai-collaboration": {
      "command": "node",
      "args": ["/Users/atsukisakai/Desktop/ai_collaboration_mcp_server/dist/simple-server.js"],
      "env": {
        "DEEPSEEK_API_KEY": "your-deepseek-api-key"
      }
    }
  }
}
EOF

# Or use the full server for all features
# Replace simple-server.js with index.js in the args above

Windows:

# Create config directory
mkdir "%APPDATA%\Claude"

# Create configuration file (use your preferred text editor)
# File: %APPDATA%\Claude\claude_desktop_config.json

3. Configuration Options

{
  "mcpServers": {
    "ai-collaboration": {
      "command": "node",
      "args": [
        "/Users/atsukisakai/Desktop/ai_collaboration_mcp_server/dist/index.js",
        "--default-provider", "deepseek",
        "--providers", "deepseek,openai"
      ],
      "env": {
        "DEEPSEEK_API_KEY": "your-deepseek-api-key",
        "OPENAI_API_KEY": "your-openai-api-key",
        "ANTHROPIC_API_KEY": "your-anthropic-api-key",
        "NODE_ENV": "production",
        "LOG_LEVEL": "info",
        "MCP_DISABLE_CACHING": "false",
        "MCP_DISABLE_METRICS": "false"
      }
    }
  }
}

4. Available Tools in Claude Code

After restarting Claude Code, you'll have access to these powerful tools:

  • ๐Ÿค collaborate - Multi-provider AI collaboration

  • ๐Ÿ“ review - Content analysis and quality assessment

  • โš–๏ธ compare - Side-by-side comparison of multiple items

  • โœจ refine - Iterative content improvement

5. Usage Examples in Claude Code

# Use DeepSeek for code explanation
Please use the collaborate tool to explain this Python code with DeepSeek

# Review code quality
Use the review tool to analyze the quality of this code

# Compare multiple solutions
Use the compare tool to compare these 3 approaches to solving this problem

# Improve code iteratively
Use the refine tool to make this function more efficient

6. Troubleshooting

Check MCP server connectivity:

# Test if the server starts correctly
DEEPSEEK_API_KEY="your-key" node dist/index.js --help

View logs:

# Check application logs
tail -f logs/application-$(date +%Y-%m-%d).log

Verify Claude Code configuration:

  1. Restart Claude Code completely

  2. In a new conversation, ask "What tools are available?"

  3. You should see the four MCP tools listed

  4. Test with a simple command like "Use collaborate to say hello"

7. Configuration File Locations

  • macOS: ~/.config/claude-code/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

  • Linux: ~/.config/claude-code/claude_desktop_config.json

๐Ÿ“– Usage

MCP Tools

Collaborate Tool

Execute multi-provider collaboration with strategy selection:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "collaborate",
    "arguments": {
      "prompt": "Explain quantum computing in simple terms",
      "strategy": "consensus",
      "providers": ["deepseek", "openai"],
      "config": {
        "timeout": 30000,
        "consensus_threshold": 0.7
      }
    }
  }
}

Review Tool

Analyze content quality and provide detailed feedback:

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "review",
    "arguments": {
      "content": "Your content here...",
      "criteria": ["accuracy", "clarity", "completeness"],
      "review_type": "comprehensive"
    }
  }
}

Compare Tool

Compare multiple items with detailed analysis:

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "compare",
    "arguments": {
      "items": [
        {"id": "1", "content": "Option A"},
        {"id": "2", "content": "Option B"}
      ],
      "comparison_dimensions": ["quality", "relevance", "innovation"]
    }
  }
}

Refine Tool

Iteratively improve content quality:

{
  "jsonrpc": "2.0",
  "id": 4,
  "method": "tools/call",
  "params": {
    "name": "refine",
    "arguments": {
      "content": "Content to improve...",
      "refinement_goals": {
        "primary_goal": "clarity",
        "target_audience": "general public"
      }
    }
  }
}

Available Resources

  • collaboration_history: Access past collaboration results

  • provider_stats: Monitor provider performance metrics

  • tool_usage: Track tool utilization statistics

๐Ÿ—๏ธ Architecture

Core Components

src/
โ”œโ”€โ”€ core/                    # Core framework components
โ”‚   โ”œโ”€โ”€ types.ts            # Dependency injection symbols
โ”‚   โ”œโ”€โ”€ logger.ts           # Structured logging
โ”‚   โ”œโ”€โ”€ config.ts           # Configuration management
โ”‚   โ”œโ”€โ”€ container.ts        # DI container setup
โ”‚   โ”œโ”€โ”€ provider-manager.ts # AI provider orchestration
โ”‚   โ”œโ”€โ”€ strategy-manager.ts # Execution strategy management
โ”‚   โ””โ”€โ”€ tool-manager.ts     # MCP tool management
โ”œโ”€โ”€ providers/              # AI provider implementations
โ”‚   โ”œโ”€โ”€ base-provider.ts    # Common provider functionality
โ”‚   โ”œโ”€โ”€ deepseek-provider.ts
โ”‚   โ”œโ”€โ”€ openai-provider.ts
โ”‚   โ”œโ”€โ”€ anthropic-provider.ts
โ”‚   โ””โ”€โ”€ o3-provider.ts
โ”œโ”€โ”€ strategies/             # Collaboration strategies
โ”‚   โ”œโ”€โ”€ parallel-strategy.ts
โ”‚   โ”œโ”€โ”€ sequential-strategy.ts
โ”‚   โ”œโ”€โ”€ consensus-strategy.ts
โ”‚   โ””โ”€โ”€ iterative-strategy.ts
โ”œโ”€โ”€ tools/                  # MCP tool implementations
โ”‚   โ”œโ”€โ”€ collaborate-tool.ts
โ”‚   โ”œโ”€โ”€ review-tool.ts
โ”‚   โ”œโ”€โ”€ compare-tool.ts
โ”‚   โ””โ”€โ”€ refine-tool.ts
โ”œโ”€โ”€ services/               # Enterprise services
โ”‚   โ”œโ”€โ”€ cache-service.ts
โ”‚   โ”œโ”€โ”€ metrics-service.ts
โ”‚   โ”œโ”€โ”€ search-service.ts
โ”‚   โ””โ”€โ”€ synthesis-service.ts
โ”œโ”€โ”€ server/                 # MCP server implementation
โ”‚   โ””โ”€โ”€ mcp-server.ts
โ””โ”€โ”€ types/                  # Type definitions
    โ”œโ”€โ”€ common.ts
    โ”œโ”€โ”€ interfaces.ts
    โ””โ”€โ”€ index.ts

Design Principles

  • Dependency Injection: Clean architecture with InversifyJS

  • Strategy Pattern: Pluggable collaboration strategies

  • Provider Abstraction: Unified interface for different AI services

  • Performance: Efficient caching and rate limiting

  • Observability: Comprehensive metrics and logging

  • Extensibility: Easy to add new providers and strategies

๐Ÿ”ง Configuration

Configuration Schema

The server uses YAML configuration files with JSON Schema validation. See config/schema.json for the complete schema.

Key Configuration Sections

  • Server: Basic server settings (name, version, protocol)

  • Providers: AI provider configurations and credentials

  • Strategies: Strategy-specific settings and timeouts

  • Cache: Caching behavior (memory, Redis, file)

  • Metrics: Performance monitoring settings

  • Logging: Log levels and output configuration

Environment Variables

Variable

Description

Default

DEEPSEEK_API_KEY

DeepSeek API key

Required

OPENAI_API_KEY

OpenAI API key

Optional

ANTHROPIC_API_KEY

Anthropic API key

Optional

O3_API_KEY

O3 API key (defaults to OPENAI_API_KEY)

Optional

MCP_PROTOCOL

Transport protocol

stdio

MCP_DEFAULT_PROVIDER

Default AI provider

deepseek

NODE_ENV

Environment mode

production

LOG_LEVEL

Logging level

info

๐Ÿ“Š Monitoring & Metrics

Built-in Metrics

  • Request Metrics: Response times, success rates, error counts

  • Provider Metrics: Individual provider performance

  • Tool Metrics: Usage statistics per MCP tool

  • Cache Metrics: Hit rates, memory usage

  • System Metrics: CPU, memory, and resource utilization

OpenTelemetry Integration

The server supports OpenTelemetry for distributed tracing and metrics collection:

metrics:
  enabled: true
  export:
    enabled: true
    format: "opentelemetry"
    endpoint: "http://localhost:4317"

๐Ÿงช Testing

Test Coverage

  • Unit Tests: 95+ individual component tests

  • Integration Tests: End-to-end MCP protocol testing

  • E2E Tests: Complete workflow validation

  • API Tests: Direct provider API validation

Running Tests

# Run all tests
pnpm test

# Run with coverage
pnpm run test:coverage

# Run specific test suites
pnpm run test:unit
pnpm run test:integration
pnpm run test:e2e

# Verify API connectivity
pnpm run verify-deepseek

๐Ÿšข Deployment

Docker

# Build image
docker build -t claude-code-ai-collab-mcp .

# Run container
docker run -d \
  -e DEEPSEEK_API_KEY=your-key \
  -p 3000:3000 \
  claude-code-ai-collab-mcp

Production Considerations

  • Load Balancing: Multiple server instances for high availability

  • Caching: Redis for distributed caching

  • Monitoring: Prometheus/Grafana for metrics visualization

  • Security: API key rotation and rate limiting

  • Backup: Regular configuration and data backups

๐Ÿค Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

Development Setup

# Fork and clone the repository
git clone https://github.com/atsuki-sakai/ai_collaboration_mcp_server.git
cd ai_collaboration_mcp_server

# Install dependencies
pnpm install

# Start development
pnpm run dev

# Run tests
pnpm test

# Lint and format
pnpm run lint
pnpm run lint:fix

๐Ÿ“‹ Roadmap

Version 1.1

  • GraphQL API support

  • WebSocket transport protocol

  • Advanced caching strategies

  • Custom strategy plugins

Version 1.2

  • Multi-tenant support

  • Enhanced security features

  • Performance optimizations

  • Additional AI providers

Version 2.0

  • Distributed architecture

  • Advanced workflow orchestration

  • Machine learning optimization

  • Enterprise SSO integration

๐Ÿ“„ License

This project is licensed under the MIT License - see the LICENSE file for details.

๐Ÿ†˜ Support

๐Ÿ™ Acknowledgments

Built with โค๏ธ by the Claude Code AI Collaboration Team# think_hub

Available Tools

4 tools
collaborateC

Collaborate with multiple AI providers to solve complex problems

ParametersJSON Schema
NameRequiredDescriptionDefault
promptNoThe question or task to collaborate on
strategyNoCollaboration strategy
providersNoSpecific providers to use
configNoStrategy-specific configuration
contextNoAdditional context for collaboration

TDQS

C2.7/5.0
Behavior2/5

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It mentions collaboration to 'solve complex problems' but doesn't describe how the tool behavesโ€”e.g., whether it makes external API calls, handles errors, requires authentication, has rate limits, or returns structured outputs. This leaves critical operational traits unspecified for a tool with 5 parameters and nested objects.

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, efficient sentence that states the core purpose without waste. It's appropriately sized for a tool with this complexity and is front-loaded with the main action. Every word earns its place, making it easy to parse quickly.

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 5 parameters, nested objects, no annotations, and no output schema, the description is incomplete. It doesn't explain return values, error handling, or the collaboration mechanism, leaving gaps for a tool that likely involves significant complexity. The description should provide more context to guide effective use beyond the basic schema.

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 parameters like 'prompt', 'strategy', 'providers', 'config', and 'context' are documented in the schema. The description adds no additional meaning beyond the schema, such as explaining how strategies differ or what 'complex problems' entail. Baseline 3 is appropriate as the schema does the heavy lifting, but the description doesn't compensate with extra insights.

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

Purpose3/5

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

The description states the tool 'collaborate[s] with multiple AI providers to solve complex problems', which provides a general purpose but lacks specificity about what collaboration entails. It distinguishes from siblings like 'compare', 'refine', and 'review' by focusing on multi-provider collaboration, but doesn't specify the verb+resource combination clearly (e.g., whether it orchestrates calls, aggregates responses, or something else).

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 offers no guidance on when to use this tool versus its siblings ('compare', 'refine', 'review'). It implies usage for 'complex problems' with 'multiple AI providers', but doesn't specify scenarios, prerequisites, or exclusions. Without explicit alternatives or context, the agent must infer usage based on tool names alone.

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

compareC

Compare multiple items using AI analysis across various dimensions

ParametersJSON Schema
NameRequiredDescriptionDefault
itemsNoItems to compare
comparison_typeNoType of comparison
criteriaNoComparison criteria and weights
analysis_depthNoDepth of analysis
output_formatNoOutput format
comparersNoComparer configuration

TDQS

C2.9/5.0
Behavior2/5

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 'AI analysis' but doesn't specify what that entailsโ€”such as whether it's a read-only operation, if it requires specific permissions, potential rate limits, or what the output looks like. For a tool with 6 parameters and no annotations, this leaves significant behavioral gaps.

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, efficient sentence that front-loads the core purpose without unnecessary words. Every part earns its place by clearly stating what the tool does, making it easy to scan and understand quickly.

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 complexity (6 parameters, nested objects, no output schema, and no annotations), the description is incomplete. It lacks details on output format, error handling, or practical use cases, which are crucial for an AI agent to invoke this tool effectively. The high parameter count and absence of output schema increase the need for more contextual information.

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 thoroughly. The description adds no additional meaning beyond the schemaโ€”it doesn't explain parameter interactions, default behaviors, or practical examples. This meets the baseline of 3, as the schema does the heavy lifting, but the description doesn't compensate or enhance understanding.

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's purpose: 'Compare multiple items using AI analysis across various dimensions.' It specifies the verb ('compare'), resource ('multiple items'), and method ('AI analysis across various dimensions'). However, it doesn't explicitly differentiate from sibling tools like 'collaborate', 'refine', or 'review', which prevents a perfect score.

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. There's no mention of specific scenarios, prerequisites, or comparisons with sibling tools like 'collaborate', 'refine', or 'review'. The agent must infer usage from the purpose alone, which is insufficient for optimal tool selection.

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

refineC

Iteratively refine and improve content through AI-powered analysis and enhancement

ParametersJSON Schema
NameRequiredDescriptionDefault
contentNoContent to refine
refinement_goalsNoGoals and objectives for refinement
refinement_scopeNoScope and constraints for changes
refinement_processNoProcess configuration and preferences
quality_criteriaNoQuality thresholds and metrics

TDQS

C2.6/5.0
Behavior2/5

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

No annotations are provided, so the description carries full burden. It mentions 'iteratively refine' and 'AI-powered analysis and enhancement', which hints at a process-oriented, non-destructive operation, but fails to disclose critical behavioral traits such as whether changes are reversible, authentication needs, rate limits, or expected output format. This leaves significant gaps for a tool with complex parameters.

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, efficient sentence that front-loads the core purpose ('iteratively refine and improve content'). It avoids redundancy and waste, though it could be slightly more structured for clarity. Every word earns its place, making it appropriately concise.

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 complexity (5 parameters with nested objects, no output schema, and no annotations), the description is incomplete. It doesn't explain what 'refine' entails operationally, what the output might look like, or how iterative processes work. For a tool with rich input schema but no other structured data, 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.

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 5 parameters (e.g., 'content', 'refinement_goals'). The description adds no specific meaning beyond the schema, such as examples of goals or scope. With high schema coverage, the baseline is 3, as the description doesn't compensate but doesn't detract either.

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

Purpose3/5

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

The description states the tool 'iteratively refine and improve content through AI-powered analysis and enhancement', which provides a general purpose but lacks specificity about what 'content' means or how refinement differs from sibling tools like 'review' or 'compare'. It's not tautological but remains vague about the exact resource and scope.

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 like 'collaborate', 'compare', or 'review'. The description implies usage for content improvement but offers no context, exclusions, or prerequisites, leaving the agent without direction on tool selection.

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

reviewC

Get comprehensive reviews of content from multiple AI perspectives

ParametersJSON Schema
NameRequiredDescriptionDefault
contentNoContent to review
review_typeNoType of review to conduct
criteriaNoReview criteria and constraints
reviewersNoReviewer configuration
output_formatNoFormat for review output

TDQS

C2.9/5.0
Behavior2/5

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'comprehensive reviews' and 'multiple AI perspectives', which hints at the tool's approach, but doesn't describe what happens during execution (e.g., whether it's read-only, if it modifies content, response format, latency, or any limitations). For a tool with 5 parameters and no annotations, this is insufficient behavioral 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, efficient sentence that gets straight to the point. Every word contributes meaning: 'Get' (action), 'comprehensive reviews' (scope), 'of content' (target), 'from multiple AI perspectives' (method). There's no wasted verbiage or redundant information.

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?

For a tool with 5 parameters (including nested objects), no annotations, and no output schema, the description is inadequate. It doesn't explain what 'comprehensive reviews' means in practice, what the output looks like, or how the 'multiple AI perspectives' are implemented. The agent would struggle to understand the tool's behavior and results without additional context.

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 all parameters are documented in the schema. The description doesn't add any specific parameter information beyond what's in the schema. It mentions 'comprehensive reviews' which aligns with parameters like 'review_type' and 'criteria', but provides no additional syntax, format, or usage details for parameters.

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 verb ('Get') and resource ('comprehensive reviews of content'), specifying what the tool does. It adds 'from multiple AI perspectives' which provides useful context about the approach. However, it doesn't explicitly distinguish this from sibling tools like 'collaborate', 'compare', or 'refine', which might offer related functionality.

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 the sibling tools ('collaborate', 'compare', 'refine'). It doesn't mention any prerequisites, constraints, or alternative scenarios. The phrase 'comprehensive reviews' implies breadth but doesn't specify when this is preferred over more focused approaches.

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

Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3/5.0
Disambiguation4/5

The tools have distinct primary purposes: collaboration, comparison, refinement, and review. However, there is some conceptual overlap between 'refine' (iterative improvement) and 'review' (comprehensive analysis), which could cause mild confusion in tool selection for certain tasks.

Naming Consistency5/5

All tool names follow a consistent verb-only pattern (collaborate, compare, refine, review), with no mixing of conventions or styles. This makes the tool set predictable and easy to navigate.

Tool Count3/5

With only 4 tools, the server feels slightly thin for its broad purpose of 'AI collaboration and analysis.' While each tool covers a distinct function, the scope suggests more granular operations (e.g., specific analysis types or collaboration modes) might be missing, making it borderline appropriate.

Completeness3/5

The tools cover high-level AI collaboration and analysis functions, but there are notable gaps in the surface. For example, there are no tools for managing collaboration sessions, saving/loading analyses, or handling specific data types, which limits workflow completeness for the domain.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

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/atsuki-sakai/ai_collaboration_mcp_server'

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