Content
# Solo MCP - Intelligent Multi-Role Collaboration Platform
[](https://python.org)
[](LICENSE)
[](https://pypi.org/project/solo-mcp/)
[](tests/)
[](https://github.com/psf/black)
[](CONTRIBUTING.md)
An intelligent multi-role collaboration system based on Model Context Protocol (MCP), which enhances project development efficiency by simulating collaboration among different professional roles. Solo MCP enables solo developers to harness the wisdom of team collaboration, achieving higher quality software development.
## ✨ Core Features
### 🎭 Intelligent Role System
- **Multi-role Simulation**: Smartly simulates professional roles such as product manager, architect, developer, and test engineer.
- **Dynamic Role Assignment**: Automatically selects the most suitable combination of roles based on task type.
- **Role Collaboration**: Intelligent dialogue and decision negotiation among different roles.
### 🧠 Advanced Memory Management
- **Persistent Storage**: Long-term memory and quick retrieval of project knowledge
- **Context Awareness**: Intelligent recommendation of relevant historical information based on the current task
- **Learning Ability**: Learning best practices and common patterns from project history
### 🔄 Intelligent Task Orchestration
- **Automatic Task Decomposition**: Break down complex projects into manageable sub-tasks
- **Conflict Detection**: Identify and resolve potential conflicts between tasks
- **Priority Management**: Smartly prioritize tasks based on project goals
### 📊 Comprehensive Context Analysis
- **Code Understanding**: In-depth analysis of project structure, dependencies, and code quality
- **Documentation Parsing**: Automatic extraction and organization of project documentation information
- **Environment Awareness**: Identification of development environment, toolchain, and configuration
### 🚀 Standardized Integration
- **MCP Protocol**: Based on the Model Context Protocol standard to ensure compatibility
- **Plugin Architecture**: Supports custom tools and extensions
- **API Friendly**: Provides a complete REST API and Python SDK
## 🚀 Quick Start
### Environment Requirements
- Python 3.11+
- 8GB+ RAM (recommended)
- Supported operating systems: Windows, macOS, Linux
### Installation
#### Method 1: Install from PyPI (Recommended)
```bash
# Install Solo MCP
pip install solo-mcp
# Verify Installation
solo-mcp --version
# Starting the MCP Server
solo-mcp-server
```
#### Method 2: Install from Source
```bash
# Clone the Project
git clone https://github.com/CHANGGELY/solo-mcp.git
cd solo-mcp
# Create a Virtual Environment (Recommended to use Python 3.11)
python -m venv venv311
# Activate Virtual Environment
# Windows
venv311\Scripts\activate
# macOS/Linux
source venv311/bin/activate
# Upgrade pip
python -m pip install --upgrade pip
# Install Dependencies
pip install -r requirements.txt
# Install Interactive Feedback Enhanced MCP
pip install mcp-feedback-enhanced
# Verify Installation
```bash
python -m pytest tests/test_basic.py
```
### Basic Usage
```bash
```
# View Version Information
solo-mcp --version
# Start Solo MCP Server
solo-mcp-server
# Start the Server with Configuration
solo-mcp --server --config custom_config.toml
# Or run from source
python -m solo_mcp
# Run Interactive Example
```bash
python examples/demo.py
```
## 📖 Usage Example
### 1. Role Planning Example
```python
from solo_mcp.tools.roles import RolesTool
```
# Create Role Tool
roles_tool = RolesTool()
# Roles Needed for the Evaluation Project
```python
result = roles_tool.evaluate(
goal="Develop an e-commerce website",
stack="Python, FastAPI, React, PostgreSQL"
)
print(result) # Output the recommended roles list
```
### 2. Task Assignment Example
```python
from solo_mcp.config import SoloConfig
from solo_mcp.tools.orchestrator import OrchestratorTool
```
# Load Configuration
config = SoloConfig.load()
# Create Orchestrator Tool
orchestrator = OrchestratorTool(config)
# Running a Round of Collaboration
```python
result = orchestrator.run_round(
goal="Implement user authentication feature",
stack="Python, FastAPI, JWT"
)
print(result) # Output the task assignment and execution results
```
### 3. Memory Management Example
```python
from solo_mcp.config import SoloConfig
from solo_mcp.tools.memory import MemoryTool
```
# Load Configuration
config = SoloConfig.load()
# Create Memory Tool
memory_tool = MemoryTool(config)
# Storing Project Information
memory_id = memory_tool.store(
content="User authentication uses JWT token mechanism",
memory_type="technical",
context={"module": "authentication", "priority": "high"}
)
# Retrieve Relevant Information
result = memory_tool.load(
query="JWT认证 (JWT Authentication)",
memory_type="technical"
)
print(f"Found {len(result)} relevant memories")
## 🏗️ Project Structure
```
solo_mcp/
├── tools/ # Core tools module
│ ├── roles.py # Role planning and management
│ ├── orchestrator.py # Multi-role task orchestration
│ ├── memory.py # Intelligent memory management
│ ├── context.py # Context collection and processing
│ ├── learning.py # Learning engine
│ ├── adaptive.py # Adaptive optimizer
│ └── __init__.py
├── config.py # Configuration management
├── server.py # MCP Server
├── main.py # Main entry file
└── __init__.py
tests/ # Test files
├── test_basic.py # Basic functionality tests
├── test_roles.py # Role system tests
├── test_orchestrator.py # Orchestration system tests
├── test_memory.py # Memory system tests
└── test_context.py # Context system tests
memory/ # Persistent memory storage
├── memories/ # Memory data files
├── cache/ # Cache files
└── index/ # Index files
examples/ # Usage examples
├── demo.py # Basic demonstration
├── advanced_usage.py # Advanced usage
└── integration_test.py # Integration tests
docs/ # Documentation
├── api.md # API documentation
├── architecture.md # Architecture description
└── deployment.md # Deployment guide
```
## 🧪 Running Tests
```bash
# Run All Tests
pytest
# Run Specific Test File
pytest tests/test_roles.py
# Run Tests and Display Coverage
```bash
pytest --cov=solo_mcp
```
## 🔧 Configuration
The project supports configuration through environment variables and configuration files:
### Environment Variable Configuration
```bash
# Set Memory Storage Path
export SOLO_MCP_MEMORY_PATH="./custom_memory"
# Set Log Level
export SOLO_MCP_LOG_LEVEL="DEBUG"
# Set Cache Size
export SOLO_MCP_CACHE_SIZE="1000"
# Set Maximum Memory Count
export SOLO_MCP_MAX_MEMORIES="10000"
# Set Learning Engine Switch
export SOLO_MCP_ENABLE_LEARNING="true"
```
### Configuration File
Create a `config.json` file for detailed configuration:
```json
{
"memory": {
"max_memories": 10000,
"cache_size": 1000,
"enable_learning": true,
"relevance_threshold": 0.3
},
"orchestrator": {
"max_concurrent_tasks": 5,
"conflict_detection": true,
"auto_optimization": true
},
"roles": {
"default_roles": ["analyst", "developer", "designer", "tester"],
"enable_dynamic_roles": true
}
}
```
#### Integrating Interactive Feedback Enhanced MCP
Add the `mcpServers` configuration in `config.json` to enable the interactive feedback enhanced MCP:
```json
"mcpServers": {
"mcp-feedback-enhanced": {
"command": "uvx",
"args": ["mcp-feedback-enhanced@latest"],
"timeout": 600,
"autoApprove": ["interactive_feedback"]
}
}
```
> Note: The `autoApprove` list of tools can be adjusted as needed for automatic approval.
## 🤝 Contribution Guidelines
We welcome all forms of contributions! Whether it's reporting bugs, suggesting new features, or submitting code improvements.
### Development Environment Setup
1. **Fork and Clone the Repository**
```bash
git clone https://github.com/your-username/solo-mcp.git
cd solo-mcp
```
2. **Set Up the Development Environment**
```bash
# Create a virtual environment
python -m venv venv311
source venv311/bin/activate # Linux/macOS
# or venv311\Scripts\activate # Windows
# Install development dependencies
pip install -r requirements.txt
pip install -r requirements-dev.txt # if it exists
# Install pre-commit hooks
pre-commit install
```
3. **Run Tests**
```bash
# Run all tests
python -m pytest
# Run specific tests
python -m pytest tests/test_basic.py
# Generate coverage report
python -m pytest --cov=solo_mcp --cov-report=html
```
### Contribution Process
1. **Create an Issue**
- Report bugs or suggest new features
- Use the appropriate Issue template
- Provide detailed descriptions and reproduction steps
2. **Development Process**
```bash
# Create a feature branch
git checkout -b feature/amazing-feature
# Develop...
# Run tests to ensure code quality
python -m pytest
# Commit changes
git add .
git commit -m "feat: add amazing feature"
# Push to your fork
git push origin feature/amazing-feature
```
3. **Submit a Pull Request**
- Use a clear title and description
- Link related Issues
- Ensure all tests pass
- Request a code review
### Code Standards
- **Code Style**: Follow PEP 8 standards
- **Type Annotations**: Use Python type hints
- **Docstrings**: Use Google style docstrings
- **Testing**: New features must include corresponding tests
- **Commit Messages**: Use [Conventional Commits](https://www.conventionalcommits.org/) format
### Commit Message Format
```
type(scope): description
[optional body]
[optional footer]
```
Types include:
- `feat`: New feature
- `fix`: Bug fix
- `docs`: Documentation update
- `style`: Code formatting
- `refactor`: Code refactoring
- `test`: Testing related
- `chore`: Changes to the build process or auxiliary tools
### Development Guidelines
- Use [Black](https://github.com/psf/black) for code formatting
- Follow the [PEP 8](https://www.python.org/dev/peps/pep-0008/) coding standards
- Add corresponding tests for new features
- Update relevant documentation
### Code Formatting
```bash
```
# Formatting Code
black solo_mcp/ tests/
# Check Code Style
black --check solo_mcp/ tests/
```
## 🗺️ Roadmap
### Recent Goals (v1.1)
- [ ] Add more predefined role types
- [ ] Implement vectorized search for the memory system
- [ ] Optimize the task scheduling algorithm
- [ ] Add performance monitoring and metrics
- [ ] Improve API documentation
### Mid-term Goals (v1.5)
- [ ] Implement distributed memory storage
- [ ] Add web management interface
- [ ] Support plugin system
- [ ] Integrate more AI models
- [ ] Add real-time collaboration features
### Long-term Goals (v2.0)
- [ ] Support for multi-language SDK
- [ ] Cloud deployment solutions
- [ ] Enterprise-level security features
- [ ] Advanced analytics and reporting
- [ ] Automated DevOps integration
## 🐛 Feedback on Issues
If you encounter any issues or have suggestions for improvements, please:
1. Check the [Issues](https://github.com/CHANGGELY/solo-mcp/issues) to see if the issue has already been reported
2. If not, please create a new Issue and provide detailed information:
- Description of the issue
- Steps to reproduce
- Expected behavior
- System environment information
## 📄 License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## 🙏 Acknowledgments
- [Model Context Protocol](https://github.com/modelcontextprotocol) - Provides a robust foundation for context protocols
- [sentence-transformers](https://github.com/UKPLab/sentence-transformers) - Offers excellent text embedding capabilities
- Support from all contributors and users
---
**Solo MCP** - Making AI collaborative development simple and powerful 🚀
