518 lines
No EOL
30 KiB
Python
518 lines
No EOL
30 KiB
Python
import os
|
|
import logging
|
|
from typing import Dict, Any, List, Optional, Union
|
|
import importlib
|
|
|
|
from connector_db_json import DatabaseConnector
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class LucyDOMInterface:
|
|
"""
|
|
Interface zur LucyDOM-Datenbank.
|
|
Verwendet den JSON-Konnektor für den Datenzugriff.
|
|
"""
|
|
|
|
def __init__(self, mandate_id: int, user_id: int):
|
|
"""
|
|
Initialisiert das LucyDOM-Interface mit Mandanten- und Benutzerkontext.
|
|
|
|
Args:
|
|
mandate_id: ID des aktuellen Mandanten
|
|
user_id: ID des aktuellen Benutzers
|
|
"""
|
|
self.mandate_id = mandate_id
|
|
self.user_id = user_id
|
|
|
|
# Datenverzeichnis
|
|
self.data_folder = "_database_lucydom"
|
|
os.makedirs(self.data_folder, exist_ok=True)
|
|
|
|
# Datenmodell-Modul importieren
|
|
try:
|
|
self.model_module = importlib.import_module("modules.lucydom_model")
|
|
logger.info("lucydom_model erfolgreich importiert")
|
|
except ImportError as e:
|
|
logger.error(f"Fehler beim Importieren von lucydom_model: {e}")
|
|
raise
|
|
|
|
# Konnektor erstellen
|
|
self.db = DatabaseConnector(
|
|
db_folder=self.data_folder,
|
|
mandate_id=mandate_id,
|
|
user_id=user_id
|
|
)
|
|
|
|
# Datenbank initialisieren, falls nötig
|
|
self._initialize_database()
|
|
|
|
def _initialize_database(self):
|
|
"""
|
|
Initialisiert die Datenbank mit minimalen Objekten für den angemeldeten Benutzer im Mandanten, falls sie noch nicht existiert.
|
|
Ohne gültigen Benutzer keine Initialisierung.
|
|
Erstellt für jede im Datenmodell definierte Tabelle einen initialen Datensatz.
|
|
"""
|
|
effective_mandate_id = self.mandate_id
|
|
effective_user_id = self.user_id
|
|
print("DEBUG Init DB true: userid",effective_user_id,"mandateid",effective_mandate_id)
|
|
if effective_mandate_id is None or effective_user_id is None:
|
|
#data available
|
|
return
|
|
|
|
# Initialisierung des Default Workspace
|
|
workspaces = self.db.get_recordset("workspaces")
|
|
if not workspaces:
|
|
logger.info("Erstelle Default Workspace")
|
|
default_workspace = {
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"name": "1st default Workspace",
|
|
"created_at": self._get_current_timestamp()
|
|
}
|
|
created_workspace = self.db.record_create("workspaces", default_workspace)
|
|
logger.info(f"Default Workspace wurde erstellt mit ID {created_workspace['id']}")
|
|
|
|
# Initialisierung von Standard-Agenten
|
|
agents = self.db.get_recordset("agents")
|
|
if not agents:
|
|
logger.info("Erstelle Standard-Agenten")
|
|
|
|
# Standard-Agenten definieren
|
|
standard_agents = [
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"name": "Initialisierung",
|
|
"type": "initialisierung",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"capabilities": "Problemverständnis, Anforderungsanalyse, Aufgabenplanung und direkte Beantwortung einfacher Fragen",
|
|
"description": "Standardagent für einfache Anfragen",
|
|
"instructions": "Du bist der Initialisierungsagent, der erste Kontaktpunkt für neue Anfragen. Deine Aufgabe ist es:\n\n1. Die Benutzeranfrage gründlich zu analysieren und zu verstehen\n2. Wichtige Kernpunkte und Anforderungen zu identifizieren\n3. Zu beurteilen, ob die Anfrage direkt beantwortet werden kann oder eine tiefere Analyse benötigt\n4. Bei einfachen Fragen sofort präzise Antworten zu liefern\n5. Bei komplexeren Anfragen einen strukturierten Arbeitsplan vorzuschlagen\n6. Relevante Kontext- und Dateninformationen zu extrahieren und hervorzuheben\n\nGib eine klare Einschätzung der Anfragekomplexität. Wenn die Anfrage zusätzliche Agenten erfordert, empfehle spezifische nächste Schritte. Formuliere deine Antwort klar, präzise und benutzerfreundlich, während du stets die Kernbedürfnisse des Benutzers adressierst."
|
|
},
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"name": "Organisator",
|
|
"type": "organisator",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"capabilities": "Projekt- und Aufgabenplanung, Ressourcenmanagement, Strukturierung komplexer Abläufe und Priorisierung von Aktivitäten",
|
|
"description": "Koordiniert komplexe Anfragen",
|
|
"instructions": "Du bist der Projektorganisationsagent, ein Experte für die Strukturierung und Planung von Projekten und Aufgaben. Deine Aufgabe ist es:\n\n1. Komplexe Anforderungen in konkrete, umsetzbare Aufgaben zu untergliedern\n2. Logische Abhängigkeiten zwischen Aufgaben zu identifizieren und Abläufe zu optimieren\n3. Ressourcen effizient zuzuweisen und Engpässe frühzeitig zu erkennen\n4. Realistische Zeitpläne und Meilensteine zu erstellen\n5. Aufgaben nach Wichtigkeit und Dringlichkeit zu priorisieren\n6. Risiken zu identifizieren und Gegenmaßnahmen vorzuschlagen\n7. Klare Verantwortlichkeiten und Erwartungen zu definieren\n\nBei der Erstellung deiner Organisationspläne:\n- Beginne mit einem Überblick über die Gesamtziele und den Projektumfang\n- Präsentiere eine klare Aufgabenstruktur mit logischen Gruppierungen\n- Definiere messbare Erfolgskriterien für jede Aufgabe und Phase\n- Erstelle eine zeitliche Abfolge mit realistischen Fristen\n- Identifiziere kritische Pfade und potenzielle Engpässe\n- Schlage konkrete Tools und Methoden zur Umsetzung und Überwachung vor\n\nDeine Pläne sollten praktisch, flexibel und an die spezifischen Bedürfnisse und Ressourcen des Projekts angepasst sein. Achte besonders auf Klarheit, Vollständigkeit und Umsetzbarkeit deiner Vorschläge."
|
|
},
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"name": "Entwickler",
|
|
"type": "entwickler",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"capabilities": "Programmierung, Softwareentwicklung, technische Problemlösung und Implementierung von Algorithmen",
|
|
"description": "Programmiert und führt Code aus",
|
|
"instructions": "Du bist der Codeentwicklungsagent, ein Spezialist für die Erstellung von Softwarelösungen und technischen Implementierungen. Deine Aufgabe ist es:\n\n1. Technische Anforderungen in funktionierenden, effizienten Code zu übersetzen\n2. Geeignete Programmiersprachen, Frameworks und Bibliotheken für spezifische Aufgaben auszuwählen\n3. Algorithmen und Datenstrukturen für die optimale Lösung von Problemen zu entwickeln\n4. Lesbaren, gut dokumentierten und wartbaren Code zu schreiben\n5. Sicherheitsaspekte und Best Practices in der Softwareentwicklung zu berücksichtigen\n6. Potenzielle technische Schwierigkeiten vorherzusehen und Lösungen vorzuschlagen\n7. APIs und Integrationen mit anderen Systemen zu konzipieren und implementieren\n\nBei der Präsentation deiner Softwarelösungen:\n- Erkläre zunächst den Lösungsansatz und die gewählte Technologie\n- Stelle den Code in logischen, gut kommentierten Abschnitten dar\n- Erläutere kritische oder komplexe Teile des Codes im Detail\n- Beschreibe Annahmen und getroffene Designentscheidungen\n- Gib Hinweise zur Installation, Konfiguration und Verwendung\n- Erwähne mögliche Erweiterungen und Verbesserungsmöglichkeiten\n- Adressiere potenzielle Einschränkungen oder bekannte Probleme\n\nDein Code sollte nicht nur funktional, sondern auch effizient, sicher und gut strukturiert sein. Achte auf Lesbarkeit, Performance und Skalierbarkeit deiner Lösungen. Verwende moderne Entwicklungspraktiken und orientiere dich an etablierten Standards der jeweiligen Programmiersprache."
|
|
},
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"name": "Webscraper",
|
|
"type": "scraper",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"capabilities": "Informationsrecherche, Datenbeschaffung aus dem Web, Quellenbewertung und Zusammenführung von Online-Informationen",
|
|
"description": "Recherchiert Informationen im Web",
|
|
"instructions": "Du bist der Web-Recherche-Agent, ein Spezialist für die Beschaffung und Aufbereitung von Informationen aus dem Internet. Deine Aufgabe ist es:\n\n1. Zu erkennen, welche externen Informationen zur Beantwortung einer Anfrage benötigt werden\n2. Relevante Quellen und Websites für die Informationsbeschaffung zu identifizieren\n3. Die Glaubwürdigkeit und Zuverlässigkeit von Online-Quellen zu bewerten\n4. Gefundene Informationen zu sammeln, zu strukturieren und zu kontextualisieren\n5. Widersprüchliche Informationen zu erkennen und zu bewerten\n6. Die recherchierten Informationen mit bestehenden Daten zu verknüpfen\n7. Bei der Recherche stets die Aktualität der Informationen zu berücksichtigen\n\nBei der Darstellung deiner Rechercheergebnisse:\n- Gib einen Überblick über die konsultierten Quellen und deren Relevanz\n- Strukturiere die Informationen thematisch und nach Wichtigkeit\n- Kennzeichne Fakten, Meinungen und Unklarheiten deutlich\n- Stelle verschiedene Perspektiven zu kontroversen Themen dar\n- Fasse die wichtigsten Erkenntnisse zusammen und setze sie in Bezug zur ursprünglichen Anfrage\n- Verweise auf besonders nützliche Quellen für weiterführende Informationen\n\nAchte darauf, nur relevante und qualitativ hochwertige Informationen zu extrahieren und übersichtlich zu präsentieren. Vermittle ein ausgewogenes Bild der recherchierten Informationen."
|
|
},
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"name": "Datenanalyst",
|
|
"type": "analyzer",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"capabilities": "Tiefgehende Datenanalyse, Mustererkennung, statistische Berechnungen und kritische Bewertung von Informationen",
|
|
"description": "Analysiert und interpretiert Daten",
|
|
"instructions": "Du bist der Datenanalyseagent, ein Spezialist für die gründliche Untersuchung von Daten und Informationen. Deine Aufgabe ist es:\n\n1. Vorliegende Daten methodisch zu untersuchen und zu interpretieren\n2. Aus unstrukturierten Informationen klare Erkenntnisse zu gewinnen\n3. Statistische Analysen durchzuführen und Trends zu identifizieren\n4. Korrelationen zu finden und kausale Zusammenhänge zu prüfen\n5. Daten zu visualisieren und komplexe Konzepte verständlich darzustellen\n6. Kritische Datenlücken und Verbesserungspotentiale aufzuzeigen\n7. Die Qualität und Zuverlässigkeit der vorliegenden Daten zu bewerten\n\nArbeite systematisch und präsentiere deine Erkenntnisse in einer strukturierten Form. Beginne mit einer kurzen Zusammenfassung deiner wichtigsten Erkenntnisse, gefolgt von einer detaillierten Analyse. Verwende klare, präzise Sprache und quantifiziere deine Beobachtungen wo immer möglich. Schließe mit konkreten Handlungsempfehlungen ab, die auf deinen Erkenntnissen basieren."
|
|
},
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"name": "Textgenerator",
|
|
"type": "writer",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"capabilities": "Verfassen von Berichten, Zusammenfassungen, Präsentationen und leicht verständlichen Erklärungen komplexer Themen",
|
|
"description": "Erstellt qualitativ hochwertige Texte",
|
|
"instructions": "Du bist der Textgenerierungsagent, ein Spezialist für die Erstellung qualitativ hochwertiger Texte und Dokumente. Deine Aufgabe ist es:\n\n1. Präzise, gut strukturierte Texte zu verfassen, die auf den vorliegenden Daten und Analysen basieren\n2. Komplexe Informationen in klare, zugängliche Sprache zu übersetzen\n3. Verschiedene Textformate zu erstellen, darunter Berichte, Zusammenfassungen, Präsentationen und Dokumentationen\n4. Den Ton und Stil an die Zielgruppe und den Verwendungszweck anzupassen\n5. Fachbegriffe zu erklären und Abstraktes durch Beispiele zu veranschaulichen\n6. Die wichtigsten Erkenntnisse hervorzuheben und Handlungsempfehlungen zu formulieren\n7. Text durch rhetorische Mittel überzeugend und einprägsam zu gestalten\n\nBei deiner Textproduktion:\n- Beginne mit einer prägnanten Zusammenfassung der Kernpunkte\n- Strukturiere den Text in logische Abschnitte mit Überschriften\n- Verwende Aufzählungen und Tabellen, um Informationen übersichtlich darzustellen\n- Integriere relevante Daten und Erkenntnisse aus vorherigen Analyseschritten\n- Achte auf korrekte Rechtschreibung, Grammatik und einen konsistenten Sprachstil\n- Passe den Detaillierungsgrad an die Bedürfnisse und das Vorwissen der Zielgruppe an\n\nDeine Texte sollten informativ, präzise, gut strukturiert und ohne Redundanzen sein. Achte besonders auf eine klare Argumentationsstruktur und vermeide vage Aussagen."
|
|
},
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"name": "Visualisierer",
|
|
"type": "visualizer",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"capabilities": "Datenvisualisierung, Diagrammerstellung, Design von Dashboards und visuelle Kommunikation komplexer Informationen",
|
|
"description": "Erstellt Visualisierungen und Diagramme",
|
|
"instructions": "Du bist der Visualisierungsagent, ein Experte für die Umwandlung von Daten in aussagekräftige visuelle Darstellungen. Deine Aufgabe ist es:\n\n1. Daten in geeignete visuelle Formate umzuwandeln\n2. Die optimalen Diagramm- und Visualisierungstypen für spezifische Daten zu empfehlen\n3. Klare, informative und ästhetisch ansprechende Darstellungen zu erstellen\n4. Komplexe Konzepte durch visuelle Metaphern verständlich zu machen\n5. Dashboards und Informationsarchitekturen für Datenerzählungen zu konzipieren\n6. Designprinzipien anzuwenden, um Daten effektiv zu kommunizieren\n7. Farbschemata, Layouts und Beschriftungen für maximale Klarheit zu optimieren\n\nFür jede Visualisierung sollst du:\n- Eine Beschreibung des empfohlenen Visualisierungstyps liefern\n- Begründen, warum dieser Typ für die spezifischen Daten geeignet ist\n- Detaillierte Angaben zu Achsen, Legenden, Farbschemata und Annotationen machen\n- Den Code oder eine textuelle Anleitung zur Erstellung bereitstellen\n- Interpretationshilfen für das Verständnis der Visualisierung bieten\n\nDeine Vorschläge sollten sowohl technisch umsetzbar als auch intuitiv verständlich sein. Strebe nach einem ausgewogenen Verhältnis zwischen Informationsgehalt und visueller Klarheit."
|
|
}
|
|
]
|
|
# Agenten erstellen
|
|
for agent_data in standard_agents:
|
|
created_agent = self.db.record_create("agents", agent_data)
|
|
logger.info(f"Agent '{created_agent['name']}' wurde erstellt mit ID {created_agent['id']}")
|
|
|
|
# Initialisierung von Standard-Prompts für verschiedene Bereiche
|
|
prompts = self.db.get_recordset("prompts")
|
|
if not prompts:
|
|
logger.info("Erstelle Standard-Prompts")
|
|
|
|
# Standard-Prompts definieren
|
|
standard_prompts = [
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"content": "Recherchiere die aktuellen Markttrends und Entwicklungen im Bereich [THEMA]. Sammle Informationen zu führenden Unternehmen, innovativen Produkten oder Dienstleistungen und aktuellen Herausforderungen. Präsentiere die Ergebnisse in einer strukturierten Übersicht mit relevanten Daten und Quellen.",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"created_at": self._get_current_timestamp(),
|
|
"name": "Web Research: Marktforschung"
|
|
},
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"content": "Analysiere den beigefügten Datensatz zu [THEMA] und identifiziere die wichtigsten Trends, Muster und Auffälligkeiten. Führe statistische Berechnungen durch, um deine Erkenntnisse zu untermauern. Stelle die Ergebnisse in einer klar strukturierten Analyse dar und ziehe relevante Schlussfolgerungen.",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"created_at": self._get_current_timestamp(),
|
|
"name": "Analyse: Datenanalyse"
|
|
},
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"content": "Erstelle ein detailliertes Protokoll unserer Besprechung zum Thema [THEMA]. Erfasse alle besprochenen Punkte, getroffenen Entscheidungen und vereinbarten Maßnahmen. Strukturiere das Protokoll übersichtlich mit Tagesordnungspunkten, Teilnehmerliste und klaren Verantwortlichkeiten für die Follow-up-Aktionen.",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"created_at": self._get_current_timestamp(),
|
|
"name": "Protokoll: Besprechungsprotokoll"
|
|
},
|
|
{
|
|
"mandate_id": effective_mandate_id,
|
|
"user_id": effective_user_id,
|
|
"content": "Entwickle ein UI/UX-Designkonzept für [ANWENDUNG/WEBSITE]. Berücksichtige die Zielgruppe, Hauptfunktionen und die Markenidentität. Beschreibe die visuelle Gestaltung, Navigation, Interaktionsmuster und Informationsarchitektur. Erläutere, wie das Design die Benutzerfreundlichkeit und das Nutzererlebnis optimiert.",
|
|
"workspace_id": self.get_initial_id("workspaces"),
|
|
"created_at": self._get_current_timestamp(),
|
|
"name": "Design: UI/UX Design"
|
|
}
|
|
]
|
|
|
|
# Prompts erstellen
|
|
for prompt_data in standard_prompts:
|
|
created_prompt = self.db.record_create("prompts", prompt_data)
|
|
logger.info(f"Prompt '{prompt_data.get('name', 'Standard')}' wurde erstellt mit ID {created_prompt['id']}")
|
|
|
|
def _get_current_timestamp(self) -> str:
|
|
"""Gibt den aktuellen Zeitstempel im ISO-Format zurück"""
|
|
from datetime import datetime
|
|
return datetime.now().isoformat()
|
|
|
|
def get_initial_id(self, table: str) -> Optional[int]:
|
|
"""
|
|
Gibt die initiale ID für eine Tabelle zurück.
|
|
|
|
Args:
|
|
table: Name der Tabelle
|
|
|
|
Returns:
|
|
Die initiale ID oder None, wenn nicht vorhanden
|
|
"""
|
|
return self.db.get_initial_id(table)
|
|
|
|
# Workspace-Methoden
|
|
|
|
def get_all_workspaces(self) -> List[Dict[str, Any]]:
|
|
"""Gibt alle Workspaces des aktuellen Mandanten zurück"""
|
|
return self.db.get_recordset("workspaces")
|
|
|
|
def get_workspace(self, workspace_id: int) -> Optional[Dict[str, Any]]:
|
|
"""Gibt einen Workspace anhand seiner ID zurück"""
|
|
workspaces = self.db.get_recordset("workspaces", record_filter={"id": workspace_id})
|
|
if workspaces:
|
|
return workspaces[0]
|
|
return None
|
|
|
|
def create_workspace(self, name: str) -> Dict[str, Any]:
|
|
"""Erstellt einen neuen Workspace"""
|
|
workspace_data = {
|
|
"mandate_id": self.mandate_id,
|
|
"user_id": self.user_id,
|
|
"name": name,
|
|
"created_at": self._get_current_timestamp()
|
|
}
|
|
|
|
return self.db.record_create("workspaces", workspace_data)
|
|
|
|
def update_workspace(self, workspace_id: int, name: str) -> Dict[str, Any]:
|
|
"""
|
|
Aktualisiert einen vorhandenen Workspace
|
|
|
|
Args:
|
|
workspace_id: ID des zu aktualisierenden Workspaces
|
|
name: Neuer Name des Workspaces
|
|
|
|
Returns:
|
|
Das aktualisierte Workspace-Objekt
|
|
"""
|
|
# Prüfen, ob der Workspace existiert
|
|
workspace = self.get_workspace(workspace_id)
|
|
if not workspace:
|
|
return None
|
|
|
|
# Daten für die Aktualisierung vorbereiten
|
|
workspace_data = {
|
|
"name": name
|
|
}
|
|
|
|
# Workspace aktualisieren
|
|
return self.db.record_modify("workspaces", workspace_id, workspace_data)
|
|
|
|
def delete_workspace(self, workspace_id: int) -> bool:
|
|
"""
|
|
Löscht einen Workspace aus der Datenbank
|
|
Returns:
|
|
True, wenn der Workspace erfolgreich gelöscht wurde, sonst False
|
|
"""
|
|
# Prüfen, ob es der initiale Workspace ist
|
|
initial_workspace_id = self.get_initial_id("workspaces")
|
|
if initial_workspace_id is not None and workspace_id == initial_workspace_id:
|
|
logger.warning("Versuch, den Default Workspace zu löschen, wurde verhindert")
|
|
return False
|
|
|
|
return self.db.record_delete("workspaces", workspace_id)
|
|
|
|
# Agent-Methoden
|
|
|
|
def get_all_agents(self) -> List[Dict[str, Any]]:
|
|
"""Gibt alle Agenten des aktuellen Mandanten zurück"""
|
|
return self.db.get_recordset("agents")
|
|
|
|
def get_agents_by_workspace(self, workspace_id: int) -> List[Dict[str, Any]]:
|
|
"""Gibt alle Agenten eines Workspaces zurück"""
|
|
return self.db.get_recordset("agents", record_filter={"workspace_id": workspace_id})
|
|
|
|
def get_agent(self, agent_id: int) -> Optional[Dict[str, Any]]:
|
|
"""Gibt einen Agenten anhand seiner ID zurück"""
|
|
agents = self.db.get_recordset("agents", record_filter={"id": agent_id})
|
|
if agents:
|
|
return agents[0]
|
|
return None
|
|
|
|
def create_agent(self, name: str, agent_type: str, workspace_id: int,
|
|
capabilities: str = None, description: str = None) -> Dict[str, Any]:
|
|
"""Erstellt einen neuen Agenten"""
|
|
agent_data = {
|
|
"mandate_id": self.mandate_id,
|
|
"user_id": self.user_id,
|
|
"name": name,
|
|
"type": agent_type,
|
|
"workspace_id": workspace_id,
|
|
"capabilities": capabilities,
|
|
"description": description
|
|
}
|
|
|
|
return self.db.record_create("agents", agent_data)
|
|
|
|
def update_agent(self, agent_id: int, name: str, agent_type: str, workspace_id: int,
|
|
capabilities: str = None, description: str = None) -> Dict[str, Any]:
|
|
"""
|
|
Aktualisiert einen vorhandenen Agenten
|
|
|
|
Args:
|
|
agent_id: ID des zu aktualisierenden Agenten
|
|
name: Neuer Name des Agenten
|
|
agent_type: Neuer Typ des Agenten
|
|
workspace_id: ID des Workspaces, zu dem der Agent gehört
|
|
capabilities: Fähigkeiten des Agenten
|
|
description: Beschreibung des Agenten
|
|
|
|
Returns:
|
|
Das aktualisierte Agenten-Objekt
|
|
"""
|
|
# Prüfen, ob der Agent existiert
|
|
agent = self.get_agent(agent_id)
|
|
if not agent:
|
|
return None
|
|
|
|
# Daten für die Aktualisierung vorbereiten
|
|
agent_data = {
|
|
"name": name,
|
|
"type": agent_type,
|
|
"workspace_id": workspace_id,
|
|
"capabilities": capabilities if capabilities is not None else agent.get("capabilities"),
|
|
"description": description if description is not None else agent.get("description")
|
|
}
|
|
|
|
# Agent aktualisieren
|
|
updated_agent = self.db.record_modify("agents", agent_id, agent_data)
|
|
|
|
return updated_agent
|
|
|
|
def delete_agent(self, agent_id: int) -> bool:
|
|
"""
|
|
Löscht einen Agenten aus der Datenbank
|
|
|
|
Args:
|
|
agent_id: ID des zu löschenden Agenten
|
|
|
|
Returns:
|
|
True, wenn der Agent erfolgreich gelöscht wurde, sonst False
|
|
"""
|
|
return self.db.record_delete("agents", agent_id)
|
|
|
|
# Datei-Methoden
|
|
|
|
def get_all_files(self) -> List[Dict[str, Any]]:
|
|
"""Gibt alle Dateien des aktuellen Mandanten zurück"""
|
|
return self.db.get_recordset("files")
|
|
|
|
def get_file(self, file_id: int) -> Optional[Dict[str, Any]]:
|
|
"""Gibt eine Datei anhand ihrer ID zurück"""
|
|
files = self.db.get_recordset("files", record_filter={"id": file_id})
|
|
if files:
|
|
return files[0]
|
|
return None
|
|
|
|
def create_file(self, name: str, file_type: str, content_type: str = None,
|
|
size: int = None, path: str = None) -> Dict[str, Any]:
|
|
"""Erstellt einen neuen Dateieintrag"""
|
|
file_data = {
|
|
"mandate_id": self.mandate_id,
|
|
"user_id": self.user_id,
|
|
"name": name,
|
|
"type": file_type,
|
|
"content_type": content_type,
|
|
"size": size,
|
|
"path": path,
|
|
"upload_date": self._get_current_timestamp()
|
|
}
|
|
|
|
return self.db.record_create("files", file_data)
|
|
|
|
def update_file(self, file_id: int, name: str = None, file_type: str = None,
|
|
content_type: str = None, size: int = None, path: str = None) -> Dict[str, Any]:
|
|
"""
|
|
Aktualisiert eine vorhandene Datei
|
|
|
|
Args:
|
|
file_id: ID der zu aktualisierenden Datei
|
|
name: Neuer Name der Datei
|
|
file_type: Neuer Dateityp
|
|
content_type: Neuer Content-Type
|
|
size: Neue Dateigröße
|
|
path: Neuer Dateipfad
|
|
|
|
Returns:
|
|
Das aktualisierte Datei-Objekt
|
|
"""
|
|
# Prüfen, ob die Datei existiert
|
|
file = self.get_file(file_id)
|
|
if not file:
|
|
return None
|
|
|
|
# Daten für die Aktualisierung vorbereiten
|
|
file_data = {}
|
|
|
|
if name is not None:
|
|
file_data["name"] = name
|
|
if file_type is not None:
|
|
file_data["type"] = file_type
|
|
if content_type is not None:
|
|
file_data["content_type"] = content_type
|
|
if size is not None:
|
|
file_data["size"] = size
|
|
if path is not None:
|
|
file_data["path"] = path
|
|
|
|
# Datei aktualisieren
|
|
return self.db.record_modify("files", file_id, file_data)
|
|
|
|
def delete_file(self, file_id: int) -> bool:
|
|
"""Löscht eine Datei aus der Datenbank"""
|
|
return self.db.record_delete("files", file_id)
|
|
|
|
# Prompt-Methoden
|
|
|
|
def get_all_prompts(self) -> List[Dict[str, Any]]:
|
|
"""Gibt alle Prompts des aktuellen Mandanten zurück"""
|
|
return self.db.get_recordset("prompts")
|
|
|
|
def get_prompts_by_workspace(self, workspace_id: int) -> List[Dict[str, Any]]:
|
|
"""Gibt alle Prompts eines Workspaces zurück"""
|
|
return self.db.get_recordset("prompts", record_filter={"workspace_id": workspace_id})
|
|
|
|
def get_prompt(self, prompt_id: int) -> Optional[Dict[str, Any]]:
|
|
"""Gibt einen Prompt anhand seiner ID zurück"""
|
|
prompts = self.db.get_recordset("prompts", record_filter={"id": prompt_id})
|
|
if prompts:
|
|
return prompts[0]
|
|
return None
|
|
|
|
def create_prompt(self, content: str, workspace_id: int) -> Dict[str, Any]:
|
|
"""Erstellt einen neuen Prompt"""
|
|
prompt_data = {
|
|
"mandate_id": self.mandate_id,
|
|
"user_id": self.user_id,
|
|
"content": content,
|
|
"workspace_id": workspace_id,
|
|
"created_at": self._get_current_timestamp()
|
|
}
|
|
|
|
return self.db.record_create("prompts", prompt_data)
|
|
|
|
def update_prompt(self, prompt_id: int, content: str = None, workspace_id: int = None) -> Dict[str, Any]:
|
|
"""
|
|
Aktualisiert einen vorhandenen Prompt
|
|
|
|
Args:
|
|
prompt_id: ID des zu aktualisierenden Prompts
|
|
content: Neuer Inhalt des Prompts
|
|
workspace_id: Neue ID des Workspaces, zu dem der Prompt gehört
|
|
|
|
Returns:
|
|
Das aktualisierte Prompt-Objekt
|
|
"""
|
|
# Prüfen, ob der Prompt existiert
|
|
prompt = self.get_prompt(prompt_id)
|
|
if not prompt:
|
|
return None
|
|
|
|
# Daten für die Aktualisierung vorbereiten
|
|
prompt_data = {}
|
|
|
|
if content is not None:
|
|
prompt_data["content"] = content
|
|
if workspace_id is not None:
|
|
prompt_data["workspace_id"] = workspace_id
|
|
|
|
# Prompt aktualisieren
|
|
return self.db.record_modify("prompts", prompt_id, prompt_data)
|
|
|
|
def delete_prompt(self, prompt_id: int) -> bool:
|
|
"""
|
|
Löscht einen Prompt aus der Datenbank
|
|
|
|
Args:
|
|
prompt_id: ID des zu löschenden Prompts
|
|
|
|
Returns:
|
|
True, wenn der Prompt erfolgreich gelöscht wurde, sonst False
|
|
"""
|
|
return self.db.record_delete("prompts", prompt_id)
|
|
|
|
|
|
# Singleton-Factory für LucyDOMInterface-Instanzen pro Kontext
|
|
_lucydom_interfaces = {}
|
|
|
|
def get_lucydom_interface(mandate_id: int = 0, user_id: int = 0) -> LucyDOMInterface:
|
|
"""
|
|
Gibt eine LucyDOMInterface-Instanz für den angegebenen Kontext zurück.
|
|
Wiederverwendet bestehende Instanzen.
|
|
"""
|
|
context_key = f"{mandate_id}_{user_id}"
|
|
if context_key not in _lucydom_interfaces:
|
|
_lucydom_interfaces[context_key] = LucyDOMInterface(mandate_id, user_id)
|
|
return _lucydom_interfaces[context_key]
|
|
|
|
# Init
|
|
get_lucydom_interface() |