Создавайте мультиагентные приложения с помощью OpenAI Agent SDK
Этот SDK с открытым исходным кодом упрощает создание мультиагентных приложений, и его можно использовать с любым LLM, совместимым с OpenAI
Agent orchestration – изображение, генерируемое искусственным интеллектом
Используя уровни абстракции, построенные на основе фундаментально простых идей, некоторые разработчики agent framework, похоже, считают сложность достоинством.
Я склонен придерживаться принципа Эйнштейна: “Все должно быть максимально простым, но не упрощаться”. Итак, позвольте мне показать вам фреймворк, которым легко пользоваться и который легко понять.
OpenAI использует подход, существенно отличающийся от подхода других разработчиков фреймворков: они не пытаются быть умными, они стараются быть понятными.
В этой статье я покажу, как можно создавать мультиагентные приложения, используя SDK OpenAI с открытым исходным кодом.
Мы увидим, как создать простое одноагентное приложение, а затем перейдем к изучению многоагентных конфигураций. Мы рассмотрим использование инструментов, линейные и иерархические конфигурации, передачу функций от одного агента к другому и использование агентов в качестве инструментов.
В частности, мы рассмотрим следующие примеры:
- Простой вызов агента
- Агента, использующего инструментарий
- Передача от одного агента к другому
- Передача нескольким агентам
- Использование агентов в качестве инструментов
- Иерархическая организация агентов с использованием агентов в качестве инструментов
Пакет SDK agent
Agent SDK основан на нескольких концепциях, необходимых для агентных и мультиагентных систем, и создает вокруг них основу - он заменяет Swarm, образовательную платформу, разработанную OpenAI, в которой эти концепции были определены и внедрены. Пакет Agent SDK основан на Swarm и расширяет его возможности, сохраняя при этом его основополагающие принципы легкости и простоты.
Это может показаться простым, но с помощью этой платформы вы можете создавать сложные системы на основе агентов, в которых агенты используют инструменты (которые могут быть другими агентами), передают их другим агентам и могут быть организованы любым количеством хитроумных способов.
Установка осуществляется с помощью pip или вашего предпочтительного инструмента управления пакетами, и пакет называется openai-agents. Я предпочитаю UV, поэтому, чтобы начать новый проект, я бы сделал что-то вроде следующего.
uv init agentTest cd agentTest uv add openai-agents
Простой вызов агента
Простой вызов агента показан на диаграмме ниже.
Простой агент
Это схема потока данных, которая показывает запущенный агент как процесс, в котором данные поступают и выводятся. Поток, который запускает процесс, - это запрос пользователя; агент выполняет один или несколько вызовов LLM и получает ответы. Когда он выполняет свою задачу, он выводит ответ агента.
Ниже мы видим код базовой программы, которая использует SDK для реализации этого процесса. Она создает экземпляр агента, присваивает ему имя и некоторые инструкции; затем запускает его и выводит результат. Это похоже на первый пример из документации OpenAI, но здесь мы создадим приложение Streamlit.
Сначала мы импортируем библиотеки.
import streamlit as st import asyncio from agents import Agent, Runner
Конечно, нам нужен пакет Streamlit и asyncio, потому что мы будем использовать его функциональность для ожидания завершения работы агента, прежде чем продолжить. Далее мы импортируем минимум из пакета agents, Agent (для создания агента) и Runner (для запуска агента).
Ниже мы определяем код для создания и запуска агента.
agent = Agent(name="Assistant", instructions="You are a helpful assistant")
async def run_agent(input_string):
result = await Runner.run(agent, input_string)
return result.final_output
В этом коде используется модель OpenAI по умолчанию (и предполагается, что у вас есть действительный ключ API, заданный в качестве переменной среды), и, конечно, с вас будет взиматься плата, но для наших целей это будет немного. Я потратил на это всего несколько десятков центов).
Сначала мы создаем экземпляр агента под названием “Assistant” с помощью нескольких простых инструкций, затем мы определяем асинхронную функцию, которая будет запускать его со строкой (запросом), предоставленной пользователем.
Функция запуска асинхронна; нам нужно дождаться завершения LLM, прежде чем мы продолжим, и поэтому мы запустим функцию с помощью asyncio.
Мы определяем пользовательский интерфейс с помощью функций Streamlit.
st.title("Simple Agent SDK Query")
user_input = st.text_input("Enter a query and press 'Send':")
st.write("Response:")
response_container = st.container(height=300, border=True)
if st.button("Send"):
response = asyncio.run(run_agent(user_input))
with response_container:
st.markdown(response)
В основном это не требует пояснений. Пользователю предлагается ввести запрос и нажать кнопку "Отправить". При нажатии кнопки запускается run_agent через вызов asyncio.run. Результат отображается в прокручиваемом контейнере. Ниже приведен скриншот примера запуска.
Ваш результат может отличаться (магистранты известны тем, что не дают один и тот же ответ дважды).
Чтобы определить агент, задайте ему имя и некоторые инструкции. Запуск также прост: введите агент и запрос. Запуск агента запускает цикл, который завершается при получении окончательного ответа. Этот пример прост, и его не нужно выполнять в цикле более одного раза, но агенту, вызывающему инструменты, может потребоваться выполнить несколько итераций, прежде чем ответ будет получен окончательно.
Результат легко отображается. Как мы видим, это атрибут final_output значения, возвращаемого программой Runner.
Эта программа использует значения по умолчанию для нескольких параметров, которые можно задать вручную, таких как название модели и настройка температуры для LLM. Agent SDK также использует API ответов по умолчанию. Это API только для OpenAI (по крайней мере, пока), поэтому, если вам нужно использовать SDK с другим LLM, вам нужно переключиться на более широко поддерживаемый API завершения чата.
from agents import set_default_openai_api
set_default_openai_api("chat_completions")
Изначально, для простоты, мы будем использовать API ответов по умолчанию.
Агент, использующий инструменты
Агенты могут использовать инструменты, и агент совместно с LLM решает, какие инструменты, если таковые имеются, ему необходимо использовать.
Вот схема потока данных, на которой показан агент, использующий инструменты.
Агент, использующий инструмент
Он похож на простой агент, но мы можем видеть дополнительный процесс, инструмент, который использует агент. Когда агент обратится к LLM, в ответе будет указано, нужно ли использовать инструмент. Если это так, агент выполнит этот вызов и отправит результат обратно в LLM. Опять же, ответ от LLM укажет, необходим ли другой вызов инструмента. Агент продолжит этот цикл до тех пор, пока LLM больше не будет требовать ввода данных от инструмента. На этом этапе агент может ответить пользователю.
Ниже приведен код для одного агента, использующего один инструмент.
Программа состоит из четырех частей:
- Импорт из библиотеки агентов и Википедии (которая будет использоваться в качестве инструмента).
- Определение инструмента — это просто функция с помощью декоратора @function_tool.
- Определение агента, который использует этот инструмент.
- Запуск агента и печать результата в приложении Streamlit, как и раньше.
import streamlit as st
import asyncio
from agents import Agent, Runner, function_tool
import wikipedia
@function_tool
def wikipedia_lookup(q: str) -> str:
"""Look up a query in Wikipedia and return the result"""
return wikipedia.page(q).summary
research_agent = Agent(
name="Research agent",
instructions="""You research topics using Wikipedia and report on
the results. """,
model="o4-mini",
tools=[wikipedia_lookup],
)
async def run_agent(input_string):
result = await Runner.run(research_agent, input_string)
return result.final_output
# Streamlit UI
st.title("Simple Tool-using Agent")
st.write("This agent uses Wikipedia to look up information.")
user_input = st.text_input("Enter a query and press 'Send':")
st.write("Response:")
response_container = st.container(height=300, border=True)
if st.button("Send"):
response = asyncio.run(run_agent(user_input))
with response_container:
st.markdown(response)
Инструмент просматривает страницу в Википедии и возвращает краткое описание с помощью стандартного вызова библиотечной функции. Обратите внимание, что мы использовали подсказки по типу и строку документации для описания функции, чтобы агент мог разобраться, как ее использовать.
Далее следует определение агента, и здесь мы видим, что параметров больше, чем раньше: мы указываем модель, которую хотим использовать, и список инструментов (в этом списке только один).
При запуске и печати результат остается прежним, и программа послушно возвращает ответ (высота Эйфелевой башни).
Это простая проверка агента, использующего инструмент, для которой требуется всего один поиск. В более сложном запросе инструмент может использоваться для сбора информации более одного раза.
Например, я попросил: “Найдите название знаменитой башни в Париже, найдите ее высоту, а затем найдите дату рождения ее создателя“. Для этого потребовалось два вызова инструмента: один - чтобы получить информацию об Эйфелевой башне, а второй - чтобы узнать, когда родился Густав Эйфель.
Этот процесс не отражен в окончательном выводе, но мы можем увидеть этапы, через которые прошел агент, просмотрев необработанные сообщения в результатах работы агента. Я напечатал result.raw_messages для запроса, приведенного выше, и результат показан ниже.
[
0:"ModelResponse(output=[ResponseReasoningItem(id='rs_6849968a438081a2b2fda44aa5bc775e073e3026529570c1', summary=[], type='reasoning', status=None),
ResponseFunctionToolCall(arguments='{"q":"Eiffel Tower"}', call_id='call_w1iL6fHcVqbPFE1kAuCGPFok', name='wikipedia_lookup', type='function_call', id='fc_6849968c0c4481a29a1b6c0ad80fba54073e3026529570c1', status='completed')], usage=Usage(requests=1, input_tokens=111, output_tokens=214, total_tokens=325),
response_id='resp_68499689c60881a2af6411d137c13d82073e3026529570c1')"
1:"ModelResponse(output=[ResponseReasoningItem(id='rs_6849968e00ec81a280bf53dcd30842b1073e3026529570c1', summary=[], type='reasoning', status=None),
ResponseFunctionToolCall(arguments='{"q":"Gustave Eiffel"}', call_id='call_DfYTuEjjBMulsRNeCZaqvV8w', name='wikipedia_lookup', type='function_call', id='fc_6849968e74ac81a298dc17d8be4012a7073e3026529570c1', status='completed')], usage=Usage(requests=1, input_tokens=940, output_tokens=23, total_tokens=963),
response_id='resp_6849968d7c3081a2acd7b837cfee5672073e3026529570c1')"
2:"ModelResponse(output=[ResponseReasoningItem(id='rs_68499690e33c81a2b0bda68a99380840073e3026529570c1', summary=[], type='reasoning', status=None),
ResponseOutputMessage(id='msg_6849969221a081a28ede4c52ea34aa54073e3026529570c1', content=[ResponseOutputText(annotations=[], text='The famous tower in Paris is the Eiffel Tower. \n• Height: 330 metres (1,083 ft) tall \n• Creator: Alexandre Gustave Eiffel, born 15 December 1832', type='output_text')], role='assistant', status='completed', type='message')], usage=Usage(requests=1, input_tokens=1190, output_tokens=178, total_tokens=1368),
response_id='resp_6849968ff15481a292939a6eed683216073e3026529570c1')"
]
Вы можете видеть, что есть три ответа: первые два являются результатом двух вызовов инструмента, а последний - это конечный результат, который генерируется на основе информации, полученной в результате вызовов инструмента.
Вскоре мы снова увидим инструменты, когда будем использовать агентов в качестве инструментов, но сейчас мы рассмотрим, как мы можем использовать несколько взаимодействующих агентов.
Несколько агентов
Многим агентским приложениям требуется только один агент, и это уже далеко за рамки простого завершения чата, которое вы найдете в интерфейсах чата LLM, таких как ChatGPT. Агенты работают в цикле и могут использовать инструменты, что делает даже одного агента довольно мощным. Однако совместная работа нескольких агентов может привести к еще более сложному поведению.
В соответствии со своей простой философией OpenAI не пытается использовать абстракции оркестровки агентов, как некоторые другие фреймворки. Но, несмотря на свой простой дизайн, он поддерживает создание как простых, так и сложных конфигураций.
Сначала мы рассмотрим передачу управления, при которой один агент передает управление другому. После этого мы увидим, как агенты могут быть объединены иерархически.
Передача управления
Когда агент решает, что он выполнил свою задачу, и передает информацию другому агенту для дальнейшей работы, это называется передачей данных.
Существует два основных способа передачи данных: при агентской передаче вся история сообщений передается от одного агента другому. Это немного похоже на то, когда вы звоните в банк, но человек, с которым вы разговариваете в первый раз, не знает ваших конкретных обстоятельств и поэтому передает вас тому, кто знает. Разница в том, что в случае с ИИ-агентом у нового агента есть запись всего, что было сказано предыдущему.
Второй метод - программная передача управления. В этом случае другому агенту передается только необходимая информация, предоставленная одним агентом (с помощью обычных методов программирования).
Давайте сначала рассмотрим программную передачу данных.
Программная передача данных
Иногда новому агенту не обязательно знать всю историю транзакции; возможно, требуется только конечный результат. В этом случае вместо полной передачи обслуживания вы можете организовать программную передачу обслуживания, при которой второму агенту передаются только соответствующие данные.
Программная передача управления
На диаграмме показана общая программная передача управления между двумя агентами.
Ниже приведен пример такой функциональности, когда один агент находит информацию по теме, а другой использует эту информацию и пишет статью, подходящую для детей.
Чтобы упростить задачу, в этом примере мы не будем использовать наш инструмент Википедии; вместо этого мы полагаемся на знания магистра права.
import streamlit as st
import asyncio
from agents import Agent, Runner
writer_agent = Agent(
name="Writer agent",
instructions=f"""Re-write the article so that it is suitable for kids
aged around 8. Be enthusiastic about the topic -
everything is an adventure!""",
model="o4-mini",
)
researcher_agent = Agent(
name="Research agent",
instructions=f"""You research topics and report on the results.""",
model="o4-mini",
)
async def run_agent(input_string):
result = await Runner.run(researcher_agent, input_string)
result2 = await Runner.run(writer_agent, result.final_output)
return result2
# Streamlit UI
st.title("Writer Agent")
st.write("Write stuff for kids.")
user_input = st.text_input("Enter a query and press 'Send':")
st.write("Response:")
response_container = st.container(height=300, border=True)
if st.button("Send"):
response = asyncio.run(run_agent(user_input))
with response_container:
st.markdown(response.final_output)
st.write(response)
st.json(response.raw_responses)
В приведенном выше коде мы определяем два агента: один исследует тему, а другой создает текст, подходящий для детей.
Этот метод не основан на каких-либо специальных функциях SDK; он просто запускает один агент, получает выходные данные в result и использует их в качестве входных данных для следующего агента (вывод в result2). Это похоже на использование выходных данных одной функции в качестве входных данных для следующей в обычном программировании. На самом деле, именно так оно и есть.
Передача данных агентами
Однако иногда агенту необходимо знать историю того, что происходило ранее. Именно в этом и заключается функция передачи данных агентам OpenAI.
Ниже приведена схема потока данных, представляющая передачу данных агентами. Вы увидите, что это очень похоже на программную передачу данных; разница заключается в том, что данные передаются второму агенту, а также в том, что возможен вывод от первого агента, когда передача данных не требуется.
Передача данных с помощью агента
Код также аналогичен предыдущему примеру. Я немного изменил инструкции, но главное отличие заключается в списке передачах в researcher_agent. Это не отличается от того, как мы декларируем инструменты.
Агенту по исследованиям было разрешено передать материалы агенту по работе с детьми, когда он завершит свою работу. В результате агент детского писателя не только берет на себя управление обработкой, но и знает о том, что сделал Исследователь, а также о первоначальной подсказке.
Однако есть еще одно существенное отличие. Агент сам решает, состоится передача или нет. В приведенном ниже примере я поручил агенту написать что-нибудь подходящее для детей, и поэтому это поручено агенту по детскому творчеству. Если бы я не приказал ему это сделать, он бы просто вернул исходный текст.
import streamlit as st
import asyncio
from agents import Agent, Runner
kids_writer_agent = Agent(
name="Kids Writer Agent",
instructions=f"""Re-write the article so that it is suitable for kids aged around 8.
Be enthusiastic about the topic - everything is an adventure!""",
model="o4-mini",
)
researcher_agent = Agent(
name="Research agent",
instructions=f"""Answer the query and report the results.""",
model="o4-mini",
handoffs = [kids_writer_agent]
)
async def run_agent(input_string):
result = await Runner.run(researcher_agent, input_string)
return result
# Streamlit UI
st.title("Writer Agent2")
st.write("Write stuff for kids.")
user_input = st.text_input("Enter a query and press 'Send':")
st.write("Response:")
response_container = st.container(height=300, border=True)
if st.button("Send"):
response = asyncio.run(run_agent(user_input))
with response_container:
st.markdown(response.final_output)
st.write(response)
st.json(response.raw_responses)
Этого нет на скриншоте, но я добавил код для вывода ответа и raw_responses, чтобы вы могли увидеть передачу в действии, если запустите код самостоятельно.
Ниже приведен скриншот этого агента.
В распоряжении агента может быть список вариантов передачи, и он самостоятельно выберет правильного агента (или ни одного) для передачи. Вы можете увидеть, как это может быть полезно в ситуации с обслуживанием клиентов, когда сложный запрос клиента может быть передан нескольким более опытным агентам, каждый из которых должен знать историю запросов.
Теперь мы рассмотрим, как мы можем использовать передачу обслуживания, в которой задействовано несколько агентов.
Передача материалов нескольким агентам
Теперь мы увидим новую версию предыдущей программы, в которой исследовательский агент сам выбирает, кому передавать материалы, в зависимости от возраста читателя.
Задача агента - подготовить текст для трех аудиторий: взрослых, подростков и детей. Исследовательский агент соберет информацию и затем передаст ее одному из трех других агентов. Вот поток данных (обратите внимание, что я исключил ссылки на LLM для наглядности – каждый агент взаимодействует с LLM, но мы можем рассматривать это как внутреннюю функцию агента).
Передача управления нескольким агентам
А вот и код.
import streamlit as st
import asyncio
from agents import Agent, Runner, handoff
adult_writer_agent = Agent(
name="Adult Writer Agent",
instructions=f"""Write the article based on the information given that it is suitable for adults interested in culture.
""",
model="o4-mini",
)
teen_writer_agent = Agent(
name="Teen Writer Agent",
instructions=f"""Write the article based on the information given that it is suitable for teenagers who want to have a cool time.
""",
model="o4-mini",
)
kid_writer_agent = Agent(
name="Kid Writer Agent",
instructions=f"""Write the article based on the information given that it is suitable for kids of around 8 years old.
Be enthusiastic!
""",
model="o4-mini",
)
researcher_agent = Agent(
name="Research agent",
instructions=f"""Find information on the topic(s) given.""",
model="o4-mini",
handoffs = [kid_writer_agent, teen_writer_agent, adult_writer_agent]
)
async def run_agent(input_string):
result = await Runner.run(researcher_agent, input_string)
return result
# Streamlit UI
st.title("Writer Agent3")
st.write("Write stuff for adults, teenagers or kids.")
user_input = st.text_input("Enter a query and press 'Send':")
st.write("Response:")
response_container = st.container(height=300, border=True)
if st.button("Send"):
response = asyncio.run(run_agent(user_input))
with response_container:
st.markdown(response.final_output)
st.write(response)
st.json(response.raw_responses)
Структура программы аналогична, но теперь у нас есть набор агентов для передачи и их список в исследовательском агенте. Инструкции в различных программах понятны, и программа правильно отреагирует на запрос типа “Напишите эссе о Париже, Франция, для детей”, “...для подростков” или “...для взрослых”. Исследовательский агент правильно выберет подходящего для выполнения задания автора.
На скриншоте ниже показан пример написания текста для подростков.
Подсказки, приведенные в этом примере, просты. Более сложные подсказки, вероятно, дали бы лучший и более последовательный результат, но цель здесь - показать методы, а не создать умное приложение.
Это один из видов совместной работы; другой - использование других агентов в качестве инструментов. Это не слишком отличается от программной передачи управления, которую мы видели ранее.
Агенты как инструменты
Запуск агента - это вызов функции таким же образом, как и вызов инструмента. Так почему бы не использовать агенты в качестве интеллектуальных инструментов?
Вместо того чтобы передавать управление новому агенту, мы используем его как функцию, которой передаем информацию и от которой получаем информацию обратно.
Ниже приведена схема потока данных, иллюстрирующая идею. В отличие от передачи управления, главный агент не передает общее управление другому агенту; вместо этого он разумно выбирает вызов агента, как если бы это был инструмент. Вызываемый агент выполняет свою работу, а затем передает управление обратно вызывающему агенту. Опять же, потоки данных в LLM были опущены для наглядности.
Ниже приведен скриншот модифицированной версии предыдущей программы. Мы немного изменили характер приложения. Главный агент теперь является турагентом; он ожидает, что пользователь укажет ему пункт назначения и возрастную группу, для которой он должен ввести данные. Пользовательский интерфейс изменен таким образом, что возрастная группа выбирается с помощью переключателя. В поле ввода текста должен быть пункт назначения.
В логику приложения был внесен ряд изменений. Пользовательский интерфейс изменяет способ ввода информации, и это отражается на способе создания приглашения – мы используем f-строку для объединения двух фрагментов данных в приглашении.
Кроме того, теперь у нас есть дополнительный агент, который форматирует текст. Другие агенты аналогичны (но обратите внимание, что подсказки были доработаны), и мы также используем структурированный вывод, чтобы гарантировать, что выводимый текст будет именно таким, как мы ожидаем.
Однако, по сути, мы видим, что агенты записи и форматирования указаны в качестве инструментов в агенте researcher.
import streamlit as st
import asyncio
from agents import Agent, Runner, function_tool
from pydantic import BaseModel
class PRArticle(BaseModel):
article_text: str
commentary: str
adult_writer_agent = Agent(
name="Adult Writer Agent",
instructions="""Write the article based on the information given that it is suitable for adults interested in culture.
Be mature.""",
model="gpt-4o",
)
teen_writer_agent = Agent(
name="Teen Writer Agent",
instructions="""Write the article based on the information given that it is suitable for teenagers who want to have a good time.
Be cool!""",
model="gpt-4o",
)
kid_writer_agent = Agent(
name="Kid Writer Agent",
instructions="""Write the article based on the information given that it is suitable for kids of around 8 years old.
Be enthusiastic!""",
model="gpt-4o",
)
format_agent = Agent(
name="Format Agent",
instructions=f"""Edit the article to add a title and subtitles and ensure the text is formatted as Markdown. Return only the text of article.""",
model="gpt-4o",
)
researcher_agent = Agent(
name="Research agent",
instructions="""You are a Travel Agent who will find useful information for your customers of all ages.
Find information on the destination(s) given.
When you have a result send it to the appropriate writer agent to produce a short PR text.
When you have the result send it to the Format agent for final processing.
""",
model="gpt-4o",
tools = [kid_writer_agent.as_tool(
tool_name="kids_article_writer",
tool_description="Write an essay for kids",),
teen_writer_agent.as_tool(
tool_name="teen_article_writer",
tool_description="Write an essay for teens",),
adult_writer_agent.as_tool(
tool_name="adult_article_writer",
tool_description="Write an essay for adults",),
format_agent.as_tool(
tool_name="format_article",
tool_description="Add titles and subtitles and format as Markdown",
),],
output_type = PRArticle
)
async def run_agent(input_string):
result = await Runner.run(researcher_agent, input_string)
return result
# Streamlit UI
st.title("Travel Agent")
st.write("The travel agent will write about destinations for different audiences.")
destination = st.text_input("Enter a destination, select the age group and press 'Send':")
age_group = st.radio(
"What age group is the reader?",
["Adult", "Teenager", "Child"],
horizontal=True,
)
st.write("Response:")
response_container = st.container(height=500, border=True)
if st.button("Send"):
response = asyncio.run(run_agent(f"The destination is {destination} and reader the age group is {age_group}"))
with response_container:
st.markdown(response.final_output.article_text)
st.write(response)
st.json(response.raw_responses)
Список инструментов немного отличается от того, который мы видели ранее:
- Название инструмента совпадает с именем агента плюс .agent_as_tool() - метод, который делает агент совместимым с другими инструментами.
- Инструменту требуется несколько параметров — имя и описание.
Еще одним очень полезным дополнением является использование структурированных выходных данных, как упоминалось выше. Это отделяет нужный нам текст от любых других комментариев, которые может захотеть вставить LLM. Если вы запустите код, вы сможете увидеть в raw_responses дополнительную информацию, которую генерирует LLM.
Использование структурированных выходных данных помогает получать согласованные результаты и решает проблему, которая меня особенно беспокоит.
Я попросил обработать выходные данные с помощью агента форматирования, который будет структурировать результат как Markdown. Это зависит от LLM, от подсказки, и кто знает, может быть, это зависит от времени суток или погоды, но всякий раз, когда мне кажется, что я все правильно понял, LLM внезапно вставляет Markdown fencing. Итак, вместо чистого:
## This is a header This is some text Вместо этого я получаю: Here is your text formatted as Markdown: ''' Markdown # This is a header This is some text '''
Бесит!
В любом случае, ответ, похоже, заключается в использовании структурированных выходных данных. Если вы попросите его отформатировать ответ в виде текста того, что вы хотите, плюс второе поле под названием "комментарий" или что-то в этом роде, то, похоже, он поступит правильно. Любой посторонний материал, который LLM решит выложить, попадает во второе поле, а чистая уценка - в текстовое поле.
Хорошо, Шекспир, это не так: изменение инструкций, чтобы они были более подробными, могло бы дать лучшие результаты (текущие подсказки очень просты). Но это работает достаточно хорошо, чтобы проиллюстрировать метод.
Вывод
Это лишь малая часть возможностей OpenAI Agents SDK. Спасибо за прочтение, и я надеюсь, что вы нашли это полезным. Мы рассмотрели, как создавать агенты и как комбинировать их различными способами, а также очень кратко рассмотрели структурированные выходные данные.
Примеры, конечно, просты, но я надеюсь, что они иллюстрируют простой способ управления агентами, не прибегая к сложным абстракциям и громоздким фреймворкам.
В приведенном здесь коде используется Response API, поскольку он используется по умолчанию. Однако он должен работать таким же образом и с API завершений. Это означает, что вы не ограничены ChatGPT, и, если немного поднапрячься, этот SDK можно использовать с любым LLM, который поддерживает OpenAI Completions API.
