Von Q&A zu Routing & Entscheidungslogik¶

Multi-Chain-Flows für Finance & Risk¶

Überblick¶

Warum Routing & Entscheidungslogik?
Grundlagen: Conditional Chains & Decision Trees
Agenten-Auswahl & Spezialisierung
Praktische Anwendungen in Finance & Risk
Implementierung in LangFlow
Ausblick: Migration zu LangGraph

Warum Routing & Entscheidungslogik?¶

Limitierungen einfacher RAG-Systeme:¶

Komplexe Fragen erfordern unterschiedliche Verarbeitungswege
Fachspezifische Antworten benötigen spezialisierte Agenten
Compliance-Anforderungen verlangen regelbasierte Entscheidungen
Multi-Dokument-Abfragen erfordern intelligente Quellenauswahl

Von einfachem RAG zu intelligenten Flows¶

Entwicklung von RAG zu Routing

Einfaches RAG: 1. Dokument → Vektorstore 2. Query → Retrieval 3. Kontext + Prompt → Antwort

Mit Routing: 1. Query-Analyse → Entscheidung über Verarbeitungsweg 2. Spezialisierte Agenten für unterschiedliche Aufgaben 3. Dynamische Dokumentenauswahl

Grundlagen: Conditional Chains¶

def route_query(query):
    # Analyse der Anfrage
    if "risiko" in query.lower():
        return risk_agent(query)
    elif "finanzkennzahlen" in query.lower():
        return finance_agent(query)
    elif "compliance" in query.lower():
        return compliance_agent(query)
    else:
        return general_agent(query)

Vorteile: - Spezialisierte Verarbeitung je nach Anforderung - Bessere Antwortqualität durch Fokussierung - Effizientere Ressourcennutzung

Decision Trees in LLM-Flows¶

Decision Tree Beispiel

Komponenten: - Router-Node: Analysiert die Anfrage und entscheidet über den Pfad - Spezialisierte Agenten: Optimiert für bestimmte Aufgabentypen - Zusammenführung: Kombiniert Ergebnisse bei Bedarf

Beispiel: Finance & Risk Router¶

from langchain.chains import LLMRouterChain, MultiPromptChain
from langchain.chains.router.llm_router import RouterOutputParser
from langchain.prompts import PromptTemplate

router_template = """
Entscheide, welcher Spezialist am besten geeignet ist, um folgende Anfrage zu beantworten:

Anfrage: {input}

Wähle einen der folgenden Spezialisten:
1. Finance-Experte: Für Fragen zu Finanzkennzahlen, Reporting, Controlling
2. Risk-Analyst: Für Fragen zu Risikobewertung, Compliance, Regulierung
3. ESG-Spezialist: Für Fragen zu Nachhaltigkeit, ESG-Reporting, Umweltrisiken

Spezialist:
"""

router_prompt = PromptTemplate(
    template=router_template,
    input_variables=["input"]
)

router_chain = LLMRouterChain.from_llm(
    llm=llm,
    prompt=router_prompt,
    output_parser=RouterOutputParser()
)

Agenten-Auswahl & Spezialisierung¶

Finance-Agent: - Optimiert für Finanzkennzahlen und Reporting - Zugriff auf Finanzberichte und KPI-Definitionen - Strukturierte Ausgabe von Kennzahlen

Risk-Agent: - Fokus auf Risikoanalyse und Compliance - Zugriff auf Regulierungsdokumente - Prüfung auf Compliance-Konformität

ESG-Agent: - Spezialisiert auf Nachhaltigkeitsthemen - Zugriff auf ESG-Berichte und Standards - Verknüpfung von ESG mit finanziellen Auswirkungen

Use Case: Compliance-Bot für Finance & Risk¶

Anfrage: "Welche ESG-Risiken müssen wir im Quartalsbericht Q2/2023 berücksichtigen?"

Flow: 1. Router erkennt ESG + Reporting-Thema 2. ESG-Agent identifiziert relevante ESG-Faktoren 3. Finance-Agent prüft Reporting-Anforderungen 4. Risk-Agent bewertet Compliance-Relevanz 5. Zusammenführung der Ergebnisse in strukturierte Antwort

Implementierung in LangFlow¶

LangFlow Beispiel

Komponenten: - LLM-Router als Entscheidungsknoten - Spezialisierte Prompt-Templates für jeden Agenten - Vectorstore mit themenspezifischen Kollektionen - Output-Parser für strukturierte Antworten

Multi-RAG mit Routing¶

# Spezialisierte Vectorstores
finance_vectorstore = Chroma(
    collection_name="finance_docs",
    embedding_function=embeddings
)

risk_vectorstore = Chroma(
    collection_name="risk_docs",
    embedding_function=embeddings
)

esg_vectorstore = Chroma(
    collection_name="esg_docs",
    embedding_function=embeddings
)

# Routing-Funktion
def route_to_vectorstore(query):
    # Analyse der Anfrage durch LLM
    category = classifier_chain.run(query)

    if category == "finance":
        return finance_vectorstore
    elif category == "risk":
        return risk_vectorstore
    elif category == "esg":
        return esg_vectorstore
    else:
        # Fallback auf allgemeinen Vectorstore
        return general_vectorstore

Dynamische Pfade im Flow-Design¶

Sequentielles Routing: 1. Anfrage → Klassifikation 2. Spezialisierter Agent → Antwort

Paralleles Routing: 1. Anfrage → Mehrere spezialisierte Agenten gleichzeitig 2. Zusammenführung der Ergebnisse

Hierarchisches Routing: 1. Anfrage → Hauptkategorie 2. Unterkategorie → Spezialisierter Agent 3. Stufenweise Verfeinerung

Beispiel: KPI-Analyse mit Routing¶

def kpi_analysis_flow(query, financial_data):
    # Schritt 1: Klassifizierung der KPI-Anfrage
    kpi_type = kpi_classifier(query)

    # Schritt 2: Routing zu spezialisierten Analysten
    if kpi_type == "profitability":
        results = profitability_analyst(financial_data)
    elif kpi_type == "liquidity":
        results = liquidity_analyst(financial_data)
    elif kpi_type == "growth":
        results = growth_analyst(financial_data)
    else:
        results = general_analyst(financial_data)

    # Schritt 3: Kontextuelle Interpretation
    interpretation = context_interpreter(results, query)

    return interpretation

Vorteile für Finance & Risk¶

Compliance-Sicherheit: - Regelbasierte Entscheidungen für sensible Themen - Nachvollziehbare Entscheidungspfade - Prüfung auf regulatorische Anforderungen

Präzisere Antworten: - Spezialisierte Agenten für Fachbereiche - Domänenspezifisches Wissen - Strukturierte Ausgabeformate

Effizienz: - Gezielte Dokumentenauswahl - Reduzierte Verarbeitungszeit - Optimierte Ressourcennutzung

Ausblick: Migration zu LangGraph¶

from langgraph.graph import StateGraph

# Definiere den Zustandsgraphen
workflow = StateGraph()

# Füge Knoten hinzu
workflow.add_node("router", router_chain)
workflow.add_node("finance_agent", finance_chain)
workflow.add_node("risk_agent", risk_chain)
workflow.add_node("esg_agent", esg_chain)

# Definiere Übergänge
workflow.add_edge("router", "finance_agent")
workflow.add_edge("router", "risk_agent")
workflow.add_edge("router", "esg_agent")

# Kompiliere den Graphen
compiled_graph = workflow.compile()

Zusammenfassung¶

Routing & Entscheidungslogik erweitert einfache RAG-Systeme
Spezialisierte Agenten verbessern die Antwortqualität
Conditional Chains ermöglichen dynamische Verarbeitungspfade
LangFlow bietet visuelle Modellierung von Entscheidungsbäumen
Finance & Risk profitieren von fachspezifischer Verarbeitung

Nächste Schritte¶

Praktische Übungen mit LangFlow
Implementierung eines Finance & Risk Routers
Erstellung spezialisierter Agenten
Testen mit realen Anwendungsfällen

Fragen & Diskussion¶

?