Як використовувати рекурсивні мовні моделі для автоматизації складних задач: керівництво від практиків

Рекурсивні мовні моделі — це техніка, де одна модель викликає саму себе або ланцюжок моделей, щоб розбити складну задачу на підзадачі й вирішити кожну окремо. Це вирішує головний біль розробників і аналітиків: ChatGPT чи Claude не можуть за один запит написати, перевірити й задеплоїти код — але можуть, якщо правильно вибудувати ланцюжок. Цей туторіал займе близько 2–3 годин на перше налаштування і дасть вам готовий пайплайн для реальних задач. Для старту потрібен акаунт OpenAI або Anthropic, базове розуміння Python і бажання автоматизувати рутину.

🛠️ Що знадобиться

• Python 3.11+ — основна мова для оркестрації агентів; безкоштовний, завантажити з python.org
• LangChain 0.3 або LangGraph — фреймворк для побудови рекурсивних ланцюжків агентів; безкоштовний, pip install langchain langgraph
• OpenAI API або Anthropic Claude API — мовна модель, що виконує роботу; платний, але є безкоштовні кредити при реєстрації
• VS Code з розширенням Python — зручний редактор із дебагером; безкоштовний
• Tavily API — інструмент для пошуку в інтернеті в реальному часі, потрібен для агентів, що збирають дані; є безкоштовний тариф

📋 Покрокова інструкція

Крок 1: Встановлення середовища та ключів доступу

Відкрийте термінал і виконайте: pip install langchain langgraph langchain-openai tavily-python python-dotenv. Далі зайдіть на platform.openai.com → розділ API Keys → натисніть “Create new secret key” → скопіюйте ключ. Створіть файл .env у кореневій папці проєкту й вставте туди OPENAI_API_KEY=ваш_ключ і TAVILY_API_KEY=ваш_ключ (ключ Tavily отримайте на tavily.com → Sign Up → Dashboard → API Keys). Ніколи не комітьте .env у Git — одразу додайте його в .gitignore, інакше ключі стануть публічними.

Крок 2: Проєктування рекурсивного графу задач

Перед кодом намалюйте схему на папері або в будь-якому інструменті (навіть у Notes): є головний агент-оркестратор, який отримує задачу, розбиває її на підзадачі й делегує спеціалізованим агентам. Наприклад, задача “Зроби аналіз конкурентів” розбивається на: агент-пошуковик збирає дані, агент-аналітик їх структурує, агент-редактор оформлює звіт. Ключовий принцип рекурсії: кожен агент може знову викликати оркестратора, якщо підзадача виявилась складнішою за очікувану. Зафіксуйте в схемі умову зупинки — наприклад, “не більше 3 рівнів вкладеності”, інакше отримаєте нескінченну петлю і рахунок за API, що буде неприємним сюрпризом.

Крок 3: Написання базового оркестратора на LangGraph

Створіть файл orchestrator.py і вставте цей код:

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from typing import TypedDict, List
from dotenv import load_dotenv

load_dotenv()

class AgentState(TypedDict):
    task: str
    subtasks: List[str]
    results: List[str]
    depth: int

llm = ChatOpenAI(model="gpt-4o", temperature=0.2)

def orchestrator_node(state: AgentState) -> AgentState:
    if state["depth"] >= 3:
        return {**state, "subtasks": []}
    prompt = f"Розбий задачу на 2-3 підзадачі:\n{state['task']}\nВидай лише список через кому."
    response = llm.invoke(prompt)
    subtasks = [s.strip() for s in response.content.split(",")]
    return {**state, "subtasks": subtasks, "depth": state["depth"] + 1}

def worker_node(state: AgentState) -> AgentState:
    results = []
    for subtask in state["subtasks"]:
        prompt = f"Виконай завдання та дай конкретну відповідь:\n{subtask}"
        response = llm.invoke(prompt)
        results.append(response.content)
    return {**state, "results": results}

def should_recurse(state: AgentState) -> str:
    if state["depth"] < 2 and len(state["subtasks"]) > 0:
        return "worker"
    return END

graph = StateGraph(AgentState)
graph.add_node("orchestrator", orchestrator_node)
graph.add_node("worker", worker_node)
graph.set_entry_point("orchestrator")
graph.add_conditional_edges("orchestrator", should_recurse)
graph.add_edge("worker", END)
app = graph.compile()

Запустіть файл через python orchestrator.py — якщо помилок немає, граф скомпільовано успішно.

Крок 4: Додавання реальних інструментів — пошуку та генерації коду

Щоб агенти не “вигадували” дані, підключіть Tavily для реального пошуку. Додайте в orchestrator.py новий вузол:

from tavily import TavilyClient
import os

tavily = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))

def search_node(state: AgentState) -> AgentState:
    enriched_results = []
    for subtask in state["subtasks"]:
        search_result = tavily.search(query=subtask, max_results=3)
        context = "\n".join([r["content"] for r in search_result["results"]])
        prompt = f"На основі цих даних дай відповідь на питання '{subtask}':\n{context}"
        response = llm.invoke(prompt)
        enriched_results.append(response.content)
    return {**state, "results": enriched_results}

Далі додайте вузол у граф: graph.add_node("search", search_node) і підключіть його між оркестратором і worker-агентом через умовне ребро залежно від типу задачі. Тепер агент спочатку шукає актуальну інформацію, а потім аналізує її — це кардинально підвищує якість відповідей.

Крок 5: Запуск і перевірка повного пайплайну

Створіть файл run.py із таким вмістом і запустіть його:

from orchestrator import app

result = app.invoke({
    "task": "Проаналізуй топ-3 інструменти для автоматизації тестування у 2026 році",
    "subtasks": [],
    "results": [],
    "depth": 0
})

for i, res in enumerate(result["results"]):
    print(f"\n=== Результат {i+1} ===\n{res}")

Виконайте python run.py — ви побачите, як оркестратор розбив задачу на підзадачі, кожна пройшла через пошук і аналіз, а на виході ви отримали структурований звіт. Фінальний результат: повністю автоматизований багатоагентний пайплайн, що розбиває будь-яку складну задачу на кроки й виконує їх послідовно без вашої участі.

⚠️ Типові помилки та як їх уникнути

• Нескінченна рекурсія без умови зупинки — завжди додавайте перевірку глибини (depth >= 3) як перший рядок в оркестраторі; без цього за 10 хвилин спустошите кредити API
• Занадто широкі підзадачі — якщо оркестратор видає підзадачі типу “зроби все”, додайте до промпту чіткий шаблон: “Кожна підзадача має бути конкретною дією, що займає не більше 5 хвилин”
• Відсутність логування проміжних кроків — без логів неможливо зрозуміти, де пайплайн зламався; одразу додайте print(f"Depth: {state['depth']}, Task: {state['task']}") на початок кожного вузла
• Використання temperature=1.0 для оркестратора — висока температура робить розбиття задач непередбачуваним; тримайте temperature між 0.1 і 0.3 для логічних вузлів і можете підняти до 0.7 лише для творчих задач

💡 Поради для кращого результату

По-перше, додайте “мета-промпт” на початок кожного агента — одне речення, що описує його роль: “Ти — агент-аналітик, який лише структурує дані й ніколи не генерує нові факти.” Це різко зменшує галюцинації. По-друге, використовуйте gpt-4o-mini для проміжних вузлів і gpt-4o лише для фінального синтезу — це знижує вартість пайплайну в 5–10 разів без помітної втрати якості. По-третє, зберігайте стан між запусками в JSON-файл через json.dump(result, open("state.json", "w")) — так можна відновити роботу після помилки без повного перезапуску. По-четверте, тестуйте кожен вузол окремо функцією з хардкодованим станом перед тим, як збирати весь граф — це заощадить години дебагінгу.

❓ Часті запитання (FAQ)

1. Чи можна використовувати безкоштовні моделі замість GPT-4o?
Так, LangChain підтримує локальні моделі через Ollama — встановіть Ollama, завантажте ollama pull llama3.2 і замініть ChatOpenAI на ChatOllama(model="llama3.2"). Якість буде нижчою для складних задач, але для прототипування цілком підходить і коштує нуль гривень.

2. Скільки коштуватиме запуск одного пайплайну на GPT-4o?
Типовий пайплайн із 3 рівнями рекурсії і 3 підзадачами на кожному рівні споживає приблизно 50,000–100,000 токенів. При поточних цінах OpenAI це від $0.25 до $0.50 за один запуск — прийнятно для бізнес-задач, але слідкуйте за лімітами через dashboard на platform.openai.com.

3. Як зробити так, щоб агенти спілкувалися між собою, а не через оркестратор?
Для цього використовуйте архітектуру multi-agent mesh замість hub-and-spoke: кожен агент має власний список інших агентів і може викликати їх напряму. У LangGraph це реалізується через додаткові ребра між вузлами без проходження через центральний оркестратор — подивіться приклади в офіційній документації LangGraph розділ “Multi-agent networks”.

4. Що робити, якщо агент повертає некоректний формат відповіді?
Використовуйте Pydantic-схеми з методом llm.with_structured_output(YourSchema) — модель буде примусово повертати JSON у вказаному форматі. Це найнадійніший спосіб уникнути парсинг-помилок у рекурсивних пайплайнах.

5. Чи можна задеплоїти такий пайплайн у продакшн?
Так, LangGraph Cloud (langgraph.dev) дозволяє задеплоїти граф як API-ендпоінт за кілька хвилин — натисніть “New Deployment” → вкажіть GitHub-репозиторій → виберіть файл із графом. Альтернатива — загорнути в FastAPI і задеплоїти на Railway або Fly.io, що дає більше контролю над інфраструктурою.

🏁 Підсумок

Ви побудували повноцінний рекурсивний мультиагентний пайплайн: від встановлення середовища до задеплоєного оркестратора, що розбиває складні задачі на підзадачі, шукає реальні дані через Tavily і синтезує структурований результат — автоматично й без вашої участі.

Прямо зараз відкрийте термінал, виконайте pip install langchain langgraph langchain-openai і запустіть найпростіший варіант оркестратора з Кроку 3 на будь-якій реальній задачі з вашої роботи — перший результат побачите за 15 хвилин, і це змінить те, як ви дивитесь на автоматизацію.