Claude (Anthropic) Integration

Claude (Anthropic) Integration

Integrate Dispersl with Claude through Model Context Protocol (MCP) to enhance Claude's capabilities with multi-agent development workflows and specialized AI agents.

What You'll Get

With Dispersl integrated into Claude, you can:

Access multi-agent coordination directly through Claude conversations
Generate complex software projects with specialized AI agents
Create comprehensive development workflows beyond Claude's built-in capabilities
Manage Git operations and version control through AI
Generate documentation and tests automatically
Coordinate between multiple specialized agents for complex tasks

Prerequisites

Claude account (Claude Pro recommended for advanced features)
Active Dispersl account with API access
Dispersl MCP key (obtained from your dashboard)

Setup Instructions

Step 1: Get Your Dispersl MCP Key

Obtain your Dispersl MCP key from your dashboard:

Log into your Dispersl dashboard
Navigate to Settings → MCP Integration
Generate a new MCP key or copy your existing key
Keep this key secure for configuration

Or via API:

curl -X GET "https://api.dispersl.com/v1/mcp/key" \
  -H "Authorization: Bearer YOUR_DISPERSL_API_KEY"

Step 2: Configure Claude Desktop

To add Dispersl to Claude Desktop:

Open Claude Desktop
Click Claude from the menu bar
Click on the "Settings" tab
Click on the "Developer" tab
Click "Edit Config"

Add the following code to your claude_desktop_config.json file:

{
  "mcpServers": {
    "dispersl": {
      "command": "npx",
      "args": [
        "-y",
        "@dispersl/mcp-gateway",
        "--sse",
        "https://mcp.dispersl.com/YOUR_DISPERSL_MCP_KEY"
      ]
    }
  }
}

Important: Replace YOUR_DISPERSL_MCP_KEY with your actual Dispersl MCP key from the dashboard.

Restart Claude Desktop to apply the changes

You should see the hammer icon with the number of tools connected, indicating that Dispersl agents are now available.

Step 3: Configure Claude Web (Browser)

For Claude web interface with browser extensions:

Install the MCP Bridge extension (if available)
Configure the extension with your Dispersl MCP key
Enable Dispersl integration in the extension settings

Step 4: Configure Claude API Integration

For developers using Claude API with MCP:

import anthropic
from dispersl_mcp import DispersalMCPClient
 
# Initialize Claude client
claude = anthropic.Anthropic(api_key="your-claude-api-key")
 
# Initialize Dispersl MCP client
dispersl = DispersalMCPClient(mcp_key="your-dispersl-mcp-key")
 
# Use both together
def enhanced_claude_request(prompt):
    # First, check if Dispersl agents can help
    if "build" in prompt.lower() or "create" in prompt.lower():
        # Use Dispersl for complex development tasks
        result = dispersl.coordinate_agents(prompt)
        return result
    else:
        # Use Claude for general conversation
        response = claude.messages.create(
            model="claude-3-sonnet-20240229",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.content

Verification

After setup, you should be able to see the Dispersl tools in the tools menu. To verify your connection is working, try using the following command in Claude Desktop:

Check my Dispersl integrations

Claude should respond with information about your connected Dispersl agents and available capabilities.

You can also test multi-agent coordination:

Use Dispersl to plan a complete web application with authentication, database, and tests

If successful, Claude will show available Dispersl agents and coordinate multi-agent workflows.

Using Dispersl with Claude

Multi-Agent Project Planning

Complex Application Development

I need to build a complete e-commerce platform. Can you use Dispersl to:
1. Plan the overall architecture
2. Generate the backend API
3. Create the frontend components
4. Set up comprehensive testing
5. Configure deployment pipelines
6. Generate documentation

Please coordinate the appropriate Dispersl agents for each task.

Microservices Architecture

Use Dispersl to design and implement a microservices architecture for a social media platform with:
- User service (authentication, profiles)
- Post service (content management)
- Notification service (real-time updates)
- API gateway and service discovery
- Docker containerization
- Kubernetes deployment configs

Code Generation and Testing

Full-Stack Development

Dispersl: Create a task management application with:
- React TypeScript frontend
- Node.js Express backend
- PostgreSQL database with Prisma
- JWT authentication
- Real-time updates with WebSockets
- Comprehensive test coverage
- CI/CD pipeline setup

API Development

Use Dispersl Code Agent to build a REST API for a blog platform with:
- CRUD operations for posts and comments
- User authentication and authorization
- File upload for images
- Search functionality
- Rate limiting and security middleware
- OpenAPI documentation

Testing and Quality Assurance

Comprehensive Testing Setup

Dispersl Test Agent: Set up complete testing infrastructure for my existing Node.js application:
- Unit tests with Jest (90%+ coverage)
- Integration tests for all API endpoints
- End-to-end tests with Playwright
- Performance testing with Artillery
- Security testing setup
- Automated test reporting

Version Control and DevOps

Git Workflow Management

Dispersl Git Agent: Help me set up a professional Git workflow for my team:
- Feature branch strategy
- Automated code review checks
- Commit message standards
- Release management
- Hotfix procedures
- Integration with GitHub Actions

CI/CD Pipeline Setup

Use Dispersl to create a complete CI/CD pipeline with:
- Automated testing on pull requests
- Code quality checks (ESLint, Prettier)
- Security scanning
- Docker image building
- Deployment to staging and production
- Rollback procedures

Documentation Generation

Project Documentation

Dispersl Docs Agent: Generate comprehensive documentation for my project:
- API reference with examples
- Setup and installation guide
- Architecture overview
- Contributing guidelines
- Troubleshooting guide
- Deployment instructions

Advanced Configuration

Custom Agent Settings

Configure specific agents for your workflow:

{
  "mcpServers": {
    "dispersl": {
      "command": "npx",
      "args": ["dispersl-mcp"],
      "env": {
        "DISPERSL_MCP_KEY": "YOUR_DISPERSL_MCP_KEY",
        "DISPERSL_DEFAULT_MODEL": "anthropic/claude-3-sonnet",
        "DISPERSL_CODE_AGENT_MODEL": "anthropic/claude-3-sonnet",
        "DISPERSL_TEST_AGENT_MODEL": "openai/gpt-4",
        "DISPERSL_GIT_AGENT_MODEL": "deepseek/deepseek-r1"
      }
    }
  }
}

Project-Specific Configuration

Set up different configurations for different project types:

{
  "mcpServers": {
    "dispersl-web": {
      "command": "npx",
      "args": ["dispersl-mcp", "--profile", "web"],
      "env": {
        "DISPERSL_MCP_KEY": "YOUR_DISPERSL_MCP_KEY",
        "DISPERSL_FOCUS": "frontend,backend,testing"
      }
    },
    "dispersl-mobile": {
      "command": "npx",
      "args": ["dispersl-mcp", "--profile", "mobile"],
      "env": {
        "DISPERSL_MCP_KEY": "YOUR_DISPERSL_MCP_KEY",
        "DISPERSL_FOCUS": "mobile,testing,deployment"
      }
    }
  }
}

Best Practices

Effective Prompting

Be specific about agent roles: Mention which Dispersl agent you want to use
Provide clear requirements: Include technical specifications and constraints
Use structured requests: Break complex tasks into clear steps
Include context: Provide relevant project information and existing code

Workflow Optimization

Start with planning: Use the Plan Agent for complex projects
Coordinate agents: Let multiple agents work together on large tasks
Monitor progress: Track agent coordination and task completion
Iterate and refine: Use feedback to improve agent performance

Security and Privacy

Secure MCP keys: Never share or expose your MCP keys
Environment variables: Use secure environment variable storage
Access control: Limit MCP key permissions as needed
Regular rotation: Update MCP keys periodically

Troubleshooting

Common Issues

"Dispersl agents not available"

Verify your MCP key is correct and active
Check that the dispersl-mcp package is installed
Restart Claude Desktop after configuration changes
Verify your Dispersl account has sufficient credits

"Agent coordination failed"

Check your internet connection
Verify Dispersl service status
Review your usage limits and quotas
Check for any API rate limiting

Configuration errors

Validate JSON syntax in configuration files
Ensure file paths and permissions are correct
Check environment variable names and values
Verify the dispersl-mcp package version

Getting Help

Check Claude's developer tools for error messages
Review Dispersl logs in your dashboard
Test individual agents to isolate issues
Community support: Join our Discord for help
Documentation: Review the complete MCP integration guide

Example Workflows

Startup MVP Development

I'm building an MVP for a food delivery app. Use Dispersl to:

1. Plan Agent: Create a comprehensive development plan
2. Code Agent: Build the backend API with user auth, restaurant management, and order processing
3. Code Agent: Create a React Native mobile app
4. Test Agent: Generate comprehensive test suites
5. Git Agent: Set up version control and branching strategy
6. Docs Agent: Create API documentation and user guides

Please coordinate all agents and provide regular progress updates.

Legacy System Modernization

Help me modernize a legacy PHP application using Dispersl:

1. Analyze the existing codebase structure
2. Plan a migration strategy to Node.js/TypeScript
3. Create a new API layer with proper architecture
4. Set up comprehensive testing for the new system
5. Plan a gradual migration approach
6. Generate documentation for the new architecture

Use appropriate Dispersl agents for each phase.

Open Source Project Setup

Dispersl: Help me set up a new open source project with:

- Clean, well-documented codebase
- Comprehensive testing and CI/CD
- Contribution guidelines and templates
- Issue and PR templates
- Security policies and code of conduct
- Documentation website
- Package publishing setup

Coordinate multiple agents to create a professional open source project.

Next Steps

Complete the setup following the instructions above
Test the integration with simple tasks
Explore multi-agent coordination for complex projects
Customize agent configurations for your workflow
Scale up to production projects with confidence

Ready to enhance Claude with Dispersl's multi-agent AI development platform!

Zed