Konnos/Autogen-MCP-Server
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add comprehensive documentation for Autogen-MCP-Server project

Browse Source
This commit is contained in:
KonnosPB
2025-07-06 23:20:16 +02:00
parent 252b15baf9
commit a774772fe1
2 changed files with 361 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
.copilot-instructions.md Normal file
View File

@@ -0,0 +1,179 @@
# Copilot Instructions for Autogen-MCP-Server
## Project Overview
This project implements a hierarchical MCP (Model Context Protocol) server system using AutoGen multi-agent architecture. The system acts as a coordinator for multiple specialized MCP servers through configurable AI agents.
## Architecture
- **Main MCP Server**: Entry point for MCP-capable clients (e.g., AnythingLLM)
- **AutoGen Framework**: Multi-agent coordination system
- **Moderator Agent**: Orchestrates and routes requests to specialized agents
- **Specialized Agents**: Each agent handles specific domains (Azure DevOps, Database, etc.)
- **MCP Server Integration**: Each specialized agent connects to dedicated MCP servers
- **Configuration-Driven**: YAML/JSON configuration for agent setup and routing
## Key Components
### 1. MCP Server (Entry Point)
- Implements MCP protocol
- Receives requests from clients
- Forwards to AutoGen moderator
- Returns responses back to clients
### 2. Moderator Agent
- Analyzes incoming requests
- Determines appropriate specialized agent
- Coordinates multi-agent conversations
- Aggregates and formats responses
### 3. Specialized Agents
- Domain-specific expertise
- Connected to specialized MCP servers
- Configurable via YAML/JSON
- Pluggable architecture
### 4. Configuration System
- Agent definitions in YAML/JSON
- Routing rules based on keywords/patterns
- MCP server connections
- Model configurations
- Fallback strategies
## Development Guidelines
### Virtual Environment Management
- **ALWAYS activate the .venv before running any terminal commands**
- Use `source .venv/bin/activate` (Linux/macOS) or `.venv\Scripts\activate` (Windows)
- Never run Python commands or install packages without the virtual environment activated
- All pip installs, python executions, and package management must be done within the .venv
### Project Cleanliness
- **Keep the project structure clean and organized**
- After creating new files, verify they are actually needed and remove unnecessary ones
- Do not create duplicate files in subdirectories
- **NEVER create copies of existing files in subdirectories**
- Before creating a new file, check if a similar file already exists
- Remove temporary files, unused imports, and dead code regularly
- Maintain a minimal and focused project structure
### File Management Rules
- **Check for existing files before creating new ones**
- Use existing files and extend them rather than creating duplicates
- If a file needs to be moved, use proper refactoring instead of copying
- Remove any files that become obsolete after refactoring
- Keep related functionality in the same file when appropriate
### Code Structure
```
src/
├── mcp_server/ # Main MCP server implementation
├── agents/ # AutoGen agent implementations
│ ├── moderator.py # Moderator agent
│ ├── base_agent.py # Base class for specialized agents
│ └── specialized/ # Specialized agent implementations
├── config/ # Configuration management
├── utils/ # Utility functions
└── main.py # Entry point
```
### Configuration Format
```yaml
moderator:
name: "AgentModerator"
model: "gpt-4"
system_message: "..."
agents:
- name: "AzureDevOpsAgent"
specialization: "azure_devops"
model: "gpt-4"
mcp_server:
url: "mcp://azure-devops-server"
tools: ["get_work_items", "create_pull_request"]
routing_rules:
- keywords: ["azure", "devops", "pipeline"]
agent: "AzureDevOpsAgent"
```
### Key Technologies
- **Python 3.12+**
- **AutoGen**: Multi-agent framework
- **MCP SDK**: Model Context Protocol implementation
- **Pydantic**: Configuration validation
- **PyYAML**: Configuration parsing
- **AsyncIO**: Asynchronous operations
### Development Phases
1. **Phase 1**: Basic MCP server + single specialized agent
2. **Phase 2**: Moderator agent + routing logic
3. **Phase 3**: Configuration system + multiple agents
4. **Phase 4**: Error handling + monitoring
5. **Phase 5**: Plugin system + hot-reload
### Testing Strategy
- Unit tests for each component
- Integration tests for agent communication
- Configuration validation tests
- End-to-end tests with real MCP clients
- Performance tests for multi-agent scenarios
### Error Handling
- Graceful degradation when agents/servers unavailable
- Timeout handling for long-running operations
- Fallback strategies in configuration
- Comprehensive logging and monitoring
### Performance Considerations
- Async/await for non-blocking operations
- Connection pooling for MCP servers
- Request caching where appropriate
- Token usage optimization
## Implementation Notes
### Agent Factory Pattern
Use factory pattern to create agents from configuration:
```python
class AgentFactory:
@staticmethod
def create_agent(config: AgentConfig) -> BaseAgent:
# Create agent based on configuration
```
### MCP Server Registry
Maintain registry of available MCP servers:
```python
class MCPServerRegistry:
def register_server(self, name: str, server: MCPServer):
# Register MCP server
def get_server(self, name: str) -> MCPServer:
# Get MCP server by name
```
### Configuration Hot-Reload
Implement configuration reload without restart:
```python
class ConfigManager:
def reload_config(self):
# Reload configuration and update agents
```
## Security Considerations
- Validate all configuration inputs
- Sanitize requests between agents
- Implement proper authentication for MCP servers
- Log all agent interactions for audit
## Monitoring & Observability
- Request tracing across agent boundaries
- Performance metrics collection
- Error rate monitoring
- Token usage tracking
## Future Enhancements
- Web UI for configuration management
- Agent performance analytics
- Dynamic agent scaling
- Advanced routing algorithms
- Integration with more MCP servers

183
README.md
View File

@@ -1,3 +1,184 @@
# Autogen-MCP-Server
Ein MCP Server, der eine Gruppe von LLM und MCP Servern koppelt
Ein hierarchisches MCP-System mit AutoGen Multi-Agent-Architektur für die Koordination spezialisierter KI-Agenten.
## 🎯 Projektziel
Dieses Projekt implementiert einen intelligenten MCP (Model Context Protocol) Server, der als Einstiegspunkt für ein System aus spezialisierten KI-Agenten fungiert. Das System ermöglicht es, komplexe Anfragen automatisch an die am besten geeigneten Experten-Agenten zu routen und koordinierte Antworten zu liefern.
## 🏗️ Architektur
```
MCP Client (AnythingLLM)
↓
Hauptserver (MCP Server)
↓
Moderator-Agent (AutoGen)
↓
Spezialisierte Agenten
↓
Spezialisierte MCP Server
```
### Komponenten
- **🚪 Hauptserver**: MCP-konformer Einstiegspunkt für Clients
- **🎭 Moderator-Agent**: Intelligente Koordination und Routing
- **🔧 Spezialisierte Agenten**: Experten für spezifische Domänen (Azure DevOps, Datenbanken, etc.)
- **⚙️ MCP-Server**: Spezialisierte Backend-Services für jeden Agenten
- **📋 Konfigurationssystem**: YAML/JSON-basierte Agenten-Konfiguration
## 🌟 Hauptfeatures
### ✅ Intelligente Anfragerouting
- Automatische Erkennung der passenden Experten-Agenten
- Keyword-basierte und semantische Routing-Regeln
- Fallback-Strategien für unbekannte Anfragen
### ✅ Konfigurierbare Agenten
- YAML/JSON-Konfiguration für alle Agenten
- Plug-and-Play-Architektur für neue Domänen
- Hot-Reload für Konfigurationsänderungen
### ✅ Enterprise-Ready
- Umfassende Fehlerbehandlung
- Logging und Monitoring
- Skalierbare Architektur
- Sicherheitsfeatures
## 🚀 Anwendungsfall
**Beispiel-Workflow:**
1. Benutzer stellt Frage zu Azure DevOps in AnythingLLM
2. AnythingLLM sendet Anfrage an unseren MCP Server
3. Moderator-Agent analysiert die Anfrage
4. Azure DevOps-Spezialist wird aktiviert
5. Spezialist nutzt Azure DevOps MCP Server für Informationen
6. Antwort wird über die Kette zurück an den Benutzer geliefert
## 📝 Konfigurationsbeispiel
```yaml
# autogen-config.yml
moderator:
name: "AgentModerator"
model: "gpt-4"
system_message: "Du koordinierst spezialisierte Agenten..."
agents:
- name: "AzureDevOpsAgent"
specialization: "azure_devops"
model: "gpt-4"
mcp_server:
url: "mcp://azure-devops-server"
tools: ["get_work_items", "create_pull_request"]
- name: "DatabaseAgent"
specialization: "database"
model: "gpt-3.5-turbo"
mcp_server:
url: "mcp://database-server"
tools: ["query_db", "get_schema"]
routing_rules:
- keywords: ["azure", "devops", "pipeline", "build"]
agent: "AzureDevOpsAgent"
- keywords: ["database", "sql", "query", "table"]
agent: "DatabaseAgent"
```
## 🛠️ Technologie-Stack
- **Python 3.13+**
- **AutoGen**: Multi-Agent Framework
- **MCP SDK**: Model Context Protocol
- **Pydantic**: Konfigurationsvalidierung
- **PyYAML**: Konfigurationsparsing
- **AsyncIO**: Asynchrone Operationen
## 🎯 Entwicklungsphasen
### Phase 1: MVP (Minimum Viable Product)
- [x] Grundlegende MCP Server Implementierung
- [x] Einfacher Spezialist-Agent (Azure DevOps)
- [x] Basis-Konfigurationssystem
### Phase 2: Moderator-System
- [ ] Moderator-Agent Implementierung
- [ ] Intelligente Anfragerouting
- [ ] Multi-Agent-Koordination
### Phase 3: Erweiterte Konfiguration
- [ ] Vollständiges YAML/JSON-Konfigurationssystem
- [ ] Mehrere spezialisierte Agenten
- [ ] Hot-Reload-Funktionalität
### Phase 4: Enterprise-Features
- [ ] Umfassende Fehlerbehandlung
- [ ] Logging und Monitoring
- [ ] Performance-Optimierungen
### Phase 5: Erweiterungen
- [ ] Plugin-System für neue Agenten
- [ ] Web-UI für Konfiguration
- [ ] Analytics und Metriken
## 🔧 Installation & Setup
```bash
# Repository klonen
git clone https://github.com/KonnosPB/Autogen-MCP-Server.git
cd Autogen-MCP-Server
# Abhängigkeiten installieren
pip install -r requirements.txt
# Konfiguration anpassen
cp config/example-config.yml config/config.yml
# config.yml bearbeiten...
# Server starten
python src/main.py
```
## 📊 Vorteile
### Für Entwickler
- **Modulare Architektur**: Einfache Erweiterung um neue Domänen
- **Konfigurierbar**: Keine Code-Änderungen für neue Agenten
- **Testbar**: Isolierte Komponenten für einfache Tests
### Für Unternehmen
- **Skalierbar**: Neue Experten-Domänen ohne Neudeployment
- **Wartbar**: Zentrale Konfiguration
- **Ausfallsicher**: Fallback-Strategien und Fehlerbehandlung
### Für Benutzer
- **Intelligent**: Automatische Weiterleitung an die richtige Expertise
- **Schnell**: Direkte Verbindung zu spezialisierten Services
- **Umfassend**: Ein Interface für viele verschiedene Domänen
## 🤝 Beitragen
Wir freuen uns über Beiträge! Siehe [CONTRIBUTING.md](CONTRIBUTING.md) für Details.
## 📄 Lizenz
Dieses Projekt ist unter der MIT-Lizenz lizenziert - siehe [LICENSE](LICENSE) für Details.
## 🌍 Roadmap
- **Q1 2025**: MVP mit Azure DevOps Integration
- **Q2 2025**: Mehrere spezialisierte Agenten
- **Q3 2025**: Enterprise-Features und Monitoring
- **Q4 2025**: Plugin-System und Web-UI
## 📞 Support
- **Issues**: GitHub Issues für Bugs und Feature-Requests
- **Diskussionen**: GitHub Discussions für Fragen und Ideen
- **Dokumentation**: [Wiki](https://github.com/KonnosPB/Autogen-MCP-Server/wiki)
---
*Dieses Projekt kombiniert die Kraft von AutoGen Multi-Agent-Systemen mit der Flexibilität des Model Context Protocol für eine neue Generation intelligenter Assistenten.*