OpenAI Agents SDK: uma estrutura Python para criar fluxos de trabalho colaborativos de inteligência múltipla

Introdução geral

O OpenAI Agents SDK é uma ferramenta de desenvolvimento leve da OpenAI, projetada para criar fluxos de trabalho multiinteligentes. Baseado em Python, é fácil começar a usá-lo e permite que os desenvolvedores automatizem tarefas complexas configurando Agents, Handoffs, Guardrails e Tracing. Por exemplo, você pode usá-lo para criar um assistente que escreve código ou um sistema inteligente que lida com interações multilíngues. O destaque é sua compatibilidade e flexibilidade com todos os provedores de modelos que suportam o formato da API de conclusões de bate-papo da OpenAI. A documentação detalhada e o código de amostra são fornecidos oficialmente para que os desenvolvedores de todos os níveis possam começar a trabalhar rapidamente.

Lista de funções

• Personalização inteligente da carroceriaDefinição de comandos, ferramentas e restrições para modelos de linguagem para criar assistentes inteligentes exclusivos.
• Troca de tarefasSuporte à alternância contínua de tarefas entre inteligências, como passar do assistente em inglês para o assistente em espanhol.
• certificação de segurançaVerificações integradas de entrada e saída garantem resultados seguros e confiáveis.
• Rastreamento operacionalRegistro automático do processo de operação do corpo inteligente para facilitar a depuração e a otimização.
• Extensão da ferramentaPermite a adição de ferramentas personalizadas, como verificar o clima ou lidar com tarefas específicas.
• compatibilidade de modelosProvedores de modelos múltiplos são suportados, desde que estejam em conformidade com o formato da API OpenAI.

Usando a Ajuda

Processo de instalação

Para usar o SDK do OpenAI Agents, primeiro você precisa criar um ambiente Python. Aqui estão as etapas:

1. Criação de um ambiente virtual
   Crie um ambiente Python separado para evitar conflitos com outros projetos, digitando o seguinte comando no terminal:

python -m venv env

Em seguida, ative o ambiente:

• Windows:env\Scripts\activate
• Sistemas Mac/Linux:fonte env/bin/activate

2. Instalação do SDK
   Depois de ativar o ambiente, execute o seguinte comando para instalar o SDK:

pip install openai-agents

3. Configuração de chaves de API
   Antes de executar o código, você precisa definir a chave da API da OpenAI. Digite-a no terminal:

export OPENAI_API_KEY='Sua chave'

Ou carregue-a no código por meio de uma variável de ambiente. Tome cuidado para proteger a chave.

Depois de concluir as etapas acima, você estará pronto para começar a usar a ferramenta.

Como usar

No centro do SDK do OpenAI Agents estão Agente responder cantando Corredor Classe.Agente usado para definir o comportamento das inteligências.Corredor Responsável pela execução e pelo retorno dos resultados. A seguir, há uma descrição detalhada da operação das principais funções.

1. criação de um assistente inteligente básico

Quer começar rapidamente? Experimente este exemplo simples de um corpo inteligente escrevendo um haicai sobre programação:

from agents import Agent, Runner
agent = Agent(name="Assistant", instructions="You are a helpful assistant")
result = Runner.run_sync(agent, "Write a haiku about recursion in programming.")
print(result.final_output)

procedimento::

• Crie uma inteligência, defina o nome e as instruções.
• despesa ou gasto Executador.run_sync Sincronize a execução e insira os requisitos da tarefa.
• Sua execução produzirá algo como: "Código em código, função chama a si mesma, dança do loop infinito".

2. ativação da alternância de tarefas

A alternância de tarefas é um recurso do SDK que permite a colaboração de várias inteligências. Por exemplo, lidar com solicitações em vários idiomas:

from agents import Agent, Runner
import asyncio
spanish_agent = Agent(name="Agente espanhol", instructions="You only falar espanhol.")
english_agent = Agent(name="Agente inglês", instructions="Você só fala inglês.")
triage_agent = Agente(
name="Agente de triagem", instruções="Transferência para o agente apropriado com base no idioma.
name="Triage agent", instructions="Handoff to the appropriate agent based on the language of the request.", handoffs=[spanish_agent], instructions="You only speak English.")
instructions="Handoff to the appropriate agent based on the language of the request.", handoffs=[spanish_agent, english_agent], )
)
async def main(): result = await Runner.run()
result = await Runner.run(triage_agent, input="Hola, ¿cómo estás?")
print(result.final_output)
se __name__ == "__main__".
asyncio.run(main())

procedimento::

• Definir inteligências múltiplas, cada uma com instruções específicas.
• Criar a inteligência primária (agente_triagem) e especificar inteligências comutáveis.
• despesa ou gasto Runner.run Executando de forma assíncrona e inserindo problemas em espanhol.
• O corpo inteligente principal mudará de acordo com o idioma espanhol_agente, retornando algo como: "¡Hola! Estoy bien, gracias por preguntar. ¿Y tú, cómo estás?"

3. adição de ferramentas personalizadas

Você pode usar o ferramenta_funcional Defina ferramentas que permitam que as inteligências chamem funções externas. Por exemplo, verificar o clima:

from agents import Agent, Runner, function_tool
@function_tool
def get_weather(city: str) -> str:
return f"The weather in {city} is sunny."
agent = Agent(
name="Weather agent",
instructions="You are a helpful agent.",
tools=[get_weather],
)
async def main():
result = await Runner.run(agent, input="What's the weather in Tokyo?")
print(result.final_output)
if __name__ == "__main__":
asyncio.run(main())

procedimento::

• Defina uma função com @função_ferramenta Decoração.
• Acrescentar ferramentas a um corpo inteligente ferramentas Parâmetros.
• Após a execução, a Sociedade Inteligente chama a ferramenta e retorna: "O tempo em Tóquio está ensolarado".

4. uso do runtracking

O SDK tem um recurso de rastreamento integrado que registra os detalhes das ações do smartbody a cada execução. Você pode saber mais sobre a operação do smartbody usando a função resultado Objetos para visualizar processos em execução ou para integração com ferramentas externas (por exemplo, Logfire) para análise. Funciona por padrão, sem configurações adicionais.

5) Configuração da autenticação de segurança

A validação de segurança (Guardrails) pode verificar entradas e saídas. Por exemplo, impedir que um usuário peça a um corpo inteligente que faça a lição de casa de matemática:

from agents import Agent, Runner, input_guardrail
from pydantic import BaseModel
class MathCheck(BaseModel).
is_math_homework: bool
reasoning: str
guardrail_agent = Agent(
name="Verificação de trilhos de proteção",
instructions="Verifique se o usuário está pedindo para você fazer o dever de casa de matemática",
output_type=MathCheck.
)
@input_guardrail
async def math_guardrail(ctx, agent, input): result = await Runner.run(runner.check, )
result = await Runner.run(guardrail_agent, input)
return GuardrailFunctionOutput(
output_info=result.final_output,
tripwire_triggered=result.final_output.is_math_homework, )
)
agente = Agente(
nome="Agente de suporte",
instruções="Ajude os clientes com suas dúvidas.",
input_guardrails=[math_guardrail], )
)
async def main():: async def
async def main(): try.
await Runner.run(agent, "Can you solve 2x + 3 = 11?")
except Exception as e: print("O Guardrail interrompeu a
print("O Guardrail interrompeu a solicitação")

procedimento::

• Defina uma inteligência de proteção que verifique a entrada.
• despesa ou gasto @input_guardrail Criar funções de proteção.
• Adicione os guardas à inteligência principal. A execução é interrompida se a entrada envolver trabalho matemático.

Detalhes do processo de operação

• circulação inteligente: Chamada Runner.run() Quando você faz isso, o SDK executa as seguintes etapas:
  1. Chame o modelo de linguagem para gerar uma resposta.
  2. Verifique se há chamadas de ferramentas ou trocas de tarefas.
  3. Execute a chamada da ferramenta e registre os resultados.
  4. Se houver uma troca de tarefas, passe para o novo corpo inteligente.
  5. Loop até que a saída final seja gerada, ou até que o voltas máximas Boné.
• Tipo de saídaSe você definir o tipo de saídaa inteligência gerará uma saída estruturada do tipo especificado; caso contrário, a resposta à primeira chamada ou chave sem ferramentas será a saída final.

Recomendações de uso

• ajustar os componentes durante o testeVisualização de cada etapa em detalhes com o recurso de rastreamento para identificar rapidamente os problemas.
• otimizaçãoConfiguração de acordo com as necessidades da missão voltas máximasEvite andar muito de bicicleta.
• extensõesReferência a documentos oficiais exemplos para explorar mais usos.

Documentação oficial: https://openai.github.io/openai-agents-python/