Einrichten von Multi-Agent-Workflows mit MCP in Cursor

Mit zunehmender Projektgröße reicht ein einzelner KI-Agent möglicherweise nicht mehr aus. Cursor unterstützt Multi-Agent-Workflows über MCP-Server (Model Context Protocol), die es mehreren spezialisierten Agenten ermöglichen, gleichzeitig an verschiedenen Aspekten Ihres Projekts zusammenzuarbeiten. Diese Anleitung zeigt Ihnen, wie Sie mehrere Agenten effektiv einrichten und koordinieren.

Was ist Multi-Agent-Koordination?

Die Multi-Agent-Koordination ermöglicht es Ihnen:

• Komplexe Aufgaben aufzuteilen über spezialisierte Agenten (z. B. einer für Frontend, einer für Backend)
• Parallel zu arbeiten an verschiedenen Teilen Ihrer Codebase
• Trennung der Belange aufrechtzuerhalten mit dedizierten Agenten für bestimmte Domänen
• Ihre KI-Unterstützung zu skalieren mit dem Wachstum Ihres Projekts

Voraussetzungen

Bevor Sie Multi-Agent-Workflows einrichten:

1. Cursor Pro oder höher - Multi-Agent-Funktionen erfordern einen kostenpflichtigen Plan
2. MCP-Server-Unterstützung - Stellen Sie sicher, dass MCP in Ihren Cursor-Einstellungen aktiviert ist
3. Git-Repository - Multi-Agent-Workflows funktionieren am besten mit Versionskontrolle

Einrichten der Worktree-Konfiguration

Die Datei .cursor/worktrees.json ist der Schlüssel zur Multi-Agent-Koordination.

Schritt 1: Die Konfigurationsdatei Erstellen

Erstellen Sie .cursor/worktrees.json im Projektstammverzeichnis:

{
  "worktrees": [
    {
      "id": "frontend-agent",
      "name": "Frontend Agent",
      "description": "Handles UI components, styling, and client-side logic",
      "directories": ["src/components", "src/pages", "src/styles", "public"],
      "rules": [
        "Use React and TypeScript",
        "Follow the existing component patterns",
        "Use Tailwind CSS for styling",
        "Ensure responsive design"
      ]
    },
    {
      "id": "backend-agent",
      "name": "Backend Agent",
      "description": "Manages API endpoints, database models, and server logic",
      "directories": ["src/api", "src/models", "src/middleware", "migrations"],
      "rules": [
        "Use Express.js with TypeScript",
        "Follow RESTful conventions",
        "Implement proper error handling",
        "Add input validation"
      ]
    },
    {
      "id": "test-agent",
      "name": "Testing Agent",
      "description": "Writes and maintains test suites",
      "directories": ["tests", "src/__tests__", "cypress"],
      "rules": [
        "Use Jest for unit tests",
        "Use React Testing Library for component tests",
        "Aim for 80%+ coverage",
        "Write integration tests for API endpoints"
      ]
    }
  ]
}

Schritt 2: MCP-Server Konfigurieren

Fügen Sie MCP-Server zu Ihren Cursor-Einstellungen hinzu (Cmd/Ctrl + Shift + P → "Cursor Settings"):

{
  "mcpServers": {
    "task-coordinator": {
      "command": "npx",
      "args": ["-y", "@cursor-task/coordinator"],
      "env": {
        "WORKTREE_CONFIG": "./.cursor/worktrees.json"
      }
    },
    "file-sync": {
      "command": "npx",
      "args": ["-y", "@cursor-task/file-sync"]
    }
  }
}

Verwendung des Multi-Agent-Modus

Starten einer Multi-Agent-Sitzung

1. Öffnen Sie Composer (Cmd/Ctrl + I)
2. Klicken Sie auf den Agenten-Selektor (oben in Composer)
3. Wählen Sie den "Multi-Agent"-Modus
4. Wählen Sie aus, welche Agenten aktiviert werden sollen

Aufgabenzuweisung

Agenten übernehmen automatisch Aufgaben basierend auf den von Ihnen referenzierten Dateien:

@src/components/UserProfile.tsx @src/api/users.ts 

Implementieren Sie eine Benutzerprofilseite, die Daten von der API abruft und anzeigt.
Der Frontend-Agent sollte die UI handhaben, und der Backend-Agent sollte sicherstellen, dass der API-Endpunkt die richtigen Daten zurückgibt.

Manuelles Aufgaben-Routing

Sie können Aufgaben auch an bestimmte Agenten richten:

[@frontend-agent] Erstelle eine responsive Navigationskomponente mit mobilem Hamburger-Menü

[@backend-agent] Füge einen /api/navigation-Endpunkt hinzu, der Menüelemente basierend auf der Benutzerrolle zurückgibt

Kommunikation Zwischen Agenten

Agenten kommunizieren über ein gemeinsames Aufgabendateisystem.

Aufgabendateien

Aufgaben werden in .cursor/tasks/ verfolgt:

.cursor/
  tasks/
    TASK-001-frontend-nav.md
    TASK-002-backend-api.md
    TASK-003-integration-test.md

Jede Aufgabendatei enthält:

# TASK-001: Navigation Component

## Status: IN_PROGRESS
## Assigned: frontend-agent
## Dependencies: None

## Description
Create a responsive navigation component...

## Acceptance Criteria
- [ ] Mobile hamburger menu works
- [ ] Desktop horizontal layout
- [ ] Active state highlighting

## Notes
- Use the existing Button component
- Follow the design in Figma (link)

Agenten-Übergaben

Wenn ein Agent eine Aufgabe abschließt, von der ein anderer abhängt:

## Handoff Notes

Completed by: frontend-agent
Handed to: test-agent

The Navigation component is in src/components/Navigation.tsx.
Props interface is defined. Ready for testing.

Best Practices für Multi-Agent-Workflows

1. Klare Grenzen Definieren

Jeder Agent sollte einen klar definierten Umfang haben:

{
  "id": "database-agent",
  "directories": ["src/db", "migrations", "seeds"],
  "rules": [
    "Only modify files in the assigned directories",
    "Run migrations before committing changes",
    "Document schema changes in CHANGELOG.md"
  ]
}

2. Gemeinsame Verträge Verwenden

Definieren Sie Schnittstellen, auf die sich Agenten einigen:

// src/types/shared.ts
// This file is read by ALL agents

export interface ApiResponse<T> {
  data: T;
  success: boolean;
  error?: string;
}

export interface User {
  id: string;
  email: string;
  name: string;
  role: 'admin' | 'user';
}

3. Konfliktlösung Implementieren

Wenn Agenten dieselben Dateien ändern:

{
  "conflictResolution": {
    "strategy": "last-write-wins",
    "notification": true,
    "manualReview": ["src/types/shared.ts", "package.json"]
  }
}

4. Agentenaktivität Überwachen

Verfolgen Sie, was jeder Agent tut:

# Aktive Aufgaben anzeigen
cat .cursor/tasks/*.md | grep "Status: IN_PROGRESS"

# Kürzliche Agenten-Commits prüfen
git log --oneline --all --grep="agent:" | head -20

Beispiel: Vollständiger Multi-Agent-Workflow

Lassen Sie uns eine Funktion mit drei zusammenarbeitenden Agenten erstellen:

Phase 1: Backend-Agent

[@backend-agent] Erstelle einen /api/products-Endpunkt mit CRUD-Operationen.
Verwende die bestehende Datenbankverbindung in src/db/index.ts.
Folge der ApiResponse-Schnittstelle in src/types/shared.ts.

Phase 2: Frontend-Agent (startet nach Backend-Commit)

[@frontend-agent] Erstelle eine ProductList-Komponente, die von /api/products abruft.
Verwende React Query für die Datenabfrage.
Zeige Produkte in einem responsiven Raster an.

Phase 3: Test-Agent (startet nach Frontend-Commit)

[@test-agent] Schreibe Tests für die ProductList-Komponente und den /api/products-Endpunkt.
Schließe Fehlerzustandstests ein.
Ziele auf 85%+ Abdeckung.

Fehlerbehebung bei Multi-Agent-Problemen

Problem	Lösung
Agenten überschreiben die Änderungen des anderen	Definieren Sie strengere Verzeichnisgrenzen in worktrees.json
Aufgaben werden nicht übernommen	Prüfen Sie, ob Aufgabendateien in .cursor/tasks/ mit korrektem Status sind
Agenten konfligieren bei gemeinsamen Dateien	Fügen Sie Dateien zu manualReview in conflictResolution hinzu
Ein Agent ist untätig	Stellen Sie sicher, dass Aufgabenabhängigkeiten als abgeschlossen markiert sind

Erweitert: Benutzerdefinierte MCP-Server

Für spezialisierte Workflows erstellen Sie benutzerdefinierte MCP-Server:

// mcp-server-custom.js
const { Server } = require('@modelcontextprotocol/sdk/server/index.js');

const server = new Server({
  name: 'custom-task-router',
  version: '1.0.0'
}, {
  capabilities: {
    tools: {}
  }
});

server.setRequestHandler('tools/call', async (request) => {
  if (request.params.name === 'route-task') {
    const { task, agentPool } = request.params.arguments;
    // Custom routing logic
    const bestAgent = selectBestAgent(task, agentPool);
    return {
      content: [{
        type: 'text',
        text: `Task routed to ${bestAgent}`
      }]
    };
  }
});

Verwandte Ressourcen

• Verwendung von MCP-Servern in Cursor
• Cursor Agent Mode Masterclass
• Umgang mit Großen Projekten in Cursor