From b6fd69e65c708e3a771ab345377f330be5878528 Mon Sep 17 00:00:00 2001
From: valueon <p.motsch@valueon.ch>
Date: Fri, 14 Mar 2025 00:29:45 +0100
Subject: [PATCH] test3

---
 .gitignore                                    | 162 +++++
 backend/agent_service.py                      | 255 +++++++
 backend/app.py                                | 305 ++++++++
 .../__pycache__/__init__.cpython-311.pyc      | Bin 195 -> 0 bytes
 .../__pycache__/settings.cpython-311.pyc      | Bin 3322 -> 0 bytes
 .../backend/__pycache__/urls.cpython-311.pyc  | Bin 378 -> 0 bytes
 .../backend/__pycache__/views.cpython-311.pyc | Bin 458 -> 0 bytes
 .../backend/__pycache__/wsgi.cpython-311.pyc  | Bin 717 -> 0 bytes
 backend/data/.gitignore                       |   4 +
 backend/database.py                           | 299 ++++++++
 backend/db.sqlite3                            | Bin 131072 -> 0 bytes
 backend/models.py                             |  80 +++
 backend/results/.gitignore                    |   4 +
 backend/static/.gitignore                     |   4 +
 backend/uploads/.gitignore                    |   4 +
 frontend/frontend/.env                        |   1 -
 frontend/index.html                           | 204 ++++++
 frontend/script.js                            | 654 ++++++++++++++++++
 frontend/styles.css                           | 555 +++++++++++++++
 .../backend}/backend/__init__.py              |   0
 {backend => ida_prod/backend}/backend/asgi.py |   0
 .../backend}/backend/settings.py              |   0
 {backend => ida_prod/backend}/backend/urls.py |   0
 .../backend}/backend/views.py                 |   0
 {backend => ida_prod/backend}/backend/wsgi.py |   0
 {backend => ida_prod/backend}/manage.py       |   0
 .../frontend}/frontend/.gitignore             |   0
 .../frontend}/frontend/README.md              |   0
 .../frontend}/frontend/package-lock.json      |   0
 .../frontend}/frontend/package.json           |   0
 .../frontend}/frontend/public/favicon.ico     | Bin
 .../frontend}/frontend/public/index.html      |   0
 .../frontend}/frontend/public/logo192.png     | Bin
 .../frontend}/frontend/public/logo512.png     | Bin
 .../frontend}/frontend/public/manifest.json   |   0
 .../frontend}/frontend/public/robots.txt      |   0
 .../frontend}/frontend/src/App.css            |   0
 .../frontend}/frontend/src/App.js             |   0
 .../frontend}/frontend/src/App.test.js        |   0
 .../frontend}/frontend/src/api.js             |   0
 .../frontend}/frontend/src/index.css          |   0
 .../frontend}/frontend/src/index.js           |   0
 .../frontend}/frontend/src/logo.svg           |   0
 .../frontend}/frontend/src/reportWebVitals.js |   0
 .../frontend}/frontend/src/setupTests.js      |   0
 ida_prod/requirements.txt                     |   9 +
 ida_prod/start.sh                             |  22 +
 readme.md                                     | 168 +++++
 requirements.txt                              |  20 +-
 start.bat                                     |  53 ++
 start.sh                                      |  91 ++-
 test/data.py                                  |  55 ++
 main.py => test/gw_main.py                    |   0
 test.py => test/gw_test.py                    |   0
 54 files changed, 2923 insertions(+), 26 deletions(-)
 create mode 100644 .gitignore
 create mode 100644 backend/agent_service.py
 create mode 100644 backend/app.py
 delete mode 100644 backend/backend/__pycache__/__init__.cpython-311.pyc
 delete mode 100644 backend/backend/__pycache__/settings.cpython-311.pyc
 delete mode 100644 backend/backend/__pycache__/urls.cpython-311.pyc
 delete mode 100644 backend/backend/__pycache__/views.cpython-311.pyc
 delete mode 100644 backend/backend/__pycache__/wsgi.cpython-311.pyc
 create mode 100644 backend/data/.gitignore
 create mode 100644 backend/database.py
 delete mode 100644 backend/db.sqlite3
 create mode 100644 backend/models.py
 create mode 100644 backend/results/.gitignore
 create mode 100644 backend/static/.gitignore
 create mode 100644 backend/uploads/.gitignore
 delete mode 100644 frontend/frontend/.env
 create mode 100644 frontend/index.html
 create mode 100644 frontend/script.js
 create mode 100644 frontend/styles.css
 rename {backend => ida_prod/backend}/backend/__init__.py (100%)
 rename {backend => ida_prod/backend}/backend/asgi.py (100%)
 rename {backend => ida_prod/backend}/backend/settings.py (100%)
 rename {backend => ida_prod/backend}/backend/urls.py (100%)
 rename {backend => ida_prod/backend}/backend/views.py (100%)
 rename {backend => ida_prod/backend}/backend/wsgi.py (100%)
 rename {backend => ida_prod/backend}/manage.py (100%)
 rename {frontend => ida_prod/frontend}/frontend/.gitignore (100%)
 rename {frontend => ida_prod/frontend}/frontend/README.md (100%)
 rename {frontend => ida_prod/frontend}/frontend/package-lock.json (100%)
 rename {frontend => ida_prod/frontend}/frontend/package.json (100%)
 rename {frontend => ida_prod/frontend}/frontend/public/favicon.ico (100%)
 rename {frontend => ida_prod/frontend}/frontend/public/index.html (100%)
 rename {frontend => ida_prod/frontend}/frontend/public/logo192.png (100%)
 rename {frontend => ida_prod/frontend}/frontend/public/logo512.png (100%)
 rename {frontend => ida_prod/frontend}/frontend/public/manifest.json (100%)
 rename {frontend => ida_prod/frontend}/frontend/public/robots.txt (100%)
 rename {frontend => ida_prod/frontend}/frontend/src/App.css (100%)
 rename {frontend => ida_prod/frontend}/frontend/src/App.js (100%)
 rename {frontend => ida_prod/frontend}/frontend/src/App.test.js (100%)
 rename {frontend => ida_prod/frontend}/frontend/src/api.js (100%)
 rename {frontend => ida_prod/frontend}/frontend/src/index.css (100%)
 rename {frontend => ida_prod/frontend}/frontend/src/index.js (100%)
 rename {frontend => ida_prod/frontend}/frontend/src/logo.svg (100%)
 rename {frontend => ida_prod/frontend}/frontend/src/reportWebVitals.js (100%)
 rename {frontend => ida_prod/frontend}/frontend/src/setupTests.js (100%)
 create mode 100644 ida_prod/requirements.txt
 create mode 100644 ida_prod/start.sh
 create mode 100644 readme.md
 create mode 100644 start.bat
 create mode 100644 test/data.py
 rename main.py => test/gw_main.py (100%)
 rename test.py => test/gw_test.py (100%)

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 55864e2e18820eecf1f85fbc75ae1f5386981eac..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 195
zcmZ3^%ge<81Q$Hdri19mAOZ#$p^VRLK*n^26oz01O-8?!3`I;p{%4TnuP|q;n9$<X
zqT(3OltcxW%#xC#%;bz1m;B_?+|<01;ur(N_^`yB(p3Mv7z3mD<ouM>nDoSw)bhm2
zn54wy?9{vzI2|9KnU`4-AFo$X`HRCQH$SB`C)KWq6=)5}A;tVa;sY}yBjX1K7*WIw
G6axT8hBEE|

diff --git a/backend/backend/__pycache__/settings.cpython-311.pyc b/backend/backend/__pycache__/settings.cpython-311.pyc
deleted file mode 100644
index cdcbd4efc1909f743a365321821e6e5ed31ee7f5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3322
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
GWbQvs(>2-v

diff --git a/backend/backend/__pycache__/urls.cpython-311.pyc b/backend/backend/__pycache__/urls.cpython-311.pyc
deleted file mode 100644
index 7fda6d5f3a0319bf0cf4ef859bd021f8cea9deca..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 378
zcmY*VJxfC|6uo(Quh`b&4^Y95UE1m-A}-d!MM2S_1WJ6lyuSLrNb)T0)X~w+f1rrJ
zMX2CVx;k|$bn9e7Rp`n6IOlN54SB6pN?<U=kDzb*w-tYIf63y|kY^AeNCYuy69U2!
zG;(6vrUV>7B3z^|4#2y~6#~+Bg?A0L!ps^qGIcYqyEC#9CB@?`!Vb^EVbPR^;F>os
zYTmRgdOQizdM+a+shOU74<YuI^eitM+uWm3Ch83q#)9S5=@Gk8C>1*we6JO1EknP{
zTB)DMm}teC`<+`J<#?H}=0V3#1+su^?DGM;<NiG+;=kLi^=z=*IF3`1M|dJP%?kTy
tb!N((5<(`hGhUAg?2gxCUI4E+YCUd0^*-I|ms_1vXUiFt?UDA&e*lhlX5;_>

diff --git a/backend/backend/__pycache__/views.cpython-311.pyc b/backend/backend/__pycache__/views.cpython-311.pyc
deleted file mode 100644
index e4a839ef9bcfc56480f1fe07c1c3209b5494c012..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 458
zcmZWlze~eF6uwIWt&LqAv~Cf)bSc$Iqqx{XJ5;dfPy*%5ooO`5#k-584&vbMSpNd0
z__qiV93<f6<W}g`$-7dE;^W@;e%<%p-Fqq)3qZ<!<Hfs?_EQBvqRpIfNjd|70fqqx
zVH-k#wL8$(u-*a{<4au|!fdg@X>>$*Oe0QQI3p`#NY$l|%Mu1a{HkGyH6K38%=0`e
zo9fLh7ZT2qN3NIlNf1!$jM31lpQFg5YfN>kz%0keWkR^%ifc_;d$x1T3FFQIMpoSy
zg86ROsZ%!zNhG*aTko8pAR&j5Q`_jc6cfiog7i?|IYsUTiSXQB`J~6IaX%|?6vhGR
zpx9>%a*P_ymnGbS4|C;VH7#$ZrL9-felzXVu*b3jniV}W@${|Lt`IR(8<?_(fT@ME
nyo5=9C!{zD$Sy0&Q2l||B#d+j;X5d&f6vH(aC-#)!?fc!Dg<#U

diff --git a/backend/backend/__pycache__/wsgi.cpython-311.pyc b/backend/backend/__pycache__/wsgi.cpython-311.pyc
deleted file mode 100644
index dd3fa83588464d93f3e1f833d8874e83d557453f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 717
zcmY*X&r2LJ6n>diw;k&urFstHMQCTV(2JBpyK7}jtI*Z9ECaJ~@^*H%nPiw`wR-Z<
z|G{fdmg3)1Sc@RcN$9CJ!JDUMT({WwlDwB6@B6-le4m+d!P>C-Gd>~!zst$kCT^3f
zo=uK`LmN2Zjv#GfV?{V=rClL_q(43h-zLY!cO#$RlgAFgiR~jJ-~d*R?c`*<1nnvA
zv|wrK;N1P#T5r-w$!-$UuFB~Si$0^|G|N>VBjdSl(@^}9DUF(%9@0?(6N2psq)byr
zQ^f}Yp9tJVL3df6+-ymfBBz}W%QBHf%p^*7Iu`G>Wl2?zG?A7tz1g5jTJS{EZX)n8
z)rfA-m`tzwK39?Uc%R8wjWtCo^-=oIycNHv_Kfm5W<u?!D2>0T<HUFWlvmwYBE_Q^
zO<1mlcVravjW;hh);Gh}+SXQcW4#r=+iYyVT|1b)y}hT=m_){UsajOS&`Joy!cn@I
z9SQLwtKTbO^NJ-Zswj7pT*<<<g&ezVAWSiRhw%qom5Q$4*H?pWjkyk*oY6*NOrAu&
zprN8csa^-mE8zzw2DmAM<)>k!I0i8@xX1Q`TW$YhN$+L**Y}=}-v32jvlRAcf&OHN
z%L*an(y5Y(ODKnjK-|OorC-3x@c(uJ&R6#w=6=E4aNZj(zdD8b8PtbRzo;z?YYV5f
P#k1Pt;dJTw0}K8aZ@$%O

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 02356a0d42d32f91248d15f34270836d2d3c80c1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 131072
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
SAOHd&00JNY0wC~s5cogMRiNtt

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 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Data Platform - Multi-Agent Service</title>
+    <link rel="stylesheet" href="./styles.css">
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css">
+</head>
+<body>
+    <!-- Navigation -->
+    <nav class="navbar">
+        <div class="navbar-container">
+            <h1 class="navbar-logo">Data Platform</h1>
+            <div class="navbar-user">
+                <span>Demo User</span>
+                <button class="icon-button">
+                    <i class="fas fa-cog"></i>
+                </button>
+            </div>
+        </div>
+    </nav>
+
+    <div class="app-container">
+        <!-- Seitenleiste -->
+        <aside class="sidebar">
+            <div class="workspace-section">
+                <h2>Workspaces</h2>
+                <ul class="workspace-list" id="workspace-list">
+                    <!-- Workspace-Liste wird vom JavaScript gefüllt -->
+                </ul>
+            </div>
+            
+            <ul class="sidebar-nav">
+                <li class="sidebar-item active">
+                    <a href="#workflow">
+                        <i class="fas fa-play-circle"></i>
+                        <span>Workflow-Ausführung</span>
+                    </a>
+                </li>
+                <li class="sidebar-item">
+                    <a href="#data">
+                        <i class="fas fa-database"></i>
+                        <span>Meine Daten</span>
+                    </a>
+                </li>
+                <li class="sidebar-item">
+                    <a href="#prompts">
+                        <i class="fas fa-comment-alt"></i>
+                        <span>Meine Prompts</span>
+                    </a>
+                </li>
+                <li class="sidebar-item">
+                    <a href="#agents">
+                        <i class="fas fa-wrench"></i>
+                        <span>Meine Agents</span>
+                    </a>
+                </li>
+            </ul>
+        </aside>
+        
+        <!-- Hauptinhalt -->
+        <main class="main-content">
+            <div class="workflow-container">
+
+                <!-- Meine Prompts Ansicht -->
+                <div id="prompts-view" style="display:none;">
+                    <h2>Meine Prompts</h2>
+                    <div class="card">
+                        <h3>Gespeicherte Prompts</h3>
+                        <div id="prompts-list">
+                            <!-- Wird dynamisch gefüllt -->
+                        </div>
+                        <button class="add-btn" id="add-prompt-btn">
+                            <i class="fas fa-plus"></i> Neuen Prompt erstellen
+                        </button>
+                    </div>
+                </div>
+                
+                <!-- Meine Agents Ansicht -->
+                <div id="agents-view" style="display:none;">
+                    <h2>Meine Agents</h2>
+                    <div class="card">
+                        <h3>Verfügbare Agents</h3>
+                        <div id="agents-list-container">
+                            <!-- Wird dynamisch gefüllt -->
+                        </div>
+                        <button class="add-btn" id="add-agent-btn">
+                            <i class="fas fa-plus"></i> Neuen Agent hinzufügen
+                        </button>
+                    </div>
+                </div>
+
+                
+                <!-- Linke Seite - Workflow-Konfiguration -->
+                <div class="config-panel">
+                    <h2>Workflow-Konfiguration</h2>
+                    
+                    <!-- 1. Dateien auswählen -->
+                    <div class="card">
+                        <h3>1. Dateien auswählen</h3>
+                        
+                        <div class="files-container">
+                            <div class="file-selection">
+                                <div class="section-header">
+                                    <span>Verfügbare Dateien</span>
+                                    <button class="upload-btn" id="upload-btn">
+                                        <i class="fas fa-upload"></i> Hochladen
+                                    </button>
+                                    <input type="file" id="file-input" multiple hidden>
+                                </div>
+                                <ul class="file-list" id="available-files">
+                                    <!-- Wird dynamisch gefüllt -->
+                                </ul>
+                            </div>
+                            
+                            <div class="selected-files">
+                                <h4>Ausgewählte Dateien</h4>
+                                <div class="selected-files-container" id="selected-files-container">
+                                    <div class="empty-state" id="empty-files-state">
+                                        <i class="fas fa-upload"></i>
+                                        <span>Keine Dateien ausgewählt</span>
+                                    </div>
+                                    <ul class="selected-file-list" id="selected-files">
+                                        <!-- Wird dynamisch gefüllt -->
+                                    </ul>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                    
+                    <!-- 2. Prompt eingeben -->
+                    <div class="card">
+                        <h3>2. Prompt eingeben</h3>
+                        <textarea 
+                            id="prompt-input" 
+                            placeholder="Beschreiben Sie die Aufgabe für die Agenten..."
+                        ></textarea>
+                    </div>
+                    
+                    <!-- 3. Agenten auswählen -->
+                    <div class="card">
+                        <h3>3. Agenten auswählen</h3>
+                        <ul class="agent-list" id="agent-list">
+                            <!-- Wird dynamisch gefüllt -->
+                        </ul>
+                    </div>
+                    
+                    <!-- Aktionsbuttons -->
+                    <div class="action-buttons">
+                        <button class="reset-btn" id="reset-btn">Zurücksetzen</button>
+                        <button class="start-btn" id="start-workflow-btn">Workflow starten</button>
+                    </div>
+                </div>
+                
+                <!-- Rechte Seite - Ausführung und Ergebnisse -->
+                <div class="results-panel">
+                    <h2>Ausführung & Ergebnisse</h2>
+                    
+                    <!-- Ausführungsprotokoll -->
+                    <div class="card">
+                        <h3>Ausführungsprotokoll</h3>
+                        <div class="log-container" id="execution-log">
+                            <div class="log-empty-state">Workflow noch nicht gestartet. Protokoll wird hier angezeigt.</div>
+                        </div>
+                    </div>
+                    
+                    <!-- Ergebnisse -->
+                    <div class="card">
+                        <h3>Ergebnisse</h3>
+                        <div class="results-container" id="results-container">
+                            <div class="results-empty-state" id="empty-results-state">
+                                <div>Keine Ergebnisse verfügbar</div>
+                                <div class="sub-text">Führen Sie einen Workflow aus, um Ergebnisse zu sehen</div>
+                            </div>
+                            <div class="results-list" id="results-list">
+                                <!-- Wird dynamisch gefüllt -->
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Meine Daten Ansicht -->
+            <div id="data-view" style="display:none;">
+                <h2>Meine Daten</h2>
+                <div class="card">
+                    <h3>Verfügbare Dateien</h3>
+                    <div class="files-container">
+                        <ul class="file-list" id="my-files-list">
+                            <!-- Wird dynamisch gefüllt -->
+                        </ul>
+                        <button class="upload-btn" id="upload-files-btn">
+                            <i class="fas fa-upload"></i> Neue Dateien hochladen
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </main>
+    </div>
+
+    <script src="script.js"></script>
+</body>
+</html>
\ No newline at end of file
diff --git a/frontend/script.js b/frontend/script.js
new file mode 100644
index 00000000..77ceeabd
--- /dev/null
+++ b/frontend/script.js
@@ -0,0 +1,654 @@
+document.addEventListener('DOMContentLoaded', function() {
+    // Backend API Basis-URL
+    const API_BASE_URL = 'http://localhost:8000';
+    
+    // Status-Management
+    let state = {
+        workspaces: [],
+        files: [],
+        currentWorkspace: null,
+        selectedFiles: [],
+        selectedAgents: [],
+        prompt: "",
+        logs: [],
+        results: [],
+        isRunning: false,
+        currentWorkflowId: null
+    };
+    let activeView = 'workflow'; // Standard-Ansicht beim Start    
+
+    // DOM-Elemente für Menüpunkte
+    const workflowLink = document.querySelector('a[href="#workflow"]').parentElement;
+    const dataLink = document.querySelector('a[href="#data"]').parentElement;
+    const promptsLink = document.querySelector('a[href="#prompts"]').parentElement;
+    const agentsLink = document.querySelector('a[href="#agents"]').parentElement;
+
+    // DOM-Elemente für die Ansichten
+    const workflowView = document.querySelector('.workflow-container');
+    const dataView = document.getElementById('data-view');
+    const promptsView = document.getElementById('prompts-view');
+    const agentsView = document.getElementById('agents-view');
+
+    // DOM-Elemente
+    const workspaceList = document.getElementById('workspace-list');
+    const availableFiles = document.getElementById('available-files');
+    const selectedFiles = document.getElementById('selected-files');
+    const emptyFilesState = document.getElementById('empty-files-state');
+    const fileInput = document.getElementById('file-input');
+    const uploadBtn = document.getElementById('upload-btn');
+    const promptInput = document.getElementById('prompt-input');
+    const agentList = document.getElementById('agent-list');
+    const resetBtn = document.getElementById('reset-btn');
+    const startWorkflowBtn = document.getElementById('start-workflow-btn');
+    const executionLog = document.getElementById('execution-log');
+    const resultsContainer = document.getElementById('results-container');
+    const emptyResultsState = document.getElementById('empty-results-state');
+    const resultsList = document.getElementById('results-list');
+
+    // API-Funktionen
+    async function fetchWorkspaces() {
+        try {
+            const response = await fetch(`${API_BASE_URL}/workspaces`);
+            if (!response.ok) throw new Error('Fehler beim Abrufen der Workspaces');
+            
+            const workspaces = await response.json();
+            state.workspaces = workspaces;
+            
+            if (workspaces.length > 0) {
+                state.currentWorkspace = workspaces[0];
+            }
+            
+            renderWorkspaces();
+            return workspaces;
+        } catch (error) {
+            console.error('Fehler beim Abrufen der Workspaces:', error);
+            return [];
+        }
+    }
+    
+    async function fetchFiles() {
+        try {
+            const response = await fetch(`${API_BASE_URL}/files`);
+            if (!response.ok) throw new Error('Fehler beim Abrufen der Dateien');
+            
+            const files = await response.json();
+            state.files = files;
+            
+            renderFiles();
+            return files;
+        } catch (error) {
+            console.error('Fehler beim Abrufen der Dateien:', error);
+            return [];
+        }
+    }
+    
+    async function uploadFile(file) {
+        try {
+            const formData = new FormData();
+            formData.append('file', file);
+            
+            const response = await fetch(`${API_BASE_URL}/files/upload`, {
+                method: 'POST',
+                body: formData
+            });
+            
+            if (!response.ok) throw new Error('Fehler beim Hochladen der Datei');
+            
+            const newFile = await response.json();
+            return newFile;
+        } catch (error) {
+            console.error('Fehler beim Hochladen der Datei:', error);
+            return null;
+        }
+    }
+    
+    async function runWorkflowAPI(workflowData) {
+        try {
+            const response = await fetch(`${API_BASE_URL}/workflow/run`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(workflowData)
+            });
+            
+            if (!response.ok) throw new Error('Fehler beim Starten des Workflows');
+            
+            const result = await response.json();
+            return result;
+        } catch (error) {
+            console.error('Fehler beim Starten des Workflows:', error);
+            return null;
+        }
+    }
+    
+    async function fetchWorkflowStatus(workflowId) {
+        try {
+            const response = await fetch(`${API_BASE_URL}/workflow/${workflowId}/status`);
+            if (!response.ok) throw new Error('Fehler beim Abrufen des Workflow-Status');
+            
+            const status = await response.json();
+            return status;
+        } catch (error) {
+            console.error('Fehler beim Abrufen des Workflow-Status:', error);
+            return null;
+        }
+    }
+    
+    async function fetchWorkflowLogs(workflowId) {
+        try {
+            const response = await fetch(`${API_BASE_URL}/workflow/${workflowId}/logs`);
+            if (!response.ok) throw new Error('Fehler beim Abrufen der Workflow-Logs');
+            
+            const logs = await response.json();
+            return logs;
+        } catch (error) {
+            console.error('Fehler beim Abrufen der Workflow-Logs:', error);
+            return [];
+        }
+    }
+    
+    async function fetchWorkflowResults(workflowId) {
+        try {
+            const response = await fetch(`${API_BASE_URL}/workflow/${workflowId}/results`);
+            if (!response.ok) throw new Error('Fehler beim Abrufen der Workflow-Ergebnisse');
+            
+            const results = await response.json();
+            return results;
+        } catch (error) {
+            console.error('Fehler beim Abrufen der Workflow-Ergebnisse:', error);
+            return [];
+        }
+    }
+
+    // Funktion zum Wechseln der Ansicht
+    function setActiveView(view) {
+        // Aktive Klasse von allen Menüpunkten entfernen
+        workflowLink.classList.remove('active');
+        dataLink.classList.remove('active');
+        promptsLink.classList.remove('active');
+        agentsLink.classList.remove('active');
+        
+        // Alle Ansichten ausblenden
+        workflowView.style.display = 'none';
+        dataView.style.display = 'none';
+        promptsView.style.display = 'none';
+        agentsView.style.display = 'none';
+        
+        // Aktive Ansicht und Menüpunkt setzen
+        activeView = view;
+        
+        switch (view) {
+            case 'workflow':
+                workflowLink.classList.add('active');
+                workflowView.style.display = 'flex';
+                break;
+            case 'data':
+                dataLink.classList.add('active');
+                dataView.style.display = 'block';
+                // Aktualisiere Daten bei Ansichtswechsel
+                fetchFiles();
+                break;
+            case 'prompts':
+                promptsLink.classList.add('active');
+                promptsView.style.display = 'block';
+                // Prompts laden wenn wir die Ansicht wechseln
+                if (state.currentWorkspace) {
+                    renderPrompts();
+                }
+                break;
+            case 'agents':
+                agentsLink.classList.add('active');
+                agentsView.style.display = 'block';
+                // Agenten laden wenn wir die Ansicht wechseln
+                if (state.currentWorkspace) {
+                    renderAgentsList();
+                }
+                break;
+        }
+    }
+
+    // Workspaces rendern
+    function renderWorkspaces() {
+        workspaceList.innerHTML = '';
+        state.workspaces.forEach(workspace => {
+            const li = document.createElement('li');
+            li.className = `workspace-item ${workspace.id === state.currentWorkspace?.id ? 'active' : ''}`;
+            li.innerHTML = `
+                <i class="fas fa-folder"></i>
+                <span>${workspace.name}</span>
+            `;
+            li.addEventListener('click', async () => {
+                state.currentWorkspace = workspace;
+                state.selectedFiles = [];
+                state.selectedAgents = [];
+                state.prompt = "";
+                
+                renderWorkspaces();
+                renderFiles();
+                renderSelectedFiles();
+                renderAgents();
+            });
+            workspaceList.appendChild(li);
+        });
+    }
+
+    // Verfügbare Dateien rendern
+    function renderFiles() {
+        availableFiles.innerHTML = '';
+        state.files.forEach(file => {
+            const li = document.createElement('li');
+            li.className = 'file-item';
+            const isSelected = state.selectedFiles.some(f => f.id === file.id);
+            li.innerHTML = `
+                <div class="file-item-name">
+                    <input type="checkbox" id="file-${file.id}" ${isSelected ? 'checked' : ''}>
+                    <label for="file-${file.id}">
+                        <i class="fas ${file.type === 'document' ? 'fa-file-alt' : 'fa-file-image'}"></i>
+                        ${file.name}
+                    </label>
+                </div>
+                <span class="file-item-info">${file.size || ''}</span>
+            `;
+            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 = `
+                    <div class="file-item-name">
+                        <i class="fas ${file.type === 'document' ? 'fa-file-alt' : 'fa-file-image'}"></i>
+                        ${file.name}
+                    </div>
+                    <button class="remove-file-btn" data-id="${file.id}">
+                        <i class="fas fa-times"></i>
+                    </button>
+                `;
+                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 = '<div class="empty-state">Keine Prompts im aktuellen Workspace verfügbar.</div>';
+            return;
+        }
+        
+        state.currentWorkspace.prompts.forEach(prompt => {
+            const promptItem = document.createElement('div');
+            promptItem.className = 'prompt-item';
+            promptItem.innerHTML = `
+                <div class="prompt-content">${prompt.content}</div>
+                <div class="prompt-meta">Erstellt am: ${new Date(prompt.created_at).toLocaleString()}</div>
+                <div class="prompt-actions">
+                    <button class="use-prompt-btn" data-id="${prompt.id}">
+                        <i class="fas fa-play"></i> Verwenden
+                    </button>
+                </div>
+            `;
+            
+            // 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 = '<div class="empty-state">Keine Agenten im aktuellen Workspace verfügbar.</div>';
+            return;
+        }
+        
+        state.currentWorkspace.agents.forEach(agent => {
+            const agentItem = document.createElement('div');
+            agentItem.className = 'agent-list-item';
+            agentItem.innerHTML = `
+                <div class="agent-header">
+                    <h4>${agent.name}</h4>
+                    <span class="agent-type">${agent.type}</span>
+                </div>
+                <div class="agent-description">${agent.description || ''}</div>
+                <div class="agent-capabilities">
+                    ${agent.capabilities ? agent.capabilities.map(cap => `<span class="capability-tag">${cap}</span>`).join('') : ''}
+                </div>
+            `;
+            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 = '<div class="empty-state">Keine Agenten im ausgewählten Workspace verfügbar.</div>';
+            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 = `
+                <div class="agent-header">
+                    <input type="checkbox" id="agent-${agent.id}" class="agent-checkbox" ${isSelected ? 'checked' : ''}>
+                    <label for="agent-${agent.id}" class="agent-name">${agent.name}</label>
+                </div>
+                <div class="agent-description">${agent.description || ''}</div>
+            `;
+            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 = '<div class="log-empty-state">Workflow noch nicht gestartet. Protokoll wird hier angezeigt.</div>';
+            return;
+        }
+
+        executionLog.innerHTML = '';
+        state.logs.forEach(log => {
+            const logEntry = document.createElement('div');
+            logEntry.className = 'log-entry';
+            logEntry.innerHTML = `
+                <span class="log-time">[${new Date(log.timestamp).toLocaleTimeString()}]</span>
+                <span class="log-message log-${log.type}">${log.message}</span>
+            `;
+            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 = `
+                    <div class="result-header">
+                        <div>
+                            <div class="result-title">${result.title}</div>
+                            <div class="result-agent">Erstellt von: ${result.agent_name}</div>
+                        </div>
+                        <button class="save-btn">
+                            <i class="fas fa-save"></i> Speichern
+                        </button>
+                    </div>
+                    <div class="result-content">${result.content}</div>
+                `;
+            } else if (result.type === 'chart') {
+                resultItem.innerHTML = `
+                    <div class="result-header">
+                        <div>
+                            <div class="result-title">${result.title}</div>
+                            <div class="result-agent">Erstellt von: ${result.agent_name}</div>
+                        </div>
+                        <button class="save-btn">
+                            <i class="fas fa-save"></i> Speichern
+                        </button>
+                    </div>
+                    <div class="chart-container">
+                        <div class="chart-title">Umsatzentwicklung nach Quartal</div>
+                        <div>${result.content}</div>
+                    </div>
+                `;
+            }
+            
+            resultsList.appendChild(resultItem);
+        });
+    }
+
+    // Workflow-Ausführung
+    async function runWorkflow() {
+        if (state.selectedFiles.length === 0 || state.selectedAgents.length === 0 || !promptInput.value.trim()) {
+            alert("Bitte wählen Sie Dateien und Agenten aus und geben Sie einen Prompt ein.");
+            return;
+        }
+
+        state.isRunning = true;
+        state.prompt = promptInput.value;
+        state.logs = [];
+        state.results = [];
+        
+        startWorkflowBtn.textContent = 'Wird ausgeführt...';
+        startWorkflowBtn.classList.add('running');
+        startWorkflowBtn.disabled = true;
+        
+        renderLogs();
+        renderResults();
+
+        // API-Aufruf an das Backend
+        const workflowData = {
+            workspace_id: state.currentWorkspace.id,
+            files: state.selectedFiles.map(file => file.id),
+            agents: state.selectedAgents.map(agent => agent.id),
+            prompt: state.prompt,
+            workflow_name: "Workflow " + new Date().toLocaleString()
+        };
+
+        try {
+            // Workflow starten
+            const response = await runWorkflowAPI(workflowData);
+            
+            if (response && response.workflow_id) {
+                state.currentWorkflowId = response.workflow_id;
+                
+                // Polling für Status, Logs und Ergebnisse
+                pollWorkflowStatus();
+            } else {
+                throw new Error("Workflow konnte nicht gestartet werden");
+            }
+        } catch (error) {
+            console.error("Fehler beim Starten des Workflows:", error);
+            state.isRunning = false;
+            startWorkflowBtn.textContent = 'Workflow starten';
+            startWorkflowBtn.classList.remove('running');
+            startWorkflowBtn.disabled = false;
+            
+            alert("Fehler beim Starten des Workflows: " + error.message);
+        }
+    }
+
+    // Polling für Workflow-Status, Logs und Ergebnisse
+    async function pollWorkflowStatus() {
+        if (!state.currentWorkflowId || !state.isRunning) return;
+        
+        try {
+            // Status abrufen
+            const status = await fetchWorkflowStatus(state.currentWorkflowId);
+            
+            // Logs abrufen und anzeigen
+            const logs = await fetchWorkflowLogs(state.currentWorkflowId);
+            updateLogs(logs);
+            
+            // Wenn der Workflow abgeschlossen ist, Ergebnisse abrufen
+            if (status && (status.status === 'completed' || status.status === 'failed')) {
+                const results = await fetchWorkflowResults(state.currentWorkflowId);
+                updateResults(results);
+                
+                state.isRunning = false;
+                startWorkflowBtn.textContent = 'Workflow starten';
+                startWorkflowBtn.classList.remove('running');
+                startWorkflowBtn.disabled = false;
+                
+                return; // Polling beenden
+            }
+            
+            // Weiteres Polling nach kurzer Verzögerung
+            setTimeout(pollWorkflowStatus, 2000);
+        } catch (error) {
+            console.error("Fehler beim Abrufen des Workflow-Status:", error);
+            state.isRunning = false;
+            startWorkflowBtn.textContent = 'Workflow starten';
+            startWorkflowBtn.classList.remove('running');
+            startWorkflowBtn.disabled = false;
+        }
+    }
+
+    // Zurücksetzen
+    function resetWorkflow() {
+        state.selectedFiles = [];
+        state.selectedAgents = [];
+        promptInput.value = "";
+        state.prompt = "";
+        
+        renderFiles();
+        renderSelectedFiles();
+        renderAgents();
+    }
+
+    // Event-Listener für Menüpunkte
+    workflowLink.addEventListener('click', function(e) {
+        e.preventDefault();
+        setActiveView('workflow');
+    });
+
+    dataLink.addEventListener('click', function(e) {
+        e.preventDefault();
+        setActiveView('data');
+    });
+
+    promptsLink.addEventListener('click', function(e) {
+        e.preventDefault();
+        setActiveView('prompts');
+    });
+
+    agentsLink.addEventListener('click', function(e) {
+        e.preventDefault();
+        setActiveView('agents');
+    });
+        
+    // Event-Listener
+    uploadBtn.addEventListener('click', () => fileInput.click());
+    
+    fileInput.addEventListener('change', async (e) => {
+        if (e.target.files.length > 0) {
+            // Dateien hochladen
+            for (const file of e.target.files) {
+                try {
+                    const newFile = await uploadFile(file);
+                    if (newFile) {
+                        state.files.push(newFile);
+                        state.selectedFiles.push(newFile);
+                    }
+                } catch (error) {
+                    console.error("Fehler beim Hochladen der Datei:", error);
+                }
+            }
+            
+            renderFiles();
+            renderSelectedFiles();
+            fileInput.value = "";
+        }
+    });
+    
+    promptInput.addEventListener('input', (e) => {
+        state.prompt = e.target.value;
+    });
+    
+    resetBtn.addEventListener('click', resetWorkflow);
+    startWorkflowBtn.addEventListener('click', runWorkflow);
+
+    // Initialisierung
+    async function init() {
+        // Daten vom Backend laden
+        await fetchWorkspaces();
+        await fetchFiles();
+        
+        // UI initialisieren
+        renderFiles();
+        renderSelectedFiles();
+        renderAgents();
+        renderLogs();
+        renderResults();
+
+        // Initial die Standard-Ansicht setzen
+        setActiveView(activeView);
+    }
+    
+    // Anwendung initialisieren
+    init();
+});
\ No newline at end of file
diff --git a/frontend/styles.css b/frontend/styles.css
new file mode 100644
index 00000000..1f419be2
--- /dev/null
+++ b/frontend/styles.css
@@ -0,0 +1,555 @@
+/* Grundlegende Resets und Fonts */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+body {
+    font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+    background-color: #f0f2f5;
+    color: #333;
+    line-height: 1.6;
+}
+
+ul {
+    list-style: none;
+}
+
+a {
+    text-decoration: none;
+    color: inherit;
+}
+
+button {
+    cursor: pointer;
+    border: none;
+    background: none;
+    font-family: inherit;
+}
+
+/* Navbar */
+.navbar {
+    background-color: #2563eb;
+    color: white;
+    padding: 1rem;
+    box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+}
+
+.navbar-container {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    max-width: 1800px;
+    margin: 0 auto;
+}
+
+.navbar-logo {
+    font-size: 1.5rem;
+    font-weight: 600;
+}
+
+.navbar-user {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.icon-button {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    width: 2rem;
+    height: 2rem;
+    border-radius: 50%;
+    color: white;
+    transition: background-color 0.2s;
+}
+
+.icon-button:hover {
+    background-color: rgba(255, 255, 255, 0.2);
+}
+
+/* App Container Layout */
+.app-container {
+    display: flex;
+    max-width: 1800px;
+    margin: 0 auto;
+    min-height: calc(100vh - 4rem);
+}
+
+/* Sidebar */
+.sidebar {
+    width: 250px;
+    background-color: white;
+    box-shadow: 2px 0 5px rgba(0, 0, 0, 0.05);
+    padding: 1.5rem 1rem;
+    flex-shrink: 0;
+}
+
+.workspace-section h2 {
+    font-size: 1.2rem;
+    margin-bottom: 0.5rem;
+    font-weight: 600;
+}
+
+.workspace-list {
+    margin-bottom: 1.5rem;
+}
+
+.workspace-item {
+    padding: 0.5rem 0.75rem;
+    border-radius: 0.375rem;
+    margin-bottom: 0.25rem;
+    display: flex;
+    align-items: center;
+    cursor: pointer;
+}
+
+.workspace-item i {
+    margin-right: 0.5rem;
+    color: #4b5563;
+}
+
+.workspace-item:hover {
+    background-color: #f3f4f6;
+}
+
+.workspace-item.active {
+    background-color: #e0f2fe;
+    color: #1d4ed8;
+}
+
+.sidebar-nav {
+    margin-top: 1rem;
+}
+
+.sidebar-item {
+    padding: 0.75rem;
+    border-radius: 0.375rem;
+    margin-bottom: 0.25rem;
+}
+
+.sidebar-item a {
+    display: flex;
+    align-items: center;
+}
+
+.sidebar-item i {
+    margin-right: 0.75rem;
+    width: 1.25rem;
+    text-align: center;
+}
+
+.sidebar-item:hover {
+    background-color: #f3f4f6;
+}
+
+.sidebar-item.active {
+    background-color: #e0f2fe;
+    color: #1d4ed8;
+}
+
+/* Main Content */
+.main-content {
+    flex: 1;
+    padding: 1.5rem;
+    overflow-y: auto;
+}
+
+.workflow-container {
+    display: flex;
+    gap: 1.5rem;
+}
+
+.config-panel, .results-panel {
+    flex: 1;
+}
+
+/* Cards */
+.card {
+    background-color: white;
+    border-radius: 0.5rem;
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+    padding: 1.25rem;
+    margin-bottom: 1.25rem;
+}
+
+h2 {
+    font-size: 1.5rem;
+    font-weight: 600;
+    margin-bottom: 1rem;
+}
+
+h3 {
+    font-size: 1.125rem;
+    font-weight: 600;
+    margin-bottom: 1rem;
+    color: #4b5563;
+}
+
+h4 {
+    font-size: 0.875rem;
+    font-weight: 600;
+    margin-bottom: 0.5rem;
+    color: #6b7280;
+}
+
+/* File Selection */
+.files-container {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.section-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 0.5rem;
+    font-weight: 500;
+}
+
+.upload-btn {
+    background-color: #fff;
+    border: 1px solid #d1d5db;
+    border-radius: 0.375rem;
+    padding: 0.375rem 0.75rem;
+    font-size: 0.875rem;
+    color: #4b5563;
+    display: flex;
+    align-items: center;
+    gap: 0.375rem;
+    transition: all 0.2s;
+}
+
+.upload-btn:hover {
+    background-color: #f9fafb;
+    border-color: #9ca3af;
+}
+
+.file-list {
+    max-height: 200px;
+    overflow-y: auto;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.375rem;
+    background-color: #f9fafb;
+}
+
+.file-item {
+    padding: 0.625rem;
+    border-bottom: 1px solid #e5e7eb;
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    background-color: white;
+}
+
+.file-item:last-child {
+    border-bottom: none;
+}
+
+.file-item-name {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    flex: 1;
+}
+
+.file-item-info {
+    font-size: 0.75rem;
+    color: #6b7280;
+}
+
+.selected-files-container {
+    border: 1px dashed #d1d5db;
+    border-radius: 0.375rem;
+    min-height: 100px;
+    background-color: #f9fafb;
+}
+
+.empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    height: 100px;
+    color: #9ca3af;
+    gap: 0.5rem;
+}
+
+.empty-state i {
+    font-size: 1.5rem;
+}
+
+.selected-file-list {
+    padding: 0.5rem;
+}
+
+.selected-file-item {
+    background-color: white;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.375rem;
+    padding: 0.5rem 0.75rem;
+    margin-bottom: 0.5rem;
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.selected-file-item:last-child {
+    margin-bottom: 0;
+}
+
+.remove-file-btn {
+    color: #ef4444;
+    width: 1.5rem;
+    height: 1.5rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 50%;
+    transition: background-color 0.2s;
+}
+
+.remove-file-btn:hover {
+    background-color: #fee2e2;
+}
+
+/* Prompt input */
+#prompt-input {
+    width: 100%;
+    min-height: 150px;
+    border: 1px solid #d1d5db;
+    border-radius: 0.375rem;
+    padding: 0.75rem;
+    font-family: inherit;
+    resize: vertical;
+    font-size: 0.875rem;
+}
+
+#prompt-input:focus {
+    outline: none;
+    border-color: #2563eb;
+    box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.1);
+}
+
+/* Agent list */
+.agent-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.agent-item {
+    background-color: #f9fafb;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.375rem;
+    padding: 0.75rem;
+}
+
+.agent-header {
+    display: flex;
+    align-items: center;
+}
+
+.agent-checkbox {
+    margin-right: 0.75rem;
+}
+
+.agent-name {
+    font-weight: 500;
+}
+
+.agent-description {
+    margin-top: 0.25rem;
+    font-size: 0.875rem;
+    color: #6b7280;
+    margin-left: 2rem;
+}
+
+/* Action buttons */
+.action-buttons {
+    display: flex;
+    justify-content: space-between;
+    gap: 0.75rem;
+}
+
+.reset-btn {
+    background-color: #f3f4f6;
+    color: #4b5563;
+    border-radius: 0.375rem;
+    padding: 0.625rem 1.25rem;
+    font-weight: 500;
+    transition: background-color 0.2s;
+}
+
+.reset-btn:hover {
+    background-color: #e5e7eb;
+}
+
+.start-btn {
+    background-color: #10b981;
+    color: white;
+    border-radius: 0.375rem;
+    padding: 0.625rem 1.25rem;
+    font-weight: 500;
+    transition: background-color 0.2s;
+}
+
+.start-btn:hover {
+    background-color: #059669;
+}
+
+.start-btn.running {
+    background-color: #9ca3af;
+    cursor: not-allowed;
+}
+
+/* Log Container */
+.log-container {
+    background-color: #111827;
+    color: #34d399;
+    border-radius: 0.375rem;
+    padding: 0.75rem;
+    font-family: 'Consolas', 'Monaco', monospace;
+    font-size: 0.875rem;
+    height: 300px;
+    overflow-y: auto;
+}
+
+.log-empty-state {
+    color: #6b7280;
+    font-style: italic;
+}
+
+.log-entry {
+    margin-bottom: 0.25rem;
+}
+
+.log-time {
+    color: #9ca3af;
+}
+
+.log-message {
+    margin-left: 0.5rem;
+}
+
+.log-info {
+    color: #ffffff;
+}
+
+.log-success {
+    color: #34d399;
+}
+
+.log-error {
+    color: #f87171;
+}
+
+.log-start {
+    color: #60a5fa;
+}
+
+.log-complete {
+    color: #c084fc;
+}
+
+/* Results Container */
+.results-container {
+    min-height: 200px;
+}
+
+.results-empty-state {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    background-color: #f9fafb;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.375rem;
+    padding: 2.5rem 1rem;
+    color: #6b7280;
+    text-align: center;
+}
+
+.sub-text {
+    font-size: 0.875rem;
+    color: #9ca3af;
+    margin-top: 0.25rem;
+}
+
+.results-list {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+}
+
+.result-item {
+    background-color: #f9fafb;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.375rem;
+    padding: 1rem;
+}
+
+.result-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    margin-bottom: 0.75rem;
+}
+
+.result-title {
+    font-weight: 600;
+    font-size: 1.125rem;
+}
+
+.result-agent {
+    font-size: 0.75rem;
+    color: #6b7280;
+}
+
+.save-btn {
+    display: flex;
+    align-items: center;
+    gap: 0.25rem;
+    color: #2563eb;
+    font-size: 0.875rem;
+    font-weight: 500;
+    padding: 0.25rem 0.5rem;
+    border-radius: 0.25rem;
+    transition: background-color 0.2s;
+}
+
+.save-btn:hover {
+    background-color: #e0f2fe;
+}
+
+.result-content {
+    background-color: white;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.375rem;
+    padding: 0.75rem;
+    font-size: 0.875rem;
+    white-space: pre-line;
+}
+
+.chart-container {
+    background-color: white;
+    border: 1px solid #e5e7eb;
+    border-radius: 0.375rem;
+    padding: 0.75rem;
+    text-align: center;
+    height: 200px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: #6b7280;
+}
+
+.chart-title {
+    border-bottom: 1px solid #e5e7eb;
+    padding-bottom: 0.5rem;
+    margin-bottom: 0.75rem;
+    font-weight: 500;
+}
\ No newline at end of file
diff --git a/backend/backend/__init__.py b/ida_prod/backend/backend/__init__.py
similarity index 100%
rename from backend/backend/__init__.py
rename to ida_prod/backend/backend/__init__.py
diff --git a/backend/backend/asgi.py b/ida_prod/backend/backend/asgi.py
similarity index 100%
rename from backend/backend/asgi.py
rename to ida_prod/backend/backend/asgi.py
diff --git a/backend/backend/settings.py b/ida_prod/backend/backend/settings.py
similarity index 100%
rename from backend/backend/settings.py
rename to ida_prod/backend/backend/settings.py
diff --git a/backend/backend/urls.py b/ida_prod/backend/backend/urls.py
similarity index 100%
rename from backend/backend/urls.py
rename to ida_prod/backend/backend/urls.py
diff --git a/backend/backend/views.py b/ida_prod/backend/backend/views.py
similarity index 100%
rename from backend/backend/views.py
rename to ida_prod/backend/backend/views.py
diff --git a/backend/backend/wsgi.py b/ida_prod/backend/backend/wsgi.py
similarity index 100%
rename from backend/backend/wsgi.py
rename to ida_prod/backend/backend/wsgi.py
diff --git a/backend/manage.py b/ida_prod/backend/manage.py
similarity index 100%
rename from backend/manage.py
rename to ida_prod/backend/manage.py
diff --git a/frontend/frontend/.gitignore b/ida_prod/frontend/frontend/.gitignore
similarity index 100%
rename from frontend/frontend/.gitignore
rename to ida_prod/frontend/frontend/.gitignore
diff --git a/frontend/frontend/README.md b/ida_prod/frontend/frontend/README.md
similarity index 100%
rename from frontend/frontend/README.md
rename to ida_prod/frontend/frontend/README.md
diff --git a/frontend/frontend/package-lock.json b/ida_prod/frontend/frontend/package-lock.json
similarity index 100%
rename from frontend/frontend/package-lock.json
rename to ida_prod/frontend/frontend/package-lock.json
diff --git a/frontend/frontend/package.json b/ida_prod/frontend/frontend/package.json
similarity index 100%
rename from frontend/frontend/package.json
rename to ida_prod/frontend/frontend/package.json
diff --git a/frontend/frontend/public/favicon.ico b/ida_prod/frontend/frontend/public/favicon.ico
similarity index 100%
rename from frontend/frontend/public/favicon.ico
rename to ida_prod/frontend/frontend/public/favicon.ico
diff --git a/frontend/frontend/public/index.html b/ida_prod/frontend/frontend/public/index.html
similarity index 100%
rename from frontend/frontend/public/index.html
rename to ida_prod/frontend/frontend/public/index.html
diff --git a/frontend/frontend/public/logo192.png b/ida_prod/frontend/frontend/public/logo192.png
similarity index 100%
rename from frontend/frontend/public/logo192.png
rename to ida_prod/frontend/frontend/public/logo192.png
diff --git a/frontend/frontend/public/logo512.png b/ida_prod/frontend/frontend/public/logo512.png
similarity index 100%
rename from frontend/frontend/public/logo512.png
rename to ida_prod/frontend/frontend/public/logo512.png
diff --git a/frontend/frontend/public/manifest.json b/ida_prod/frontend/frontend/public/manifest.json
similarity index 100%
rename from frontend/frontend/public/manifest.json
rename to ida_prod/frontend/frontend/public/manifest.json
diff --git a/frontend/frontend/public/robots.txt b/ida_prod/frontend/frontend/public/robots.txt
similarity index 100%
rename from frontend/frontend/public/robots.txt
rename to ida_prod/frontend/frontend/public/robots.txt
diff --git a/frontend/frontend/src/App.css b/ida_prod/frontend/frontend/src/App.css
similarity index 100%
rename from frontend/frontend/src/App.css
rename to ida_prod/frontend/frontend/src/App.css
diff --git a/frontend/frontend/src/App.js b/ida_prod/frontend/frontend/src/App.js
similarity index 100%
rename from frontend/frontend/src/App.js
rename to ida_prod/frontend/frontend/src/App.js
diff --git a/frontend/frontend/src/App.test.js b/ida_prod/frontend/frontend/src/App.test.js
similarity index 100%
rename from frontend/frontend/src/App.test.js
rename to ida_prod/frontend/frontend/src/App.test.js
diff --git a/frontend/frontend/src/api.js b/ida_prod/frontend/frontend/src/api.js
similarity index 100%
rename from frontend/frontend/src/api.js
rename to ida_prod/frontend/frontend/src/api.js
diff --git a/frontend/frontend/src/index.css b/ida_prod/frontend/frontend/src/index.css
similarity index 100%
rename from frontend/frontend/src/index.css
rename to ida_prod/frontend/frontend/src/index.css
diff --git a/frontend/frontend/src/index.js b/ida_prod/frontend/frontend/src/index.js
similarity index 100%
rename from frontend/frontend/src/index.js
rename to ida_prod/frontend/frontend/src/index.js
diff --git a/frontend/frontend/src/logo.svg b/ida_prod/frontend/frontend/src/logo.svg
similarity index 100%
rename from frontend/frontend/src/logo.svg
rename to ida_prod/frontend/frontend/src/logo.svg
diff --git a/frontend/frontend/src/reportWebVitals.js b/ida_prod/frontend/frontend/src/reportWebVitals.js
similarity index 100%
rename from frontend/frontend/src/reportWebVitals.js
rename to ida_prod/frontend/frontend/src/reportWebVitals.js
diff --git a/frontend/frontend/src/setupTests.js b/ida_prod/frontend/frontend/src/setupTests.js
similarity index 100%
rename from frontend/frontend/src/setupTests.js
rename to ida_prod/frontend/frontend/src/setupTests.js
diff --git a/ida_prod/requirements.txt b/ida_prod/requirements.txt
new file mode 100644
index 00000000..9ecd9896
--- /dev/null
+++ b/ida_prod/requirements.txt
@@ -0,0 +1,9 @@
+Django
+gunicorn
+django-cors-headers
+djangorestframework
+whitenoise
+openai
+Flask
+requests
+gunicorn
\ No newline at end of file
diff --git a/ida_prod/start.sh b/ida_prod/start.sh
new file mode 100644
index 00000000..276092ae
--- /dev/null
+++ b/ida_prod/start.sh
@@ -0,0 +1,22 @@
+#!/bin/bash
+# Installiere Abhängigkeiten
+cd backend
+python -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+
+# Migration durchführen
+python manage.py migrate
+python manage.py collectstatic --noinput
+
+# React bauen
+cd ../frontend
+npm install
+npm run build
+
+# React-Frontend nach Django-Statisches-Verzeichnis verschieben
+cp -r build/* ../backend/staticfiles/
+
+# Starte Gunicorn (Django-Server)
+cd ../backend
+gunicorn backend.wsgi --bind 0.0.0.0:8000
diff --git a/readme.md b/readme.md
new file mode 100644
index 00000000..525d7f72
--- /dev/null
+++ b/readme.md
@@ -0,0 +1,168 @@
+# Data Platform - Multi-Agent Service
+
+Eine Full-Stack-Webapplikation für die Ausführung von Multi-Agent-Workflows zur Verarbeitung und Analyse von Daten basierend auf natürlichsprachlichen Benutzeranfragen.
+
+Hier: http://localhost:8000/docs 
+
+## Übersicht
+
+Das System ermöglicht Benutzern:
+- Hochladen und Verwalten verschiedener Datendateien
+- Definieren von Prompts/Anweisungen für KI-Agenten
+- Auswählen und Kombinieren spezialisierter Agenten
+- Ausführen von Workflows mit Echtzeit-Protokollierung
+- Visualisieren und Verwalten der Ergebnisse
+
+## Projektstruktur
+
+Das Projekt besteht aus zwei Hauptkomponenten:
+
+### Frontend (HTML/CSS/JavaScript)
+
+- `index.html` - Hauptstruktur der Benutzeroberfläche
+- `styles.css` - Umfangreiches CSS für das responsive Design
+- `script.js` - Client-seitige Logik für Interaktionen
+
+### Backend (Python/FastAPI)
+
+- `app.py` - Hauptanwendung mit API-Endpunkten
+- `models.py` - Datenmodelle und Validierungsschemas
+- `database.py` - Datenpersistenz (JSON-basiert für Demo)
+- `agent_service.py` - Multi-Agent-Orchestrierung
+- `requirements.txt` - Python-Abhängigkeiten
+
+## Hauptfunktionen
+
+### Workspace-Management
+- Mehrere Workspaces für verschiedene Projekte
+- Organisierte Gruppenarbeit mit geteilten Ressourcen
+
+### Datei-Verarbeitung
+- Upload verschiedener Dateitypen (PDF, Excel, Bilder, etc.)
+- Automatische Erkennung und Kategorisierung
+
+### Agent-Orchestrierung
+- Kombination verschiedener Agent-Typen:
+  - **Datenanalyse-Agent**: Extrahiert Insights aus strukturierten Daten
+  - **Visualisierungs-Agent**: Erstellt Diagramme und visuelle Darstellungen
+  - **Text-Generator**: Verfasst Berichte und Zusammenfassungen
+  - **Web-Scraper**: Sammelt externe Daten
+  - **Marktanalyse-Agent**: Spezialisiert auf Wettbewerbsanalyse
+
+### Workflow-Ausführung
+- Echtzeit-Protokollierung des Fortschritts
+- Vollständige Nachverfolgbarkeit aller Schritte
+
+### Ergebnis-Management
+- Strukturierte Darstellung von Analysen, Diagrammen und Berichten
+- Export- und Sharing-Funktionen
+
+## Installation und Einrichtung
+
+### Voraussetzungen
+- Python 3.8+
+- Ein moderner Webbrowser
+- Optional: Node.js für Entwicklungswerkzeuge
+
+### Frontend-Installation
+1. Klonen des Repositories
+2. Platzieren der Frontend-Dateien auf einem Webserver oder lokalen Entwicklungsserver:
+   ```bash
+   # Mit Python einen einfachen HTTP-Server starten
+   python -m http.server 8080
+   ```
+
+### Backend-Installation
+1. Virtuelle Umgebung erstellen und aktivieren:
+   ```bash
+   python -m venv venv
+   source venv/bin/activate  # Linux/Mac
+   venv\Scripts\activate     # Windows
+   ```
+
+2. Abhängigkeiten installieren:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+3. Server starten:
+   ```bash
+   uvicorn app:app --reload --host 0.0.0.0 --port 8000
+   ```
+
+4. Zugangspunkte:
+   - Frontend: `http://localhost:8080`
+   - Backend API: `http://localhost:8000`
+   - API-Dokumentation: `http://localhost:8000/docs`
+
+## Verwendung: Der Customer Journey
+
+### 1. Workspace auswählen oder erstellen
+- Wählen Sie einen vorhandenen Workspace oder erstellen Sie einen neuen für Ihr Projekt
+
+### 2. Dateien hochladen
+- Laden Sie die zu analysierenden Dateien hoch
+- Das System erkennt automatisch Dateitypen und bereitet sie für die Verarbeitung vor
+
+### 3. Prompt formulieren
+- Definieren Sie in natürlicher Sprache, was Sie analysieren möchten
+- Je präziser Ihre Anweisungen, desto zielgerichteter die Ergebnisse
+
+### 4. Agenten konfigurieren
+- Wählen Sie die passenden Agenten für Ihre Aufgabe
+- Kombinieren Sie Agenten für umfassendere Analysen
+  - Datenanalyse → Visualisierung → Textgenerierung
+
+### 5. Workflow ausführen
+- Starten Sie den Workflow und verfolgen Sie die Ausführung in Echtzeit
+- Im linken Bereich sehen Sie die Konfiguration
+- Im rechten Bereich werden Protokoll und Ergebnisse angezeigt
+
+### 6. Ergebnisse verwenden
+- Sehen Sie Analysen, Diagramme und Berichte ein
+- Exportieren oder teilen Sie die Ergebnisse
+- Iterieren Sie bei Bedarf mit angepassten Prompts oder Agent-Konfigurationen
+
+## Anpassung und Erweiterung
+
+### Integration mit echten KI-Diensten
+Die aktuelle Implementierung simuliert die Agent-Verarbeitung. Für eine produktive Nutzung:
+
+1. Erweitern Sie `agent_service.py` mit Integrationen zu:
+   - OpenAI GPT-Modellen (ChatGPT, GPT-4)
+   - Claude von Anthropic
+   - Eigenentwickelten Modellen mit spezieller Expertise
+
+2. Implementieren Sie robuste Datei-Parser für:
+   - PDF-Dokumente mit OCR
+   - Excel- und CSV-Verarbeitung
+   - Bild- und Medienanalyse
+
+3. Ergänzen Sie Authentifizierung und Autorisierung:
+   - Benutzer-Accounts mit Rollenkonzept
+   - API-Schlüsselverwaltung für externe Dienste
+   - Sichere Datenspeicherung
+
+### Datenbank-Migration
+Für größere Installationen die JSON-basierte Datenbank ersetzen durch:
+- PostgreSQL für relationale Daten
+- MongoDB für Dokumente und unstrukturierte Daten
+- Redis für Caching und Workflow-Status
+
+## Technische Details
+
+### Frontend-Architektur
+- Vanilla JavaScript ohne Framework-Abhängigkeiten
+- Modularer CSS-Ansatz für einfache Anpassungen
+- Responsive Design für Desktop und mobile Nutzung
+
+### Backend-Architektur
+- FastAPI für hohe Performance und automatische API-Dokumentation
+- Asynchrone Verarbeitung für parallele Agent-Ausführung
+- Erweiterbare Service-Struktur für einfache Integration neuer Agententypen
+
+## Lizenz
+
+PRIVATE LICENSE PATRICK MOTSCH ValueOn AG
+---
+Für Fragen oder Unterstützung wenden Sie sich bitte an p.motsch@valueon.ch
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 9ecd9896..79715519 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,9 +1,11 @@
-Django
-gunicorn
-django-cors-headers
-djangorestframework
-whitenoise
-openai
-Flask
-requests
-gunicorn
\ No newline at end of file
+fastapi==0.103.1
+uvicorn==0.23.2
+python-multipart==0.0.6
+pydantic==2.4.2
+typing-extensions==4.8.0
+python-dateutil==2.8.2
+six==1.16.0
+starlette==0.27.0
+anyio==3.7.1
+idna==3.4
+sniffio==1.3.0
\ No newline at end of file
diff --git a/start.bat b/start.bat
new file mode 100644
index 00000000..1a7c2e65
--- /dev/null
+++ b/start.bat
@@ -0,0 +1,53 @@
+@echo off
+echo Data Platform - Multi-Agent Service
+echo Startskript fuer Frontend und Backend
+echo ----------------------------------------
+
+:: Verzeichnisstruktur erstellen, falls sie nicht existiert
+if not exist backend\data mkdir backend\data
+if not exist backend\uploads mkdir backend\uploads
+if not exist backend\results mkdir backend\results
+if not exist backend\static mkdir backend\static
+
+:: Prüfen, ob Python installiert ist
+python --version >nul 2>&1
+if %errorlevel% neq 0 (
+    echo Python ist nicht installiert. Bitte installieren Sie Python 3.8 oder hoeher.
+    exit /b 1
+)
+
+:: Virtuelle Umgebung erstellen, falls sie nicht existiert
+if not exist backend\venv (
+    echo Erstelle virtuelle Python-Umgebung...
+    cd backend
+    python -m venv venv
+    cd ..
+)
+
+:: Virtuelle Umgebung aktivieren
+echo Aktiviere virtuelle Umgebung...
+call backend\venv\Scripts\activate
+
+:: Abhängigkeiten installieren
+echo Installiere Abhaengigkeiten...
+pip install -r requirements.txt
+
+:: Starte Backend in neuem Fenster
+echo Starte Backend-Server...
+start cmd /k "cd backend && call venv\Scripts\activate && uvicorn app:app --reload --host 0.0.0.0 --port 8000"
+
+:: Kurz warten, um sicherzustellen, dass das Backend startet
+timeout /t 2 >nul
+
+:: Starte Frontend-Server in neuem Fenster
+echo Starte Frontend-Server...
+start cmd /k "cd frontend && python -m http.server 8080"
+
+echo ----------------------------------------
+echo Server wurden gestartet!
+echo Frontend laeuft auf: http://localhost:8080
+echo Backend API laeuft auf: http://localhost:8000
+echo API-Dokumentation: http://localhost:8000/docs
+echo Schliesse die Kommandozeilenfenster, um die Server zu beenden.
+
+pause
\ No newline at end of file
diff --git a/start.sh b/start.sh
index 276092ae..2a705b27 100644
--- a/start.sh
+++ b/start.sh
@@ -1,22 +1,81 @@
 #!/bin/bash
-# Installiere Abhängigkeiten
-cd backend
-python -m venv venv
-source venv/bin/activate
+
+# Farben für die Ausgabe
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+echo -e "${GREEN}Data Platform - Multi-Agent Service${NC}"
+echo -e "${BLUE}Startskript für Frontend und Backend${NC}"
+echo "----------------------------------------"
+
+# Verzeichnisstruktur erstellen, falls sie nicht existiert
+mkdir -p backend/data
+mkdir -p backend/uploads
+mkdir -p backend/results
+mkdir -p backend/static
+
+# Prüfen, ob Python installiert ist
+if command -v python3 &>/dev/null; then
+    PYTHON_CMD="python3"
+elif command -v python &>/dev/null; then
+    PYTHON_CMD="python"
+else
+    echo "Python ist nicht installiert. Bitte installieren Sie Python 3.8 oder höher."
+    exit 1
+fi
+
+# Virtuelle Umgebung erstellen, falls sie nicht existiert
+if [ ! -d "backend/venv" ]; then
+    echo "Erstelle virtuelle Python-Umgebung..."
+    cd backend
+    $PYTHON_CMD -m venv venv
+    cd ..
+fi
+
+# Virtuelle Umgebung aktivieren
+echo "Aktiviere virtuelle Umgebung..."
+source backend/venv/bin/activate 2>/dev/null || . backend/venv/bin/activate
+
+# Abhängigkeiten installieren
+echo "Installiere Abhängigkeiten..."
 pip install -r requirements.txt
 
-# Migration durchführen
-python manage.py migrate
-python manage.py collectstatic --noinput
+# Backend als Hintergrundprozess starten
+echo "Starte Backend-Server..."
+cd backend
+uvicorn app:app --reload --host 0.0.0.0 --port 8000 &
+BACKEND_PID=$!
+cd ..
 
-# React bauen
-cd ../frontend
-npm install
-npm run build
+# Kurz warten, um sicherzustellen, dass das Backend startet
+sleep 2
 
-# React-Frontend nach Django-Statisches-Verzeichnis verschieben
-cp -r build/* ../backend/staticfiles/
+# Frontend-Server starten
+echo "Starte Frontend-Server..."
+cd frontend
+$PYTHON_CMD -m http.server 8080 &
+FRONTEND_PID=$!
+cd ..
 
-# Starte Gunicorn (Django-Server)
-cd ../backend
-gunicorn backend.wsgi --bind 0.0.0.0:8000
+echo "----------------------------------------"
+echo -e "${GREEN}Server wurden gestartet!${NC}"
+echo "Frontend läuft auf: http://localhost:8080"
+echo "Backend API läuft auf: http://localhost:8000"
+echo "API-Dokumentation: http://localhost:8000/docs"
+echo -e "${BLUE}Drücke STRG+C, um beide Server zu beenden${NC}"
+
+# Funktion zum Beenden der Server bei STRG+C
+cleanup() {
+    echo -e "\n${GREEN}Beende Server...${NC}"
+    kill $BACKEND_PID
+    kill $FRONTEND_PID
+    echo "Server wurden beendet"
+    exit 0
+}
+
+# Signal-Handler für STRG+C
+trap cleanup SIGINT
+
+# Warten auf Benutzeraktion
+wait
\ No newline at end of file
diff --git a/test/data.py b/test/data.py
new file mode 100644
index 00000000..a80f76eb
--- /dev/null
+++ b/test/data.py
@@ -0,0 +1,55 @@
+data_object_model = {
+    "Mandate": {
+        "id": "mandate_001",
+        "users": [
+            {
+                "id": "user_001",
+                "settings": {
+                    "id": "setting_001",
+                    "preferences": {}
+                },
+                "sessions": [
+                    {
+                        "id": "session_001",
+                        "timestamp": "2025-03-13T12:00:00Z",
+                        "active": True
+                    }
+                ],
+                "workspaces": [
+                    {
+                        "id": "workspace_001",
+                        "prompts": [
+                            {
+                                "id": "prompt_001",
+                                "content": "",
+                                "created_at": "2025-03-13T10:30:00Z"
+                            }
+                        ],
+                        "agents": [
+                            {
+                                "id": "agent_001",
+                                "type": "assistant",
+                                "capabilities": []
+                            }
+                        ],
+                        "dataObjectReferences": ["dataobject_001", "dataobject_002"]
+                    }
+                ],
+                "dataObjects": [
+                    {
+                        "id": "dataobject_001",
+                        "type": "document",
+                        "content": {},
+                        "metadata": {}
+                    },
+                    {
+                        "id": "dataobject_002",
+                        "type": "image",
+                        "content": {},
+                        "metadata": {}
+                    }
+                ]
+            }
+        ]
+    }
+}
diff --git a/main.py b/test/gw_main.py
similarity index 100%
rename from main.py
rename to test/gw_main.py
diff --git a/test.py b/test/gw_test.py
similarity index 100%
rename from test.py
rename to test/gw_test.py