Agent MCP

Agent MCP

Ein Framework zum Erstellen von Multi-Agenten-Systemen mithilfe des MCP (Model Context Protocol) für eine koordinierte, effiziente KI-Zusammenarbeit.

Kurzanleitung

Hinweis : Ich empfehle die Verwendung von MultipleCursor , um verschiedene Chatfenster auf derselben Codebasis zu starten, wie im obigen Screenshot gezeigt.

1. Umgebung einrichten

• Repo klonen und .env.example nach .env kopieren
• Fügen Sie Ihren OpenAI-API-Schlüssel zu .env hinzu
• Installieren Sie mit uv venv && uv pip install -e .

2. Starten Sie den MCP-Server

WICHTIG : Beim Serverstart wird eine Datenbank im .agent -Ordner Ihres Projekts erstellt. Ihr Admin-Token wird in dieser Datenbank gespeichert. So finden Sie es:

1. Installieren Sie eine SQLite-Viewer-Erweiterung in Ihrem Code-Editor
2. Öffnen Sie die Datenbank unter /path/to/your/project/.agent/mcp_state.db
3. Überprüfen Sie die project_context Tabelle auf das Administratortoken

3. Hauptkontextdokument (MCD) erstellen

• Erstellen Sie in Ihrem Projekt eine detaillierte MCD.md Datei mit Architektur, API-Routen, Datenmodellen usw.
• Dies kann eine einzelne Datei oder mehrere Dateien sein (für komplexe Projekte)
• Vorlagen finden Sie im Ordner MCD-EXAMPLE

4. Starten Sie den Admin-Agenten

1. Öffnen Sie Ihren KI-Codierungsassistenten (Claude Code, Cursor usw.) in Ihrem Projektordner
2. Kopieren Sie das Admin-Token, das Sie in Schritt 2 gefunden haben
3. Bitten Sie die KI, „als Administratoragent mit diesem Token zu initialisieren: [Ihr Token]“.
4. Sagen Sie dem Admin-Agenten, dass er Ihr MCD mit Folgendem zum Projektkontext hinzufügen soll:
   Please add the MCD.md file to the project context. Don't summarize it.

5. Erstellen und Verwalten von Worker-Agenten über den Administrator

1. Bitten Sie Ihren Admin-Agenten, einen Worker-Agenten zu erstellen:
   Create a worker agent with ID "frontend-worker" to implement the login page.
2. Öffnen Sie ein neues Fenster/eine neue Sitzung in Ihrem KI-Assistenten (gleiche Codebasis)
3. Initialisieren Sie den Worker mit genau dieser Eingabeaufforderung:
   You are [worker-id] agent, your Admin Token: "[admin-token]" Look at your tasks and ask the project RAG agent at least 5-7 questions to understand what you need to do. I want you to critically think when asking a question, then criticize yourself before asking that question. How you criticize yourself is by proposing an idea, criticizing it, and based on that criticism you pull through with that idea. AUTO --worker --memory
4. Der Arbeiter findet automatisch seine zugewiesenen Aufgaben und beginnt mit der Arbeit

Befolgen Sie die nachstehenden ausführlichen Anweisungen, um weitere Informationen zu erhalten.

Merkmale

• Rahmen für die Zusammenarbeit mehrerer Agenten
• Aufgabenmanagement und Koordination
• Kontext- und Wissensaustausch zwischen Agenten
• Graphische Visualisierung von Agenteninteraktionen
• Unterstützung für Einbettungs- und RAG-Funktionen
• Interaktives Dashboard zur Visualisierung von Aufgaben, Agenten und Kontext

Projektplanung mit dem Main Context Document (MCD)

Sehen Sie sich das Video-Tutorial an: So fügen Sie MCD-Kontext zu Agent MCP hinzu

Bevor Sie mit der Entwicklung beginnen, ist es wichtig, gründlich zu recherchieren und ein Main Context Document (MCD) zu erstellen – die zentrale Informationsquelle für Ihre Anwendung. Dieses Dokument enthält einen detaillierten Plan mit folgenden Details:

• Systemarchitektur und Komponentenbeziehungen
• UI/UX-Design für alle Bildschirme und Komponenten
• API-Routen und Endpunkte
• Datenstrukturen und Modelle
• Umsetzungseinheiten und Aufgaben
• Abhängigkeiten und Technologie-Stack

Der MCD ist aus folgenden Gründen von entscheidender Bedeutung:

1. Es ermöglicht den Agenten, das Gesamtsystem zu verstehen, bevor sie an einzelnen Komponenten arbeiten.
2. Es ermöglicht lineares, koordiniertes Bauen (wie der Bau eines Hauses nach Bauplänen)
3. Es reduziert die Token-Nutzung durch Bereitstellung eines strukturierten, relevanten Kontexts
4. Es verhindert widersprüchliche Implementierungen zwischen Agenten

Überprüfen Sie die Datei MCD.md in diesem Repository, um die Struktur und den erforderlichen Detaillierungsgrad zu verstehen. Die MCD sollte Folgendes enthalten:

• Überblick und Ziele
• Kontext- und Architekturdiagramme
• Funktionale Anforderungen
• Design-Spezifikationen (UI/UX, API, Datenmodelle)
• Implementierungsdetails
• Aufgabenaufschlüsselung für Agenten

Mit einem umfassenden MCD können Agenten Ihre Anwendung Stück für Stück implementieren und haben dabei ein klares Verständnis davon, wie jedes Teil in das Ganze passt.

Installation

Voraussetzungen

• Python 3.8+
• uv (empfohlen für eine schnellere Paketinstallation)

Aufstellen

1. Klonen Sie das Repository:
   git clone https://github.com/your-username/agent-mcp.git cd agent-mcp
2. Richten Sie Umgebungsvariablen ein, indem Sie die Beispieldatei kopieren:
   cp .env.example .env
3. Bearbeiten Sie die .env Datei und fügen Sie Ihren OpenAI-API-Schlüssel hinzu:
   OPENAI_API_KEY=your_openai_api_key_here
4. Mit UV installieren:
   uv venv uv pip install -e .
   Oder mit pip:
   pip install -e .

Multi-Agent-Workflow

Workflow-Übersicht

1. Beginnen Sie mit gründlicher Recherche : Nutzen Sie vor dem Codieren KI, um ein umfassendes Main Context Document (MCD) zu erstellen.
2. Starten Sie die Infrastruktur : Starten Sie den MCP-Server und suchen Sie Ihr Administratortoken in der Datenbank
3. Admin-Agent-Setup : Initialisieren Sie Ihren Admin-Agenten mit dem Token und docs/INSTRUCTIONS.md
4. Mitarbeitererstellung : Der Administrator erstellt spezialisierte Mitarbeiter für verschiedene Aspekte Ihres Projekts
5. Aufgabenzuweisung : Der Administrator unterteilt den MCD in einzelne Aufgaben und weist sie den Mitarbeitern zu
6. Parallele Entwicklung : Mitarbeiter führen Aufgaben aus und teilen dabei den Kontext über das MCP
7. Kontexterhaltung : Alle Agenten speichern ihr Wissen in der zentralen Datenbank

Entwicklungsschleife

Architekturübersicht

Das MCP-System verwendet eine hierarchische Struktur mit:

• Admin-Agent : Koordiniert andere Agenten, weist Aufgaben zu und behält die Gesamtleitung des Projekts bei
• Worker Agents : Spezialisierte Agenten, die bestimmte Aufgaben ausführen (Frontend, Backend, Datenmodellierung usw.)

Einrichtung und Betrieb des Agenten

1. Starten des MCP-Servers

Optionen:

• --port : Port, auf dem der Server ausgeführt wird (Standard: 8080)
• --project-dir : Basisverzeichnis für das Projekt

2. MCP-Token verstehen

Das MCP-System verwendet zwei Arten von Token zur Authentifizierung:

Administrator-Token :

1. Nach dem Start des Servers wird automatisch ein Admin-Token generiert
2. Dieses Token wird in der SQLite-Datenbank .agent/mcp_state.db gespeichert
3. Installieren Sie eine SQLite-Viewer-Erweiterung für VS Code oder ein anderes SQLite-Tool
4. Öffnen Sie die Datenbank und überprüfen Sie die Tabelle project_context
5. Suchen Sie nach dem Admin-Token-Eintrag
6. Das Admin-Token sollte NUR mit dem Admin-Agenten verwendet werden

Arbeiter-Token :

1. Wenn der Admin-Agent einen Worker-Agenten erstellt, wird ein spezifischer Worker-Token generiert
2. Der Admin-Agent stellt dieses Worker-Token bereit, wenn er aufgefordert wird, einen Worker zu erstellen
3. Jeder Mitarbeiter verfügt über ein eigenes Token mit spezifischen Berechtigungen
4. Worker-Token werden auch in der Datenbank .agent/mcp_state.db gespeichert

WICHTIG : Verwenden Sie NICHT das Administratortoken für Worker-Agenten. Verwenden Sie immer das spezifische Workertoken, das vom Administrator-Agenten beim Erstellen des Workers bereitgestellt wird.

3. Agenten-Workflow (WICHTIG)

Hinweis : Alle Agenten werden über den Chat mit Ihrem KI-Assistenten erstellt und verwaltet. Sie verwenden KEINE Befehlszeilentools zum Erstellen von Agenten.

MCP-Server – Dies ist die EINZIGE Komponente, die Sie mit einem Befehl starten:

Admin-Agent – Erstellen Sie, indem Sie Ihrem KI-Assistenten Folgendes mitteilen:

Worker-Agenten – Erstellen Sie über den Admin-Agenten mit:

1. Sagen Sie dem Admin-Agenten: „Erstellen Sie einen Worker-Agenten mit der ID ‚frontend-worker‘, um die Anmeldeseite zu implementieren.“
2. Der Administrator stellt für diesen Agenten ein spezielles Worker-Token bereit.
3. Öffnen Sie ein neues Fenster/eine neue Sitzung des KI-Assistenten
4. Initialisieren Sie mit dem Worker-Token und der Worker-Eingabeaufforderung aus Abschnitt 4 unten

Das Dashboard ( http://localhost:8080 ):

• Dies dient nur der Visualisierung - Sie erstellen hier keine Agenten
• Die gesamte eigentliche Arbeit erfolgt über die Chatfenster Ihres KI-Assistenten
• Das Dashboard zeigt Beziehungen zwischen Agenten und Aufgaben

4. Initialisieren von Worker-Agenten (Kopieren/Einfügen)

Nachdem Ihr Admin-Agent einen Worker erstellt hat, öffnen Sie ein neues AI-Assistentenfenster und initialisieren Sie den Worker mit dieser GENAUEN Eingabeaufforderung:

Nehmen Sie diese beiden Ersetzungen vor:

1. Ersetzen Sie [agent_id] durch die Worker-ID, die Sie dem Administrator zum Erstellen mitgeteilt haben (z. B. „frontend-worker“).
2. Ersetzen Sie your_worker_token_here durch das spezifische Worker-Token, das der Admin-Agent beim Erstellen dieses Workers bereitgestellt hat (NICHT das Admin-Token).

Nach der Initialisierung wird der Worker:

1. Suchen Sie nach Aufgaben, die der ID zugewiesen sind
2. Fragen Sie das RAG-System zum Projektkontext
3. Beginnen Sie, seine Aufgaben selbstständig zu erledigen
4. Speichern Sie Implementierungsdetails im gemeinsam genutzten Speichersystem

Um optimale Ergebnisse zu erzielen, kopieren Sie auch den Inhalt von docs/INSTRUCTIONS.md und fügen Sie ihn vor dem AUTO-Befehl ein.

Dashboard und Terminal-Benutzeroberfläche

Dashboard (Visualisierung)

Greifen Sie unter http://localhost:8080 auf das Dashboard zu, um zu visualisieren, was in Ihrem Multi-Agenten-System passiert:

• Überwachen Sie die Agentenaktivitäten in Echtzeit
• Anzeigen des Aufgabenstatus und der Abhängigkeiten
• Beobachten Sie die Beziehungen und Koordination der Agenten
• Verfolgen Sie Dateivorgänge und Kontextfreigabe

Wichtig: Das Dashboard dient nur der Visualisierung. Sie erstellen oder verwalten hier keine Agenten. Die gesamte Agentenerstellung und Aufgabenzuweisung erfolgt über den Chat Ihres KI-Assistenten.

Mehrere Agentensitzungen: Visuelle Anleitung

Bei komplexen Projekten haben Sie mehrere Chat-Sitzungen gleichzeitig geöffnet:

Und so funktioniert es:

1. Ein Fenster/eine Sitzung für Ihren Admin-Agenten
2. Separate Fenster/Sitzungen für jeden Worker-Agenten
3. Der Administrator verwendet das Administrator-Token, die Mitarbeiter verwenden ihre spezifischen Mitarbeiter-Token
4. Jeder Mitarbeiter hat eine EINZIGARTIGE Agenten-ID und ein Token

Beispiel-Setup mit 3 Agenten:

Sie können Claude Code, RooCode oder MultipleCursor verwenden, um mehrere Fenster/Sitzungen zu verwalten, die auf derselben Codebasis arbeiten.

Vollständiger Beispiel-Workflow

Hier ist ein schrittweises Beispiel für die Verwendung von Agent MCP von Anfang bis Ende:

Schritt 1: Erstellen Sie Ihr Projekt

Schritt 2: Agent MCP installieren

Schritt 3: Erstellen Sie Ihr MCD

Schritt 4: Starten Sie den MCP-Server

Schritt 5: Admin-Token suchen

1. Installieren Sie SQLite Viewer in Ihrem Code-Editor
2. Öffnen Sie .agent/mcp_state.db
3. Suchen Sie in der Tabelle project_context nach dem Token

Schritt 6: Admin-Agent initialisieren

1. Öffnen Sie Ihren KI-Assistenten (Claude Code, Cursor usw.)
2. Erzähl es:

Schritt 7: Worker-Agent erstellen

1. Sagen Sie dem Administratoragenten:

2. Der Admin-Agent stellt Ihnen ein Worker-Token für diesen neuen Agenten zur Verfügung

Schritt 8: Worker-Agent initialisieren

1. Öffnen Sie ein neues KI-Assistentenfenster
2. Erzähl es:

Der Arbeiter beginnt nun automatisch mit der Arbeit an den ihm zugewiesenen Aufgaben!

Token-System und Ressourcenverwaltung

Token verstehen

Token erfüllen im MCP-System mehrere Zwecke:

1. Authentifizierungstoken : Wird zur Agentenidentifizierung und für den Administratorzugriff verwendet
2. RAG-Token : Wird zum Einbetten und Abrufen von Kontext aus der Wissensdatenbank verwendet
3. OpenAI-Token : Werden während Agentenvorgängen verbraucht (Modellnutzung)

Token-Verwaltung

So überwachen und verwalten Sie die Token-Nutzung:

1. Installieren Sie das SQLite Viewer-Plugin oder verwenden Sie die Befehlszeile:
   sqlite3 /path/to/project/.agent/mcp_state.db
2. Verwendung des Abfragetokens:
   SELECT * FROM token_usage;
3. Überwachen Sie im Dashboard unter der Registerkarte „Ressourcen“

Ressourcenoptimierung

Für große Projekte:

1. Verwenden Sie spezialisierte Agenten mit gezielten Funktionen, um die Kontextgröße zu reduzieren
2. Teilen Sie Aufgaben in kleinere Einheiten mit klaren Abhängigkeiten auf
3. Nutzen Sie das RAG-System für eine effiziente Kontextsuche
4. Gemeinsam genutzte Informationen im Projektkontext speichern, statt sie in Nachrichten zu wiederholen

Projekt RAG und Wissensdatenbank (Zentrales Speichersystem)

Sehen Sie sich das Tutorial oben an: Erfahren Sie genau, wie Sie Ihr MCD zum zentralen Speichersystem hinzufügen

Wie das Gedächtnissystem funktioniert

1. Der MCP-Server verwaltet eine zentrale Datenbank für alle Projektkontexte
2. Wenn Sie den Server starten, erstellt er einen .agent -Ordner in Ihrem Projektverzeichnis
3. Ihr Admin-Agent fügt Ihre MCD dieser Datenbank hinzu, wenn Sie sie initialisieren
4. Worker-Agenten fragen diese Datenbank automatisch ab, um ihre Aufgaben zu verstehen
5. Alle Implementierungsdetails werden in dieser Datenbank gespeichert, damit andere Agenten darauf zugreifen können.

Einrichten des Projekt-RAG

Das Retrieval-Augmented Generation (RAG)-System ermöglicht Agenten den effizienten Zugriff auf relevantes Projektwissen:

1. Projektdateien indizieren:
   python -m agent_mcp.features.rag.indexing -- --project-dir /path/to/project
2. Fügen Sie der Wissensdatenbank Dokumentation hinzu:
   python -m agent_mcp.features.rag.indexing -- --add-doc /path/to/document.md

Verwenden von RAG in Agent-Workflows

Agenten können die Wissensdatenbank folgendermaßen abfragen:

Gemeinschaft

Treten Sie unserer Discord-Community bei, um über Agent MCP zu diskutieren, Ihre Projekte zu teilen, Hilfe zu erhalten und sich mit anderen Entwicklern zu vernetzen, die mit KI-Tools arbeiten. Wir sind eine wachsende Community, die sich darauf konzentriert, die Grenzen des Möglichen mit Multi-Agenten-Systemen und KI-Zusammenarbeit zu erweitern.