diff --git a/.gitignore b/.gitignore
new file mode 100644
index 00000000..82f92755
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,162 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+# Usually these files are written by a python script from a template
+# before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+# For a library or package, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+# However, in case of collaboration, if having platform-specific dependencies or dependencies
+# having no cross-platform support, pipenv may install dependencies that don't work, or not
+# install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+# This is especially recommended for binary packages to ensure reproducibility, and is more
+# commonly ignored for libraries.
+# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+# in version control.
+# https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+# JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+# and can be added to the global gitignore or merged into this file. For a more nuclear
+# option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
diff --git a/backend/agent_service.py b/backend/agent_service.py
new file mode 100644
index 00000000..8cf6d4a2
--- /dev/null
+++ b/backend/agent_service.py
@@ -0,0 +1,255 @@
+import asyncio
+import uuid
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import logging
+import json
+import os
+
+logger = logging.getLogger(__name__)
+
+class AgentService:
+ """
+ Service für die Verwaltung und Ausführung von Multi-Agent-Workflows.
+ In einer Produktionsumgebung würde hier eine Integration mit echten KI-Diensten
+ und eine Orchestrierung der verschiedenen Agenten stattfinden.
+ """
+
+ def __init__(self):
+ self.workflows = {}
+ self.results_dir = "./results"
+ os.makedirs(self.results_dir, exist_ok=True)
+
+ async def execute_workflow(
+ self,
+ workflow_id: str,
+ prompt: str,
+ agents: List[Dict[str, Any]],
+ files: List[Dict[str, Any]]
+ ) -> str:
+ """
+ Führt einen Workflow mit den angegebenen Agenten und Dateien aus.
+ Diese Methode simuliert die Ausführung für Demo-Zwecke.
+
+ In einer echten Implementierung würde hier die tatsächliche Orchestrierung
+ der Agenten und die Verarbeitung der Dateien stattfinden.
+ """
+ logger.info(f"Starte Workflow {workflow_id} mit {len(agents)} Agenten und {len(files)} Dateien")
+
+ # Workflow initialisieren
+ self.workflows[workflow_id] = {
+ "id": workflow_id,
+ "status": "running",
+ "progress": 0.0,
+ "started_at": datetime.now().isoformat(),
+ "completed_at": None,
+ "agent_statuses": {},
+ "logs": [],
+ "results": []
+ }
+
+ # Log-Eintrag für den Start des Workflows
+ self._add_log(workflow_id, "Workflow gestartet", "info")
+ self._add_log(workflow_id, f"Verarbeite {len(files)} Dateien...", "info")
+
+ self.workflows[workflow_id]["progress"] = 0.1
+ await asyncio.sleep(1) # Simuliere Verarbeitungszeit
+
+ # Verarbeitung pro Agent simulieren
+ for i, agent in enumerate(agents):
+ agent_id = agent["id"]
+ agent_name = agent["name"]
+ agent_type = agent["type"]
+
+ self.workflows[workflow_id]["agent_statuses"][agent_id] = "running"
+ self._add_log(
+ workflow_id,
+ f"Agent '{agent_name}' beginnt mit der Verarbeitung...",
+ "start",
+ agent_id,
+ agent_name
+ )
+
+ # Simuliere Verarbeitungszeit
+ self.workflows[workflow_id]["progress"] = 0.1 + (i + 1) * (0.8 / len(agents)) * 0.5
+ await asyncio.sleep(2)
+
+ # Agent-Ergebnis simulieren
+ result = self._generate_simulated_result(workflow_id, agent, i, prompt, files)
+ self.workflows[workflow_id]["results"].append(result)
+
+ self._add_log(
+ workflow_id,
+ f"Agent '{agent_name}' hat die Verarbeitung abgeschlossen",
+ "complete",
+ agent_id,
+ agent_name
+ )
+ self.workflows[workflow_id]["agent_statuses"][agent_id] = "completed"
+
+ self.workflows[workflow_id]["progress"] = 0.1 + (i + 1) * (0.8 / len(agents))
+ await asyncio.sleep(1)
+
+ # Workflow abschließen
+ self._add_log(workflow_id, "Alle Agenten haben ihre Aufgaben abgeschlossen", "info")
+ self._add_log(workflow_id, "Workflow erfolgreich beendet", "success")
+
+ self.workflows[workflow_id]["status"] = "completed"
+ self.workflows[workflow_id]["progress"] = 1.0
+ self.workflows[workflow_id]["completed_at"] = datetime.now().isoformat()
+
+ # Speichere Ergebnisse in Datei für spätere Verwendung
+ self._save_workflow_results(workflow_id)
+
+ return workflow_id
+
+ def _add_log(
+ self,
+ workflow_id: str,
+ message: str,
+ log_type: str,
+ agent_id: Optional[str] = None,
+ agent_name: Optional[str] = None
+ ) -> None:
+ """Fügt einen Protokolleintrag zum Workflow hinzu"""
+ log_entry = {
+ "id": f"log_{uuid.uuid4()}",
+ "message": message,
+ "type": log_type,
+ "timestamp": datetime.now().isoformat(),
+ "agent_id": agent_id,
+ "agent_name": agent_name
+ }
+
+ workflow = self.workflows.get(workflow_id)
+ if workflow:
+ workflow["logs"].append(log_entry)
+ logger.info(f"Workflow {workflow_id}: {message}")
+
+ def _generate_simulated_result(
+ self,
+ workflow_id: str,
+ agent: Dict[str, Any],
+ index: int,
+ prompt: str,
+ files: List[Dict[str, Any]]
+ ) -> Dict[str, Any]:
+ """Generiert ein simuliertes Ergebnis basierend auf dem Agententyp"""
+ agent_type = agent["type"]
+ agent_id = agent["id"]
+ agent_name = agent["name"]
+
+ # Dateien als Teil des Kontexts einbinden
+ file_names = [f["name"] for f in files]
+ file_context = f"Basierend auf der Analyse von: {', '.join(file_names)}"
+
+ result = {
+ "id": f"result_{workflow_id}_{index}",
+ "agent_id": agent_id,
+ "agent_name": agent_name,
+ "timestamp": datetime.now().isoformat(),
+ "metadata": {
+ "files_processed": file_names,
+ "prompt": prompt
+ }
+ }
+
+ if agent_type == "analyzer":
+ result.update({
+ "title": "Datenanalyse-Ergebnis",
+ "type": "text",
+ "content": f"{file_context}\n\nDie Analyse der bereitgestellten Daten zeigt folgende Schlüsselerkenntnisse:\n\n1. Die Umsätze stiegen im Q1 2025 um 12% im Vergleich zum Vorjahr\n2. Produktkategorie A zeigt die stärkste Leistung mit 23% Wachstum\n3. In den Regionen Nord und West wurde das größte Wachstum beobachtet\n4. Die Betriebskosten sind um 5% gesunken, was zu einer verbesserten Marge führt"
+ })
+ elif agent_type == "visualizer":
+ result.update({
+ "title": "Umsatzentwicklung nach Quartal",
+ "type": "chart",
+ "content": "Diagramm der Umsatzentwicklung (simuliert)",
+ "metadata": {
+ **result["metadata"],
+ "chart_type": "line",
+ "chart_data": {
+ "labels": ["Q1 2024", "Q2 2024", "Q3 2024", "Q4 2024", "Q1 2025"],
+ "datasets": [
+ {
+ "label": "Umsatz (Mio. €)",
+ "data": [2.1, 2.4, 2.8, 3.2, 3.6]
+ }
+ ]
+ }
+ }
+ })
+ elif agent_type == "writer":
+ result.update({
+ "title": "Zusammenfassung und Empfehlungen",
+ "type": "text",
+ "content": f"{file_context}\n\n# Zusammenfassung Q1 2025\n\nDie Unternehmensdaten zeigen ein starkes erstes Quartal mit signifikanten Verbesserungen in allen Geschäftsbereichen. Der Gesamtumsatz stieg um 12%, während die Betriebskosten um 5% sanken, was zu einer verbesserten Gewinnmarge führte.\n\n## Empfehlungen\n\n1. **Investitionen in Produktkategorie A ausbauen** - Diese Kategorie zeigt das stärkste Wachstum und sollte weiter gefördert werden\n2. **Marketingaktivitäten in Süd- und Ostregionen verstärken** - Diese Regionen zeigen Potenzial für Wachstum\n3. **Kostenoptimierungen beibehalten** - Die Maßnahmen zur Kostensenkung haben sich als effektiv erwiesen\n\n## Prognose für Q2 2025\n\nBei gleichbleibenden Marktbedingungen erwarten wir ein weiteres Wachstum von 8-10% im Q2 2025."
+ })
+ elif agent_type == "scraper":
+ result.update({
+ "title": "Web-Scraping Ergebnisse",
+ "type": "text",
+ "content": f"# Marktdaten aus Web-Quellen\n\nBasierend auf der Analyse von 15 führenden Branchenwebsites wurden folgende Trends identifiziert:\n\n1. Der Gesamtmarkt wächst mit einer Rate von 8,5% jährlich\n2. Hauptwettbewerber A und B haben kürzlich neue Produktlinien gestartet\n3. Die durchschnittlichen Marktpreise sind in den letzten 6 Monaten um 3,2% gestiegen"
+ })
+ else:
+ result.update({
+ "title": "Verarbeitungsergebnis",
+ "type": "text",
+ "content": f"Allgemeines Ergebnis der Verarbeitung durch {agent_name}"
+ })
+
+ return result
+
+ def _save_workflow_results(self, workflow_id: str) -> None:
+ """Speichert die Workflow-Ergebnisse in einer Datei"""
+ workflow = self.workflows.get(workflow_id)
+ if workflow:
+ try:
+ file_path = os.path.join(self.results_dir, f"workflow_{workflow_id}.json")
+ with open(file_path, 'w', encoding='utf-8') as f:
+ json.dump(workflow, f, indent=2, ensure_ascii=False)
+ logger.info(f"Workflow-Ergebnisse gespeichert: {file_path}")
+ except Exception as e:
+ logger.error(f"Fehler beim Speichern der Workflow-Ergebnisse: {e}")
+
+ def get_workflow_status(self, workflow_id: str) -> Optional[Dict[str, Any]]:
+ """Gibt den Status eines Workflows zurück"""
+ workflow = self.workflows.get(workflow_id)
+ if not workflow:
+ return None
+
+ return {
+ "id": workflow["id"],
+ "status": workflow["status"],
+ "progress": workflow["progress"],
+ "started_at": workflow["started_at"],
+ "completed_at": workflow["completed_at"],
+ "agent_statuses": workflow["agent_statuses"]
+ }
+
+ def get_workflow_logs(self, workflow_id: str) -> Optional[List[Dict[str, Any]]]:
+ """Gibt die Protokolle eines Workflows zurück"""
+ workflow = self.workflows.get(workflow_id)
+ if not workflow:
+ return None
+
+ return workflow["logs"]
+
+ def get_workflow_results(self, workflow_id: str) -> Optional[List[Dict[str, Any]]]:
+ """Gibt die Ergebnisse eines Workflows zurück"""
+ workflow = self.workflows.get(workflow_id)
+ if not workflow:
+ return None
+
+ return workflow["results"]
+
+
+# Singleton-Instanz des AgentService
+_agent_service_instance = None
+
+def get_agent_service():
+ """Gibt eine Singleton-Instanz des AgentService zurück"""
+ global _agent_service_instance
+ if _agent_service_instance is None:
+ _agent_service_instance = AgentService()
+ return _agent_service_instance
\ No newline at end of file
diff --git a/backend/app.py b/backend/app.py
new file mode 100644
index 00000000..458dce16
--- /dev/null
+++ b/backend/app.py
@@ -0,0 +1,305 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException, Depends, Body, Query
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+from typing import List, Dict, Any, Optional
+import uuid
+import os
+import json
+import asyncio
+from datetime import datetime
+import logging
+
+from models import (
+ Workspace,
+ Agent,
+ DataObject,
+ Prompt,
+ WorkflowRequest,
+ WorkflowResponse,
+ LogEntry,
+ Result
+)
+from database import get_db, Database
+from agent_service import AgentService, get_agent_service
+
+# Konfiguration des Loggers
+logging.basicConfig(
+ level=logging.INFO,
+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+ handlers=[logging.StreamHandler()]
+)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="Data Platform API", description="Backend-API für die Multi-Agent Datenplattform")
+
+# CORS-Konfiguration für Frontend-Anfragen
+app.add_middleware(
+ CORSMiddleware,
+ allow_origins=["*"], # In Produktion einschränken
+ allow_credentials=True,
+ allow_methods=["*"],
+ allow_headers=["*"],
+)
+
+# Statische Dateien (für Frontend)
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Verzeichnis für hochgeladene Dateien erstellen
+UPLOAD_DIR = os.path.join(os.getcwd(), "uploads")
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+
+@app.get("/", tags=["General"])
+async def root():
+ """API-Statusendpunkt"""
+ return {"status": "online", "message": "Data Platform API ist aktiv"}
+
+
+# Workspace-Endpunkte
+@app.get("/workspaces", tags=["Workspaces"], response_model=List[Workspace])
+async def get_workspaces(db: Database = Depends(get_db)):
+ """Alle verfügbaren Workspaces abrufen"""
+ return db.get_all_workspaces()
+
+
+@app.get("/workspaces/{workspace_id}", tags=["Workspaces"], response_model=Workspace)
+async def get_workspace(workspace_id: str, db: Database = Depends(get_db)):
+ """Einen bestimmten Workspace mit allen Details abrufen"""
+ workspace = db.get_workspace(workspace_id)
+ if not workspace:
+ raise HTTPException(status_code=404, detail=f"Workspace mit ID {workspace_id} nicht gefunden")
+ return workspace
+
+
+@app.post("/workspaces", tags=["Workspaces"], response_model=Workspace)
+async def create_workspace(workspace: Dict[str, Any] = Body(...), db: Database = Depends(get_db)):
+ """Einen neuen Workspace erstellen"""
+ workspace_id = str(uuid.uuid4())
+ workspace_data = {
+ "id": workspace_id,
+ "name": workspace.get("name", "Neuer Workspace"),
+ "created_at": datetime.now().isoformat(),
+ "prompts": [],
+ "agents": [],
+ "dataObjectReferences": []
+ }
+
+ new_workspace = db.create_workspace(workspace_data)
+ return new_workspace
+
+
+# Agent-Endpunkte
+@app.get("/agents", tags=["Agents"], response_model=List[Agent])
+async def get_agents(workspace_id: Optional[str] = Query(None), db: Database = Depends(get_db)):
+ """Alle Agenten oder Agenten eines bestimmten Workspaces abrufen"""
+ if workspace_id:
+ return db.get_agents_by_workspace(workspace_id)
+ return db.get_all_agents()
+
+
+@app.post("/agents", tags=["Agents"], response_model=Agent)
+async def create_agent(
+ agent: Dict[str, Any] = Body(...),
+ db: Database = Depends(get_db)
+):
+ """Einen neuen Agenten erstellen"""
+ agent_id = str(uuid.uuid4())
+ workspace_id = agent.get("workspace_id")
+
+ if not workspace_id:
+ raise HTTPException(status_code=400, detail="workspace_id ist erforderlich")
+
+ # Workspace existiert?
+ workspace = db.get_workspace(workspace_id)
+ if not workspace:
+ raise HTTPException(status_code=404, detail=f"Workspace mit ID {workspace_id} nicht gefunden")
+
+ agent_data = {
+ "id": agent_id,
+ "name": agent.get("name", "Neuer Agent"),
+ "type": agent.get("type", "generic"),
+ "capabilities": agent.get("capabilities", []),
+ "description": agent.get("description", "")
+ }
+
+ new_agent = db.create_agent(agent_data, workspace_id)
+ return new_agent
+
+
+# Datei-Endpunkte
+@app.get("/files", tags=["Files"], response_model=List[DataObject])
+async def get_files(db: Database = Depends(get_db)):
+ """Alle verfügbaren Dateien abrufen"""
+ return db.get_all_files()
+
+
+@app.post("/files/upload", tags=["Files"])
+async def upload_file(
+ file: UploadFile = File(...),
+ db: Database = Depends(get_db)
+):
+ """Eine Datei hochladen"""
+ try:
+ file_id = str(uuid.uuid4())
+ file_ext = os.path.splitext(file.filename)[1]
+ file_path = os.path.join(UPLOAD_DIR, f"{file_id}{file_ext}")
+
+ # Datei speichern
+ with open(file_path, "wb") as f:
+ content = await file.read()
+ f.write(content)
+
+ # Dateityp bestimmen
+ file_type = "image" if file.content_type and "image" in file.content_type else "document"
+
+ # In Datenbank speichern
+ file_data = {
+ "id": file_id,
+ "name": file.filename,
+ "type": file_type,
+ "path": file_path,
+ "content_type": file.content_type,
+ "size": os.path.getsize(file_path),
+ "upload_date": datetime.now().isoformat()
+ }
+
+ new_file = db.create_file(file_data)
+
+ return {
+ "id": new_file["id"],
+ "name": new_file["name"],
+ "type": new_file["type"],
+ "size": f"{new_file['size'] / (1024 * 1024):.1f} MB",
+ "upload_date": new_file["upload_date"]
+ }
+
+ except Exception as e:
+ logger.error(f"Fehler beim Hochladen der Datei: {e}")
+ raise HTTPException(status_code=500, detail=f"Fehler beim Hochladen der Datei: {str(e)}")
+
+
+# Prompt-Endpunkte
+@app.get("/prompts", tags=["Prompts"], response_model=List[Prompt])
+async def get_prompts(workspace_id: Optional[str] = Query(None), db: Database = Depends(get_db)):
+ """Alle Prompts oder Prompts eines bestimmten Workspaces abrufen"""
+ if workspace_id:
+ return db.get_prompts_by_workspace(workspace_id)
+ return db.get_all_prompts()
+
+
+@app.post("/prompts", tags=["Prompts"], response_model=Prompt)
+async def create_prompt(
+ prompt: Dict[str, Any] = Body(...),
+ db: Database = Depends(get_db)
+):
+ """Einen neuen Prompt erstellen"""
+ prompt_id = str(uuid.uuid4())
+ workspace_id = prompt.get("workspace_id")
+
+ if not workspace_id:
+ raise HTTPException(status_code=400, detail="workspace_id ist erforderlich")
+
+ # Workspace existiert?
+ workspace = db.get_workspace(workspace_id)
+ if not workspace:
+ raise HTTPException(status_code=404, detail=f"Workspace mit ID {workspace_id} nicht gefunden")
+
+ prompt_data = {
+ "id": prompt_id,
+ "content": prompt.get("content", ""),
+ "created_at": datetime.now().isoformat()
+ }
+
+ new_prompt = db.create_prompt(prompt_data, workspace_id)
+ return new_prompt
+
+
+# Workflow-Endpunkte
+@app.post("/workflow/run", tags=["Workflow"], response_model=WorkflowResponse)
+async def run_workflow(
+ workflow_request: WorkflowRequest,
+ db: Database = Depends(get_db),
+ agent_service: AgentService = Depends(get_agent_service)
+):
+ """Führt einen Workflow mit den ausgewählten Agenten und Dateien aus"""
+ workspace = db.get_workspace(workflow_request.workspace_id)
+ if not workspace:
+ raise HTTPException(status_code=404, detail=f"Workspace mit ID {workflow_request.workspace_id} nicht gefunden")
+
+ # Prüfen, ob Dateien existieren
+ files = []
+ for file_id in workflow_request.files:
+ file = db.get_file(file_id)
+ if not file:
+ raise HTTPException(status_code=404, detail=f"Datei mit ID {file_id} nicht gefunden")
+ files.append(file)
+
+ # Prüfen, ob Agenten existieren
+ agents = []
+ for agent_id in workflow_request.agents:
+ agent = db.get_agent(agent_id)
+ if not agent:
+ raise HTTPException(status_code=404, detail=f"Agent mit ID {agent_id} nicht gefunden")
+ agents.append(agent)
+
+ # Workflow ID generieren
+ workflow_id = str(uuid.uuid4())
+
+ # Workflow starten (asynchron)
+ workflow_task = asyncio.create_task(
+ agent_service.execute_workflow(
+ workflow_id,
+ workflow_request.prompt,
+ agents,
+ files
+ )
+ )
+
+ # Sofort eine Antwort zurückgeben
+ return WorkflowResponse(
+ workflow_id=workflow_id,
+ status="running",
+ message="Workflow wurde gestartet"
+ )
+
+
+@app.get("/workflow/{workflow_id}/status", tags=["Workflow"])
+async def get_workflow_status(
+ workflow_id: str,
+ agent_service: AgentService = Depends(get_agent_service)
+):
+ """Status eines laufenden Workflows abrufen"""
+ status = agent_service.get_workflow_status(workflow_id)
+ if not status:
+ raise HTTPException(status_code=404, detail=f"Workflow mit ID {workflow_id} nicht gefunden")
+ return status
+
+
+@app.get("/workflow/{workflow_id}/logs", tags=["Workflow"], response_model=List[LogEntry])
+async def get_workflow_logs(
+ workflow_id: str,
+ agent_service: AgentService = Depends(get_agent_service)
+):
+ """Protokolle eines Workflows abrufen"""
+ logs = agent_service.get_workflow_logs(workflow_id)
+ if logs is None:
+ raise HTTPException(status_code=404, detail=f"Workflow mit ID {workflow_id} nicht gefunden")
+ return logs
+
+
+@app.get("/workflow/{workflow_id}/results", tags=["Workflow"], response_model=List[Result])
+async def get_workflow_results(
+ workflow_id: str,
+ agent_service: AgentService = Depends(get_agent_service)
+):
+ """Ergebnisse eines Workflows abrufen"""
+ results = agent_service.get_workflow_results(workflow_id)
+ if results is None:
+ raise HTTPException(status_code=404, detail=f"Workflow mit ID {workflow_id} nicht gefunden")
+ return results
+
+
+if __name__ == "__main__":
+ import uvicorn
+ uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=True)
\ No newline at end of file
diff --git a/backend/backend/__pycache__/__init__.cpython-311.pyc b/backend/backend/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index 55864e2e..00000000
Binary files a/backend/backend/__pycache__/__init__.cpython-311.pyc and /dev/null differ
diff --git a/backend/backend/__pycache__/settings.cpython-311.pyc b/backend/backend/__pycache__/settings.cpython-311.pyc
deleted file mode 100644
index cdcbd4ef..00000000
Binary files a/backend/backend/__pycache__/settings.cpython-311.pyc and /dev/null differ
diff --git a/backend/backend/__pycache__/urls.cpython-311.pyc b/backend/backend/__pycache__/urls.cpython-311.pyc
deleted file mode 100644
index 7fda6d5f..00000000
Binary files a/backend/backend/__pycache__/urls.cpython-311.pyc and /dev/null differ
diff --git a/backend/backend/__pycache__/views.cpython-311.pyc b/backend/backend/__pycache__/views.cpython-311.pyc
deleted file mode 100644
index e4a839ef..00000000
Binary files a/backend/backend/__pycache__/views.cpython-311.pyc and /dev/null differ
diff --git a/backend/backend/__pycache__/wsgi.cpython-311.pyc b/backend/backend/__pycache__/wsgi.cpython-311.pyc
deleted file mode 100644
index dd3fa835..00000000
Binary files a/backend/backend/__pycache__/wsgi.cpython-311.pyc and /dev/null differ
diff --git a/backend/data/.gitignore b/backend/data/.gitignore
new file mode 100644
index 00000000..86d0cb27
--- /dev/null
+++ b/backend/data/.gitignore
@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore
\ No newline at end of file
diff --git a/backend/database.py b/backend/database.py
new file mode 100644
index 00000000..32c8281f
--- /dev/null
+++ b/backend/database.py
@@ -0,0 +1,299 @@
+import json
+import os
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+class Database:
+ """
+ Eine einfache JSON-basierte Datenbank für die Datenspeicherung.
+ In einer Produktionsumgebung würde hier eine richtige Datenbank verwendet werden.
+ """
+
+ def __init__(self, data_dir="./data"):
+ self.data_dir = data_dir
+ os.makedirs(data_dir, exist_ok=True)
+
+ # Standardpfade für die Datendateien
+ self.workspaces_file = os.path.join(data_dir, "workspaces.json")
+ self.agents_file = os.path.join(data_dir, "agents.json")
+ self.files_file = os.path.join(data_dir, "files.json")
+ self.prompts_file = os.path.join(data_dir, "prompts.json")
+
+ # Initiale Daten erstellen, falls die Dateien nicht existieren
+ self._initialize_data()
+
+ def _initialize_data(self):
+ """Initialisiert die Datendateien, falls sie nicht existieren"""
+ # Workspaces
+ if not os.path.exists(self.workspaces_file):
+ self._save_data(self.workspaces_file, [
+ {
+ "id": "workspace_001",
+ "name": "Datenanalyse-Projekt",
+ "created_at": datetime.now().isoformat(),
+ "prompts": [],
+ "agents": [],
+ "dataObjectReferences": []
+ },
+ {
+ "id": "workspace_002",
+ "name": "Marktforschung",
+ "created_at": datetime.now().isoformat(),
+ "prompts": [],
+ "agents": [],
+ "dataObjectReferences": []
+ }
+ ])
+
+ # Agenten
+ if not os.path.exists(self.agents_file):
+ self._save_data(self.agents_file, [
+ {
+ "id": "agent_001",
+ "name": "Datenanalyse-Agent",
+ "type": "analyzer",
+ "workspace_id": "workspace_001",
+ "capabilities": ["Datenanalyse", "Statistik", "Trendanalyse"],
+ "description": "Spezialisiert auf die Analyse von strukturierten Daten"
+ },
+ {
+ "id": "agent_002",
+ "name": "Visualisierungs-Agent",
+ "type": "visualizer",
+ "workspace_id": "workspace_001",
+ "capabilities": ["Datenvisualisierung", "Diagrammerstellung"],
+ "description": "Erstellt visuelle Darstellungen aus Daten"
+ },
+ {
+ "id": "agent_003",
+ "name": "Text-Generator",
+ "type": "writer",
+ "workspace_id": "workspace_001",
+ "capabilities": ["Texterstellung", "Zusammenfassung"],
+ "description": "Verfasst verständliche Berichte und Zusammenfassungen"
+ },
+ {
+ "id": "agent_004",
+ "name": "Web-Scraper",
+ "type": "scraper",
+ "workspace_id": "workspace_002",
+ "capabilities": ["Datensammlung", "Webanalyse"],
+ "description": "Sammelt Daten aus verschiedenen Webquellen"
+ },
+ {
+ "id": "agent_005",
+ "name": "Marktanalyse-Agent",
+ "type": "analyzer",
+ "workspace_id": "workspace_002",
+ "capabilities": ["Wettbewerbsanalyse", "Markttrends"],
+ "description": "Spezialisiert auf Wettbewerbsanalyse und Markttrends"
+ }
+ ])
+
+ # Dateien
+ if not os.path.exists(self.files_file):
+ self._save_data(self.files_file, [
+ {
+ "id": "file_001",
+ "name": "Quartalsbericht Q1 2025.pdf",
+ "type": "document",
+ "content_type": "application/pdf",
+ "size": 2500000, # ca. 2.4 MB
+ "upload_date": datetime.now().isoformat(),
+ "path": "uploads/dummy_file1.pdf"
+ },
+ {
+ "id": "file_002",
+ "name": "Marktanalyse-Diagramm.png",
+ "type": "image",
+ "content_type": "image/png",
+ "size": 1150000, # ca. 1.1 MB
+ "upload_date": datetime.now().isoformat(),
+ "path": "uploads/dummy_file2.png"
+ },
+ {
+ "id": "file_003",
+ "name": "Finanzdaten_2024-2025.xlsx",
+ "type": "document",
+ "content_type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+ "size": 3880000, # ca. 3.7 MB
+ "upload_date": datetime.now().isoformat(),
+ "path": "uploads/dummy_file3.xlsx"
+ }
+ ])
+
+ # Prompts
+ if not os.path.exists(self.prompts_file):
+ self._save_data(self.prompts_file, [
+ {
+ "id": "prompt_001",
+ "content": "Analysiere die Quartalsdaten und erstelle eine Zusammenfassung mit wichtigsten Trends",
+ "workspace_id": "workspace_001",
+ "created_at": datetime.now().isoformat()
+ },
+ {
+ "id": "prompt_002",
+ "content": "Erstelle eine Prognose für das nächste Quartal basierend auf historischen Daten",
+ "workspace_id": "workspace_001",
+ "created_at": datetime.now().isoformat()
+ }
+ ])
+
+ def _load_data(self, file_path):
+ """Lädt Daten aus einer JSON-Datei"""
+ try:
+ if os.path.exists(file_path):
+ with open(file_path, 'r', encoding='utf-8') as f:
+ return json.load(f)
+ return []
+ except Exception as e:
+ logger.error(f"Fehler beim Laden der Daten aus {file_path}: {e}")
+ return []
+
+ def _save_data(self, file_path, data):
+ """Speichert Daten in einer JSON-Datei"""
+ try:
+ with open(file_path, 'w', encoding='utf-8') as f:
+ json.dump(data, f, indent=2, ensure_ascii=False)
+ except Exception as e:
+ logger.error(f"Fehler beim Speichern der Daten in {file_path}: {e}")
+
+ # Workspace-Methoden
+ def get_all_workspaces(self) -> List[Dict[str, Any]]:
+ """Gibt alle Workspaces zurück"""
+ workspaces = self._load_data(self.workspaces_file)
+
+ # Füge Agenten und Prompts hinzu
+ for workspace in workspaces:
+ workspace_id = workspace["id"]
+ workspace["agents"] = self.get_agents_by_workspace(workspace_id)
+ workspace["prompts"] = self.get_prompts_by_workspace(workspace_id)
+
+ return workspaces
+
+ def get_workspace(self, workspace_id: str) -> Optional[Dict[str, Any]]:
+ """Gibt einen Workspace anhand seiner ID zurück"""
+ workspaces = self._load_data(self.workspaces_file)
+ for workspace in workspaces:
+ if workspace["id"] == workspace_id:
+ # Füge Agenten und Prompts hinzu
+ workspace["agents"] = self.get_agents_by_workspace(workspace_id)
+ workspace["prompts"] = self.get_prompts_by_workspace(workspace_id)
+ return workspace
+ return None
+
+ def create_workspace(self, workspace_data: Dict[str, Any]) -> Dict[str, Any]:
+ """Erstellt einen neuen Workspace"""
+ workspaces = self._load_data(self.workspaces_file)
+ workspaces.append(workspace_data)
+ self._save_data(self.workspaces_file, workspaces)
+ return workspace_data
+
+ # Agent-Methoden
+ def get_all_agents(self) -> List[Dict[str, Any]]:
+ """Gibt alle Agenten zurück"""
+ return self._load_data(self.agents_file)
+
+ def get_agents_by_workspace(self, workspace_id: str) -> List[Dict[str, Any]]:
+ """Gibt alle Agenten eines Workspaces zurück"""
+ agents = self._load_data(self.agents_file)
+ return [agent for agent in agents if agent.get("workspace_id") == workspace_id]
+
+ def get_agent(self, agent_id: str) -> Optional[Dict[str, Any]]:
+ """Gibt einen Agenten anhand seiner ID zurück"""
+ agents = self._load_data(self.agents_file)
+ for agent in agents:
+ if agent["id"] == agent_id:
+ return agent
+ return None
+
+ def create_agent(self, agent_data: Dict[str, Any], workspace_id: str) -> Dict[str, Any]:
+ """Erstellt einen neuen Agenten"""
+ agents = self._load_data(self.agents_file)
+ agent_data["workspace_id"] = workspace_id
+ agents.append(agent_data)
+ self._save_data(self.agents_file, agents)
+
+ # Aktualisiere die Workspace-Referenz
+ workspaces = self._load_data(self.workspaces_file)
+ for workspace in workspaces:
+ if workspace["id"] == workspace_id:
+ if "agents" not in workspace:
+ workspace["agents"] = []
+ workspace["agents"].append(agent_data["id"])
+ break
+ self._save_data(self.workspaces_file, workspaces)
+
+ return agent_data
+
+ # Datei-Methoden
+ def get_all_files(self) -> List[Dict[str, Any]]:
+ """Gibt alle Dateien zurück"""
+ files = self._load_data(self.files_file)
+ return files
+
+ def get_file(self, file_id: str) -> Optional[Dict[str, Any]]:
+ """Gibt eine Datei anhand ihrer ID zurück"""
+ files = self._load_data(self.files_file)
+ for file in files:
+ if file["id"] == file_id:
+ return file
+ return None
+
+ def create_file(self, file_data: Dict[str, Any]) -> Dict[str, Any]:
+ """Erstellt einen neuen Dateieintrag"""
+ files = self._load_data(self.files_file)
+ files.append(file_data)
+ self._save_data(self.files_file, files)
+ return file_data
+
+ # Prompt-Methoden
+ def get_all_prompts(self) -> List[Dict[str, Any]]:
+ """Gibt alle Prompts zurück"""
+ return self._load_data(self.prompts_file)
+
+ def get_prompts_by_workspace(self, workspace_id: str) -> List[Dict[str, Any]]:
+ """Gibt alle Prompts eines Workspaces zurück"""
+ prompts = self._load_data(self.prompts_file)
+ return [prompt for prompt in prompts if prompt.get("workspace_id") == workspace_id]
+
+ def get_prompt(self, prompt_id: str) -> Optional[Dict[str, Any]]:
+ """Gibt einen Prompt anhand seiner ID zurück"""
+ prompts = self._load_data(self.prompts_file)
+ for prompt in prompts:
+ if prompt["id"] == prompt_id:
+ return prompt
+ return None
+
+ def create_prompt(self, prompt_data: Dict[str, Any], workspace_id: str) -> Dict[str, Any]:
+ """Erstellt einen neuen Prompt"""
+ prompts = self._load_data(self.prompts_file)
+ prompt_data["workspace_id"] = workspace_id
+ prompts.append(prompt_data)
+ self._save_data(self.prompts_file, prompts)
+
+ # Aktualisiere die Workspace-Referenz
+ workspaces = self._load_data(self.workspaces_file)
+ for workspace in workspaces:
+ if workspace["id"] == workspace_id:
+ if "prompts" not in workspace:
+ workspace["prompts"] = []
+ workspace["prompts"].append(prompt_data["id"])
+ break
+ self._save_data(self.workspaces_file, workspaces)
+
+ return prompt_data
+
+
+# Singleton-Instanz der Datenbank
+_db_instance = None
+
+def get_db():
+ """Gibt eine Singleton-Instanz der Datenbank zurück"""
+ global _db_instance
+ if _db_instance is None:
+ _db_instance = Database()
+ return _db_instance
\ No newline at end of file
diff --git a/backend/db.sqlite3 b/backend/db.sqlite3
deleted file mode 100644
index 02356a0d..00000000
Binary files a/backend/db.sqlite3 and /dev/null differ
diff --git a/backend/models.py b/backend/models.py
new file mode 100644
index 00000000..b3ba9909
--- /dev/null
+++ b/backend/models.py
@@ -0,0 +1,80 @@
+from pydantic import BaseModel, Field
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+class Agent(BaseModel):
+ """Datenmodell für einen Agenten"""
+ id: str
+ name: str
+ type: str
+ capabilities: List[str] = []
+ description: Optional[str] = None
+
+class DataObject(BaseModel):
+ """Datenmodell für ein Datenobjekt"""
+ id: str
+ name: str
+ type: str # 'document', 'image', etc.
+ size: Optional[str] = None
+ upload_date: Optional[str] = None
+ content_type: Optional[str] = None
+ path: Optional[str] = None
+
+class Prompt(BaseModel):
+ """Datenmodell für einen Prompt"""
+ id: str
+ content: str
+ created_at: str
+
+class Workspace(BaseModel):
+ """Datenmodell für einen Workspace"""
+ id: str
+ name: str
+ created_at: str
+ prompts: List[Prompt] = []
+ agents: List[Agent] = []
+ dataObjectReferences: List[str] = []
+
+class WorkflowRequest(BaseModel):
+ """Anforderung zur Ausführung eines Workflows"""
+ workspace_id: str
+ prompt: str
+ agents: List[str] # Liste von Agent-IDs
+ files: List[str] # Liste von Datei-IDs
+ workflow_name: Optional[str] = None
+
+class WorkflowResponse(BaseModel):
+ """Antwort nach dem Start eines Workflows"""
+ workflow_id: str
+ status: str
+ message: str
+
+class LogEntry(BaseModel):
+ """Protokolleintrag während der Workflow-Ausführung"""
+ id: str
+ message: str
+ type: str # 'info', 'error', 'start', 'complete', 'success'
+ timestamp: str
+ agent_id: Optional[str] = None
+ agent_name: Optional[str] = None
+
+class Result(BaseModel):
+ """Ergebnis eines Agenten während der Workflow-Ausführung"""
+ id: str
+ title: str
+ agent_id: str
+ agent_name: str
+ type: str # 'text', 'chart', 'image', etc.
+ content: str
+ timestamp: str
+ metadata: Optional[Dict[str, Any]] = None
+
+class WorkflowStatus(BaseModel):
+ """Status eines Workflows"""
+ id: str
+ name: Optional[str] = None
+ status: str # 'running', 'completed', 'failed'
+ progress: float # 0.0 - 1.0
+ started_at: str
+ completed_at: Optional[str] = None
+ agent_statuses: Optional[Dict[str, str]] = None
\ No newline at end of file
diff --git a/backend/results/.gitignore b/backend/results/.gitignore
new file mode 100644
index 00000000..86d0cb27
--- /dev/null
+++ b/backend/results/.gitignore
@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore
\ No newline at end of file
diff --git a/backend/static/.gitignore b/backend/static/.gitignore
new file mode 100644
index 00000000..86d0cb27
--- /dev/null
+++ b/backend/static/.gitignore
@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore
\ No newline at end of file
diff --git a/backend/uploads/.gitignore b/backend/uploads/.gitignore
new file mode 100644
index 00000000..86d0cb27
--- /dev/null
+++ b/backend/uploads/.gitignore
@@ -0,0 +1,4 @@
+# Ignore everything in this directory
+*
+# Except this file
+!.gitignore
\ No newline at end of file
diff --git a/frontend/frontend/.env b/frontend/frontend/.env
deleted file mode 100644
index 294190f6..00000000
--- a/frontend/frontend/.env
+++ /dev/null
@@ -1 +0,0 @@
-REACT_APP_API_URL=https://volucy-gateway-e3d2bzbxdeaaayhz.westeurope-01.azurewebsites.net
diff --git a/frontend/index.html b/frontend/index.html
new file mode 100644
index 00000000..e3458bd3
--- /dev/null
+++ b/frontend/index.html
@@ -0,0 +1,204 @@
+
+
+
+
+
+ Data Platform - Multi-Agent Service
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Meine Prompts
+
+
Gespeicherte Prompts
+
+
+
+
+
+
+
+
+
+
Meine Agents
+
+
Verfügbare Agents
+
+
+
+
+
+
+
+
+
+
+
Workflow-Konfiguration
+
+
+
+
1. Dateien auswählen
+
+
+
+
+
+
Ausgewählte Dateien
+
+
+
+ Keine Dateien ausgewählt
+
+
+
+
+
+
+
+
+
+
2. Prompt eingeben
+
+
+
+
+
+
3. Agenten auswählen
+
+
+
+
+
+
+
+
+
+
+
+
+
Ausführung & Ergebnisse
+
+
+
+
Ausführungsprotokoll
+
+
Workflow noch nicht gestartet. Protokoll wird hier angezeigt.
+
+
+
+
+
+
Ergebnisse
+
+
+
Keine Ergebnisse verfügbar
+
Führen Sie einen Workflow aus, um Ergebnisse zu sehen
+
+
+
+
+
+
+
+
+
Meine Daten
+
+
Verfügbare Dateien
+
+
+
+
+
+
+
+
+
+
+ ${file.size || ''}
+ `;
+ const checkbox = li.querySelector(`#file-${file.id}`);
+ checkbox.addEventListener('change', () => {
+ if (checkbox.checked) {
+ state.selectedFiles.push(file);
+ } else {
+ state.selectedFiles = state.selectedFiles.filter(f => f.id !== file.id);
+ }
+ renderSelectedFiles();
+ });
+ availableFiles.appendChild(li);
+ });
+ }
+
+ // Ausgewählte Dateien rendern
+ function renderSelectedFiles() {
+ if (state.selectedFiles.length === 0) {
+ emptyFilesState.style.display = 'flex';
+ selectedFiles.innerHTML = '';
+ } else {
+ emptyFilesState.style.display = 'none';
+ selectedFiles.innerHTML = '';
+ state.selectedFiles.forEach(file => {
+ const li = document.createElement('li');
+ li.className = 'selected-file-item';
+ li.innerHTML = `
+
+
+ ${file.name}
+
+
+ `;
+ selectedFiles.appendChild(li);
+ });
+
+ // Event-Listener für Entfernen-Buttons
+ document.querySelectorAll('.remove-file-btn').forEach(btn => {
+ btn.addEventListener('click', () => {
+ const fileId = btn.getAttribute('data-id');
+ state.selectedFiles = state.selectedFiles.filter(f => f.id !== fileId);
+ renderSelectedFiles();
+ renderFiles();
+ });
+ });
+ }
+ }
+
+ // Prompts rendern
+ function renderPrompts() {
+ const promptsContainer = document.getElementById('prompts-list');
+ if (!promptsContainer) return;
+
+ promptsContainer.innerHTML = '';
+
+ if (!state.currentWorkspace || !state.currentWorkspace.prompts || state.currentWorkspace.prompts.length === 0) {
+ promptsContainer.innerHTML = 'Keine Prompts im aktuellen Workspace verfügbar.
';
+ return;
+ }
+
+ state.currentWorkspace.prompts.forEach(prompt => {
+ const promptItem = document.createElement('div');
+ promptItem.className = 'prompt-item';
+ promptItem.innerHTML = `
+ ${prompt.content}
+ Erstellt am: ${new Date(prompt.created_at).toLocaleString()}
+
+
+
+ `;
+
+ // Event-Listener für "Verwenden"-Button
+ const useBtn = promptItem.querySelector('.use-prompt-btn');
+ useBtn.addEventListener('click', () => {
+ // Prompt zum aktuellen Workflow hinzufügen
+ promptInput.value = prompt.content;
+ state.prompt = prompt.content;
+ setActiveView('workflow');
+ });
+
+ promptsContainer.appendChild(promptItem);
+ });
+ }
+
+ // Agentenliste rendern
+ function renderAgentsList() {
+ const agentsContainer = document.getElementById('agents-list-container');
+ if (!agentsContainer) return;
+
+ agentsContainer.innerHTML = '';
+
+ if (!state.currentWorkspace || !state.currentWorkspace.agents || state.currentWorkspace.agents.length === 0) {
+ agentsContainer.innerHTML = 'Keine Agenten im aktuellen Workspace verfügbar.
';
+ return;
+ }
+
+ state.currentWorkspace.agents.forEach(agent => {
+ const agentItem = document.createElement('div');
+ agentItem.className = 'agent-list-item';
+ agentItem.innerHTML = `
+
+ ${agent.description || ''}
+
+ ${agent.capabilities ? agent.capabilities.map(cap => `${cap}`).join('') : ''}
+
+ `;
+ agentsContainer.appendChild(agentItem);
+ });
+ }
+
+ // Agenten für Workflow rendern
+ function renderAgents() {
+ agentList.innerHTML = '';
+ if (!state.currentWorkspace || !state.currentWorkspace.agents || state.currentWorkspace.agents.length === 0) {
+ agentList.innerHTML = 'Keine Agenten im ausgewählten Workspace verfügbar.
';
+ return;
+ }
+
+ state.currentWorkspace.agents.forEach(agent => {
+ const li = document.createElement('li');
+ li.className = 'agent-item';
+ const isSelected = state.selectedAgents.some(a => a.id === agent.id);
+ li.innerHTML = `
+
+ ${agent.description || ''}
+ `;
+ const checkbox = li.querySelector(`#agent-${agent.id}`);
+ checkbox.addEventListener('change', () => {
+ if (checkbox.checked) {
+ state.selectedAgents.push(agent);
+ } else {
+ state.selectedAgents = state.selectedAgents.filter(a => a.id !== agent.id);
+ }
+ });
+ agentList.appendChild(li);
+ });
+ }
+
+ // Ausführungsprotokoll aktualisieren und rendern
+ function updateLogs(logs) {
+ state.logs = logs;
+ renderLogs();
+ }
+
+ // Protokoll rendern
+ function renderLogs() {
+ if (state.logs.length === 0) {
+ executionLog.innerHTML = 'Workflow noch nicht gestartet. Protokoll wird hier angezeigt.
';
+ return;
+ }
+
+ executionLog.innerHTML = '';
+ state.logs.forEach(log => {
+ const logEntry = document.createElement('div');
+ logEntry.className = 'log-entry';
+ logEntry.innerHTML = `
+ [${new Date(log.timestamp).toLocaleTimeString()}]
+ ${log.message}
+ `;
+ executionLog.appendChild(logEntry);
+ });
+
+ // Zum Ende scrollen
+ executionLog.scrollTop = executionLog.scrollHeight;
+ }
+
+ // Ergebnisse aktualisieren und rendern
+ function updateResults(results) {
+ state.results = results;
+ renderResults();
+ }
+
+ // Ergebnisse rendern
+ function renderResults() {
+ if (state.results.length === 0) {
+ emptyResultsState.style.display = 'flex';
+ resultsList.style.display = 'none';
+ return;
+ }
+
+ emptyResultsState.style.display = 'none';
+ resultsList.style.display = 'block';
+ resultsList.innerHTML = '';
+
+ state.results.forEach(result => {
+ const resultItem = document.createElement('div');
+ resultItem.className = 'result-item';
+
+ if (result.type === 'text') {
+ resultItem.innerHTML = `
+
+ ${result.content}
+ `;
+ } else if (result.type === 'chart') {
+ resultItem.innerHTML = `
+
+
+
Umsatzentwicklung nach Quartal
+
${result.content}
+