Конспект 5: AI Агенты и Multi-Agent системы

Обычный LLM:
User: "Какая погода в Москве?"
LLM: "Я не знаю текущую погоду" ❌

AI Agent:
User: "Какая погода в Москве?"
Agent: 
  1. Мне нужны текущие данные
  2. Вызываю weather_api(city="Moscow")
  3. Получаю: {"temp": -5, "condition": "snow"}
  4. Формулирую ответ: "В Москве -5°C, снег" ✅

┌─────────────────────────────────┐
│         AI Agent                │
│                                 │
│  ┌──────────────────────────┐  │
│  │   LLM (Brain/Reasoning)  │  │
│  └──────────────────────────┘  │
│             ↕                   │
│  ┌──────────────────────────┐  │
│  │   Tools (Actions)        │  │
│  │   - API calls            │  │
│  │   - Database queries     │  │
│  │   - Code execution       │  │
│  └──────────────────────────┘  │
│             ↕                   │
│  ┌──────────────────────────┐  │
│  │   Memory                 │  │
│  │   - Short-term (context) │  │
│  │   - Long-term (vector DB)│  │
│  └──────────────────────────┘  │
│             ↕                   │
│  ┌──────────────────────────┐  │
│  │   Planning Module        │  │
│  └──────────────────────────┘  │
└─────────────────────────────────┘

IF email.subject contains "urgent"
THEN priority = high

Thought → Action → Observation → Thought → ...

1. Создать план (список шагов)
2. Выполнить шаг 1
3. Проверить результат
4. Скорректировать план
5. Повторить

Agent 1 (Researcher) → Agent 2 (Analyzer) → Agent 3 (Writer)

1. THOUGHT (Рассуждение)
   "Что мне нужно сделать сейчас?"
   ↓
2. ACTION (Действие)
   tool_name(parameters)
   ↓
3. OBSERVATION (Наблюдение)
   Результат выполнения инструмента
   ↓
4. THOUGHT (Анализ результата)
   "Что это означает? Достаточно ли этого?"
   ↓
5. Повторить или завершить

You are an AI assistant that can use tools to help answer questions.

Available tools:
- search(query: str) -> str: Search the internet
- calculator(expression: str) -> float: Calculate mathematical expressions
- get_weather(city: str) -> dict: Get current weather
- python_repl(code: str) -> str: Execute Python code

Use this format:

Question: the input question
Thought: think about what to do
Action: tool_name(parameters)
Observation: the result of the action
... (repeat Thought/Action/Observation as needed)
Thought: I now know the final answer
Final Answer: the final answer to the original question

Begin!

Question: {{user_question}}

Thought: Мне нужно узнать дату релиза GPT-4, 
         затем вычислить разницу с сегодня.
Action: search("GPT-4 release date")
Observation: "GPT-4 was released on March 14, 2023"

Thought: Получил дату: 14 марта 2023. Теперь нужно 
         вычислить разницу с сегодняшней датой (13 декабря 2025).
Action: python_repl("from datetime import datetime; (datetime(2025,12,13) - datetime(2023,3,14)).days")
Observation: 1005

Thought: Получил результат - 1005 дней. Могу дать финальный ответ.
Final Answer: GPT-4 был выпущен 1005 дней назад (14 марта 2023 года).

// Function Node: ReAct Loop Controller

const MAX_ITERATIONS = 10;
const history = $json.history || [];
const currentIteration = $json.iteration || 0;

if (currentIteration >= MAX_ITERATIONS) {
  return { error: "Max iterations reached", history };
}

// Формируем промпт с историей
const prompt = `
${SYSTEM_PROMPT}

History:
${history.join('\n')}

Continue reasoning:
`;

return {
  prompt,
  iteration: currentIteration + 1,
  history,
  continue: true
};

[Webhook: User Question]
    ↓
[Set Variable: iteration=0, history=[]]
    ↓
[Loop Start]
    ↓
[Function: Build ReAct Prompt]
    ↓
[OpenAI Chat]
    ↓
[Function: Parse Response]
    ├─ Extract Thought
    ├─ Extract Action
    └─ Detect if finished
    ↓
[Switch по Action Type]
    ├─ search → [HTTP: Google API]
    ├─ calculator → [Code: eval]
    ├─ weather → [HTTP: Weather API]
    ├─ python → [Code: Python]
    └─ finish → [Exit Loop]
    ↓
[Function: Format Observation]
    ↓
[Update History]
    ↓
[Loop: Continue or Exit]
    ↓
[Return Final Answer]

1. Вы описываете доступные функции модели
2. Модель решает, какую функцию вызвать
3. Модель генерирует правильные параметры
4. Вы выполняете функцию
5. Возвращаете результат модели
6. Модель формулирует финальный ответ

{
  "functions": [
    {
      "name": "get_weather",
      "description": "Get current weather for a city",
      "parameters": {
        "type": "object",
        "properties": {
          "city": {
            "type": "string",
            "description": "City name, e.g. Moscow"
          },
          "units": {
            "type": "string",
            "enum": ["celsius", "fahrenheit"],
            "description": "Temperature units"
          }
        },
        "required": ["city"]
      }
    }
  ]
}

{
  "model": "gpt-4-turbo",
  "messages": [
    {"role": "user", "content": "Какая погода в Москве?"}
  ],
  "functions": [...],
  "function_call": "auto"
}

{
  "role": "assistant",
  "content": null,
  "function_call": {
    "name": "get_weather",
    "arguments": "{\"city\": \"Moscow\", \"units\": \"celsius\"}"
  }
}

{
  "messages": [
    {"role": "user", "content": "Какая погода в Москве?"},
    {
      "role": "assistant",
      "content": null,
      "function_call": {...}
    },
    {
      "role": "function",
      "name": "get_weather",
      "content": "{\"temp\": -5, \"condition\": \"snow\"}"
    }
  ]
}

{
  "role": "assistant",
  "content": "В Москве сейчас -5°C, идет снег."
}

[Webhook]
    ↓
[OpenAI Chat с functions definition]
    ↓
[Function: Check if function_call present]
    ↓
[IF function_call exists]
    ├─ [Switch по function name]
    │   ├─ get_weather → [HTTP: Weather API]
    │   ├─ search_db → [Qdrant Query]
    │   └─ calculate → [Code Node]
    ↓
[Function: Format function result]
    ↓
[OpenAI Chat: Send function result]
    ↓
[Return final answer]
    ↓
[ELSE: no function_call]
    └─ [Return direct answer]

AI Agent Node
├─ Chat Model (OpenAI, Anthropic, etc.)
├─ Tools
│   ├─ HTTP Request Tool
│   ├─ Code Tool
│   ├─ Vector Store Tool
│   └─ Custom Tools
└─ Memory (опционально)

You are a helpful AI assistant with access to tools.

Your goal: Help users by using available tools when needed.

Guidelines:
- Always think before acting
- Use tools when you lack information
- Be concise in your responses
- Admit if you don't know something

const tools = [
  {
    name: "get_user_data",
    description: "Fetch user data from database",
    parameters: {
      user_id: "string (required)"
    },
    execute: async (params) => {
      const response = await fetch(`/api/users/${params.user_id}`);
      return response.json();
    }
  },
  {
    name: "send_email",
    description: "Send email to user",
    parameters: {
      to: "string (required)",
      subject: "string (required)",
      body: "string (required)"
    }
  }
];

Tools:
- search_knowledge_base(query)
- get_user_info(user_id)
- create_ticket(title, description)
- escalate_to_human()

System Prompt:
"You are a customer support agent. 
Search the knowledge base first. 
If you can't solve, create a ticket."

Tools:
- query_database(sql)
- python_repl(code)
- create_visualization(data, chart_type)
- save_report(content)

System Prompt:
"You are a data analyst. 
Analyze data using SQL and Python.
Create visualizations and reports."

Agent 1 (Research) → Agent 2 (Analysis) → Agent 3 (Writing)

Researcher Agent:
- Ищет информацию по теме
- Собирает факты и статистику

Analyzer Agent:
- Анализирует собранные данные
- Выделяет ключевые идеи

Writer Agent:
- Пишет статью на основе идей
- Форматирует и структурирует

        Task
      /   |   \
Agent 1  Agent 2  Agent 3
      \   |   /
     Aggregator

Toxicity Agent → Score: 0.2
Spam Agent → Score: 0.8
NSFW Agent → Score: 0.1

Aggregator:
if (spam_score > 0.7) → REJECT
else if (toxicity > 0.5) → REVIEW
else → APPROVE

     Manager Agent
      /    |    \
Worker 1  Worker 2  Worker 3

Manager Agent:
- Разбивает задачу на подзадачи
- Распределяет подзадачи воркерам
- Собирает и проверяет результаты

[Webhook: Task]
    ↓
[Agent 1: Researcher]
    ↓
[Function: Extract research]
    ↓
[Agent 2: Analyzer]
    ↓
[Function: Extract insights]
    ↓
[Agent 3: Writer]
    ↓
[Save to Database]

[Webhook: Content]
    ↓
[Split In Batches: 3 agents]
    ├─ [Agent 1: Toxicity Check]
    ├─ [Agent 2: Spam Check]
    └─ [Agent 3: NSFW Check]
    ↓
[Merge]
    ↓
[Function: Aggregate scores]
    ↓
[Switch: Decision]

const conversation = [
  { role: "user", content: "Привет" },
  { role: "assistant", content: "Здравствуйте!" },
  { role: "user", content: "Как меня зовут?" },
  { role: "assistant", content: "Извините, вы не представились" }
];

Semantic Memory (семантическая):
- Факты о мире
- Хранится в: Vector DB (Qdrant)

Episodic Memory (эпизодическая):
- Конкретные взаимодействия
- Хранится в: SQL DB, MongoDB

Procedural Memory (процедурная):
- Как выполнять задачи
- Хранится в: Промпты

const sessionId = $json.sessionId;
const userMessage = $json.message;

let history = await redis.get(`session:${sessionId}`);
if (!history) history = [];

history.push({ role: "user", content: userMessage });

if (history.length > 10) {
  history = history.slice(-10);
}

await redis.set(`session:${sessionId}`, history, 'EX', 3600);

return { history };

const embedding = await getEmbedding($json.userMessage);

await qdrant.upsert({
  collection: "agent_memory",
  points: [{
    id: generateUUID(),
    vector: embedding,
    payload: {
      user_id: $json.userId,
      message: $json.userMessage,
      timestamp: new Date().toISOString()
    }
  }]
});

1. PLAN
   - Разбить задачу на шаги
   - Определить порядок

2. EXECUTE
   - Выполнить шаг 1
   - Проверить результат

3. REFLECT
   - Оценить прогресс
   - Нужна ли корректировка?

4. REPLAN (if needed)
   - Обновить план
   - Продолжить

1. TRY (Попытка)
2. OBSERVE (Наблюдение)
3. REFLECT (Рефлексия)
4. TRY AGAIN (Новая попытка)

const tools = [
  {
    name: "search_kb",
    description: "Search knowledge base for answers",
    params: { query: "string" }
  },
  {
    name: "get_order_status",
    description: "Get order status by order ID",
    params: { order_id: "string" }
  },
  {
    name: "create_ticket",
    description: "Create support ticket for complex issues",
    params: { title: "string", priority: "low|medium|high" }
  }
];

You are a customer support agent.

Your goals:
1. Answer customer questions using the knowledge base
2. Help with order status inquiries
3. Create tickets for issues you can't solve

Guidelines:
- Always be polite and empathetic
- Search KB first before creating tickets
- Ask for order ID if discussing orders

1. Researcher
   - Собирает информацию
   - Ищет источники

2. Analyzer
   - Анализирует данные
   - Выделяет ключевые идеи

3. Writer
   - Создает отчет
   - Форматирует результаты

- Quantity: количество выполненных действий
- Quality: точность выполнения
- Cost: расходы на API вызовы
- Latency: время выполнения
- Error Rate: процент ошибок
- Tool Usage: какие инструменты используются чаще

const log = {
  timestamp: new Date().toISOString(),
  agent_name: $json.agent_name,
  iteration: $json.iteration,
  action: $json.action,
  tokens_used: $json.tokens_used,
  cost: $json.tokens_used * 0.00003,
  success: $json.success
};

await db.logs.insert(log);

☑️ Все инструменты протестированы
☑️ Есть обработка ошибок
☑️ Логирование включено
☑️ Установлены лимиты (итерации, timeout)
☑️ Есть мониторинг (метрики, cost)
☑️ Human oversight для критичных действий
☑️ Fallback стратегии
☑️ Rate limiting на API вызовы
☑️ Документация для поддержки
☑️ Version control для промптов