Vertikale Anwendungsszenarien für KI-Agenten

Verschiedene Domänen haben unterschiedliche Anforderungen und Eigenschaften an Agenten.

Durch Domänenanpassung können Agenten professionellere Dienste anbieten.

Code-Agent

Code-Agent ist eine der erfolgreichsten Anwendungsdomänen für Agenten.

Kann Codebasen verstehen, neuen Code schreiben und Probleme debuggen.

Kernfähigkeiten

Code-Vervollständigung: Das nächste Codesegment basierend auf dem Kontext vorhersagen.

Code-Generierung: Code basierend auf natürlichsprachlichen Beschreibungen generieren.

Code-Review: Probleme und Verbesserungen im Code entdecken.

Bug-Lokalisierung: Fehlermeldungen analysieren und die Grundursache von Problemen lokalisieren.

Code-Refactoring: Vorschläge zur Codeoptimierung unterbreiten und umsetzen.

Repräsentative Systeme

System Entwicklerunternehmen Funktionen
GitHub Copilot GitHub/OpenAI Hauptsächlich Code-Vervollständigung, Echtzeitvorschläge
Claude Code Anthropic Kommandozeilen-Assistent, tiefes Codeverständnis
Devin Cognition Autonome Programmierung, End-to-End-Aufgabenausführung
Cursor Cursor KI-Code-Editor, tiefe IDE-Integration

Code-Implementierungsbeispiele

Text2SQL-Agent-Implementierung

class Text2SQLAgent:
    """
    Text2SQL-Agent
Natürliche Sprache in SQL-Abfragen umwandeln
    """
   
    def __init__(self, llm, schema):
        self.llm = llm
        # Informationen zum Datenbankschema
        self.schema = schema
   
    def convert(self, question):
        """
Natürlichsprachliche Probleme in SQL umwandeln
:param question: Natürlichsprachliche Frage
:return: SQL-Abfrageanweisung
        """
        prompt = f"""
Du bist ein SQL-Experte.

Datenbankschema:
{self.schema}

Regeln:
1. Nur SELECT-Abfragen generieren (INSERT/UPDATE/DELETE werden nicht unterstützt)
2. Sinnvolle Tabellenaliase verwenden
3. Notwendige JOIN-Bedingungen hinzufügen
4. Klare Spaltenaliase verwenden

Frage: {question}

Bitte die entsprechende SQL-Abfrage generieren.
"""
        sql = self.llm.generate(prompt)
       
        # Sicherheitsprüfung
        return self.sanitize(sql)
   
    def sanitize(self, sql):
        """
SQL-Sicherheitsprüfung
Sicherstellen, dass keine gefährlichen Operationen enthalten sind
        """
        # Prüfung auf Kleinschreibung
        sql_lower = sql.lower().strip()
       
        # Prüfen, dass es nur SELECT enthält
        forbidden_keywords = [
            "insert", "update", "delete", "drop",
            "create", "alter", "truncate", "exec",
            "execute", "grant", "revoke"
        ]
       
        for keyword in forbidden_keywords:
            if keyword in sql_lower:
                raise ValueError(f"Verbotene Schlüsselwörter: {keyword}")
       
        return sql
   
    def execute(self, question, db_connection):
        """
Text2SQL-Abfrage ausführen
        """
        sql = self.convert(question)
        cursor = db_connection.cursor()
        cursor.execute(sql)
        results = cursor.fetchall()
        columns = [desc[0] for desc in cursor.description]
        return {"columns": columns, "rows": results}

Datenanalyse-Agent

Der Datenanalyse-Agent kann Datenanforderungen verstehen, Abfragen ausführen und Analyseberichte erstellen.

Ermöglicht nicht-technischen Nutzern die Durchführung komplexer Datenanalysen.

Kernfähigkeiten

Datenverständnis: Datenbankstruktur und Datenbedeutung verstehen.

Abfragegenerierung: Text2SQL, Umwandlung von natürlicher Sprache in Abfragen.

Visualisierung: Diagrammvorschläge und -konfigurationen generieren.

Berichtserstellung: Ergebnisse analysieren und Berichte in natürlicher Sprache erstellen.

Code-Implementierung

Implementierung des Datenanalyse-Agenten

class DataAnalysisAgent:
    """
Datenanalyse-Agent
Datenanforderungen verstehen, Analysen ausführen, Berichte erstellen
    """
   
    def __init__(self, llm, db_connection, chart_generator):
        self.llm = llm
        self.db = db_connection
        self.chart_generator = chart_generator
   
    def analyze(self, request):
        """
Datenanalyseanfragen bearbeiten
        """
        # Schritt 1: Die Analyseanforderungen verstehen
        intent = self.parse_intent(request)
       
        # Schritt 2: Die Abfrage generieren
        query = self.generate_query(intent)
       
        # Schritt 3: Die Abfrage ausführen
        data = self.execute_query(query)
       
        # Schritt 4: Die Daten analysieren
        analysis = self.perform_analysis(data, intent)
       
        # Schritt 5: Visualisierungsvorschläge generieren
        charts = self.suggest_charts(analysis)
       
        # Schritt 6: Den Bericht erstellen
        report = self.generate_report(analysis, charts)
       
        return {
            "intent": intent,
            "query": query,
            "data": data,
            "analysis": analysis,
            "charts": charts,
            "report": report
        }
   
    def parse_intent(self, request):
        """Benutzerabsicht analysieren"""
        prompt = f"""
Analysiere die folgende Datenanfrage und extrahiere die wichtigsten Informationen:

Anfrage: {request}

Bitte extrahieren:
1. Analyseziel (Vergleich, Trend, Verteilung usw.)
2. Beteiligte Tabellen und Felder
3. Zeitraum (falls vorhanden)
4. Filterbedingungen (falls vorhanden)
"""
        return self.llm.generate(prompt)
   
    def generate_query(self, intent):
        """SQL-Abfrage generieren"""
        prompt = f"""
Generiere eine SQL-Abfrage basierend auf der folgenden Absicht:

{intent}

Datenbankschema:
{self.get_schema()}
"""
        return self.llm.generate(prompt)
   
    def execute_query(self, query):
        """Abfrage ausführen"""
        cursor = self.db.cursor()
        cursor.execute(query)
        columns = [desc[0] for desc in cursor.description]
        rows = cursor.fetchall()
        return {"columns": columns, "rows": rows}
   
    def perform_analysis(self, data, intent):
        """Datenanalyse ausführen"""
        # Vereinfachte Implementierung
        import statistics
       
        rows = data["rows"]
        columns = data["columns"]
       
        analysis = {
            "row_count": len(rows),
            "summary": {}
        }
       
        # Statistiken für numerische Spalten berechnen
        for i, col in enumerate(columns):
            if self.is_numeric(rows, i):
                values = [row[i] for row in rows if row[i] is not None]
                if values:
                    analysis["summary"][col] = {
                        "min": min(values),
                        "max": max(values),
                        "avg": statistics.mean(values),
                        "median": statistics.median(values)
                    }
       
        return analysis
   
    def suggest_charts(self, analysis):
        """Visualisierungsdiagramme empfehlen"""
        suggestions = []
       
        # Diagramme basierend auf Analysetyp empfehlen
        if "trend" in str(analysis).lower():
            suggestions.append({
                "type": "line",
                "description": "Liniendiagramm, geeignet zur Darstellung von Trends"
            })
       
        if "comparison" in str(analysis).lower():
            suggestions.append({
                "type": "bar",
                "description": "Balkendiagramm, geeignet zum Vergleichen von Kategorien"
            })
       
        suggestions.append({
            "type": "table",
            "description": "Datentabelle, zeigt detaillierte Daten"
        })
       
        return suggestions
   
    def generate_report(self, analysis, charts):
        """Analysebericht erstellen"""
        prompt = f"""
Basierend auf den folgenden Analyseergebnissen, generieren Sie einen Bericht in natürlicher Sprache:

Analyseergebnisse:
{analysis}

Empfohlenes Diagramm:
{charts}

Bitte erstellen Sie einen klaren Analysebericht.
"""
        return self.llm.generate(prompt)

Kundenservice-Agent

Der Kundenservice-Agent muss mehrstufige Gespräche führen, die Absicht des Nutzers verstehen und präzise Antworten liefern.

Es ist eines der am weitesten verbreiteten Einsatzszenarien von KI.

Kernfähigkeiten

Absichtserkennung: Verstehen, was der Nutzer tun möchte.

Slot-Füllung: Wichtige Informationen extrahieren (Zeit, Ort usw.).

Dialogzustandsverfolgung: Kontext mehrstufiger Gespräche verwalten.

Antwortgenerierung: Natürliche und professionelle Antworten generieren.

Code-Implementierung

Implementierung eines Kundenservice-Agenten

class CustomerServiceAgent:
    """
Kundenservice-Agent
Benutzeranfragen bearbeiten und Service-Support bieten
    """
   
    def __init__(self, llm, knowledge_base, dialogue_manager):
        self.llm = llm
        # Wissensdatenbank
        self.knowledge_base = knowledge_base
        # Dialogmanager
        self.dialogue_manager = dialogue_manager
   
    def handle(self, user_input, session_id):
        """
Benutzernachrichten verarbeiten
        """
        # Konversationsverlauf abrufen
        history = self.dialogue_manager.get_history(session_id)
       
        # Benutzerabsicht erkennen
        intent = self.recognize_intent(user_input, history)
       
        # Basierend auf Absicht verarbeiten
        if intent.type == "greeting":
            response = self.handle_greeting()
        elif intent.type == "inquiry":
            response = self.handle_inquiry(intent)
        elif intent.type == "complaint":
            response = self.handle_complaint(intent)
        elif intent.type == "order_status":
            response = self.handle_order_status(intent)
        elif intent.type == "refund":
            response = self.handle_refund(intent)
        else:
            response = self.handle_general(user_input)
       
        # Konversationsverlauf aktualisieren
        self.dialogue_manager.add_message(
            session_id,
            {"role": "user", "content": user_input}
        )
        self.dialogue_manager.add_message(
            session_id,
            {"role": "assistant", "content": response}
        )
       
        return response
   
    def recognize_intent(self, text, history):
        """Benutzerabsicht erkennen"""
        prompt = f"""
Analysiere Benutzernachrichten und identifiziere den Absichtstyp.

Aktuelle Nachricht: {text}

Konversationsverlauf:
{history}

Absichtstypen:
- greeting: Begrüßung
- inquiry: Fragen stellen
- complaint: Beschwerde
- order_status: Bestellung prüfen
- refund: Rückerstattung
- goodbye: Verabschiedung

Bitte geben Sie den Absichtstyp und die Konfidenz aus.
"""
        result = self.llm.generate(prompt)
        return Intent.parse(result)
   
    def handle_inquiry(self, intent):
        """Anfrage bearbeiten"""
        # Relevante Inhalte aus der Wissensdatenbank abrufen
        relevant_docs = self.knowledge_base.search(intent.query)
       
        if relevant_docs:
            # Wenn relevante Dokumente vorhanden sind, anhand der Dokumente antworten
            prompt = f"""
Beantworten Sie die Frage des Benutzers anhand des folgenden Dokuments.

Dokument:
{relevant_docs}

Frage: {intent.query}
"""
            return self.llm.generate(prompt)
        else:
            # Keine relevanten Dokumente, an Mitarbeiter weiterleiten oder erfassen
            return "Ich muss dieses Problem weiter verstehen. Bitte warten Sie, während ich für Sie nachsehe."


class Intent:
    """Benutzerabsicht"""
   
    def __init__(self, type, query, confidence):
        self.type = type
        self.query = query
        self.confidence = confidence
   
    @classmethod
    def parse(cls, text):
        """Absichtstext analysieren"""
        # Vereinfachte Implementierung
        return cls(type="inquiry", query=text, confidence=0.9)

Recherche-Agent

Der Research Agent kann autonom tiefgehende Recherchen durchführen, Informationen sammeln und zusammenführen.

Simuliert die Arbeitsweise menschlicher Forscher.

Kernfähigkeiten

Suchplanung: Einen Plan zur Informationssammlung formulieren.

Sammlung aus mehreren Quellen: Informationen aus mehreren Quellen sammeln.

Informationsüberprüfung: Die Genauigkeit von Informationen gegenseitig überprüfen.

Berichtserstellung: Informationen zusammenführen, um strukturierte Berichte zu erstellen.

Code-Implementierung

Implementierung des Research-Agents

class ResearchAgent:
    """
Recherche-Agent
Autonom tiefgehende Recherchen durchführen und Berichte erstellen
    """
   
    def __init__(self, search_tools, llm):
        # Liste der Suchwerkzeuge
        self.search_tools = search_tools
        self.llm = llm
   
    def research(self, topic, depth=3):
        """
Rechercheaufgabe ausführen
:param topic: Recherchethema
:param depth: Recherchetiefe (Anzahl der Suchrunden)
        """
        # Schritt 1: Einen Rechercheplan erstellen
        plan = self.create_research_plan(topic, depth)
       
        # Schritt 2: Mehrere Suchrunden ausführen
        findings = []
        for phase in plan.phases:
            # Mehrere Richtungen parallel durchsuchen
            phase_results = self.search_phase(phase)
            findings.extend(phase_results)
           
            # Aktuelle Erkenntnisse zusammenführen
            synthesis = self.synthesize(findings)
            findings.append({
                "type": "synthesis",
                "content": synthesis,
                "phase": phase.number
            })
       
        # Schritt 3: Den Abschlussbericht erstellen
        report = self.generate_report(findings)
       
        return {
            "topic": topic,
            "plan": plan,
            "findings": findings,
            "report": report
        }
   
    def create_research_plan(self, topic, depth):
        """Rechercheplan erstellen"""
        prompt = f"""
Erstelle einen detaillierten Plan für das folgende Recherchethema:

Thema: {topic}
Tiefe: {depth}

Bitte plane:
1. Wichtige Richtungen, die recherchiert werden müssen (3-5)
2. Kernfragen, die für jede Richtung beantwortet werden müssen
3. Vorschläge für Informationsquellen
"""
        return ResearchPlan.parse(self.llm.generate(prompt))
   
    def search_phase(self, phase):
        """Einzelne Suchphase ausführen"""
        results = []
       
        for query in phase.queries:
            # Suchwerkzeuge zum Suchen verwenden
            for tool in self.search_tools:
                search_results = tool.search(query)
                results.extend(search_results)
       
        return results
   
    def synthesize(self, findings):
        """Erkenntnisse zusammenführen"""
        prompt = f"""
Fasse die folgenden Rechercheergebnisse zusammen und extrahiere die wichtigsten Informationen:

Liste der Erkenntnisse:
{findings}

Bitte extrahieren:
1. Wichtigste Schlussfolgerungen
2. Belege, die die Schlussfolgerungen stützen
3. Bestehende Kontroversen oder Unsicherheiten
4. Fragen, die weiterer Recherche bedürfen
"""
        return self.llm.generate(prompt)
   
    def generate_report(self, findings):
        """Abschlussbericht erstellen"""
        prompt = f"""
Erstellen Sie einen strukturierten Bericht basierend auf den folgenden Forschungsergebnissen:

Forschungsergebnisse:
{findings}

Berichtsanforderungen:
1. Zusammenfassung für die Geschäftsleitung
2. Einführung in den Hintergrund
3. Wichtige Erkenntnisse (nach Unterthema)
4. Schlussfolgerungen und Empfehlungen
5. Referenzen

Bitte erstellen Sie einen vollständigen Bericht.
"""
        return self.llm.generate(prompt)


class ResearchPlan:
    """Forschungsplan"""
   
    @classmethod
    def parse(cls, text):
        """Plantext parsen"""
        # Vereinfachte Implementierung
        return cls(phases=[
            ResearchPhase(number=1, queries=["Verwandtes Thema 1"], goals=["Grundlegende Konzepte verstehen"]),
            ResearchPhase(number=2, queries=["Verwandtes Thema 2"], goals=["Eingehende Analyse"]),
        ])
   
    def __init__(self, phases):
        self.phases = phases


class ResearchPhase:
    """Forschungsphase"""
   
    def __init__(self, number, queries, goals):
        self.number = number
        self.queries = queries
        self.goals = goals

Weitere vertikale Anwendungen

RPA + Agent

Die Kombination aus RPA (Robotic Process Automation) und Agent.

Sie kann die Automatisierung komplexerer Geschäftsprozesse ermöglichen.

Agent verleiht RPA intelligente Entscheidungsfähigkeiten.

Game-NPC-Agent

NPC-(Non-Player Character)-Agenten in Spielen.

Sie können dynamische Dialoge, Handlungsgenerierung und Rollenspiel durchführen.

Eine realistischere Spielwelterfahrung schaffen.

Wissenschaftlicher Forschungs-Agent

KI für die Wissenschaft verändert die wissenschaftliche Forschung.

Literaturübersicht: Automatisch eine große Anzahl wissenschaftlicher Arbeiten lesen und zusammenfassen.

Experimentdesign: Versuchspläne und Hypothesen vorschlagen.

Datenanalyse: Experimentelle Daten verarbeiten und Muster entdecken.

Verfassen von Arbeiten: Beim Schreiben von Forschungsarbeiten unterstützen.

Kapitelzusammenfassung

Dieses Kapitel stellt die Anwendungen von Agent in verschiedenen vertikalen Domänen vor.

Code-AgentUnterstützt beim Programmieren und verbessert die Entwicklungseffizienz.

Datenanalyse-AgentErmöglicht auch nicht-technischem Personal die Datenanalyse.

Kundenservice-AgentBietet intelligenten Kundenservice.

Forschungs-AgentFührt selbstständig eingehende Recherchen durch.

Es gibt auch weitere Szenarien wie RPA+Agent, Spiel-NPCs und wissenschaftliche Forschungs-Agenten.

Agenten in vertikalen Domänen müssen mit Domänenwissen angepasst werden.

Die Auswahl der richtigen Szenarien und Einstiegspunkte ist entscheidend für eine erfolgreiche Implementierung.

Andere Erweiterungen