From 4cebd2abc4de0d98b9fb70bbed7217a2278f127e Mon Sep 17 00:00:00 2001 From: Floke Date: Tue, 15 Jul 2025 19:32:00 +0000 Subject: [PATCH] =?UTF-8?q?generate=5Fknowledge=5Fbase.py=20hinzugef=C3=BC?= =?UTF-8?q?gt?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- generate_knowledge_base.py | 149 +++++++++++++++++++++++++++++++++++++ 1 file changed, 149 insertions(+) create mode 100644 generate_knowledge_base.py diff --git a/generate_knowledge_base.py b/generate_knowledge_base.py new file mode 100644 index 00000000..5290a231 --- /dev/null +++ b/generate_knowledge_base.py @@ -0,0 +1,149 @@ +# generate_knowledge_base.py + +import os +import yaml +import logging +import time +import openai +from config import Config # Wir nutzen die Config für den API-Schlüssel + +# --- Konfiguration --- +# HIER BITTE IHRE FOKUSBRANCHEN EINTRAGEN +# Diese Namen sollten mit den Keys im BRANCH_GROUP_MAPPING aus config.py übereinstimmen. +FOKUS_BRANCHEN = [ + "Medizintechnik", + "Anlagenbau", + "Facility Management", + "Maschinenbau", + "IT / Telekommunikation" # Beispiel, bitte anpassen +] + +POSITIONEN = { + "IT": "IT-Leiter", + "Management / GF / C-Level": "Geschäftsführer / C-Level", + "Finanzen": "Finanzleiter / CFO", + "Procurement / Einkauf": "Einkaufsleiter", + "Field Service Management": "Leiter Kundenservice / Field Service" +} + +OUTPUT_FILE = "marketing_wissen_entwurf.yaml" + +# Logging einrichten +logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') + +def call_openai_with_retry(prompt, max_retries=3, delay=5): + """Ruft die OpenAI API mit Retry-Logik auf.""" + for attempt in range(max_retries): + try: + logging.info(f"Sende Prompt an OpenAI (Versuch {attempt + 1}/{max_retries})...") + response = openai.ChatCompletion.create( + model="gpt-4-turbo", # Oder ein anderes Modell Ihrer Wahl + messages=[{"role": "user", "content": prompt}], + temperature=0.5, + max_tokens=500 + ) + content = response.choices[0].message['content'].strip() + return content + except Exception as e: + logging.error(f"Fehler bei OpenAI-API-Aufruf: {e}") + if attempt < max_retries - 1: + logging.info(f"Warte {delay} Sekunden vor dem nächsten Versuch...") + time.sleep(delay) + else: + logging.error("Maximale Anzahl an Wiederholungen erreicht. Breche ab.") + return None + +def generate_pain_points_prompt(branch_name): + """Erstellt den Prompt zur Generierung von Pain Points für eine Branche.""" + return "\n".join([ + "Du bist ein Top-Strategieberater mit Branchen-Expertise bei einer führenden Unternehmensberatung. Du analysierst die operativen Kernprozesse von Unternehmen und identifizierst die entscheidenden Hebel für Effizienzsteigerungen im Außendienst.", + f"Branche: {branch_name}", + "\n--- Denkprozess (Chain of Thought) ---", + "1. Versetze dich in ein typisches Unternehmen dieser Branche.", + "2. Was sind die häufigsten, sich wiederholenden Aufgaben, die mobile Techniker dort ausführen (z.B. Wartung, Reparatur, Installation, Inspektion)?", + "3. Welche spezifischen Probleme und Engpässe treten bei der Planung und Durchführung DIESER Aufgaben auf? Denke an Regularien, Kundenanforderungen, technische Komplexität und wirtschaftlichen Druck.", + "4. Formuliere aus diesen Problemen 5 prägnante, operative 'Pain Points', die sich auf den Service-Außendienst beziehen.", + "\n--- Aufgabe ---", + "Gib eine Liste von genau 5 Pain Points für die angegebene Branche aus. Formuliere sie als Herausforderungen aus Sicht des Unternehmens.", + "Gib das Ergebnis ausschließlich als saubere YAML-Liste unter dem Schlüssel 'pain_points:' aus. KEINE weiteren Einleitungen oder Kommentare.", + "\n--- Beispiel für den gewünschten Output-Stil (Branche: Aufzüge und Rolltreppen) ---", + """ +pain_points: + - "Sicherstellung der gesetzlich vorgeschriebenen, regelmäßigen Sicherheitsüberprüfungen und deren lückenlose Dokumentation." + - "Minimierung der Ausfallzeiten von Aufzügen in hochfrequentierten Gebäuden durch extrem schnelle Reaktionszeiten bei Störungen." + - "Effiziente Routenplanung, um die Vielzahl an dezentral verteilten Anlagen mit minimalem Fahrtaufwand abzudecken." + - "Bereitstellung von technischer Dokumentation und spezifischen Wartungsplänen für hunderte verschiedene Modelle direkt vor Ort." + - "Management von Ersatzteilen und deren Verfügbarkeit im Servicefahrzeug." + """ + ]) + +def generate_position_focus_prompt(position_name): + """Erstellt den Prompt zur Generierung des Fokus-Textes für eine Position.""" + return "\n".join([ + "Du bist ein erfahrener B2B-Vertriebs-Coach. Du formulierst Kernaussagen, die den spezifischen Blickwinkel unterschiedlicher Entscheidungsträger treffen.", + f"Position: {position_name}", + "\n--- Aufgabe ---", + "Formuliere EINEN EINZIGEN Satz, der den typischen Fokus oder das Hauptinteresse dieser Position in Bezug auf die Optimierung von Serviceprozessen beschreibt.", + "Dieser Satz wird später in einer E-Mail verwendet, beginnend mit 'Für Sie als...'. Formuliere den Satz so, dass er dort direkt passt.", + "Beispiel für 'Geschäftsführer': 'stehen vermutlich die Steigerung der Effizienz, die Kundenzufriedenheit und die Skalierbarkeit Ihrer Serviceprozesse im Vordergrund.'", + "Gib NUR den reinen Satz ohne Anführungszeichen oder einleitende Phrasen aus." + ]) + + +def main(): + """Hauptfunktion zur Generierung der Wissensbasis.""" + logging.info("Starte die Generierung der Wissensbasis für Marketing-Texte...") + + # API-Schlüssel laden + Config.load_api_keys() + openai.api_key = Config.API_KEYS.get('openai') + if not openai.api_key: + logging.critical("OpenAI API Key nicht in config.py gefunden. Skript wird beendet.") + return + + knowledge_base = {'Branchen': {}, 'Positionen': {}} + + # 1. Pain Points für jede Fokusbranche generieren + logging.info(f"Generiere Pain Points für {len(FOKUS_BRANCHEN)} Fokusbranchen...") + for branch in FOKUS_BRANCHEN: + logging.info(f"--- Verarbeite Branche: {branch} ---") + prompt = generate_pain_points_prompt(branch) + response_text = call_openai_with_retry(prompt) + if response_text: + try: + # Versuche, den YAML-Teil zu parsen + parsed_yaml = yaml.safe_load(response_text) + knowledge_base['Branchen'][branch] = { + 'pain_points': parsed_yaml.get('pain_points', ['FEHLER: Konnte Pain Points nicht parsen.']), + 'references_DE': '[HIER DEUTSCHE REFERENZKUNDEN EINTRAGEN]', + 'references_GB': '[HIER ENGLISCHE REFERENZKUNDEN EINTRAGEN]' + } + except yaml.YAMLError as e: + logging.error(f"Fehler beim Parsen der YAML-Antwort für {branch}: {e}") + knowledge_base['Branchen'][branch] = {'pain_points': [f'PARSING-FEHLER: {response_text}']} + time.sleep(2) # Kurze Pause, um Rate-Limits zu vermeiden + + # 2. Fokus für jede Position generieren + logging.info(f"\nGeneriere Fokus-Texte für {len(POSITIONEN)} Positionen...") + for key, name in POSITIONEN.items(): + logging.info(f"--- Verarbeite Position: {name} ---") + prompt = generate_position_focus_prompt(name) + response_text = call_openai_with_retry(prompt) + if response_text: + knowledge_base['Positionen'][key] = { + 'focus_DE': response_text, + 'focus_GB': '[HIER ENGLISCHE ÜBERSETZUNG DES FOKUS-SATZES EINTRAGEN]' + } + time.sleep(2) + + # 3. Ergebnis in YAML-Datei speichern + try: + with open(OUTPUT_FILE, 'w', encoding='utf-8') as f: + yaml.dump(knowledge_base, f, allow_unicode=True, sort_keys=False, width=120) + logging.info(f"\nErfolgreich! Die Wissensbasis wurde in '{OUTPUT_FILE}' gespeichert.") + logging.info("BITTE ÜBERPRÜFEN SIE DIESE DATEI UND PASSEN SIE SIE NACH BEDARF AN.") + except Exception as e: + logging.error(f"Fehler beim Speichern der YAML-Datei: {e}") + +if __name__ == "__main__": + main() \ No newline at end of file