Отраслевые сценарии применения ИИ-агентов

Разные предметные области предъявляют к агентам разные требования и характеристики.

Благодаря настройке под предметную область агенты могут предоставлять более профессиональные услуги.

Кодовый агент

Кодовый агент — одна из самых успешных областей применения агентов.

Способен понимать кодовые базы, писать новый код и отлаживать проблемы.

Основные возможности

Автодополнение кода: Прогнозировать следующий фрагмент кода на основе контекста.

Генерация кода: Генерировать код на основе описаний на естественном языке.

Ревью кода: Выявлять проблемы и улучшения в коде.

Локализация ошибок: Анализировать сообщения об ошибках и находить первопричину проблем.

Рефакторинг кода: Предлагать и применять рекомендации по оптимизации кода.

Типичные системы

Система Компания-разработчик Особенности
GitHub Copilot GitHub/OpenAI В основном автодополнение кода, предложения в реальном времени
Claude Code Anthropic Ассистент командной строки, глубокое понимание кода
Devin Познание Автономное программирование, выполнение задач от начала до конца
Cursor Cursor ИИ-редактор кода, глубокая интеграция с IDE

Примеры реализации кода

Реализация агента Text2SQL

class Text2SQLAgent:
    """
    Агент Text2SQL
Преобразование естественного языка в SQL-запросы
    """
   
    def __init__(self, llm, schema):
        self.llm = llm
        # Информация о схеме базы данных
        self.schema = schema
   
    def convert(self, question):
        """
Преобразовать задачи на естественном языке в SQL
:param question: вопрос на естественном языке
:return: SQL-запрос
        """
        prompt = f"""
Вы эксперт по SQL.

Схема базы данных:
{self.schema}

Правила:
1. Генерируйте только SELECT-запросы (INSERT/UPDATE/DELETE не поддерживаются)
2. Используйте осмысленные псевдонимы таблиц
3. Добавляйте необходимые условия JOIN
4. Используйте понятные псевдонимы столбцов

Вопрос: {question}

Пожалуйста, сгенерируйте соответствующий SQL-запрос.
"""
        sql = self.llm.generate(prompt)
       
        # Проверка безопасности
        return self.sanitize(sql)
   
    def sanitize(self, sql):
        """
Проверка безопасности SQL
Убедитесь, что опасные операции не включены
        """
        # Проверка на нижний регистр
        sql_lower = sql.lower().strip()
       
        # Проверьте, что он содержит только SELECT
        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"Запрещённые ключевые слова: {keyword}")
       
        return sql
   
    def execute(self, question, db_connection):
        """
Выполнить запрос Text2SQL
        """
        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}

Агент анализа данных

Агент анализа данных может понимать требования к данным, выполнять запросы и создавать аналитические отчёты.

Позволяет нетехническим пользователям выполнять сложный анализ данных.

Основные возможности

Понимание данных: Понимать структуру базы данных и смысл данных.

Генерация запросов: Text2SQL, преобразование естественного языка в запросы.

Визуализация: Генерировать предложения по диаграммам и конфигурации.

Генерация отчётов: Анализировать результаты и генерировать отчёты на естественном языке.

Реализация кода

Реализация агента анализа данных

class DataAnalysisAgent:
    """
Агент анализа данных
Понимать требования к данным, выполнять анализ, генерировать отчёты
    """
   
    def __init__(self, llm, db_connection, chart_generator):
        self.llm = llm
        self.db = db_connection
        self.chart_generator = chart_generator
   
    def analyze(self, request):
        """
Обрабатывать запросы на анализ данных
        """
        # Шаг 1: Понять требования к анализу
        intent = self.parse_intent(request)
       
        # Шаг 2: Сгенерировать запрос
        query = self.generate_query(intent)
       
        # Шаг 3: Выполнить запрос
        data = self.execute_query(query)
       
        # Шаг 4: Анализ данных
        analysis = self.perform_analysis(data, intent)
       
        # Шаг 5: Генерация предложений по визуализации
        charts = self.suggest_charts(analysis)
       
        # Шаг 6: Генерация отчёта
        report = self.generate_report(analysis, charts)
       
        return {
            "intent": intent,
            "query": query,
            "data": data,
            "analysis": analysis,
            "charts": charts,
            "report": report
        }
   
    def parse_intent(self, request):
        """Разобрать намерение пользователя"""
        prompt = f"""
Проанализируйте следующий запрос данных и извлеките ключевую информацию:

Запрос: {request}

Пожалуйста, извлеките:
1. Цель анализа (сравнение, тренд, распределение и т. д.)
2. Задействованные таблицы и поля
3. Временной диапазон (если есть)
4. Условия фильтрации (если есть)
"""
        return self.llm.generate(prompt)
   
    def generate_query(self, intent):
        """Сгенерировать SQL-запрос"""
        prompt = f"""
Сгенерируйте SQL-запрос на основе следующего намерения:

{intent}

Схема базы данных:
{self.get_schema()}
"""
        return self.llm.generate(prompt)
   
    def execute_query(self, query):
        """Выполнить запрос"""
        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):
        """Выполнить анализ данных"""
        # Упрощённая реализация
        import statistics
       
        rows = data["rows"]
        columns = data["columns"]
       
        analysis = {
            "row_count": len(rows),
            "summary": {}
        }
       
        # Вычислить статистику для числовых столбцов
        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(значения)
                    }
       
        return analysis
   
    def suggest_charts(self, analysis):
        """Рекомендовать диаграммы визуализации"""
        suggestions = []
       
        # Рекомендовать диаграммы на основе типа анализа
        if "trend" in str(analysis).lower():
            suggestions.append({
                "type": "line",
                "description": "Линейная диаграмма, подходит для отображения тенденций"
            })
       
        if "comparison" in str(analysis).lower():
            suggestions.append({
                "type": "bar",
                "description": "Столбчатая диаграмма, подходит для сравнения категорий"
            })
       
        suggestions.append({
            "type": "table",
            "description": "Таблица данных, показывающая подробные данные"
        })
       
        return suggestions
   
    def generate_report(self, analysis, charts):
        """Сгенерировать отчет об анализе"""
        prompt = f"""
На основе следующих результатов анализа сгенерируйте отчет на естественном языке:

Результаты анализа:
{analysis}

Рекомендуемая диаграмма:
{charts}

Пожалуйста, сгенерируйте понятный отчет об анализе.
"""
        return self.llm.generate(prompt)

Агент службы поддержки клиентов

Агенту службы поддержки клиентов необходимо вести многоходовые диалоги, понимать намерения пользователя и предоставлять точные ответы.

Это один из наиболее широко применяемых сценариев ИИ.

Основные возможности

Распознавание намерений: Понять, что хочет сделать пользователь.

Заполнение слотов: Извлечение ключевой информации (время, местоположение и т. д.).

Отслеживание состояния диалога: Управление контекстом многоходового диалога.

Генерация ответов: Генерировать естественные и профессиональные ответы.

Реализация кода

Реализация агента службы поддержки клиентов

class CustomerServiceAgent:
    """
Агент службы поддержки клиентов
Обрабатывать запросы пользователей и обеспечивать сервисную поддержку
    """
   
    def __init__(self, llm, knowledge_base, dialogue_manager):
        self.llm = llm
        # База знаний
        self.knowledge_base = knowledge_base
        # Менеджер диалога
        self.dialogue_manager = dialogue_manager
   
    def handle(self, user_input, session_id):
        """
Обработать сообщения пользователя
        """
        # Получить историю диалога
        history = self.dialogue_manager.get_history(session_id)
       
        # Распознать намерение пользователя
        intent = self.recognize_intent(user_input, history)
       
        # Обработать на основе намерения
        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)
       
        # Обновить историю диалога
        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):
        """Распознать намерение пользователя"""
        prompt = f"""
Проанализировать сообщения пользователя и определить тип намерения.

Текущее сообщение: {text}

История диалога:
{history}

Типы намерений:
- greeting: Приветствие
- inquiry: Задать вопросы
- complaint: Жалоба
- order_status: Проверить заказ
- refund: Возврат
- goodbye: Прощание

Пожалуйста, выведите тип намерения и уверенность.
"""
        result = self.llm.generate(prompt)
        return Intent.parse(result)
   
    def handle_inquiry(self, intent):
        """Обработать запрос"""
        # Извлечь релевантное содержимое из базы знаний
        relevant_docs = self.knowledge_base.search(intent.query)
       
        if relevant_docs:
            # Если есть релевантные документы, отвечайте на основе документов
            prompt = f"""
Ответьте на вопрос пользователя на основе следующего документа.

Документ:
{relevant_docs}

Вопрос: {intent.query}
"""
            return self.llm.generate(prompt)
        else:
            # Нет соответствующих документов, передать человеку или записать
            return "Мне нужно разобраться в этом вопросе подробнее. Пожалуйста, подождите, пока я проверю для вас."


class Intent:
    """Намерение пользователя"""
   
    def __init__(self, type, query, confidence):
        self.type = type
        self.query = query
        self.confidence = confidence
   
    @classmethod
    def parse(cls, text):
        """Разбор текста намерения"""
        # Упрощённая реализация
        return cls(type="inquiry", query=text, confidence=0.9)

Исследовательский агент

Исследовательский агент может автономно проводить углублённые исследования, собирать и обобщать информацию.

Имитирует стиль работы исследователей-людей.

Основные возможности

Планирование поиска: Сформулировать план сбора информации.

Сбор из нескольких источников: Собирать информацию из нескольких источников.

Проверка информации: Перекрёстно проверять точность информации.

Генерация отчёта: Синтезировать информацию для создания структурированных отчётов.

Реализация кода

Реализация исследовательского агента

class ResearchAgent:
    """
Исследовательский агент
Автономно проводить глубокое исследование и генерировать отчёты
    """
   
    def __init__(self, search_tools, llm):
        # Список инструментов поиска
        self.search_tools = search_tools
        self.llm = llm
   
    def research(self, topic, depth=3):
        """
Выполнить задачу исследования
:param topic: Тема исследования
:param depth: Глубина исследования (количество раундов поиска)
        """
        # Шаг 1: Создать план исследования
        plan = self.create_research_plan(topic, depth)
       
        # Шаг 2: Выполнить несколько раундов поиска
        findings = []
        for phase in plan.phases:
            # Поиск в нескольких направлениях параллельно
            phase_results = self.search_phase(phase)
            findings.extend(phase_results)
           
            # Синтезировать текущие findings
            synthesis = self.synthesize(findings)
            findings.append({
                "type": "synthesis",
                "content": synthesis,
                "phase": phase.number
            })
       
        # Шаг 3: Сгенерировать итоговый отчёт
        report = self.generate_report(findings)
       
        return {
            "topic": topic,
            "plan": plan,
            "findings": findings,
            "report": report
        }
   
    def create_research_plan(self, topic, depth):
        """Создать план исследования"""
        prompt = f"""
Создайте подробный план для следующей темы исследования:

Тема: {topic}
Глубина: {depth}

Пожалуйста, составьте план:
1. Ключевые направления, которые необходимо исследовать (3-5)
2. Основные вопросы, на которые нужно ответить для каждого направления
3. Рекомендации по источникам информации
"""
        return ResearchPlan.parse(self.llm.generate(prompt))
   
    def search_phase(self, phase):
        """Выполнить один этап поиска"""
        results = []
       
        for query in phase.queries:
            # Использовать инструменты поиска для поиска
            for tool in self.search_tools:
                search_results = tool.search(query)
                results.extend(search_results)
       
        return results
   
    def synthesize(self, findings):
        """Обобщение результатов"""
        prompt = f"""
Обобщите следующие результаты исследования и извлеките ключевую информацию:

Список результатов:
{findings}

Пожалуйста, извлеките:
1. Основные выводы
2. Доказательства, подтверждающие выводы
3. Существующие спорные вопросы или неопределённости
4. Вопросы, требующие дальнейшего исследования
"""
        return self.llm.generate(prompt)
   
    def generate_report(self, findings):
        """Создать итоговый отчёт"""
        prompt = f"""
Создайте структурированный отчёт на основе следующих результатов исследования:

Результаты исследования:
{findings}

Требования к отчёту:
1. Краткое резюме
2. Введение и предыстория
3. Ключевые выводы (по подтемам)
4. Выводы и рекомендации
5. Источники

Пожалуйста, сгенерируйте полный отчёт.
"""
        return self.llm.generate(prompt)


class ResearchPlan:
    """План исследования"""
   
    @classmethod
    def parse(cls, text):
        """Разбор текста плана"""
        # Упрощённая реализация
        return cls(phases=[
            ResearchPhase(number=1, queries=["Связанная тема 1"], goals=["Понять основные концепции"]),
            ResearchPhase(number=2, queries=["Связанная тема 2"], goals=["Углублённый анализ"]),
        ])
   
    def __init__(self, phases):
        self.phases = phases


class ResearchPhase:
    """Фаза исследования"""
   
    def __init__(self, number, queries, goals):
        self.number = number
        self.queries = queries
        self.goals = goals

Другие вертикальные приложения

RPA + агент

Сочетание RPA (Robotic Process Automation) и агента.

Это позволяет автоматизировать более сложные бизнес-процессы.

Агент наделяет RPA возможностями интеллектуального принятия решений.

Игровой NPC-агент

NPC (неигровые персонажи) агенты в играх.

Они могут вести динамичный диалог, генерировать сюжет и отыгрывать роли.

Создают более реалистичный игровой опыт.

Агент научных исследований

ИИ для науки преображает научные исследования.

Обзор литературы: Автоматически читать и обобщать большое количество статей.

Планирование эксперимента: Предлагать экспериментальные планы и гипотезы.

Анализ данных: Обрабатывать экспериментальные данные и выявлять закономерности.

Написание статей: Помогать в написании научных статей.

Краткое содержание главы

В этой главе представлены применения Агента в различных вертикальных областях.

Агент по кодуПомогает в программировании и повышает эффективность разработки.

Агент анализа данныхПозволяет нетехническим специалистам также анализировать данные.

Агент по обслуживанию клиентовОбеспечивает интеллектуальное обслуживание клиентов.

Исследовательский агентАвтономно проводит углублённые исследования.

Существуют также другие сценарии, такие как RPA+Agent, игровые NPC и агенты для научных исследований.

Агенты в вертикальных доменах должны настраиваться с учётом предметных знаний.

Выбор правильных сценариев и точек входа — залог успешного внедрения.

Другие расширения