Lösungen - Conversational AI & Chat Systems

🎯 Übersicht

Diese Musterlösungen zeigen vollständige Implementierungen für alle Conversational AI Übungen. Nutzen Sie diese zur Überprüfung Ihrer eigenen Lösungen oder als Referenz für erweiterte Features.

---

Lösung 1: Basis Chat-System mit Memory

Vollständige Implementierung

from langchain.memory import ConversationBufferMemory
from langchain.llms import OpenAI
from langchain.chains import ConversationChain
from langchain.schema import BaseMessage
import os

# API Key Setup
os.environ["OPENAI_API_KEY"] = "your-api-key-here"

class FinanceChatSystem:
    def __init__(self):
        # LLM initialisieren
        self.llm = OpenAI(temperature=0.7)

        # Memory für Konversation
        self.memory = ConversationBufferMemory()

        # Chain mit Finance-Prompt
        self.conversation = ConversationChain(
            llm=self.llm,
            memory=self.memory,
            verbose=True
        )

        # Finance-spezifischer Systemprompt
        self.setup_finance_context()

    def setup_finance_context(self):
        """Initialer Kontext für Finanzberatung"""
        system_msg = """Sie sind ein erfahrener Finanzberater. 
        Antworten Sie professionell und präzise auf Fragen zu:
        - Investitionen und Portfolio-Management
        - Risikobewertung
        - Finanzplanung
        - Marktanalysen
        Verwenden Sie den bisherigen Gesprächskontext."""

        # Ersten Kontext setzen
        self.memory.save_context(
            {"input": "System Setup"}, 
            {"output": system_msg}
        )

    def chat(self, user_input: str) -> str:
        """Verarbeite User Input mit Memory"""
        response = self.conversation.predict(input=user_input)
        return response

    def get_conversation_history(self):
        """Zeige bisherige Konversation"""
        return self.memory.buffer

# Verwendung
finance_chat = FinanceChatSystem()

# Test-Konversation
print("=== Finance Chat System ===")
print(finance_chat.chat("Hallo, ich möchte 10.000€ investieren"))
print("\n" + "="*50 + "\n")
print(finance_chat.chat("Welche Risiken sollte ich beachten?"))
print("\n" + "="*50 + "\n")
print(finance_chat.chat("Wie diversifiziere ich am besten?"))

Erweiterte Memory-Strategien

from langchain.memory import ConversationSummaryMemory, ConversationBufferWindowMemory

class AdvancedFinanceChatSystem:
    def __init__(self, memory_type="buffer"):
        self.llm = OpenAI(temperature=0.7)

        # Verschiedene Memory-Strategien
        if memory_type == "buffer":
            self.memory = ConversationBufferMemory()
        elif memory_type == "summary":
            self.memory = ConversationSummaryMemory(llm=self.llm)
        elif memory_type == "window":
            self.memory = ConversationBufferWindowMemory(k=5)  # Letzte 5 Nachrichten

        self.conversation = ConversationChain(
            llm=self.llm,
            memory=self.memory,
            verbose=True
        )

    def compare_memory_strategies(self, test_inputs):
        """Vergleiche verschiedene Memory-Strategien"""
        results = {}

        for memory_type in ["buffer", "summary", "window"]:
            chat_system = AdvancedFinanceChatSystem(memory_type)
            responses = []

            for input_text in test_inputs:
                response = chat_system.chat(input_text)
                responses.append(response)

            results[memory_type] = {
                "responses": responses,
                "memory_size": len(str(chat_system.memory.buffer)),
                "final_context": str(chat_system.memory.buffer)
            }

        return results

# Vergleichstest
test_inputs = [
    "Ich habe 50.000€ zu investieren",
    "Mein Risikoprofil ist konservativ",
    "Ich bin 35 Jahre alt",
    "Empfehlen Sie mir eine Strategie",
    "Was ist mit ESG-Investments?"
]

advanced_system = AdvancedFinanceChatSystem()
comparison_results = advanced_system.compare_memory_strategies(test_inputs)

# Ergebnisse analysieren
for memory_type, results in comparison_results.items():
    print(f"\n=== {memory_type.upper()} MEMORY ===")
    print(f"Memory Size: {results['memory_size']} characters")
    print(f"Final Context Preview: {results['final_context'][:200]}...")

---

Lösung 2: Finanz-PDF Analyse mit Chat

Vollständige RAG-Chat Implementierung

from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import CharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationalRetrievalChain
from langchain.llms import OpenAI

class FinancePDFChatSystem:
    def __init__(self, pdf_path: str):
        self.pdf_path = pdf_path
        self.llm = OpenAI(temperature=0)
        self.embeddings = OpenAIEmbeddings()
        self.memory = ConversationBufferMemory(
            memory_key="chat_history", 
            return_messages=True
        )

        # PDF verarbeiten und Vectorstore erstellen
        self.vectorstore = self.setup_pdf_processing()

        # Conversational RAG Chain
        self.qa_chain = ConversationalRetrievalChain.from_llm(
            llm=self.llm,
            retriever=self.vectorstore.as_retriever(search_kwargs={"k": 4}),
            memory=self.memory,
            verbose=True
        )

    def setup_pdf_processing(self):
        """Verarbeite PDF und erstelle Vectorstore"""
        # PDF laden
        loader = PyPDFLoader(self.pdf_path)
        documents = loader.load()

        # Text splitten
        text_splitter = CharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200
        )
        texts = text_splitter.split_documents(documents)

        # Vectorstore erstellen
        vectorstore = FAISS.from_documents(texts, self.embeddings)
        return vectorstore

    def ask_question(self, question: str) -> dict:
        """Stelle Frage über das PDF mit Chat-Kontext"""
        result = self.qa_chain({"question": question})

        return {
            "answer": result["answer"],
            "source_documents": result.get("source_documents", []),
            "chat_history": result.get("chat_history", [])
        }

    def get_conversation_summary(self):
        """Zusammenfassung der bisherigen Konversation"""
        history = self.memory.chat_memory.messages
        return [{"role": msg.type, "content": msg.content} for msg in history]

# Verwendung
pdf_chat = FinancePDFChatSystem("path/to/financial_report.pdf")

# Mehrteilige Konversation
print("=== PDF Chat System ===")

# Erste Frage
result1 = pdf_chat.ask_question("Was sind die wichtigsten Kennzahlen in diesem Bericht?")
print(f"Antwort 1: {result1['answer']}")

# Nachfrage mit Kontext
result2 = pdf_chat.ask_question("Wie haben sich diese Kennzahlen im Vergleich zum Vorjahr entwickelt?")
print(f"Antwort 2: {result2['answer']}")

# Weitere kontextuelle Frage
result3 = pdf_chat.ask_question("Welche Risiken werden in Bezug auf diese Entwicklung erwähnt?")
print(f"Antwort 3: {result3['answer']}")

# Konversationshistorie anzeigen
print("\n=== Conversation History ===")
for entry in pdf_chat.get_conversation_summary():
    print(f"{entry['role']}: {entry['content'][:100]}...")

---

Lösung 3: LangFlow Chat-Interface Setup

Konfiguration und Anpassung

# finance_conversational_qa_flow.json - Anpassungen

"""
Wichtige Konfigurationsschritte für LangFlow:

1. API-Keys setzen:
   - OpenAI API Key in allen LLM-Knoten
   - Ggf. andere Provider (Anthropic, etc.)

2. Memory-Konfiguration:
   - ConversationBufferMemory für Standard-Chats
   - ConversationSummaryMemory für lange Gespräche
   - Memory-Key: "chat_history"

3. Retriever-Setup (falls RAG):
   - Vectorstore: FAISS oder Pinecone
   - Embeddings: OpenAI Embeddings
   - Top-K: 3-5 Dokumente

4. Prompt-Templates anpassen:
   System-Prompt für Finance-Kontext:
"""

finance_system_prompt = """Du bist ein erfahrener Finanzberater mit folgenden Eigenschaften:

EXPERTISE:
- 10+ Jahre Erfahrung in Vermögensberatung
- Spezialist für Risikomanagement und Portfolio-Optimierung
- Kenntnis aktueller Markttrends und Regulierungen

KOMMUNIKATIONSSTIL:
- Professionell aber verständlich
- Erkläre komplexe Konzepte einfach
- Nutze konkrete Zahlen und Beispiele
- Berücksichtige immer die Risikotoleranz

GESPRÄCHSKONTEXT:
- Verwende die bisherige Gesprächshistorie
- Baue auf vorherigen Antworten auf
- Stelle Rückfragen bei unklaren Anfragen

COMPLIANCE:
- Gib keine konkreten Anlageempfehlungen ohne Risikohinweise
- Erwähne immer mögliche Verlustrisiken
- Empfiehl bei komplexen Fällen professionelle Beratung"""

Erweiterte Flow-Komponenten

{
  "advanced_finance_flow": {
    "components": {
      "memory_manager": {
        "type": "ConversationSummaryMemory",
        "config": {
          "max_token_limit": 1000,
          "return_messages": true
        }
      },
      "finance_classifier": {
        "type": "RouterChain",
        "routes": {
          "investment_advice": "Investment-Experte",
          "risk_assessment": "Risiko-Analyst", 
          "market_analysis": "Markt-Spezialist",
          "general_finance": "Allgemein-Berater"
        }
      },
      "context_retriever": {
        "type": "VectorStoreRetriever",
        "config": {
          "vectorstore": "finance_knowledge_base",
          "search_type": "similarity",
          "k": 5
        }
      }
    }
  }
}

---

Bewertung der Memory-Strategien

Vergleichstabelle

Memory-Typ	Vorteile	Nachteile	Use Case
Buffer	Vollständiger Kontext	Tokens wachsen unbegrenzt	Kurze Gespräche
Summary	Konstante Token-Anzahl	Verlust von Details	Lange Gespräche
Window	Begrenzte Tokens	Verliert alten Kontext	Mittlere Gespräche

Performance-Analyse

def analyze_memory_performance():
    """Analysiere Performance verschiedener Memory-Strategien"""

    memory_stats = {
        "buffer": {
            "token_growth": "Linear",
            "context_retention": "100%",
            "cost_efficiency": "Niedrig bei langen Gesprächen"
        },
        "summary": {
            "token_growth": "Konstant", 
            "context_retention": "70-80%",
            "cost_efficiency": "Hoch"
        },
        "window": {
            "token_growth": "Konstant",
            "context_retention": "Abhängig von Fenstergröße",
            "cost_efficiency": "Mittel"
        }
    }

    return memory_stats

# Empfehlungen
recommendations = {
    "Finanzberatung (kurz)": "ConversationBufferMemory",
    "Finanzberatung (lang)": "ConversationSummaryMemory", 
    "Dokumentenanalyse": "ConversationBufferWindowMemory",
    "Support-Chat": "ConversationSummaryMemory"
}

---

🎯 Zusätzliche Features

Error Handling

def robust_chat_system():
    try:
        response = chat_system.ask_question(user_input)
        return response
    except Exception as e:
        return {
            "error": str(e),
            "fallback": "Entschuldigung, ich konnte Ihre Frage nicht verarbeiten. Können Sie sie anders formulieren?"
        }

Logging und Monitoring

import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def log_conversation(question, answer, metadata):
    logger.info(f"Q: {question}")
    logger.info(f"A: {answer}")
    logger.info(f"Metadata: {metadata}")

Diese Lösungen bilden die Grundlage für professionelle Conversational AI Systeme im Finance-Bereich!