✅ Создание интеллектуальных многоагентных систем с AutoGen и LangChain для бизнеса

Введение в мир агентного ИИ

Как вы думаете, возможно ли создать систему, которая будет самостоятельно решать задачи, взаимодействуя с другими агентами? Ответ на этот вопрос — да! В этой статье мы расскажем о том, как я построил интеллектуальную многопользовательскую систему с использованием AutoGen, LangChain и Hugging Face. Мы покажем, как эти инструменты могут помочь в создании практических рабочих процессов агентного ИИ, которые легко интегрируются в бизнес.

Что такое агентный ИИ?

Агентный ИИ — это концепция, в которой несколько интеллектуальных агентов взаимодействуют друг с другом для достижения общей цели. Эти агенты могут быть настроены на выполнение различных задач, что делает их универсальными инструментами для автоматизации бизнес-процессов. С помощью AutoGen, LangChain и Hugging Face мы можем создать систему, которая не только выполняет задачи, но и учится на своих ошибках, улучшая свои результаты с каждым циклом.

Настройка окружения

Первым шагом в создании нашей системы является установка необходимых библиотек и инициализация модели языка Hugging Face FLAN-T5. Эта модель генерирует связный и контекстуально насыщенный текст, что является основой для наших экспериментов с агентами.

import warnings
warnings.filterwarnings('ignore')

from typing import List, Dict
import autogen
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain
from langchain_community.llms import HuggingFacePipeline
from transformers import pipeline
import json

print("Загрузка моделей...\n")

pipe = pipeline(
   "text2text-generation",
   model="google/flan-t5-base",
   max_length=200,
   temperature=0.7
)

llm = HuggingFacePipeline(pipeline=pipe)
print("✓ Модели загружены!\n")

Основы LangChain

LangChain позволяет создавать интеллектуальные шаблоны запросов, которые позволяют нашей модели логически подходить к задачам. Например, мы можем создать цепочку, которая принимает задачу и возвращает детальное решение.

def demo_langchain_basics():
   print("="*70)
   print("ДЕМО 1: LangChain - Интеллектуальные цепочки запросов")
   print("="*70 + "\n")
   prompt = PromptTemplate(
       input_variables=["task"],
       template="Задача: {task}\n\nПредоставьте подробное пошаговое решение:"
   )
   chain = LLMChain(llm=llm, prompt=prompt)
   task = "Создайте функцию на Python для вычисления последовательности Фибоначчи"
   print(f"Задача: {task}\n")
   result = chain.run(task=task)
   print(f"Ответ LangChain:\n{result}\n")
   print("✓ Демонстрация LangChain завершена\n")

Многоступенчатое рассуждение с LangChain

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

def demo_langchain_multi_step():
   print("="*70)
   print("ДЕМО 2: LangChain - Многоступенчатое рассуждение")
   print("="*70 + "\n")
   planner = PromptTemplate(
       input_variables=["goal"],
       template="Разбейте эту цель на 3 шага: {goal}"
   )
   executor = PromptTemplate(
       input_variables=["step"],
       template="Объясните, как выполнить этот шаг: {step}"
   )
   plan_chain = LLMChain(llm=llm, prompt=planner)
   exec_chain = LLMChain(llm=llm, prompt=executor)
   goal = "Построить модель машинного обучения"
   print(f"Цель: {goal}\n")
   plan = plan_chain.run(goal=goal)
   print(f"План:\n{plan}\n")
   print("Выполняем первый шаг...")
   execution = exec_chain.run(step="Собрать и подготовить данные")
   print(f"Выполнение:\n{execution}\n")
   print("✓ Многоступенчатое рассуждение завершено\n")

Создание простых агентов

Мы можем создать легковесных агентов, каждый из которых будет выполнять определенную роль, такую как исследователь, программист или рецензент. Эти агенты будут сотрудничать в решении задач, обмениваясь информацией и наращивая результаты друг друга.

class SimpleAgent:
   def __init__(self, name: str, role: str, llm_pipeline):
       self.name = name
       self.role = role
       self.pipe = llm_pipeline
       self.memory = []
   def process(self, message: str) -> str:
       prompt = f"Вы {self.role}.\nПользователь: {message}\nВаш ответ:"
       response = self.pipe(prompt, max_length=150)[0]['generated_text']
       self.memory.append({"user": message, "agent": response})
       return response
   def __repr__(self):
       return f"Agent({self.name}, role={self.role})"

Концепции AutoGen

Мы можем проиллюстрировать основные идеи AutoGen, определив концептуальную конфигурацию агентов и их рабочего процесса. Это позволяет нам визуализировать, как агенты будут взаимодействовать друг с другом.

def demo_autogen_conceptual():
   print("="*70)
   print("ДЕМО 4: Концепции AutoGen (Концептуальная демонстрация)")
   print("="*70 + "\n")
   agent_config = {
       "agents": [
           {"name": "UserProxy", "type": "user_proxy", "role": "Координирует задачи"},
           {"name": "Assistant", "type": "assistant", "role": "Решает проблемы"},
           {"name": "Executor", "type": "executor", "role": "Запускает код"}
       ],
       "workflow": [
           "1. UserProxy получает задачу",
           "2. Assistant генерирует решение",
           "3. Executor тестирует решение",
           "4. Обратная связь до завершения"
       ]
   }
   print(json.dumps(agent_config, indent=2))
   print("\nКлючевые особенности AutoGen:")
   print("  • Автоматизированные разговоры агентов")
   print("  • Возможности выполнения кода")
   print("  • Поддержка человека в процессе")
   print("  • Сотрудничество многопользовательских агентов")
   print("  • Вызов инструментов/функций\n")
   print("✓ Концепции AutoGen объяснены\n")

Сочетание LangChain и агентов

Интегрируя структурированное рассуждение LangChain с нашей простой системой агентов, мы создаем гибридную интеллектуальную платформу, которая может решать сложные задачи.

def demo_hybrid_system():
   print("="*70)
   print("ДЕМО 6: Гибридная система LangChain + Многопользовательская система")
   print("="*70 + "\n")
   reasoning_prompt = PromptTemplate(
       input_variables=["problem"],
       template="Анализируйте эту проблему: {problem}\nКаковы ключевые шаги?"
   )
   reasoning_chain = LLMChain(llm=llm, prompt=reasoning_prompt)
   planner = SimpleAgent("Planner", "стратегический планировщик", pipe)
   executor = SimpleAgent("Executor", "исполнитель задач", pipe)
   problem = "Оптимизировать медленный запрос к базе данных"
   print(f"Проблема: {problem}\n")
   print("[LangChain] Анализ проблемы...")
   analysis = reasoning_chain.run(problem=problem)
   print(f"Анализ: {analysis[:120]}...\n")
   print(f"[{planner.name}] Создание плана...")
   plan = planner.process(f"Запланируйте, как: {problem}")
   print(f"План: {plan[:120]}...\n")
   print(f"[{executor.name}] Выполнение...")
   result = executor.process(f"Выполнить: Добавить индексы базы данных")
   print(f"Результат: {result[:120]}...\n")
   print("✓ Гибридная система завершена\n")

Заключение

В этой статье мы продемонстрировали, как агентный ИИ может быть реализован через модульный подход, интегрируя глубину рассуждений LangChain с коллаборативной силой агентов. Мы показали, как мощные, автономные ИИ-системы могут быть созданы без дорогой инфраструктуры, используя инструменты с открытым исходным кодом и креативный дизайн.