commit c5181387e5eacc0c7eb8c4cb2a383197aea7aca1 Author: ValueOn AG Date: Wed May 14 11:07:12 2025 +0200 first commit diff --git a/poweron/diagramm_datenfluss.mermaid b/poweron/diagramm_datenfluss.mermaid new file mode 100644 index 0000000..18930d7 --- /dev/null +++ b/poweron/diagramm_datenfluss.mermaid @@ -0,0 +1,110 @@ +flowchart TD + %% Externe Entitäten + USER((Benutzer)) + AI_PROVIDER((AI-Provider\nOpenAI/Anthropic)) + WEB((Internet/\nWebseiten)) + + %% Hauptprozesse + AUTH[Authentifizierung] + WS_MANAGE[Workspace-\nVerwaltung] + AGENT_MANAGE[Agenten-\nVerwaltung] + FILE_MANAGE[Datei-\nVerwaltung] + PROMPT_MANAGE[Prompt-\nVerwaltung] + + WF_INIT[Workflow-\nInitialisierung] + WF_EXEC[Workflow-\nAusführung] + MOD_CYCLE[Moderator-\nZyklus] + AGENT_EXEC[Agenten-\nAusführung] + WEB_SCRAPE[Web-\nScraping] + USER_INTERACT[Benutzer-\nInteraktion] + RESULT_COLLECT[Ergebnis-\nSammlung] + + %% Datenspeicher + DB_USERS[(Benutzer-\nDatenbank)] + DB_MANDATE[(Mandanten-\nDatenbank)] + DB_WS[(Workspace-\nDatenbank)] + DB_AGENTS[(Agenten-\nDatenbank)] + DB_FILES[(Datei-\nDatenbank)] + DB_PROMPTS[(Prompts-\nDatenbank)] + DB_WORKFLOWS[(Workflow-\nDatenbank)] + FILE_SYSTEM[(Datei-\nSystem)] + + %% Datenflüsse - Authentifizierung und Basisdaten + USER -->|Login-Daten| AUTH + AUTH -->|Token| USER + AUTH -->|Benutzerinfo lesen/schreiben| DB_USERS + AUTH -->|Mandanteninfo lesen| DB_MANDATE + + %% Workspace-Management + USER -->|Workspace erstellen/bearbeiten| WS_MANAGE + WS_MANAGE -->|Workspace-Daten lesen/schreiben| DB_WS + WS_MANAGE -->|Workspace-Info| USER + + %% Agenten-Management + USER -->|Agenten konfigurieren| AGENT_MANAGE + AGENT_MANAGE -->|Agenten-Daten lesen/schreiben| DB_AGENTS + AGENT_MANAGE -->|Agenten-Info| USER + + %% Datei-Management + USER -->|Dateien hochladen| FILE_MANAGE + FILE_MANAGE -->|Metadaten speichern| DB_FILES + FILE_MANAGE -->|Dateien speichern| FILE_SYSTEM + FILE_MANAGE -->|Datei-Info| USER + + %% Prompt-Management + USER -->|Prompts erstellen/bearbeiten| PROMPT_MANAGE + PROMPT_MANAGE -->|Prompts lesen/schreiben| DB_PROMPTS + PROMPT_MANAGE -->|Prompt-Info| USER + + %% Workflow-Ausführung - Initialisierung + USER -->|Workflow starten| WF_INIT + WF_INIT -->|Workflow-Meta lesen/schreiben| DB_WORKFLOWS + WF_INIT -->|Ausgewählte Agenten lesen| DB_AGENTS + WF_INIT -->|Ausgewählte Dateien lesen| DB_FILES + WF_INIT -->|Dateiinhalte lesen| FILE_SYSTEM + WF_INIT -->|Prompt| DB_PROMPTS + WF_INIT -->|Workflow-Status| USER + + %% Workflow-Ausführung - Hauptprozess + WF_INIT -->|Workflow-Kontext| WF_EXEC + WF_EXEC -->|Moderator aktivieren| MOD_CYCLE + MOD_CYCLE -->|Agentenauswahl| AGENT_EXEC + AGENT_EXEC -->|Anfrage| AI_PROVIDER + AI_PROVIDER -->|Antwort| AGENT_EXEC + + %% Web-Scraping-Integration + AGENT_EXEC -->|Web-Recherche anfordern| WEB_SCRAPE + WEB_SCRAPE -->|Suchanfragen| WEB + WEB -->|Webinhalte| WEB_SCRAPE + WEB_SCRAPE -->|Extrahierte Informationen| AGENT_EXEC + + %% Benutzerinteraktion während Workflow + MOD_CYCLE -->|Benutzereingabe anfordern| USER_INTERACT + USER_INTERACT -->|Anfrage| USER + USER -->|Antwort/zusätzliche Dateien| USER_INTERACT + USER_INTERACT -->|Benutzerinput| MOD_CYCLE + + %% Ergebnissammlung und -speicherung + AGENT_EXEC -->|Agentenergebnisse| RESULT_COLLECT + USER_INTERACT -->|Benutzereingaben| RESULT_COLLECT + RESULT_COLLECT -->|Ergebnisse speichern| DB_WORKFLOWS + RESULT_COLLECT -->|Logs speichern| DB_WORKFLOWS + RESULT_COLLECT -->|Workflow-Status aktualisieren| DB_WORKFLOWS + RESULT_COLLECT -->|Ergebnisse anzeigen| USER + + %% Workflow-Steuerung + MOD_CYCLE -->|Nächster Zyklus| MOD_CYCLE + MOD_CYCLE -->|Workflow abschließen| RESULT_COLLECT + USER -->|Workflow stoppen| WF_EXEC + + %% Stile + classDef entity fill:#68A7AD,stroke:#376B6D,stroke-width:2px,color:white + classDef process fill:#99C4C8,stroke:#5E8B8F,stroke-width:1px + classDef store fill:#E5CB9F,stroke:#BA9C6F,stroke-width:1px + classDef mainProcess fill:#F5A7A7,stroke:#F07272,stroke-width:2px,color:white + + class USER,AI_PROVIDER,WEB entity + class AUTH,WS_MANAGE,AGENT_MANAGE,FILE_MANAGE,PROMPT_MANAGE process + class WF_INIT,MOD_CYCLE,AGENT_EXEC,WEB_SCRAPE,USER_INTERACT,RESULT_COLLECT mainProcess + class WF_EXEC mainProcess + class DB_USERS,DB_MANDATE,DB_WS,DB_AGENTS,DB_FILES,DB_PROMPTS,DB_WORKFLOWS,FILE_SYSTEM store \ No newline at end of file diff --git a/poweron/diagramm_datenfluss.png b/poweron/diagramm_datenfluss.png new file mode 100644 index 0000000..3199a94 Binary files /dev/null and b/poweron/diagramm_datenfluss.png differ diff --git a/poweron/diagramm_hld.mermaid b/poweron/diagramm_hld.mermaid new file mode 100644 index 0000000..43a410f --- /dev/null +++ b/poweron/diagramm_hld.mermaid @@ -0,0 +1,53 @@ +--- +config: + layout: fixed +--- +flowchart TB + subgraph subGraph0["Frontend Layer"] + UI["Benutzeroberfläche (JS/HTML/CSS)"] + UIM["UI-Module"] + GST["Globaler Zustand"] + end + subgraph subGraph1["API Layer"] + FAPI["FastAPI Backend"] + AMOD["API-Module & Router"] + AUTH["Authentifizierung & Autorisierung"] + end + subgraph subGraph2["Core Services Layer"] + GW["Gateway Interface"] + LDOM["LucyDOM Interface"] + AGS["Agent Service"] + end + subgraph subGraph3["External Connectors"] + AI["AI Connectors\n(OpenAI/Anthropic)"] + WS["Web Scraping\nConnector"] + end + subgraph subGraph4["Data Layer"] + DB["JSON-Datenbank"] + FS["Dateisystem"] + end + UI <--> UIM & FAPI + UIM <--> GST + FAPI <--> AMOD + AMOD <--> AUTH & GW & LDOM & AGS + GW <--> DB + LDOM <--> DB + AGS <--> DB & AI & WS & FS + UI:::frontendClass + UIM:::frontendClass + GST:::frontendClass + FAPI:::apiClass + AMOD:::apiClass + AUTH:::apiClass + GW:::coreClass + LDOM:::coreClass + AGS:::coreClass + AI:::connectorClass + WS:::connectorClass + DB:::dataClass + FS:::dataClass + classDef frontendClass fill:#D6EAF8,stroke:#2E86C1,stroke-width:2px + classDef apiClass fill:#D5F5E3,stroke:#239B56,stroke-width:2px + classDef coreClass fill:#FCF3CF,stroke:#D4AC0D,stroke-width:2px + classDef connectorClass fill:#F5EEF8,stroke:#8E44AD,stroke-width:2px + classDef dataClass fill:#FADBD8,stroke:#C0392B,stroke-width:2px diff --git a/poweron/diagramm_hld.png b/poweron/diagramm_hld.png new file mode 100644 index 0000000..f418497 Binary files /dev/null and b/poweron/diagramm_hld.png differ diff --git a/poweron/diagramm_komponenten.mermaid b/poweron/diagramm_komponenten.mermaid new file mode 100644 index 0000000..21fa004 --- /dev/null +++ b/poweron/diagramm_komponenten.mermaid @@ -0,0 +1,156 @@ +--- +config: + layout: fixed +--- +flowchart TB + subgraph FE_Modules["frontend_agents/public/js/modules"] + direction LR + WF["workflow.js\nWorkflow control"] + WFC["workflowCoordination.js\nWorkflow coordination"] + WFU["workflowUi.js\nWorkflow UI"] + WFD["workflowData.js\nWorkflow API logic"] + WFT["workflowUtils.js\nWorkflow utils"] + FL["files.js\nFile management"] + PR["prompts.js\nPrompt management"] + US["users.js\nUser management"] + MD["mandates.js\nMandate management"] + end + subgraph FE_Shared["frontend_agents/public/js/shared"] + direction LR + API["apiCalls.js\nAPI communication"] + NAV["navigation.js\nNavigation"] + GLOB["globalState.js\nState management"] + UTIL["utils.js\nHelpers"] + end + subgraph FE_Security["frontend_agents/public/js/security"] + AUTH_FE["auth.js\nAuthentication"] + end + subgraph FE_Main["frontend_agents/public/js"] + MAIN["main.js\nMain app"] + end + subgraph BE_Routes["gateway/routes"] + direction LR + R_MAND["routeMandates.py\nMandate API"] + R_USER["routeUsers.py\nUser API"] + R_FL["routeFiles.py\nFile API"] + R_PR["routePrompts.py\nPrompt API"] + R_WF["routeWorkflows.py\nWorkflow API"] + R_ATTR["routeAttributes.py\nAttribute API"] + end + subgraph BE_Modules["gateway/modules"] + GI["gatewayInterface.py\nMandate/Auth"] + LDI["lucydomInterface.py\nData management"] + WM["workflowManager.py\nWorkflow engine"] + WAR["workflowAgentsRegistry.py\nAgent registry"] + DP["documentProcessor.py\nDocument processing"] + CFG["configuration.py\nConfiguration"] + MU["mimeUtils.py\nMIME utils"] + AGC["agentCoach.py"] + AGAN["agentAnalyst.py"] + AGC2["agentCoder.py"] + AGE["agentEmail.py"] + AGDOC["agentDocumentation.py"] + AGWC["agentWebcrawler.py"] + end + subgraph BE_Connectors["gateway/connectors"] + DBJSON["connectorDbJson.py\nJSON DB connector"] + AICHAT["connectorAiOpenai.py\nOpenAI connector"] + AIANTH["connectorAiAnthropic.py\nAnthropic connector"] + end + subgraph BE_Main["gateway"] + APP["app.py\nFastAPI main app"] + AUTH_BE["auth.py\nToken management"] + end + + %% Frontend connections + MAIN --> NAV & GLOB & AUTH_FE + WF --> WFC & WFU & WFD & WFT + WFC --> WFU & WFD & WFT + WFD --> API + FL --> GLOB + PR --> GLOB + US --> GLOB + MD --> GLOB + + %% API call from frontend to backend + API -- REST/JSON --> APP + + %% Backend API structure + APP --> AUTH_BE & R_MAND & R_USER & R_FL & R_PR & R_WF & R_ATTR + + %% Backend route to module connections + R_MAND --> GI + R_USER --> GI + R_FL --> LDI + R_PR --> LDI + R_WF --> WM + R_ATTR --> LDI + + %% Backend module connections + WM --> WAR & DP & AGC & AGAN & AGC2 & AGE & AGDOC & AGWC + GI --> DBJSON + LDI --> DBJSON + DP --> LDI + WAR --> LDI + AGC --> LDI + AGAN --> LDI + AGC2 --> LDI + AGE --> LDI + AGDOC --> LDI + AGWC --> LDI + WM --> CFG & MU + LDI --> AICHAT & AIANTH + + %% Legend + classDef frontendMainClass fill:#D6EAF8,stroke:#2E86C1,stroke-width:2px + classDef frontendComponentClass fill:#AED6F1,stroke:#2E86C1,stroke-width:1px + classDef backendMainClass fill:#D5F5E3,stroke:#239B56,stroke-width:2px + classDef backendRouteClass fill:#ABEBC6,stroke:#239B56,stroke-width:1px + classDef coreClass fill:#FCF3CF,stroke:#D4AC0D,stroke-width:2px + classDef coreSubClass fill:#F9E79F,stroke:#D4AC0D,stroke-width:1px + classDef connectorClass fill:#F5EEF8,stroke:#8E44AD,stroke-width:2px + + %% Assign classes + WF:::frontendComponentClass + WFC:::frontendComponentClass + WFU:::frontendComponentClass + WFD:::frontendComponentClass + WFT:::frontendComponentClass + FL:::frontendComponentClass + PR:::frontendComponentClass + US:::frontendComponentClass + MD:::frontendComponentClass + MAIN:::frontendMainClass + NAV:::frontendMainClass + GLOB:::frontendMainClass + UTIL:::frontendMainClass + AUTH_FE:::frontendMainClass + API:::frontendMainClass + R_MAND:::backendRouteClass + R_USER:::backendRouteClass + R_FL:::backendRouteClass + R_PR:::backendRouteClass + R_WF:::backendRouteClass + R_ATTR:::backendRouteClass + APP:::backendMainClass + AUTH_BE:::backendMainClass + GI:::coreClass + LDI:::coreClass + WM:::coreClass + WAR:::coreClass + DP:::coreClass + CFG:::coreClass + MU:::coreClass + AGC:::coreSubClass + AGAN:::coreSubClass + AGC2:::coreSubClass + AGE:::coreSubClass + AGDOC:::coreSubClass + AGWC:::coreSubClass + DBJSON:::connectorClass + AICHAT:::connectorClass + AIANTH:::connectorClass + + %% Legend + %% Note: REST/JSON arrow = API call, normal arrow = direct import/usage + %% Example: API -- REST/JSON --> APP diff --git a/poweron/diagramm_komponenten.png b/poweron/diagramm_komponenten.png new file mode 100644 index 0000000..dab97fa Binary files /dev/null and b/poweron/diagramm_komponenten.png differ diff --git a/poweron/doc_statemachine_backend.md b/poweron/doc_statemachine_backend.md new file mode 100644 index 0000000..5fffb2f --- /dev/null +++ b/poweron/doc_statemachine_backend.md @@ -0,0 +1,247 @@ +# State Machine Documentation for Backend Chat Workflow + +## Overview + +Das Backend implementiert eine State Machine, die Benutzereingaben, Agenten-Workflows und die Kommunikation mit dem Frontend orchestriert. Die State Machine steuert Statusübergänge, Logging, Dokumentenmanagement und Fehlerbehandlung für robuste Multi-Agent-Workflows. + +## Core Objects + +### Workflow Object +```json +{ + "id": "uuid-string", + "mandateId": int, + "userId": int, + "name": "Workflow name", + "startedAt": "ISO-datetime", + "status": "string", // running, completed, failed, stopped + "lastActivity": "ISO-datetime", + "dataStats": { + "bytesSent": int, + "bytesReceived": int, + "tokensUsed": int, + "processingTime": float + }, + "currentRound": int, + "messageIds": [ "string" ], + "messages": [ /* WorkflowMessage */ ], + "logs": [ /* WorkflowLog */ ] +} +``` + +### Message Object +```json +{ + "id": "msg_uuid-string", + "workflowId": "workflow-uuid", + "parentMessageId": "string|null", + "startedAt": "ISO-datetime", + "finishedAt": "ISO-datetime|null", + "sequenceNo": int, + "status": "string", // first, step, last + "role": "string", // user, assistant, system + "dataStats": { /* optional */ }, + "documents": [ /* Document */ ], + "content": "string", + "agentName": "string" +} +``` + +### Log Entry Object +```json +{ + "id": "log_uuid-string", + "workflowId": "workflow-uuid", + "message": "string", + "type": "string", // info, warning, error + "timestamp": "ISO-datetime", + "agentName": "string", + "status": "string", // running, completed, failed, stopped + "progress": int, // Optional, 0-100 + "mandateId": int, + "userId": int +} +``` + +### Document Object +```json +{ + "id": "doc_uuid-string", + "fileId": int, + "name": "string", // Filename ohne Extension + "ext": "string", // File Extension + "data": "base64-encoded-string", // File-Inhalt + "contents": [ /* ContentItem */ ] +} +``` + +### Content Item Object +```json +{ + "sequenceNr": int, // Reihenfolge im Dokument + "name": "string", + "ext": "string", + "contentType": "string", // mime type + "data": "string|base64", // Originalinhalt + "dataExtracted": "string", // Optional: AI-Extrakt + "metadata": { + "isText": boolean, + "base64Encoded": boolean, + "aiProcessed": boolean + // Optional: weitere Metadaten + }, + "summary": "string" // AI-generierte Zusammenfassung +} +``` + +## State Machine Workflow + +### 1. Workflow Initialization +- **Trigger**: User message via `/api/workflows/start` oder `/api/workflows/start?id=string` +- **Input**: `UserInputRequest` mit `prompt` und optional `listFileId` +- **Prozess**: + - Wenn `id` existiert und Workflow existiert: Workflow laden, `currentRound` inkrementieren, Status auf "running" + - Sonst: Neuen Workflow anlegen, `currentRound`=1, Status "running" +- **Logs**: "Workflow initialized" oder "Running workflow", progress 0% +- **API**: 200 OK mit Workflow-ID, Fehler: 400/404/500 + +### 2. Workflow Exception +- **Trigger**: User stoppt Workflow via API oder Exception tritt auf +- **Prozess**: + - Bei Status=="stopped": Status auf "stopped", Log, `lastActivity` aktualisieren, sofort abbrechen + - Bei Status=="failed": Status auf "failed", Log, `lastActivity` aktualisieren, sofort abbrechen + - Sonst: Normal fortfahren +- **Logs**: "Workflow failure reported", progress 100% +- **API**: 200 OK bei Stop, 500 bei Exception + +### 3. User Message Processing +- **Prozess**: + - User-Input wird als Message-Objekt mit Dokumenten gespeichert, Status "first" + - Datei-Inhalte werden extrahiert (`getDocumentContents()`) + - Statische Summaries für Content Items generieren +- **State Changes**: + - User-Message zu `workflow.messages` und `workflow.messageIds` hinzufügen + - `workflow.lastActivity` aktualisieren +- **Logs**: "Workflow processing started", progress 0% + +### 4. Project Manager Analysis +- **Prozess**: + - Prompt für Project Manager AI generieren + - Analyse und Workplan generieren +- **Outputs**: + - `objFinalDocuments`: Liste erwarteter Output-Dokumente + - `objWorkplan`: Liste Agenten-Tasks + - `objUserResponse`: Textantwort an User + - `userLanguage`: Detektierte Sprache +- **State Changes**: + - Assistant-Message mit Status "step" speichern + - User-Language im Interface setzen +- **Logs**: "Analyzing request and planning work" (10%), "Work plan created" (25%) + +### 5. Agent Execution +- **Prozess** (für jeden Task im Workplan): + - Input-Dokumente vorbereiten + - Agent ausführen + - Output-Dokumente speichern + - Assistant-Message mit Status "step" speichern +- **Logs**: "Running task X/Y: agentName" (30-90%) + +### 6. Final Response Generation +- **Prozess**: + - Final-Message mit Review der gelieferten Dokumente erzeugen + - Dokumente zum Workflow hinzufügen +- **State Changes**: Final-Message mit Status "last" speichern +- **Logs**: "Creating final response" (90%) + +### 7. Workflow Completion +- **Prozess**: + - Workflow finalisieren, Status auf "completed" + - `workflow.lastActivity` aktualisieren +- **Logs**: "Workflow completed successfully" (100%) +- **API**: Message mit Status "last" in Response, Status-Endpoint gibt "completed" zurück + +### 8. Workflow Stopped +- **Trigger**: `/api/workflows/{workflowId}/stop` +- **Prozess**: + - Workflow sofort stoppen, Status auf "stopped" + - `lastActivity` aktualisieren +- **Logs**: "Workflow stopped by user" (100%) +- **API**: 200 OK + +### 9. Workflow Failed +- **Trigger**: Exception im Workflow +- **Prozess**: + - Fehler loggen, Status auf "failed" + - `lastActivity` aktualisieren +- **Logs**: Fehler-Log (100%) +- **API**: Status-Endpoint gibt "failed" zurück + +### 10. Workflow Resumption +- **Trigger**: `/api/workflows/start?id={workflowId}` +- **Prozess**: + - Workflow laden, `currentRound` inkrementieren, Status auf "running" + - Neue User-Message hinzufügen +- **Logs**: "Resuming workflow, round {currentRound}" (0%) +- **API**: wie Workflow-Init + +### 11. Workflow Reset/Deletion +- **Trigger**: `/api/workflows/{workflowId}` DELETE +- **Prozess**: + - Workflow und zugehörige Daten löschen +- **Logs**: System-Log "workflow deleted" +- **API**: 200 OK oder 404 + +## API Endpoints und Polling Support + +### Main Workflow Endpoints +- `POST /api/workflows/start?id=string`: Startet neuen Workflow oder setzt fort +- `POST /api/workflows/{workflowId}/stop`: Stoppt laufenden Workflow +- `DELETE /api/workflows/{workflowId}`: Löscht Workflow +- `GET /api/workflows/{workflowId}/status`: Holt Workflow-Status +- `GET /api/workflows/{workflowId}/logs?id=string`: Holt Logs (optional ab ID) +- `GET /api/workflows/{workflowId}/messages?id=string`: Holt Messages (optional ab ID) + +### Document Management +- `DELETE /api/workflows/{workflowId}/messages/{messageId}`: Löscht Message +- `DELETE /api/workflows/{workflowId}/messages/{messageId}/files/{fileId}`: Entfernt Datei aus Message + +### Backend Support für Frontend Polling +- Selektive Datenübertragung via `id`-Parameter bei `/logs` und `/messages` +- Logs enthalten Timestamp, Progress, Status +- Messages enthalten Status ("first", "step", "last") +- Status-Endpoint liefert nur Status und lastActivity +- Caching für häufige Polling-Requests +- Batch/Paging für große Log-/Message-Sets + +## Dokumentenstruktur +- `data`: base64-kodierter Originalinhalt +- `contents`: Liste extrahierter Content Items +- Agents können auf das Original und die extrahierten Inhalte zugreifen + +## State Transitions + +``` +[null] → [running] // New workflow created +[running] → [completed] // Workflow completes successfully +[running] → [stopped] // User manually stops workflow +[running] → [failed] // Error occurs during workflow +[completed] → [running] // User continues workflow with new input (new round) +[stopped] → [running] // User continues after manual stop (new round) +[failed] → [running] // User retries workflow despite error (new round) +[any] → [null] // Workflow deleted +``` + +## Exception Handling + +- Status wird auf "failed" gesetzt bei Fehlern, Fehler werden im Log dokumentiert +- Project Manager/Agenten-Outputs und Inputs werden für Debugging geloggt +- HTTP-Fehler werden mit passendem Statuscode zurückgegeben +- Fehlgeschlagene Agenten-Tasks werden geloggt, stoppen aber nicht den gesamten Workflow + +## Special Notes + +1. **Document Processing**: Datei-Uploads werden mit Content Extraction verarbeitet. +2. **AI Language Support**: Sprache wird erkannt und im Workflow gesetzt. +3. **Round Counting**: Jede Interaktion inkrementiert `currentRound`. +4. **Agent Registry**: Agents werden dynamisch geladen und registriert. +5. **Standardized Task Processing**: Alle Agents implementieren das gleiche Task-Interface. diff --git a/poweron/doc_statemachine_frontend.md b/poweron/doc_statemachine_frontend.md new file mode 100644 index 0000000..e60c7e0 --- /dev/null +++ b/poweron/doc_statemachine_frontend.md @@ -0,0 +1,249 @@ +# State Machine Documentation for Frontend Chat Workflow + +## Overview + +Die Chat-Workflow-Frontend-Logik implementiert eine State Machine, die Benutzerinteraktionen, Datei-Uploads und die Kommunikation mit dem Backend orchestriert. Die State Machine steuert die UI, das Polling und die Statusübergänge und sorgt für eine robuste, reaktive Multi-Agent-Chat-Erfahrung. + +## Core Objects + +### Frontend Workflow State Object +```json +{ + "status": "string", // null, "running", "completed", "failed", "stopped" + "workflowId": "string", // null oder eindeutige Workflow-ID + "logs": [], // Log-Einträge + "chatMessages": [], // Chat-Nachrichten + "lastPolledLogId": "string", // ID des letzten abgeholten Logs + "lastPolledMessageId": "string", // ID der letzten abgeholten Nachricht + "dataStats": { + "bytesSent": int, + "bytesReceived": int, + "tokensUsed": float, + "processingTime": float + }, + "pollFailCount": int, // Zähler für Polling-Fehler + "pollActive": boolean, // Steuert, ob Polling aktiv ist + "sessionId": "string" // Session-Isolation +} +``` + +### User Input State Object +```json +{ + "promptText": "string", // Aktueller Benutzereingabetext + "additionalFiles": [ /* File-Objekte, nicht nur IDs! */ ], + "domElements": {}, // Referenzen auf UI-DOM-Elemente + "sessionId": "string" +} +``` + +### Log Entry Object +```json +{ + "id": "log_timestamp", + "message": "string", + "progress": int, // Optional, 0-100 + "type": "string", // info, warning, error + "timestamp": "ISO-datetime", + "agentName": "string", // Name des Agents + "waiting": boolean, // Zeigt Wartedots-Animation + "highlighted": boolean // Für visuelles Highlighting +} +``` + +### Chat Message Object +```json +{ + "id": "msg_type_timestamp", + "role": "string", // user, assistant + "agentName": "string", + "content": "string", + "documents": [], // Liste von File-Objekten + "timestamp": "ISO-datetime", + "status": "string" // first, step, last +} +``` + +### File Object +```json +{ + "id": "number|string", // numerisch oder UUID + "name": "filename.ext", + "size": int, + "mimeType": "string", // MIME-Type (z.B. application/pdf) + "base64Encoded": boolean, // optional + "content": "string", // optional, für Preview + "isExtracted": boolean // optional, Parsing-Status +} +``` + +## State Machine Workflow + +### 1. Initial State +- **State**: `null` (Kein Workflow aktiv) +- **UI**: Leerer Chat, Eingabefeld aktiv, Start-Button aktiv, Stop-Button ausgeblendet, File-Upload aktiv, leeres Logpanel +- **Aktionen**: Prompt eingeben, Dateien anhängen, Start klicken +- **API**: Keine + +### 2. Prompt Preparation +- **State**: `null` (Übergang zu `running`) +- **Trigger**: Eingabe im Promptfeld, Datei-Upload, Prompt-Auswahl +- **Prozess**: Dateien werden via `api.uploadFile` hochgeladen, erscheinen als File-Objekte in `userInputState.additionalFiles` +- **API**: `POST /api/files/upload` pro Datei + +### 3. Workflow Initialization +- **State**: `running` +- **Trigger**: Start-Button oder Enter +- **Prozess**: Validierung, UI-Ladezustand, Prompt und Files an Backend, Workflow-ID empfangen +- **State-Änderungen**: `status` → `running`, `workflowId` gesetzt, Files und Prompt zurückgesetzt +- **API**: `POST /api/workflows/start` (bzw. mit ID für Fortsetzung) + +### 4. Polling for Updates +- **State**: `running` +- **Prozess**: Polling für Status, Logs, Messages (nur wenn `pollActive` true) +- **Polling-Details**: + - Status: alle 2000ms + - Logs: alle 1000ms + - Messages: alle 1000ms + - Polling stoppt sofort bei `failed` oder `stopped`, bei `completed` erst nach Message mit `status: last` + - Exponentielles Backoff bei Fehlern (`pollFailCount`) +- **API**: `GET /api/workflows/{workflowId}/status|logs|messages` + +### 5. Workflow Running +- **State**: `running` +- **Prozess**: Backend verarbeitet, Frontend pollt, Logs und Messages werden angezeigt +- **UI**: Stop-Button sichtbar, Eingabe gesperrt, Logpanel zeigt Fortschritt, Chat zeigt Agenten-Antworten +- **Aktionen**: Stop möglich, File-Previews, Downloads +- **API**: wie oben, Stop: `POST /api/workflows/{workflowId}/stop` + +### 6. Workflow Completion +- **State**: `completed` +- **Trigger**: Backend gibt Status "completed" oder Message mit `status: last` +- **Prozess**: Finalmessage, Eingabe wieder aktiv, Polling stoppt +- **API**: keine bis neue Eingabe + +### 7. Workflow Failure +- **State**: `failed` +- **Trigger**: Backend gibt Status "failed" +- **Prozess**: Fehlermeldung, Retry möglich, Polling stoppt +- **API**: keine bis Retry + +### 8. Workflow Stopped +- **State**: `stopped` +- **Trigger**: Stop-Button oder Backend gibt "stopped" +- **Prozess**: Verarbeitung gestoppt, Polling stoppt +- **API**: keine bis Fortsetzung oder Reset + +### 9. User Input Requested +- **State**: variiert +- **Trigger**: Message mit `status: last` oder Workflow nicht mehr `running` +- **Prozess**: Log "Waiting for user input", Eingabe aktiv +- **API**: keine bis neue Eingabe + +### 10. Continuation Preparation +- **State**: `completed`, `failed`, `stopped` (Übergang zu `running`) +- **Trigger**: Neue Eingabe nach vorherigem Zyklus +- **Prozess**: Fortsetzung mit bestehender Workflow-ID, Files können ergänzt werden +- **API**: wie Prompt Preparation + +### 11. Workflow Resumption +- **State**: `running` +- **Trigger**: Fortsetzung nach Stop/Fehler/Abschluss +- **Prozess**: Neue Eingabe mit bestehender Workflow-ID, Polling startet erneut +- **API**: `POST /api/workflows/start?id={workflowId}` + +### 12. Workflow Reset +- **State**: `null` +- **Trigger**: Reset-Button +- **Prozess**: Alle State-Daten gelöscht, UI zurückgesetzt +- **API**: Optional `DELETE /api/workflows/{workflowId}` + +## API Interaction Details + +### Polling Implementation +- Polling läuft nur, wenn `pollActive` true ist +- Nach Statuswechsel zu `failed` oder `stopped` wird Polling sofort gestoppt +- Bei `completed` läuft Polling weiter, bis eine Message mit `status: last` kommt +- Exponentielles Backoff bei Fehlern (`pollFailCount`) +- Events wie `workflowStatusChanged`, `chatMessagesUpdated`, etc. synchronisieren die UI + +### API Endpoints Used + +| Frontend Function | Backend Endpoint | Parameters | Description | +|--------------------------|--------------------------------------------------|------------------------------------|---------------------------------------------| +| `startWorkflow()` | `POST /api/workflows/start` | `{ prompt: string, fileIds: [] }` | Startet neuen Workflow | +| `continueWorkflow()` | `POST /api/workflows/start?id={workflowId}` | `{ prompt: string, fileIds: [] }` | Setzt bestehenden Workflow fort | +| `pollWorkflowStatus()` | `GET /api/workflows/{workflowId}/status` | None | Holt aktuellen Workflow-Status | +| `pollWorkflowLogs()` | `GET /api/workflows/{workflowId}/logs?id={lastLogId}` | Optional log ID | Holt neue Logs | +| `pollWorkflowMessages()` | `GET /api/workflows/{workflowId}/messages?id={lastMessageId}` | Optional message ID | Holt neue Nachrichten | +| `stopWorkflow()` | `POST /api/workflows/{workflowId}/stop` | None | Stoppt laufenden Workflow | +| `resetWorkflow()` | `DELETE /api/workflows/{workflowId}` | None | Löscht Workflow-Ressourcen | +| `uploadFile()` | `POST /api/files/upload` | FormData mit Datei | Lädt Datei hoch und gibt File-Objekt zurück | +| `deleteMessage()` | `DELETE /api/workflows/{workflowId}/messages/{messageId}` | None | Entfernt Nachricht aus Workflow | +| `removeFileFromMessage()`| `DELETE /api/workflows/{workflowId}/messages/{messageId}/files/{fileId}` | None | Entfernt Datei aus Nachricht | + +## Special Features + +### File Handling +- File-Uploads liefern vollständige File-Objekte (siehe oben) +- File-Previews, Download, Copy werden unterstützt +- Jedes File kann einzeln entfernt werden + +### Chat Message Rendering +- User- und Agenten-Nachrichten, Markdown, File-Attachments, Zeitstempel, Collapsible Content + +### Log Panel Features +- Info/Warning/Error, Progress, Waiting-Animation, Highlighting, Collapsible Details, Timestamps + +### Waiting States +- Dots-Animation in Logs, Spinner im Send-Button, Progress in Agent-Logs +- State-Management über `waiting`-Flag, `waitingDotsInterval`, `setLoadingState()` + +## State Transitions + +``` +[null] → [running] // Initial prompt submission +[running] → [running] // Ongoing polling updates +[running] → [completed] // Workflow completes successfully +[running] → [stopped] // User manually stops workflow +[running] → [failed] // Error occurs during workflow +[completed] → [running] // User continues workflow with new input +[stopped] → [running] // User continues after manual stop +[failed] → [running] // User retries workflow despite error +[any] → [null] // User resets workflow +``` + +## Error Handling + +### Client-side Errors +- Retry-Mechanismus im Polling (`pollFailCount`) +- Exponentielles Backoff +- Fehlerlogs und Toasts + +### Backend Communication Errors +- Fehlerlogging, User-Feedback, Retry-Option, Toasts + +### Data Inconsistencies +- Fallbacks bei ID-Matching, File-Referenzen, Content Extraction + +## Implementation Notes + +1. **Module Structure:** + - `workflow.js`: Main initialization and coordination + - `workflowCoordination.js`: State management + - `workflowData.js`: Backend communication + - `workflowUi.js`: UI rendering + - `workflowUtils.js`: Helper functions + +2. **Key Functions:** + - `initWorkflowModule()`: Entry point for initialization + - `updateWorkflowStatus()`: Core state transition function + - `pollWorkflowStatus()`: Main update loop + - `sendUserResponse()`: Handles user input submission + - `renderLogs()` und `renderChatMessages()`: UI update functions + +3. **Performance Optimizations:** + - Selektive DOM-Updates + - Scroll-Position-Preservation + - Datenmengen-Schätzung für Statistik + - Bedingtes Re-Rendering diff --git a/poweron/docu_applikation.md b/poweron/docu_applikation.md new file mode 100644 index 0000000..0c90b24 --- /dev/null +++ b/poweron/docu_applikation.md @@ -0,0 +1,382 @@ +# PowerOn AI Platform - Dokumentation + +## Inhaltsverzeichnis + +1. [Übersicht](#übersicht) +2. [Architektur](#architektur) +3. [Kernmodule](#kernmodule) +4. [Benutzeroberfläche](#benutzeroberfläche) +5. [Datenmodell](#datenmodell) +6. [Multi-Agent Workflow-System](#multi-agent-workflow-system) +7. [Externe Connectors](#externe-connectors) +8. [Installation und Konfiguration](#installation-und-konfiguration) +9. [API-Endpunkte](#api-endpunkte) +10. [Sicherheitskonzept](#sicherheitskonzept) + +## Übersicht + +Die PowerOn AI Platform ist eine umfassende Anwendung zur Verwaltung und Durchführung von Multi-Agent-Workflows für komplexe Datenanalyse- und Verarbeitungsaufgaben. Die Plattform ermöglicht die Nutzung von verschiedenen AI-Modellen, Web-Scraping und Datenverarbeitung innerhalb einer benutzerfreundlichen Oberfläche. + +### Hauptfunktionen + +- **Multi-Agent-Workflows**: Koordination verschiedener spezialisierter AI-Agenten für komplexe Aufgaben +- **Web-Scraping**: Integration von Online-Recherche in Workflows +- **Dokumentenverarbeitung**: Analyse und Verarbeitung von Dokumenten und Bildern +- **Workspace-Management**: Organisation von Projekten in Workspaces +- **Benutzerverwaltung**: Mehrstufiges Benutzermanagement mit Mandantenstruktur +- **Modernes Frontend**: Responsive Benutzeroberfläche mit dynamischen Komponenten + +## Architektur + +Die PowerOn AI Platform ist als modulare Webanwendung mit einer klaren Trennung zwischen Frontend und Backend konzipiert. + +### Backend + +Das Backend basiert auf FastAPI (Python) und bietet folgende Komponenten: + +- **Gateway-Interface**: Zentrale Komponente für Authentifizierung und Mandantenverwaltung +- **LucyDOM-Interface**: Datenbank-Interface für Workspaces, Agenten, Files und Prompts +- **Agent-Service**: Orchestrierung und Ausführung von Multi-Agent-Workflows +- **Connector-Module**: Integration mit externen Diensten (OpenAI, Anthropic, Web-Scraping) +- **JSON-Datenbank**: Lokale Datenspeicherung für Entwicklung und Deployment + +### Frontend + +Das Frontend wurde mit modernem JavaScript entwickelt: + +- **Modularer Aufbau**: Klar strukturierte JS-Module mit ES6-Import/Export +- **Responsive Design**: Anpassungsfähige UI für verschiedene Bildschirmgrössen +- **Dynamische Komponenten**: Flexible UI-Elemente für verschiedene Anwendungsfälle +- **REST-API Integration**: Kommunikation mit dem Backend über standardisierte API-Aufrufe + +## Kernmodule + +### Gateway-Interface + +Das Gateway-Interface (`gateway_interface.py`) ist verantwortlich für: + +- Benutzerauthentifizierung und -autorisierung +- Mandantenverwaltung (Multi-Tenant-Architektur) +- Basisinitialisierung der Datenbank + +### LucyDOM-Interface + +Das LucyDOM-Interface (`lucydom_interface.py`) verwaltet: + +- Workspaces und deren Inhalte +- Agenten und deren Konfiguration +- Dateiverwaltung und -zuordnung +- Prompts und Templates + +### Agent-Service + +Der Agent-Service (`agentservice_interface.py`) orchestriert: + +- Ausführung von Multi-Agent-Workflows +- Koordination spezialisierter Agenten über einen Moderator +- Verarbeitung von Dateien und Prompts +- Sammlung und Speicherung von Workflow-Ergebnissen +- Interaktion mit dem Benutzer während eines Workflows + +### Connector-Module + +Verschiedene Connectors verbinden die Plattform mit externen Diensten: + +- **AI-Chat-Connectors**: Integration mit OpenAI/Anthropic für die Agentenverarbeitung +- **Web-Scraping-Connector**: Durchführung von Online-Recherchen +- **DB-Connector**: JSON-basierte Datenspeicherung + +## Benutzeroberfläche + +Die Benutzeroberfläche ist modular aufgebaut und bietet verschiedene funktionale Bereiche: + +### Navigation + +- Hierarchische Menüstruktur mit Modulen und Untermenüs +- Workspace-Auswahl und -Verwaltung +- Benutzer- und Mandantenkontextverwaltung + +### Module + +#### Workspaces + +- Erstellung und Verwaltung von Arbeitsbereichen +- Zentrale Organisation für Agenten, Dateien und Prompts + +#### Agenten + +- Verwaltung verschiedener spezialisierter Agenten +- Konfiguration von Agentenfähigkeiten und -beschreibungen +- Standardagenten: Initialisierung, Organisator, Entwickler, Webscraper, Datenanalyst, Textgenerator, Visualisierer + +#### Dateien + +- Upload und Verwaltung von Dokumenten und Bildern +- Integration in Workflows für Datenverarbeitung + +#### Prompts + +- Erstellung und Verwaltung von Template-Prompts +- Wiederverwendung in verschiedenen Workflows + +#### Workflow + +Das Workflow-Modul ist das Herzstück der Anwendung und ermöglicht: + +- Auswahl von Agenten für spezifische Aufgaben +- Eingabe von Prompts und Anweisungen +- Auswahl relevanter Dateien für die Verarbeitung +- Echtzeit-Überwachung des Workflow-Fortschritts +- Interaktion mit dem Workflow während der Ausführung +- Anzeige und Speicherung von Ergebnissen + +### Admin-Module + +#### Mandantenverwaltung + +- Erstellung und Konfiguration von Mandanten (nur für SysAdmin) +- Zuweisung von Standardressourcen für neue Mandanten + +#### Benutzerverwaltung + +- Erstellung und Verwaltung von Benutzern +- Rechteverwaltung mit drei Stufen: Benutzer, Admin, SysAdmin + +## Datenmodell + +Die PowerOn AI Platform verwendet ein strukturiertes Datenmodell: + +### Mandanten (Mandates) + +- **id**: Eindeutige ID +- **name**: Name des Mandanten +- **language**: Standardsprache +- **disabled**: Flag für deaktivierte Mandanten +- **contact_email**: Kontakt-E-Mail + +### Benutzer (Users) + +- **id**: Eindeutige ID +- **mandate_id**: Zugehöriger Mandant +- **username**: Eindeutiger Benutzername +- **hashed_password**: Gehashtes Passwort (Argon2) +- **email**: E-Mail-Adresse +- **full_name**: Vollständiger Name +- **disabled**: Flag für deaktivierte Benutzer +- **language**: Bevorzugte Sprache +- **privilege**: Berechtigungsstufe (user, admin, sysadmin) + +### Workspaces + +- **id**: Eindeutige ID +- **mandate_id**: Zugehöriger Mandant +- **user_id**: Ersteller des Workspace +- **name**: Name des Workspace +- **created_at**: Erstellungszeitpunkt + +### Agenten (Agents) + +- **id**: Eindeutige ID +- **mandate_id**: Zugehöriger Mandant +- **user_id**: Ersteller des Agenten +- **name**: Name des Agenten +- **type**: Typ des Agenten (initialisierung, organisator, entwickler, scraper, usw.) +- **workspace_id**: Zugehöriger Workspace +- **capabilities**: Fähigkeiten des Agenten +- **description**: Beschreibung des Agenten +- **instructions**: Anweisungen für den Agenten + +### Dateien (Files) + +- **id**: Eindeutige ID +- **mandate_id**: Zugehöriger Mandant +- **user_id**: Hochladender Benutzer +- **name**: Dateiname +- **type**: Dateityp (document, image, usw.) +- **content_type**: MIME-Typ +- **size**: Dateigrösse +- **path**: Speicherort der Datei +- **upload_date**: Hochladezeitpunkt + +### Prompts + +- **id**: Eindeutige ID +- **mandate_id**: Zugehöriger Mandant +- **user_id**: Ersteller des Prompts +- **content**: Prompt-Text +- **workspace_id**: Zugehöriger Workspace +- **created_at**: Erstellungszeitpunkt +- **name**: Name des Prompts + +### Workflows + +- **id**: Eindeutige ID (uuid) +- **mandate_id**: Zugehöriger Mandant +- **user_id**: Ausführender Benutzer +- **status**: Status (running, completed, failed, stopped) +- **progress**: Fortschritt (0.0-1.0) +- **started_at**: Startzeitpunkt +- **completed_at**: Abschlusszeitpunkt +- **agent_statuses**: Status der einzelnen Agenten +- **logs**: Ausführungsprotokolle +- **results**: Ergebnisse der Agenten +- **data_stats**: Statistiken zur Datenübertragung +- **chat_history**: Chat-Verlauf zwischen Agenten + +## Multi-Agent Workflow-System + +Das Multi-Agent-System ist das zentrale Element der PowerOn AI Platform und ermöglicht die Zusammenarbeit verschiedener spezialisierter Agenten. + +### Workflow-Ablauf + +1. **Initialisierung**: Nutzer wählt Agenten, Files und gibt einen Prompt ein +2. **Moderator-Phase**: Moderator koordiniert den Einsatz verschiedener Agenten +3. **Agentenausführung**: Spezifische Agenten führen ihre Aufgaben aus +4. **Benutzerinteraktion**: Bei Bedarf kann der Benutzer in den Workflow eingreifen +5. **Ergebnissammlung**: Ergebnisse werden aggregiert und gespeichert + +### Verfügbare Standardagenten + +Die Plattform bietet folgende vordefinierte Agentenrollen: + +1. **Initialisierung**: Analysiert Anfragen, plant Aufgaben und beantwortet einfache Fragen +2. **Organisator**: Koordiniert komplexe Anfragen und erstellt strukturierte Arbeitspläne +3. **Entwickler**: Erstellt Programmcode und technische Implementierungen +4. **Webscraper**: Führt Web-Recherchen durch und bereitet Informationen auf +5. **Datenanalyst**: Analysiert Daten, identifiziert Muster und erstellt Berichte +6. **Textgenerator**: Erstellt qualitativ hochwertige Texte in verschiedenen Formaten +7. **Visualisierer**: Erstellt Datenvisualisierungen und visuelle Darstellungen + +### User Agent + +Ein besonderer Agententyp ist der "User Agent", der Benutzerinteraktionen während eines laufenden Workflows ermöglicht: + +- Beantwortung von Fragen des Moderators oder anderer Agenten +- Bereitstellung zusätzlicher Dateien während der Ausführung +- Bestätigung von Ergebnissen oder Anforderung weiterer Analysen + +## Externe Connectors + +Die Plattform integriert verschiedene externe Dienste: + +### AI-Chat-Connectors + +- **OpenAI-Connector**: Integration mit OpenAI-API (Standard) +- **Anthropic-Connector**: Alternative Integration mit Anthropic's Claude-Modellen + +Diese Connectors bieten: +- Verarbeitung von Text-Prompts +- Verarbeitung von Bildern und multimodalen Inhalten +- Anpassbare Parameter (temperature, max_tokens) + +### Web-Scraping-Connector + +Der Web-Scraping-Connector ermöglicht: +- Suche nach relevanten Websites basierend auf Keywords +- Extraktion von Inhalten aus Webseiten +- Bewertung und Strukturierung von Online-Informationen + +### JSON-DB-Connector + +Der JSON-Datenbank-Connector bietet: +- Persistente Datenspeicherung in JSON-Dateien +- Unterstützung für Multi-Tenant-Architektur +- Kontextbasierte Datenfilterung + +## Installation und Konfiguration + +### Systemanforderungen + +- Python 3.8+ für das Backend +- Moderne Browser für das Frontend +- Ausreichend Speicherplatz für Dateiuploads und Datenbank + +### Konfiguration + +Die Konfiguration erfolgt über eine `config.ini`-Datei mit folgenden Sektionen: + +- **Connector_AiOpenai**: API-Schlüssel und Parameter für OpenAI +- **Connector_AiWebscraping**: Parameter für Web-Scraping (Timeout, User-Agent, etc.) +- **Module_AgentserviceInterface**: Parameter für den Agent-Service + +## API-Endpunkte + +Die PowerOn AI Platform bietet eine umfassende REST-API: + +### Authentifizierung + +- **POST /api/token**: Login und Token-Generierung + +### Benutzer + +- **GET /api/user/me**: Informationen zum aktuellen Benutzer +- **GET /api/user**: Liste aller Benutzer (Admin) +- **POST /api/user**: Neuen Benutzer erstellen +- **PUT /api/user/{id}**: Benutzer aktualisieren +- **DELETE /api/user/{id}**: Benutzer löschen + +### Mandanten + +- **GET /api/mandates**: Liste aller Mandanten (SysAdmin) +- **POST /api/mandates**: Neuen Mandanten erstellen +- **PUT /api/mandates/{id}**: Mandant aktualisieren +- **DELETE /api/mandates/{id}**: Mandant löschen + +### Workspaces + +- **GET /api/workspaces**: Liste aller Workspaces +- **POST /api/workspaces**: Neuen Workspace erstellen +- **PUT /api/workspaces/{id}**: Workspace aktualisieren +- **DELETE /api/workspaces/{id}**: Workspace löschen + +### Agenten + +- **GET /api/agents**: Liste aller Agenten +- **POST /api/agents**: Neuen Agenten erstellen +- **PUT /api/agents/{id}**: Agenten aktualisieren +- **DELETE /api/agents/{id}**: Agenten löschen + +### Dateien + +- **GET /api/files**: Liste aller Dateien +- **POST /api/files/upload**: Datei hochladen +- **GET /api/files/{id}/download**: Datei herunterladen +- **DELETE /api/files/{id}**: Datei löschen + +### Prompts + +- **GET /api/prompts**: Liste aller Prompts +- **POST /api/prompts**: Neuen Prompt erstellen +- **PUT /api/prompts/{id}**: Prompt aktualisieren +- **DELETE /api/prompts/{id}**: Prompt löschen + +### Workflows + +- **POST /api/workflows/run**: Workflow starten +- **GET /api/workflows/{id}/status**: Workflow-Status abfragen +- **GET /api/workflows/{id}/logs**: Workflow-Logs abrufen +- **GET /api/workflows/{id}/results**: Workflow-Ergebnisse abrufen +- **POST /api/workflows/{id}/stop**: Workflow stoppen +- **POST /api/workflows/{id}/user-input**: Benutzereingabe senden + +## Sicherheitskonzept + +Die PowerOn AI Platform implementiert mehrere Sicherheitsebenen: + +### Authentifizierung + +- **Token-basierte Authentifizierung**: JWT-Tokens für API-Zugriff +- **Sichere Passworthashes**: Argon2-Algorithmus für Passwort-Hashing +- **Automatische Tokenaktualisierung**: Token-Aktualisierung bei Ablauf + +### Autorisierung + +- **Rollenbasierte Zugriffskontrolle**: + - **User**: Standardbenutzer mit Zugriff auf eigene Ressourcen + - **Admin**: Verwaltung von Benutzern und Ressourcen im eigenen Mandanten + - **SysAdmin**: Vollständige Systemverwaltung und Mandantenverwaltung + +### Mandantenisolierung + +- **Strikte Datentrennung**: Jeder Mandant hat nur Zugriff auf eigene Daten +- **Kontextbasierte Filterung**: Automatische Filterung von Abfrageergebnissen basierend auf Mandantenzugehörigkeit \ No newline at end of file diff --git a/poweron/docu_investoren.md b/poweron/docu_investoren.md new file mode 100644 index 0000000..96f5965 --- /dev/null +++ b/poweron/docu_investoren.md @@ -0,0 +1,67 @@ +# PowerOn AI Platform +## Investoren-Summary + +### Marktpositionierung + +Die PowerOn AI Platform ist eine innovative Enterprise-Lösung für die Automatisierung und Optimierung von komplexen geschäftlichen Prozessen durch einen Multi-Agent-KI-Ansatz. Wir positionieren uns an der Schnittstelle zwischen den schnell wachsenden Märkten für: +- Künstliche Intelligenz (Marktvolumen 2025: $190 Mrd.) +- Business Process Automation (Marktvolumen 2025: $19,6 Mrd.) +- Enterprise Knowledge Management (Marktvolumen 2025: $43 Mrd.) + +### Wettbewerbsvorteile + +1. **Proprietäre Multi-Agent-Technologie**: Unsere Plattform orchestriert spezifische KI-Agenten für verschiedene Aufgaben, was zu deutlich überlegenen Ergebnissen im Vergleich zu Einzelagenten-Ansätzen führt. + +2. **Modellunabhängigkeit**: Integration mit führenden KI-Providern (OpenAI, Anthropic) ohne Vendor Lock-in, wodurch wir immer die besten Modelle für spezifische Aufgaben einsetzen können. + +3. **Enterprise-Ready**: Entwickelt mit Multi-Tenant-Architektur, umfassenden Sicherheitsfeatures und Skalierbarkeit für Unternehmensanforderungen. + +4. **Anpassbar und erweiterbar**: Modulare Architektur, die kontinuierliche Feature-Erweiterungen und kundenspezifische Anpassungen ermöglicht. + +### Finanzielle Highlights + +- **Go-to-Market-Strategie**: Initiale Fokussierung auf mittelständische Unternehmen in den Bereichen Professional Services, Finanzdienstleistungen und Gesundheitswesen. + +- **Umsatzmodell**: Kombiniertes SaaS-Abonnement (pro Benutzer/Monat) und nutzungsbasierte Abrechnung (pro Verarbeitungseinheit). + +- **Erwartete Bruttomarge**: 75-85% nach Erreichen der Skalierung. + +- **Erwartetes ARR in Jahr 3**: €4,5 Mio. bei 150 Unternehmenskunden. + +- **Kostenstrukturen**: + - 40% Produktentwicklung + - 30% Vertrieb und Marketing + - 20% Betrieb und Support + - 10% Verwaltung + +### Wachstumspfad + +#### Kurzfristig (12 Monate) +- Markteinführung der Core-Plattform +- Aufbau von 3-5 Schlüsselreferenzkunden +- Entwicklung branchenspezifischer Templates + +#### Mittelfristig (24 Monate) +- Erweiterung auf Agentenmarktplatz +- Integration von proprietären Unternehmensmodellen +- Internationale Expansion + +#### Langfristig (36+ Monate) +- Entwicklung spezialisierter Branchenlösungen +- KI-Middleware für Unternehmen +- Strategische Partnerschaften mit Enterprise-Software-Anbietern + +### Investitionsbedarf + +Das aktuelle Finanzierungsziel von CHF 2.5 Mio. ermöglicht: +- Abschluss der Produktentwicklung und Erreichen der Marktreife +- Aufbau eines Vertriebs- und Marketingteams +- Sicherung strategischer Partnerschaften +- 18-monatige Runway bis zur Profitabilität + +### Exit-Potenzial + +Das Team sieht folgende Exit-Optionen: +1. Strategische Übernahme durch Enterprise-Software-Unternehmen (5-7 Jahre) +2. Erwerb durch grössere KI-Plattform (3-5 Jahre) +3. IPO bei Erreichen von CHF 50+ Mio. ARR (7-10 Jahre) diff --git a/poweron/docu_kunden.md b/poweron/docu_kunden.md new file mode 100644 index 0000000..0298e8e --- /dev/null +++ b/poweron/docu_kunden.md @@ -0,0 +1,90 @@ +# PowerOn AI Platform +## Mehrwert für Kunden + +### Herausforderungen moderner Unternehmen + +Im digitalen Zeitalter stehen Unternehmen vor komplexen Herausforderungen: + +- **Datenüberflutung**: Mitarbeiter verbringen durchschnittlich 30% ihrer Zeit mit der Suche nach Informationen +- **Ressourcenknappheit**: Fachkräftemangel in Schlüsselbereichen wie Datenanalyse und Software-Entwicklung +- **Entscheidungsdruck**: Die Notwendigkeit schneller, aber fundierter Entscheidungen in volatilen Märkten +- **Wissensmanagement**: Verteiltes Unternehmens-Know-how effektiv erfassen und nutzbar machen +- **Prozesseffizienz**: Komplexe Prozesse optimieren und Ressourcen sinnvoll einsetzen + +### Wie die PowerOn AI Platform diese Herausforderungen löst + +#### 1. Von isolierten KI-Lösungen zur intelligenten Orchestrierung + +Herkömmliche KI-Lösungen arbeiten isoliert und können nur eine Aufgabe erfüllen. **PowerOn orchestriert spezialisierte Agenten**, die zusammenarbeiten wie ein Team von Experten: + +- **Ein Recherche-Agent** sammelt aktuelle Daten aus dem Internet +- **Ein Analyse-Agent** wertet komplexe Daten aus und extrahiert Erkenntnisse +- **Ein Entwickler-Agent** programmiert und automatisiert Routinen +- **Ein Visualisierungs-Agent** erstellt aussagekräftige Grafiken und Dashboards +- **Ein Text-Agent** verfasst präzise Berichte und Zusammenfassungen + +Erst die intelligent koordinierte Zusammenarbeit dieser Spezialisten ermöglicht herausragende Ergebnisse. + +#### 2. Beschleunigte Entscheidungsprozesse + +In einer Studie mit Pilotanwendern führte der Einsatz der PowerOn Plattform zu: +- 73% schnelleren Marktanalysen +- 62% Zeitersparnis bei Berichterstellung +- 47% schnellere Prototypenentwicklung + +#### 3. Demokratisierung von KI-Fähigkeiten + +- **Keine Programmierkenntnisse erforderlich**: Intuitive Benutzeroberfläche für alle Mitarbeiter zugänglich +- **Transparenter KI-Einsatz**: Nachvollziehbare Prozesse und Ergebnisse +- **Anpassbare Workflows**: Jede Abteilung kann eigene KI-Workflows erstellen + +#### 4. Nahtlose Integration in bestehende Systeme + +- **Arbeiten mit vorhandenen Daten**: Verarbeitung aller gängigen Dateiformate +- **Keine IT-Umstellung notwendig**: Einfache Implementierung ohne Infrastrukturänderungen +- **Skalierbare Architektur**: Wachstum mit Ihren Anforderungen + +### Konkrete Anwendungsfälle und ROI + +#### Anwendungsfall 1: Marktforschung & Competitive Intelligence +- **Vorher**: 3-4 Wochen für umfassende Marktanalyse, 20+ Arbeitsstunden für Datensammlung +- **Mit PowerOn**: 3-5 Tage für gleiche Analysetiefe, automatisierte Datenextraktion aus dem Web +- **ROI**: Kosteneinsparung von €5.000-8.000 pro Analyse + +#### Anwendungsfall 2: Dokumentenanalyse & Wissensextraktion +- **Vorher**: Durcharbeiten hunderter Seiten durch hochqualifizierte Mitarbeiter +- **Mit PowerOn**: Automatische Extraktion von Schlüsselinformationen, Erstellung präziser Zusammenfassungen +- **ROI**: Reduktion des Zeitaufwands um 80%, Freisetzung von Expertenkapazität für wertschöpfende Tätigkeiten + +#### Anwendungsfall 3: Automatisierung von Berichten & Dokumentation +- **Vorher**: Monotone, fehleranfällige manuelle Erstellung von Standardberichten +- **Mit PowerOn**: Template-basierte Automatisierung mit intelligenter Datenkontextualisierung +- **ROI**: Zeitersparnis von 15-20 Stunden pro Monat pro Mitarbeiter, höhere Qualitätskonsistenz + +#### Anwendungsfall 4: Prototyping & Schnellentwicklung +- **Vorher**: Wochen für die Entwicklung von Proof-of-Concept-Lösungen +- **Mit PowerOn**: Agenten generieren funktionsfähigen Code und Visualisierungen in Stunden +- **ROI**: 70% schnellere Entwicklungszyklen, erheblich geringere Entwicklungskosten + +### Was unsere Kunden sagen + +> "Die PowerOn Plattform hat unseren Marktanalyse-Prozess revolutioniert. Was früher Wochen dauerte, geschieht jetzt in Tagen - mit tieferen Einblicken und besserer Datenqualität." +> +> **Maria Schmidt, Chief Strategy Officer, TechVision GmbH** + +> "Der ROI war sofort messbar. Allein im ersten Quartal haben wir 120 Arbeitsstunden bei Routineanalysen eingespart und konnten unsere Experten für strategische Projekte einsetzen." +> +> **Thomas Weber, Head of Business Intelligence, FinanceFirst AG** + +### Implementierung und Onboarding + +- **Schnelle Einrichtung**: Betriebsbereit innerhalb von 1-2 Wochen +- **Umfassende Schulung**: Strukturierte Einarbeitung für alle Benutzergruppen +- **Dedizierter Support**: Persönlicher Ansprechpartner für Ihr Unternehmen +- **Kontinuierliche Optimierung**: Regelmässige Updates und neue Funktionen + +### Nächste Schritte + +1. **Kostenlose Demo**: Erleben Sie die Leistungsfähigkeit der Plattform in einer persönlichen Vorführung +2. **Proof of Concept**: Testen Sie die Plattform mit einem spezifischen Anwendungsfall Ihres Unternehmens +3. **Massgeschneiderte Lösung**: Entwicklung eines auf Ihre Bedürfnisse zugeschnittenen Implementierungsplans \ No newline at end of file diff --git a/poweron/docu_summary.md b/poweron/docu_summary.md new file mode 100644 index 0000000..1d7653f --- /dev/null +++ b/poweron/docu_summary.md @@ -0,0 +1,58 @@ +# PowerOn AI Platform +## 3-Folien-Kurzpräsentation + +### 1: Die PowerOn AI Platform im Überblick + +#### Was wir erschaffen haben: +* **Multi-Agent-KI-Plattform** für komplexe geschäftliche Herausforderungen +* **Orchestrierte Zusammenarbeit** spezialisierter KI-Agenten unter Moderation +* **Enterprise-ready** mit Multi-Tenant-Architektur und Workspace-Konzept + +#### Zusammenspiel Mensch & KI bei der Entwicklung: + +| Menschlicher Beitrag | KI-Beitrag | +|---------------------|-------------| +| • Architekturentscheidungen & Systemdesign | • Umsetzung der Code-Basis in verschiedenen Sprachen | +| • Definition der Agentenrollen & -fähigkeiten | • Generierung konsistenter Implementierungen | +| • Domänenexpertise für verschiedene Anwendungsfälle | • Automatisierung repetitiver Entwicklungsaufgaben | +| • Qualitätssicherung & strategische Entscheidungen | • Dokumentationserstellung & -pflege | + +### 2: Technische Highlights & Zusammenarbeit + +#### Kern-Komponenten: +* **Frontend**: Modulares JS-System mit intuitiver Benutzeroberfläche +* **Workflow-Engine**: Intelligente Agentenkoordination mit Benutzerinteraktion +* **Connectors**: Nahtlose Integration mit OpenAI/Anthropic und Web-Quellen + +#### Wie die Entwicklung abläuft: + +| Menschlicher Entwicklungsprozess | KI-unterstützter Entwicklungsprozess | +|----------------------------------|--------------------------------------| +| • Entscheidung über Systemarchitektur | • Generierung konsistenter Codebausteine | +| • Definition von Anforderungen & Schnittstellen | • Automatische Erstellung von Boilerplate-Code | +| • Code-Reviews & kritische Optimierungen | • Fehlersuche & Vorschläge für Verbesserungen | +| • Strategische Planung der nächsten Features | • Automatische Anpassung der Dokumentation | +| • Usability-Tests & UX-Entscheidungen | • Generierung von Testfällen & Validierungslogik | + +### 3: Das System in Aktion & nächste Schritte + +#### Workflow-Beispiel: +1. **Benutzer** wählt spezifische Agenten und lädt relevante Dateien hoch +2. **KI-Moderator** analysiert die Aufgabe und aktiviert passende Spezialisten-Agenten +3. **Agenten-Team** arbeitet gemeinsam an der Lösung (Datenanalyse, Recherche, Code, Text) +4. **Benutzer** kann jederzeit eingreifen und Feedback geben +5. **Ergebnis** wird strukturiert aufbereitet und gespeichert + +#### Stand und Ausblick: + +| Bereits umgesetzt | In Entwicklung | +|------------------|----------------| +| • 7 spezialisierte Agentenrollen | • Erweiterbarer Agentenmarktplatz | +| • Vollständiger Workflow-Zyklus | • Verbessertes Fehlerhandling | +| • Dokument- & Bildverarbeitung | • Multi-Modell-Unterstützung | +| • Interaktive Web-Recherche | • Erweitertes Dashboard | +| • Multi-Tenant-Architecture | • API für Drittanbieter-Integration | + +#### Entwicklungsphilosophie: +> **"Wir kombinieren menschliche Kreativität und Urteilsvermögen mit KI-Effizienz und Präzision, +> um ein System zu erschaffen, das mehr ist als die Summe seiner Teile."** \ No newline at end of file diff --git a/poweron/poweron_summary_202404.md b/poweron/poweron_summary_202404.md new file mode 100644 index 0000000..095a4c5 --- /dev/null +++ b/poweron/poweron_summary_202404.md @@ -0,0 +1,25 @@ +# PowerOn AI Platform: Kurze Kapitelzusammenfassungen + +## 1. Systemzweck und Wertversprechen + +PowerOn adressiert die Herausforderung der Automatisierung komplexer Geschäftsprozesse durch einen innovativen Multi-Agent-KI-Ansatz. Unsere Plattform positioniert sich an der Schnittstelle von KI, Business Process Automation und Enterprise Knowledge Management mit einem kombinierten Marktvolumen von über 250 Milliarden Dollar bis 2025. Der Wettbewerbsvorteil liegt in unserer proprietären Multi-Agent-Technologie, der Modellunabhängigkeit ohne Vendor Lock-in, der Enterprise-Ready-Architektur und der modularen Anpassungsfähigkeit, die kontinuierliche Verbesserungen ermöglicht. + +## 2. Architektur und Agentensystem + +Die PowerOn Plattform basiert auf einer modularen Architektur mit klarer Trennung zwischen Frontend und Backend. Das Backend orchestriert über das Gateway-Interface, LucyDOM-Interface und den Agent-Service das Zusammenspiel aller Komponenten. Das Frontend bietet mit modernen JavaScript-Technologien eine responsive, intuitive Benutzeroberfläche. Herzstück ist unser hierarchisches Multi-Agent-System: Der Initialisierungs-Agent analysiert Anfragen, der Moderator/Organisator koordiniert spezialisierte Agenten (Entwickler, Webscraper, Datenanalysten, Textgeneratoren und Visualisierer), die parallel arbeiten und so komplexe Aufgaben effizient bewältigen. + +## 3. Workflow-Demonstration + +Der PowerOn Workflow ist ein nahtloser Prozess: Nutzer wählen Agenten und Dateien aus und formulieren einen Prompt. Der Organisator-Agent analysiert die Aufgabe und erstellt einen strukturierten Arbeitsplan. Die spezialisierten Agenten arbeiten parallel an ihren Aufgaben, während der Nutzer bei Bedarf direkt interagieren kann. Dieses Feature ermöglicht einen dynamischen, iterativen Arbeitsablauf ohne Neustart des Prozesses. Am Ende werden alle Ergebnisse aggregiert, strukturiert und gespeichert, sodass der Nutzer sowohl das Endergebnis als auch Einblick in den Analyseprozess erhält. + +## 4. Skalierbarkeit und Vernetzungspotenzial + +PowerOn ist auf Skalierbarkeit ausgelegt. Die Multi-Tenant-Architektur gewährleistet Datentrennung bei effizienter Ressourcennutzung, während die Modellunabhängigkeit Flexibilität bei der Nutzung verschiedener KI-Anbieter bietet. Umfassende REST-APIs ermöglichen nahtlose Integration in Unternehmenslandschaften. Unser hybrides Geschäftsmodell kombiniert Abonnements mit nutzungsbasierter Abrechnung, was vorhersehbare Einnahmen und Wachstumspotenzial bietet. Nach Erreichen der Skalierung erwarten wir Bruttomargen von 75-85%, da die Hauptkosten in der Entwicklung liegen, während die laufenden Betriebskosten vergleichsweise gering bleiben. + +## 5. Roadmap: Nächste Schritte und Integration + +Unsere Roadmap folgt einer dreistufigen Strategie: Kurzfristig (12 Monate) fokussieren wir auf die Markteinführung der Core-Plattform mit 3-5 Schlüsselreferenzkunden und der Entwicklung branchenspezifischer Templates. Mittelfristig (24 Monate) erweitern wir die Plattform um einen Agentenmarktplatz, integrieren proprietäre Unternehmensmodelle und beginnen mit der internationalen Expansion. Langfristig (36+ Monate) entwickeln wir spezialisierte Branchenlösungen und positionieren PowerOn als zentrale KI-Middleware für Unternehmen. Prioritäre Integrationsbereiche sind ERP/CRM-Systeme, Cloud-Speicherdienste, Business Intelligence Tools und ein SDK für kundenspezifische Integrationen. + +## 6. Nächste Schritte + +Unser Finanzierungsziel von 2,5 Millionen CHF deckt vier kritische Bereiche ab: Abschluss der Produktentwicklung, Aufbau eines schlagkräftigen Verkaufs- und Marketingteams, Sicherung strategischer Partnerschaften und eine 18-monatige Runway bis zur Profitabilität. Wir prognostizieren im dritten Jahr einen wiederkehrenden Umsatz von 4,5 Millionen CHF bei etwa 150 Unternehmenskunden. Die unmittelbaren Meilensteine sind: Abschluss der Core-Entwicklung (Q2 2025), geschlossene Beta mit drei Pilotkunden (Q3 2025) und offizieller Marktstart (Q4 2025). \ No newline at end of file diff --git a/poweron/spec.md b/poweron/spec.md new file mode 100644 index 0000000..5334726 --- /dev/null +++ b/poweron/spec.md @@ -0,0 +1,176 @@ +# PowerOn Frontend Architektur & Spezifikation + +## 1. Funktionsumfang des Frontends + +Das Frontend der PowerOn-Plattform bietet folgende Kernfunktionen: + +- **Multi-Agent Chat-Workflow**: Interaktive Chat-Oberfläche für die Steuerung von Workflows mit mehreren KI-Agenten. +- **Datei-Upload & -Verwaltung**: Nutzer können Dateien hochladen, anhängen, einsehen und herunterladen. +- **Prompt-Verwaltung**: Verwaltung und Nutzung von Prompt-Vorlagen für wiederkehrende Aufgaben. +- **Log- und Statusanzeige**: Fortschrittsanzeige, Fehler- und Statusmeldungen für Workflows. +- **Benutzer- und Mandantenverwaltung**: Admin-Funktionen zur Verwaltung von Usern und Mandanten. +- **Dynamische Datentabellen**: CRUD-Operationen (Create, Read, Update, Delete) für beliebige Entitäten über generische Tabellen und Formulare. +- **Authentifizierung**: Login via klassischem Account oder Microsoft-Account. + +## 2. Struktur des Frontends + +Das Frontend ist modular aufgebaut und besteht aus folgenden Hauptmodulen und -bereichen: + +- **js/main.js**: Einstiegspunkt, Initialisierung der App und Navigation. +- **js/shared/**: Gemeinsame Module für State-Management, API-Calls, Navigation, Utilities, Authentifizierung, Formulargenerierung. + - **globalState.js**: Zentrale State-Verwaltung und Navigation. + - **apiCalls.js**: Konsolidierte Schnittstelle für Backend-Kommunikation. + - **formGeneric.js**: Generisches Modul für CRUD-Tabellen und Formulare. + - **msftCalls.js**: Microsoft-Authentifizierung und Status. + - **navigation.js**: Dynamische Navigation und Menü-Rendering. + - **utils.js**: Hilfsfunktionen (z.B. Toasts, UI-Feedback). +- **js/modules/**: Feature-spezifische Module (z.B. prompts.js, users.js, files.js). +- **public/htmlparts/**: HTML-Teile und Stylesheets für Layout, Navigation, Workflow, Formulare. +- **public/docu/**: Dokumentation und Spezifikationen. + +## 3. Kommunikation mit dem Backend + +Die gesamte Kommunikation mit dem Backend erfolgt konsolidiert über das Modul **apiCalls.js**. Dieses Modul bietet Funktionen für alle relevanten API-Endpunkte: + +- **Workflows**: Starten, Fortsetzen, Stoppen, Status, Logs, Nachrichten, Löschen +- **Dateien**: Upload, Download, Löschen, Anhängen/Entfernen an Nachrichten +- **Prompts**: CRUD-Operationen für Prompt-Vorlagen +- **User/Mandanten**: Verwaltung von Benutzern und Mandanten +- **Generische Entitäten**: CRUD für beliebige Datentabellen + +Alle API-Aufrufe sind asynchron und liefern Promises zurück. Fehlerbehandlung und Statusmeldungen werden zentral im Modul und über UI-Feedback (Toasts) gehandhabt. + +## 4. Workflow-States (State Machine) + +Die States eines Workflows sind in den Dateien @doc_statemachine_backend.md und @doc_statemachine_frontend.md ausführlich beschrieben. Die wichtigsten States sind: + +- **null**: Kein Workflow aktiv +- **running**: Workflow läuft, Polling aktiv +- **completed**: Workflow abgeschlossen, UI bereit für neue Eingabe +- **failed**: Fehler aufgetreten, UI zeigt Fehler und Retry-Option +- **stopped**: Workflow wurde gestoppt, UI bietet Fortsetzen/Reset + +Transitions und State-Änderungen werden sowohl im Backend als auch im Frontend synchronisiert und über Polling-Mechanismen aktuell gehalten. + +## 5. Administrierung von Usern, Mandanten und Datentabellen + +Die Administration erfolgt konsolidiert über das generische Modul **formGeneric.js**: + +- **User- und Mandantenverwaltung**: CRUD-Tabellen und Formulare für Benutzer und Mandanten, inklusive Rechteverwaltung. +- **Datentabellen**: Beliebige Entitäten (z.B. Prompts, Dateien, Workflows) können als Tabelle mit Formularen verwaltet werden. +- **Features**: + - Tabellenansicht mit Filter, Sortierung, Pagination, Massenaktionen + - Formulare für Erstellen/Bearbeiten mit dynamischer Feldgenerierung + - Validierung und Transformation der Formulardaten + - Externe Buttons für "+ Neuen ... erstellen" können einfach angebunden werden + - Felder, die mit "_" beginnen oder Zeitstempel wie "created_at" werden automatisch ausgeblendet + +## 6. Implementierung & Datenstruktur für das formGeneric Modul + +**Hinweis:** Die folgenden Beispiele und Erklärungen beziehen sich exemplarisch auf die Tabelle **"prompt"**. Das Prinzip ist jedoch für alle mit formGeneric verwalteten Entitäten identisch. + +### Was macht das Modul formGeneric? + +Das Modul **formGeneric.js** stellt eine generische Lösung für die Verwaltung beliebiger Datentabellen im Frontend bereit. Es übernimmt: + +- Das Laden, Anzeigen, Erstellen, Bearbeiten und Löschen (CRUD) von Datensätzen +- Die dynamische Generierung von Tabellen und Formularen anhand der gelieferten Datenstruktur +- Die Filterung, Sortierung, Paginierung und Massenaktionen in der Tabellenansicht +- Die Validierung und Transformation von Formulardaten (optional) +- Die Anbindung externer Buttons (z.B. "+ Neuen Prompt erstellen") +- Die automatische Ausblendung von Feldern, die mit "_" beginnen oder Zeitstempel wie "created_at" enthalten +- Die Berücksichtigung von Berechtigungen: Felder wie `_hideEdit`, `_hideDelete`, `_hideView` steuern, ob die jeweiligen Aktionen für einen Datensatz im UI angezeigt werden +- Die Rendering-Logik: Längere Felder wie "content" oder "description" werden als Textarea dargestellt, boolesche Felder als Checkbox, numerische Felder als Zahlenfeld +- Die dynamische Anpassung an die Datenstruktur: Die Felder werden aus dem ersten Element der Datenliste abgeleitet + +### Immer vorhandene/unterstützte Parameter (pro Datensatz) + +- **id**: Eindeutige ID des Datensatzes (wird immer angezeigt) +- **_**-Felder: Interne Felder, die mit "_" beginnen, werden in Tabellen und Formularen ausgeblendet +- **createdAt, updatedAt, created_at**: Zeitstempel werden automatisch ausgeblendet +- **_hideEdit, _hideDelete, _hideView**: Steuern, ob die jeweiligen Aktionen (Bearbeiten, Löschen, Anzeigen) im UI für diesen Datensatz angezeigt werden +- **Weitere Felder**: Werden dynamisch als Spalten und Formularfelder generiert, sofern sie nicht explizit ausgeschlossen sind + +### Integration + +Das Modul wird wie folgt initialisiert: + +```js +window.genericEntityModule.init(globalState, { + entityType: 'prompt', // oder 'user', 'mandate', ... + apiEndpoint: { + get: api.getPrompts, + create: api.createPrompt, + update: api.updatePrompt, + delete: api.deletePrompt + }, + listContainerId: 'prompts-list', + addButtonId: 'add-prompt-btn', + transformFormData: function(formData) { /* optional */ }, + onItemCreated: function(item) { /* optional */ }, + onItemUpdated: function(item) { /* optional */ }, + onItemDeleted: function(id) { /* optional */ } +}); +``` + +### Erwartete Datenstruktur (aus der Route/API) + +Das Modul erwartet, dass die API-Endpoints Objekte mit folgender Struktur liefern (Beispiel Prompt): + +```json +{ + "id": 123, + "name": "Prompt-Name", + "description": "Beschreibung", + "content": "Prompt-Inhalt", + "createdAt": "2024-05-11T12:34:56Z", + "updatedAt": "2024-05-11T12:34:56Z", + "_internal": "...", // wird ignoriert + "_hideEdit": false, // steuert Bearbeiten-Button + "_hideDelete": false, // steuert Löschen-Button + "_hideView": false // steuert Anzeigen-Button +} +``` + +- Felder mit "_" am Anfang sowie Zeitstempel wie "createdAt", "updatedAt", "created_at" werden automatisch in Tabellen und Formularen ausgeblendet. +- Die Felder werden dynamisch aus dem ersten Element der Datenliste generiert. +- Für längere Felder wie "content" oder "description" wird automatisch ein Textarea verwendet. +- Checkboxen für boolesche Felder, Zahlenfelder für numerische Werte. +- Die Sichtbarkeit von Aktionen (Bearbeiten, Löschen, Anzeigen) wird pro Datensatz über die _hide*-Felder gesteuert. + +### Erweiterbarkeit + +- Das Modul kann für beliebige Entitäten verwendet werden, solange die API die Standard-CRUD-Methoden bereitstellt. +- Zusätzliche Aktionen (z.B. "Vorschau", "Spezial-Buttons") können über die Option `getItemActions` ergänzt werden. +- Die UI ist vollständig dynamisch und passt sich der gelieferten Datenstruktur an. + +--- + +## 7. Workflow-UI: Darstellung und Datenfluss + +Das Workflow-Modul im Frontend bildet die zentrale Chat- und Prozessansicht ab. Die wichtigsten UI-Elemente und deren Datenquellen sind: + +- **Chatbereich**: Zeigt alle Nachrichten (user, agent, system) als Chat-Bubbles an. Die Nachrichten werden aus dem Backend über `/api/workflows/{workflowId}/messages` geladen und enthalten: + - `content`: Text der Nachricht + - `role`: user, assistant, agentName + - `documents`: Anhänge (Dateien, die angezeigt oder heruntergeladen werden können) + - `timestamp`, `status` (first, step, last) +- **Logpanel**: Zeigt den Fortschritt und Status des Workflows an. Die Logs werden aus `/api/workflows/{workflowId}/logs` geladen und enthalten: + - `message`: Logtext + - `progress`: Fortschritt (0-100%) + - `type`: info, warning, error + - `agentName`, `timestamp` +- **Prompt-Eingabe**: Textfeld für Nutzereingaben, Datei-Upload-Bereich, Start/Send-Button, Stop-Button +- **Dateianhänge**: Hochgeladene Dateien werden im UI angezeigt und können entfernt werden. Die Metadaten kommen aus `/api/files/upload` und den Nachrichtenobjekten. +- **Statusanzeige**: Zeigt den aktuellen Workflow-Status (running, completed, failed, stopped) an, basierend auf `/api/workflows/{workflowId}/status`. +- **Polling-Mechanismus**: Das Frontend pollt periodisch die Status-, Log- und Nachrichtenendpunkte, um die UI aktuell zu halten. Neue Nachrichten und Logs werden automatisch ergänzt. +- **Fehler- und Abschlusszustände**: Bei Fehlern oder Abschluss werden entsprechende UI-Elemente (z.B. Retry, Reset, neue Eingabe) angezeigt. + +**Datenfluss:** +- Nach Start eines Workflows werden alle relevanten Daten (Nachrichten, Logs, Status) regelmäßig vom Backend geladen und im UI aktualisiert. +- Die Zuordnung von Nachrichten, Logs und Dateien erfolgt über IDs und Statusfelder. +- Die UI ist so gestaltet, dass sie den aktuellen Stand des Workflows und alle relevanten Aktionen für den Nutzer transparent darstellt. + +--- + +**Letzte Aktualisierung:** 2024-05-11 \ No newline at end of file