Начало работы с агентным ИИ в LangGraph

---

Введение

ИИ развивается с молниеносной скоростью — от простых чат-ботов, которые могут отвечать на вопросы или вести базовую беседу, до ИИ-чат-ботов, которые делают шаг вперёд и способны решать сложные задачи. Это становится возможным благодаря Agentic AI. Agentic AI может анализировать, предпринимать многоэтапные действия и работать более автономно, почти как цифровой помощник, который не просто разговаривает, но и действительно выполняет задачи. Проблема в том, что традиционные приложения на базе больших языковых моделей (LLM) не справляются. Обычно у них нет памяти, они плохо адаптируются к новым ситуациям и испытывают трудности с управлением сложными задачами, требующими нескольких шагов или взаимодействия различных инструментов.

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

В этой статье мы представим концепцию Agentic AI, рассмотрим как LangGraph облегчает её создание и пройдём по шагам, которые помогут вам начать собственные проекты. Мы создали несколько руководств по Agentic AI, все из которых доступны в нашем разделе ресурсов.

Основные выводы

• Агентный ИИ уже является развитием ИИ, выходящим за рамки статичных чат-ботов к автономным системам, основанным на рассуждениях, которые могут выполнять многозадачные операции.
• Традиционные приложения на основе крупных языковых моделей отстают, потому что им не хватает памяти, адаптивности и координации.
• LangGraph предоставляет структурированную основу для создания агентных рабочих процессов с использованием узлов, связей и графов, что делает агентов более надежными и масштабируемыми.
• Разработчики могут начать с малого, создавая простых агентов, которые используют инструменты, а затем переходить к сложным системам с памятью.
• Развертывание на платформах, таких как Linux-Console.net GPU Droplets, делает масштабирование практичным, предоставляя агентам необходимую вычислительную мощность для использования в реальных условиях.
• Практическое применение охватывает различные отрасли, от поддержки клиентов до научных ассистентов и автоматизированных рабочих процессов.
• Начать легко: с Python, ключом API и LangGraph любой может начать создавать своего собственного агентного ИИ.

Предварительные требования

Чтобы следовать материалу, читателям следует иметь:

• Базовые знания программирования: Знание Python. Понимание LLM: Некоторый опыт работы с инструментами, такими как GPT от OpenAI или модели Hugging Face.

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

  • Установлен Python 3.9 и выше.
• Редактор кода (VS Code, PyCharm и т.д.).
• Доступ к API LLM (ключ OpenAI API или токен Hugging Face).

Необязательно, но рекомендуется:

• Опыт работы с LangChain (так как LangGraph строится на схожих идеях).

Учетная запись Linux-Console.net (для развертывания агента).

Полезные концепции

• Граф: Граф — это способ представления отношений между объектами.
• Узлы (или вершины): Они представляют собой «объекты» (например, города, людей, аэропорты).
• Ребра (или связи): Они представляют собой соединения или отношения между этими объектами (например, маршрут полета, дружба или дорога). Таким образом, граф по сути представляет собой точки (узлы), соединенные линиями (ребрами). Представьте себе аэропорты и маршруты полетов, где каждый аэропорт является узлом (например, Нью-Йорк, Лондон, Дубай). Каждый маршрут полета — это ребро, соединяющее два узла (например, Нью-Йорк → Лондон).
• Основанный на графах рабочий процесс: LangGraph организует рабочие процессы агентов в виде графов, где каждая вершина представляет собой шаг или точку принятия решения, а ребра отображают поток управления или данных. Это делает поведение агента прозрачным, удобным для отладки и более легким для расширения.

Память в агентах: Память позволяет агентам сохранять контекст во время взаимодействий. LangGraph поддерживает различные модели памяти, такие как краткосрочная (на уровне беседы) и долгосрочная (постоянная) память.

Инструменты и действия: Агенты могут быть подключены к внешним инструментам (API, базы данных, выполнение кода) для расширения своих возможностей. LangGraph определяет, как и когда эти инструменты вызываются.

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

Представьте ситуацию, когда мы спрашиваем у ИИ-агента: «Спланируй мне поездку на выходные в Гоа.»

Обычный чат-бот может просто предоставить вам список популярных достопримечательностей. Чат-бот с поддержкой RAG может справиться немного лучше, подгружая свежие данные и составив базовый маршрут. Но Agentic AI делает шаг дальше. Думайте о нём как о помощнике-новичке, который решает задачи. Он не просто отвечает на вопросы; он действительно может рассуждать, планировать и выполнять ряд шагов, чтобы помочь вам достичь цели.

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

Все начинается с целеориентированного планирования. Агентный ИИ разложит эту задачу на более мелкие цели, такие как поиск авиабилетов, проверка отелей, проверка погоды и рекомендации по активностям.
Затем наступает этап многошагового рассуждения. Предположим, вы добавите „Убедитесь, что это бюджетно и подходит для вегетарианцев.” Вместо того чтобы давать универсальный ответ, агентный ИИ может рассуждать поэтапно: фильтровать отели по цене, проверять варианты ресторанов и объединять результаты в персонализированный маршрут.

Искусственный интеллект Aigentic также может выполнять автономное принятие решений на каждом этапе. Если он обнаружит, что один из отелей полностью забронирован, он не остановится и не будет ждать вашего вмешательства. Вместо этого он скорректирует план и автоматически выберет следующий лучший вариант. У него есть доступ к внешним инструментам и базам знаний. Например, он может запросить данные о рейсах в реальном времени через API, получить отзывы о ресторанах с Google Maps или проверить прогноз погоды перед окончательным утверждением плана. Это делает его значительно более динамичным по сравнению с системой, ограниченной только данными для обучения.

Чтобы лучше понять это, возьмем пример традиционного чат-бота, который похож на ресепшиониста в отеле и может лишь повторять заученные ответы: «Завтрак в 8 утра» или «Вот наш адрес.» Чат-бот RAG (с генерацией с поддержкой поиска информации) похож на библиотекаря: он может искать информацию в книгах или документах и суммировать её для вас, но не будет действовать на её основе.

Чат-бот с поддержкой инструментов больше похож на калькулятор: он может использовать определённый инструмент, чтобы дать вам ответ, например, решить „Сколько будет 378 × 56?”, но он не будет планировать дальше этого.

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

Теперь вы можете спросить, в чем разница между AI-агентом и агентной AI-системой. AI-агент может быть ботом с одной целью, например таким, который только планирует события в календаре. Но агентная AI-система объединяет несколько агентов, память, рассуждения и оркестрацию в одну структуру, способную справляться со сложными задачами, такими как координация вашего календаря, бронирование поездок и отправка напоминаний — всё это в одном рабочем процессе.

Если вы хотите глубже изучить фреймворки агентного ИИ, мы опубликовали подробные блоги на эту тему — посмотрите ссылки в разделе ресурсов.

Введение в LangGraph

LangGraph — это проект с открытым исходным кодом, построенный поверх LangChain, который позволяет разработчикам создавать AI-воркфлоу в виде графов. Теперь LangGraph помогает разработчикам строить агентные AI-системы, которые структурированы и позволяют разрабатывать надежные воркфлоу. Хотя большинство AI-агентов сегодня гибкие и мощные, они часто сталкиваются с такими проблемами, как непредсказуемость, отсутствие памяти или трудности в обработке многозадачных процессов. LangGraph решает эти задачи, предоставляя разработчикам возможность визуализировать и управлять воркфлоу агентов в виде графов — где узлы представляют собой шаги (например, рассуждения, использование инструментов или память), а связи — поток логики между ними.

Вместо того чтобы писать линейный, пошаговый код, LangGraph позволяет представлять систему ИИ в виде узлов (задач), соединенных ребрами (решениями или переходами). Это облегчает создание агентных ИИ-систем, которые могут рассуждать, адаптироваться и следовать структурированным путям.

Традиционные агенты ИИ часто ведут себя непредсказуемо, перескакивая между шагами без чёткой структуры. LangGraph решает эту проблему следующим образом:

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

Теперь типичный рабочий процесс начинается с Ввода пользователя, который поступает в Узел LLM, выполняющий рассуждения на основе подсказок. Узел Решение/Ветвь направляет поток: если LLM решает, что нужен инструмент, рабочий процесс переходит к Узлу инструмента (например, API или калькулятор) и может вернуться обратно к LLM для продолжения рассуждений. На протяжении всего процесса узел Память (Состояние) сохраняет контекст и историю и используется для чтения и записи как узлами LLM, так и инструментов. В завершение рабочий процесс достигает Вывода (Конец) с окончательным результатом.

Обе платформы — LangChain и LangGraph — представляют собой фреймворки, созданные для помощи разработчикам в работе с большими языковыми моделями (LLM), но они преследуют немного разные цели.

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

Пример: Простой рабочий процесс LangGraph

Мы построим граф, где:

1. Пользователь задает вопрос.
2. Большая языковая модель решает, нужен ли ей инструмент (например, калькулятор).
3. Если нужен инструмент → направьте к узлу калькулятора.
4. Иначе → ответьте напрямую.

Наконец → вернуть результат.

from langgraph.graph import StateGraph, END from langchain_openai import ChatOpenAI from langchain_community.tools import Calculator  # 1. Define the state class State(dict):     question: str     answer: str  # 2. Initialize LLM and Tool llm = ChatOpenAI(model="gpt-4o-mini") calculator = Calculator()  # 3. LLM Node (decides if it needs the calculator) def call_llm(state: State):     q = state["question"]     response = llm.invoke(f"Answer the question. If it's a math calculation, say 'USE_CALCULATOR: <expression>'.nnQuestion: {q}")          if "USE_CALCULATOR:" in response.content:         expression = response.content.split("USE_CALCULATOR:")[1].strip()         return {"expression": expression}  # route to calculator node     else:         return {"answer": response.content}  # direct answer  # 4. Calculator Node def use_calculator(state: State):     result = calculator.run(state["expression"])     return {"answer": f"Result is {result}"}  # 5. Build Graph workflow = StateGraph(State)  # Add nodes workflow.add_node("llm_node", call_llm) workflow.add_node("calculator_node", use_calculator)  # Define edges workflow.set_entry_point("llm_node") workflow.add_conditional_edges(     "llm_node",     lambda state: "calculator_node" if "expression" in state else END,     {"calculator_node": "calculator_node", END: END} ) workflow.add_edge("calculator_node", END)  # 6. Compile Graph app = workflow.compile()  # 7. Run with two examples print(app.invoke({"question": "What is the capital of Japan?"})["answer"]) print(app.invoke({"question": "What is 456 * 789?"})["answer"])

• Состояние → Содержит входной вопрос, возможное выражение и окончательный ответ.
• Узел LLM → Отвечает напрямую ИЛИ направляет математические выражения в Калькулятор.
• Узел калькулятора → Выполняет математические вычисления и возвращает результат.
• Граф → Использует условные рёбра, чтобы динамически определять путь.
• Выполнить →
  Ввод: "Какова столица Японии?" → "Токио" Ввод: "Чему равно 456 * 789?" → "Результат 359784"

Настройка вашей среды для агентского ИИ-проекта в LangGraph

Создайте аккаунт на Linux-Console.net

• Зарегистрируйтесь или войдите в свою учетную запись на Linux-Console.net.
• Linux-Console.net предоставляет GPU Droplets и другие вычислительные экземпляры, которые идеально подходят для масштабного запуска агентных AI проектов.

Создать Droplet

• На панели управления Linux-Console.net создайте новый Droplet.
• Выберите GPU Droplet (для более быстрой работы LLM) или CPU Droplet (для легких рабочих процессов).
• Выберите предпочитаемую операционную систему (рекомендуется Ubuntu 22.04).
• Добавьте SSH-ключи для безопасного доступа.
• Подключитесь к GPU Droplet по SSH с помощью VS Code.

Установите Python и зависимости

Обновите вашу систему и установите Python 3.10 или новее:

sudo apt update && sudo apt upgrade -y sudo apt install python3 python3-venv python3-pip -y

Создайте и активируйте виртуальное окружение:

python3 -m venv langgraph-env source langgraph-env/bin/activate

Установите LangGraph и инструменты

С подготовленной средой установите основные библиотеки:

pip install --upgrade pip pip install langgraph langchain openai pygraphviz matplotlib networkx graphviz

Настроить ключи API

Для использования OpenAI или других LLM установите свой API-ключ:

export OPENAI_API_KEY="your_api_key_here"

Проверить установку

Выполните быстрый тест, чтобы убедиться, что всё работает:

import langgraph print("LangGraph version:", langgraph.__version__)

Если вы видите номер версии, установка завершена.

Советы по оптимизации затрат на Linux-Console.net

При экспериментах с проектами LangGraph вам не всегда нужен самый мощный GPU Droplet. Начните с более простого экземпляра и увеличивайте его только тогда, когда это потребуется вашим рабочим процессам. Используйте снимки, чтобы сохранять окружения, чтобы можно было удалять неиспользуемые Droplets и воссоздавать их позже без дополнительной настройки. Также рассмотрите возможность использования инструментов мониторинга для отслеживания использования и предотвращения ненужных расходов.

Создание вашего первого агента с LangGraph

Основные концепции LangGraph

• Узлы: Узел — это небольшая единица вычислений: чистая функция на Python, которая читает состояние и возвращает частичные обновления состояния. Узлы являются основными рабочими элементами (например, вызов LLM, использование инструмента, преобразование данных).
• Ребра: Ребра соединяют узлы и определяют поток управления. Они могут быть безусловными (фиксированный поток) или условными (выбор следующего узла на основе состояния). Ребра позволяют вашему графу ветвиться, создавать циклы или запускать узлы параллельно.
• Состояние: Состояние — это схема (TypedDict/Pydantic/dataclass), представляющая общие данные графа. Узлы читают состояние и возвращают его частичные обновления. Редьюсеры контролируют, как несколько обновлений одного и того же ключа объединяются (например, добавление сообщений).
• Редюсеры: Аннотируйте поля состояния функциями редюсера, чтобы управлять тем, как объединяются обновления — это часто используется для «сообщений», когда вы хотите добавлять данные вместо их перезаписи.
• Граф (Graph API): LangGraph моделирует рабочий процесс как Граф (StateGraph). Он предоставляет инструменты для последовательностей, ветвлений, циклов, кеширования, повторных попыток, контрольных точек и визуализации. Вы компилируете конструктор в Граф, а затем вызываете/потоково обрабатываете его.
• Инструменты и готовые агенты: LangGraph поставляется с готовыми помощниками (например, create_react_agent), которые связывают LLM с циклом инструментов (агенты в стиле ReAct). Эти помощники отлично подходят для быстрого старта. Вы также можете собрать свои собственные узлы и связи.
• Наблюдаемость и устойчивость: LangGraph поддерживает контрольные точки, потоковую передачу данных и интеграцию с LangSmith/инструментами трассировки для отладки долгоживущих агентов. Это делает его готовым к использованию в производственных средах с выполняемыми состояниями и возможностью сохранения контрольных точек.

Давайте использовать LangGraph для проектирования рабочих процессов агента в виде графов. Вместо линейного связывания подсказок, LangGraph позволяет создавать узлы (LLM, инструменты, логика принятия решений) и связи (переходы). Это делает вашего агента более модульным, понятным и надежным.

Шаг 1: Определите состояние

Каждому агенту нужна память/состояние, чтобы узлы могли обмениваться информацией. Например, вы можете захотеть сохранить:

• Запрос пользователя
• Результаты промежуточного инструмента
• Окончательный ответ

# Define the state schema from typing import TypedDict, Optional  class AgentState(TypedDict):     query: str               # User's input     search_results: Optional[str]   # Retrieved info from the web     final_answer: Optional[str]     # Agent’s response

Этот словарь состояния будет передаваться между узлами.

Шаг 2: Создание узлов

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

Мы создадим два узла:

1. Узел рассуждения (LLM): Понимает запрос и решает, искать информацию или отвечать напрямую.
2. Узел действия (Инструмент/API): вызывает поисковый API и сохраняет результаты.

Узел рассуждений (LLM)

from langchain_openai import ChatOpenAI  llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)  def reasoning_node(state: AgentState) -> AgentState:     query = state["query"]     # For simplicity, if "search" keyword is in query, call tool     if "search" in query.lower():         print("Reasoning: Need to call search tool.")         return {**state, "search_results": None}  # Pass to action node     else:         print("Reasoning: Answering directly with LLM.")         answer = llm.invoke(query).content         return {**state, "final_answer": answer}

В качестве альтернативы вы можете использовать Ollama для доступа к различным моделям и их внедрения. Руководство, показывающее, как загружать и использовать модели Ollama, доступно в разделе наших ресурсов.

Узел действия (Поиск API)

Здесь мы смоделируем вызов поиска. На практике вы можете подключиться к реальному API (например, Tavily, SerpAPI).

def search_tool(query: str) -> str:     # Dummy search tool     return f"Results for '{query}': This is mock search output."  def action_node(state: AgentState) -> AgentState:     query = state["query"]     results = search_tool(query)     print("Action: Got search results.")     return {**state, "search_results": results}

Шаг 3: Соедините узлы в граф

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

from langgraph.graph import StateGraph, END  # Build graph graph = StateGraph(AgentState)  # Add nodes graph.add_node("reasoning", reasoning_node) graph.add_node("action", action_node)  # Define transitions graph.set_entry_point("reasoning")              # Start here graph.add_edge("reasoning", "action")           # If search needed → action graph.add_edge("action", "reasoning")           # After action, return to reasoning graph.add_edge("reasoning", END)                # End if answer ready  # Compile agent = graph.compile()

Шаг 4: Запустите граф

Теперь давайте проверим с двумя запросами:

1. Без поиска
2. С поиском

# Case 1: No search needed state = {"query": "What is the capital of France?"} result = agent.invoke(state) print("nFinal Answer:", result["final_answer"])  # Case 2: Search needed state = {"query": "search latest AI news"} result = agent.invoke(state) print("nSearch Results:", result["search_results"]) print("Final Answer:", result["final_answer"])

В этом примере кода

• Ввод: «Какая столица Франции?»

• Узел рассуждений не обнаруживает «поиск» → отвечает напрямую.

• Итоговый результат: "Париж — столица Франции."

• Ввод: "поиск последних новостей ИИ"

• Узел рассуждения принимает решение выполнить поиск.

• Узел действия получает имитационные результаты.

• Узел рассуждения суммирует результаты.

Часто задаваемые вопросы

1. Что такое агентский ИИ и чем он отличается от обычного чат-бота?

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

2. Почему мне нужен LangGraph для создания Agentic AI?

LangGraph построен на базе LangChain и предоставляет платформу для моделирования рабочих процессов агентов в виде графов. Такая структура делает ваших агентов более надежными, предсказуемыми и прозрачными. Она помогает решать распространенные задачи в разработке ИИ, такие как:

• Недостаток памяти или способности сохранять контекст.
• Трудности в контроле за ходом рассуждений.
• Отладка сложных рабочих процессов.
  Используя узлы (действия/инструменты), связи (пути принятия решений) и состояние (память), LangGraph упрощает создание агентов, которым можно доверять в производственной среде.

3. Чем LangGraph отличается от LangChain?

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

4. Нужны ли мне обширные технические знания, чтобы начать работу с LangGraph?

Не обязательно. Базовое знакомство с Python и такими понятиями, как функции или API, будет полезно, но LangGraph разработан с учетом удобства для разработчиков. Он предоставляет четкие абстракции, так что вам не нужно быть экспертом в области ИИ, чтобы начать. Фреймворк также включает инструменты визуализации, которые облегчают понимание того, как ваш агент принимает решения.

5. Каковы некоторые реальные примеры использования агентного ИИ с LangGraph?

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

6. Могу ли я масштабировать агентов LangGraph для производственных сред?

Да. Как только вы создадите и протестируете своего агента локально, вы можете развернуть его в продакшене, используя хостинг с поддержкой GPU. Платформы, такие как Linux-Console.net GPU Droplets или Paperspace, предоставляют инфраструктуру, необходимую для масштабирования ваших агентов для реальных приложений, обеспечивая их эффективную работу с интенсивными нагрузками.

7. Как системы агентного ИИ сравниваются с генеративным ИИ?

Генеративный ИИ сосредоточен на создании нового контента (например, текста, изображений или аудио) на основе шаблонов в обучающих данных. Агентный ИИ, с другой стороны, делает упор на поведение, направленное на достижение цели. Он использует рассуждения, планирование и инструменты для выполнения задач в реальном мире. Короче говоря, Генеративный ИИ посвящен «созданию», тогда как Агентный ИИ посвящен «действию».

Заключение

Agent AI — это новая глава, которая изменила наш способ взаимодействия с ИИ. Вместо того чтобы ограничиваться разовыми разговорами, эти агенты теперь могут логически решать проблемы, планировать многошаговые действия и принимать автономные решения, что делает их гораздо более полезными в реальных ситуациях. Возможности, такие как рассуждение, планирование и принятие решений, превращают хорошо известные большие языковые модели в настоящих человеческих помощников.

Но создание надежных, структурированных агентов — это непросто, и LangGraph помогает нам создавать надежных агентов.

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

По мере продолжения вашего путешествия, вот несколько практических следующих шагов для исследования:

• Экспериментируйте с различными типами узлов (инструменты, память, шаги рассуждений), чтобы разработать уникальные рабочие процессы.
• Расширяйте границы, пробуя сотрудничество нескольких агентов, где несколько агентов взаимодействуют для решения более сложных задач.
• Масштабируйте свои проекты, размещая их на инфраструктуре с поддержкой GPU, такой как GPU Droplets на Linux-Console.net, обеспечивая производительность и надежность в производстве.

Дополнительные ресурсы

• Учебники по LangChain
• Документация LangGraph
• Руководства по API OpenAI/Anthropic
• Запускайте LLM с Ollama на GPU H100 для максимальной эффективности
• Агентные ИИ-фреймворки для создания автономных ИИ-агентов
• Создание автономных систем: Руководство по рабочим процессам агентного ИИ
• Настройка среды GPU Droplet для программирования в области ИИ/МО — Jupyter Labs

Спасибо, что учитесь вместе с сообществом Linux-Console.net.