Partilhar via

Introdução aos Assistentes OpenAI do Azure (Pré-visualização)

  • Artigo

O Azure OpenAI Assistants (Pré-visualização) permite-lhe criar assistentes de IA adaptados às suas necessidades através de instruções personalizadas e aumentadas por ferramentas avançadas, como um interpretador de código e funções personalizadas. Neste artigo, fornecemos um passo a passo detalhado sobre como começar a usar a API de assistentes.

Nota

  • A pesquisa de arquivos pode ingerir até 10.000 arquivos por assistente - 500 vezes mais do que antes. É rápido, suporta consultas paralelas através de pesquisas multi-threaded e apresenta reclassificação e reescrita de consultas melhoradas.
    • O repositório vetorial é um novo objeto na API. Depois que um arquivo é adicionado a um repositório vetorial, ele é automaticamente analisado, fragmentado e incorporado, pronto para ser pesquisado. Os repositórios vetoriais podem ser usados entre assistentes e threads, simplificando o gerenciamento de arquivos e o faturamento.
  • Adicionamos suporte para o tool_choice parâmetro que pode ser usado para forçar o uso de uma ferramenta específica (como pesquisa de arquivos, interpretador de código ou uma função) em uma execução específica.

Apoio aos assistentes

Suporte a regiões e modelos

O interpretador de código está disponível em todas as regiões suportadas pelos Assistentes OpenAI do Azure. A página de modelos contém as informações mais atualizadas sobre regiões/modelos onde os Assistentes são atualmente suportados.

Versões da API

  • 2024-02-15-preview
  • 2024-05-01-preview

Tipos de ficheiro suportados

File format Tipo de MIME Intérprete de código
c. texto/x-c ✅
.cpp texto/x-c++ ✅
.csv aplicação/csv ✅
.docx aplicativo/vnd.openxmlformats-officedocument.wordprocessingml.document ✅
.html text/html ✅
.java texto/x-java ✅
.json application/json ✅
.md texto/marcação ✅
.pdf aplicação/pdf ✅
.php texto/x-php ✅
.pptx application/vnd.openxmlformats-officedocument.presentationml.presentation ✅
.py texto/x-python ✅
.py texto/x-script.python ✅
.rb texto/x-rubi ✅
.tex texto/x-tex ✅
.txt text/plain ✅
.css texto/css ✅
.jpeg image/jpeg ✅
.jpg image/jpeg ✅
.js texto/javascript ✅
.gif imagem/gif ✅
.png image/png ✅
.tar aplicação/x-tar ✅
.ts aplicação/typescript ✅
.xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet ✅
.xml application/xml ou "texto/xml" ✅
.zip aplicação/zip ✅

Ferramentas

Gorjeta

Adicionamos suporte para o tool_choice parâmetro que pode ser usado para forçar o uso de uma ferramenta específica (como file_search, code_interpreter, ou a function) em uma execução específica.

Um assistente individual pode aceder a até 128 ferramentas, incluindo interpretador de código e pesquisa de ficheiros, mas também pode definir as suas próprias ferramentas personalizadas através de funções.

Ficheiros

Os arquivos podem ser carregados via Studio ou programaticamente. O file_ids parâmetro é necessário para dar a ferramentas como code_interpreter acesso a arquivos. Ao usar o ponto de extremidade de carregamento de arquivo, você deve ter a purpose configuração para assistentes a serem usados com a API de assistentes.

Assistentes de playground

Fornecemos um passo a passo do playground dos assistentes em nosso guia de início rápido. Isso fornece um ambiente sem código para testar os recursos dos assistentes.

Componentes dos assistentes

Componente Descrição
Assistente IA personalizada que usa modelos OpenAI do Azure em conjunto com ferramentas.
Tópico Uma sessão de conversação entre um Assistente e um utilizador. Os threads armazenam mensagens e manipulam automaticamente o truncamento para ajustar o conteúdo ao contexto de um modelo.
Mensagem Uma mensagem criada por um Assistente ou um utilizador. As mensagens podem incluir texto, imagens e outros ficheiros. As mensagens são armazenadas como uma lista no Thread.
Executar Ativação de um Assistente para começar a ser executado com base no conteúdo do Thread. O Assistente usa sua configuração e as Mensagens do Thread para executar tarefas chamando modelos e ferramentas. Como parte de uma Execução, o Assistente acrescenta Mensagens ao Thread.
Etapa de execução Uma lista detalhada das etapas que o Assistente tomou como parte de uma Corrida. Um Assistente pode chamar ferramentas ou criar Mensagens durante a sua execução. Examinar as etapas de execução permite que você entenda como o Assistente está chegando aos resultados finais.

Configurar o seu primeiro Assistente

Criar um assistente

Para este exemplo, criaremos um assistente que escreve código para gerar visualizações usando os recursos da code_interpreter ferramenta. Os exemplos abaixo destinam-se a ser executados sequencialmente em um ambiente como o Jupyter Notebooks.

import os
import json
from openai import AzureOpenAI
    
client = AzureOpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
    api_version="2024-05-01-preview",
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    )

# Create an assistant
assistant = client.beta.assistants.create(
    name="Data Visualization",
    instructions=f"You are a helpful AI assistant who makes interesting visualizations based on data." 
    f"You have access to a sandboxed environment for writing and testing code."
    f"When you are asked to create a visualization you should follow these steps:"
    f"1. Write the code."
    f"2. Anytime you write new code display a preview of the code to show your work."
    f"3. Run the code to confirm that it runs."
    f"4. If the code is successful display the visualization."
    f"5. If the code is unsuccessful display the error message and try to revise the code and rerun going through the steps from above again.",
    tools=[{"type": "code_interpreter"}],
    model="gpt-4-1106-preview" #You must replace this value with the deployment name for your model.
)

Há alguns detalhes que você deve observar na configuração acima:

  • Habilitamos este assistente para acessar o interpretador de código com a linha tools=[{"type": "code_interpreter"}],. Isso dá ao modelo acesso a um ambiente python em área restrita para executar e executar código para ajudar a formular respostas à pergunta de um usuário.
  • Nas instruções, lembramos ao modelo que ele pode executar código. Às vezes, o modelo precisa de ajuda para guiá-lo para a ferramenta certa para resolver uma determinada consulta. Se você sabe que deseja usar uma biblioteca específica para gerar uma determinada resposta que você sabe que faz parte do interpretador de código, isso pode ajudar a fornecer orientação dizendo algo como "Use Matplotlib para fazer x".
  • Como este é o Azure OpenAI, o valor inserido deve model=corresponder ao nome da implantação.

Em seguida, vamos imprimir o conteúdo do assistente que acabamos de criar para confirmar que a criação foi bem-sucedida:

print(assistant.model_dump_json(indent=2))

{
  "id": "asst_7AZSrv5I3XzjUqWS40X5UgRr",
  "created_at": 1705972454,
  "description": null,
  "file_ids": [],
  "instructions": "You are a helpful AI assistant who makes interesting visualizations based on data.You have access to a sandboxed environment for writing and testing code.When you are asked to create a visualization you should follow these steps:1. Write the code.2. Anytime you write new code display a preview of the code to show your work.3. Run the code to confirm that it runs.4. If the code is successful display the visualization.5. If the code is unsuccessful display the error message and try to revise the code and rerun going through the steps from above again.",
  "metadata": {},
  "model": "gpt-4-1106-preview",
  "name": "Data Visualization",
  "object": "assistant",
  "tools": [
    {
      "type": "code_interpreter"
    }
  ]
}

Criar um thread

Agora vamos criar um tópico.

# Create a thread
thread = client.beta.threads.create()
print(thread)

Thread(id='thread_6bunpoBRZwNhovwzYo7fhNVd', created_at=1705972465, metadata={}, object='thread')

Um thread é essencialmente o registro da sessão de conversa entre o assistente e o usuário. É semelhante à matriz/lista de mensagens em uma chamada típica de API de conclusão de chat. Uma das principais diferenças é que, ao contrário de uma matriz de mensagens de conclusão de chat, você não precisa rastrear tokens a cada chamada para ter certeza de que está permanecendo abaixo do comprimento de contexto do modelo. Os threads abstraem esse detalhe de gerenciamento e compactam o histórico de threads conforme necessário para permitir que a conversa continue. A capacidade dos threads de realizar isso com conversas maiores é aprimorada ao usar os modelos mais recentes, que têm maiores comprimentos de contexto e suporte para os recursos mais recentes.

Em seguida, crie a primeira pergunta do usuário para adicionar ao thread.

# Add a user question to the thread
message = client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="Create a visualization of a sinewave"
)

Listar mensagens de thread

thread_messages = client.beta.threads.messages.list(thread.id)
print(thread_messages.model_dump_json(indent=2))

{
  "data": [
    {
      "id": "msg_JnkmWPo805Ft8NQ0gZF6vA2W",
      "assistant_id": null,
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Create a visualization of a sinewave"
          },
          "type": "text"
        }
      ],
      "created_at": 1705972476,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "user",
      "run_id": null,
      "thread_id": "thread_6bunpoBRZwNhovwzYo7fhNVd"
    }
  ],
  "object": "list",
  "first_id": "msg_JnkmWPo805Ft8NQ0gZF6vA2W",
  "last_id": "msg_JnkmWPo805Ft8NQ0gZF6vA2W",
  "has_more": false
}

Executar thread

run = client.beta.threads.runs.create(
  thread_id=thread.id,
  assistant_id=assistant.id,
  #instructions="New instructions" #You can optionally provide new instructions but these will override the default instructions
)

Também poderíamos passar um instructions parâmetro aqui, mas isso substituiria as instruções existentes que já fornecemos para o assistente.

Recuperar status do thread

# Retrieve the status of the run
run = client.beta.threads.runs.retrieve(
  thread_id=thread.id,
  run_id=run.id
)

status = run.status
print(status)

completed

Dependendo da complexidade da consulta executada, o thread pode levar mais tempo para ser executado. Nesse caso, você pode criar um loop para monitorar o status de execução do thread com código como o exemplo abaixo:

import time
from IPython.display import clear_output

start_time = time.time()

status = run.status

while status not in ["completed", "cancelled", "expired", "failed"]:
    time.sleep(5)
    run = client.beta.threads.runs.retrieve(thread_id=thread.id,run_id=run.id)
    print("Elapsed time: {} minutes {} seconds".format(int((time.time() - start_time) // 60), int((time.time() - start_time) % 60)))
    status = run.status
    print(f'Status: {status}')
    clear_output(wait=True)

messages = client.beta.threads.messages.list(
  thread_id=thread.id
) 

print(f'Status: {status}')
print("Elapsed time: {} minutes {} seconds".format(int((time.time() - start_time) // 60), int((time.time() - start_time) % 60)))
print(messages.model_dump_json(indent=2))

Quando um Run é in_progress ou em outros estados não terminais, o thread é bloqueado. Quando um thread está bloqueado, novas mensagens não podem ser adicionadas e novas execuções não podem ser criadas.

Listar mensagens de thread pós-execução

Depois que o status de execução indicar a conclusão bem-sucedida, você poderá listar o conteúdo do thread novamente para recuperar a resposta do modelo e de quaisquer ferramentas:

messages = client.beta.threads.messages.list(
  thread_id=thread.id
)

print(messages.model_dump_json(indent=2))

{
  "data": [
    {
      "id": "msg_M5pz73YFsJPNBbWvtVs5ZY3U",
      "assistant_id": "asst_eHwhP4Xnad0bZdJrjHO2hfB4",
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Is there anything else you would like to visualize or any additional features you'd like to add to the sine wave plot?"
          },
          "type": "text"
        }
      ],
      "created_at": 1705967782,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "assistant",
      "run_id": "run_AGQHJrrfV3eM0eI9T3arKgYY",
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_oJbUanImBRpRran5HSa4Duy4",
      "assistant_id": "asst_eHwhP4Xnad0bZdJrjHO2hfB4",
      "content": [
        {
          "image_file": {
            "file_id": "assistant-1YGVTvNzc2JXajI5JU9F0HMD"
          },
          "type": "image_file"
        },
        {
          "text": {
            "annotations": [],
            "value": "Here is the visualization of a sine wave: \n\nThe wave is plotted using values from 0 to \\( 4\\pi \\) on the x-axis, and the corresponding sine values on the y-axis. I've also added grid lines for easier reading of the plot."
          },
          "type": "text"
        }
      ],
      "created_at": 1705967044,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "assistant",
      "run_id": "run_8PsweDFn6gftUd91H87K0Yts",
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_Pu3eHjM10XIBkwqh7IhnKKdG",
      "assistant_id": null,
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Create a visualization of a sinewave"
          },
          "type": "text"
        }
      ],
      "created_at": 1705966634,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "user",
      "run_id": null,
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    }
  ],
  "object": "list",
  "first_id": "msg_M5pz73YFsJPNBbWvtVs5ZY3U",
  "last_id": "msg_Pu3eHjM10XIBkwqh7IhnKKdG",
  "has_more": false
}

Recuperar ID do arquivo

Tínhamos solicitado que o modelo gerasse uma imagem de uma onda sinusal. Para baixar a imagem, primeiro precisamos recuperar o ID do arquivo de imagens.

data = json.loads(messages.model_dump_json(indent=2))  # Load JSON data into a Python object
image_file_id = data['data'][0]['content'][0]['image_file']['file_id']

print(image_file_id)  # Outputs: assistant-1YGVTvNzc2JXajI5JU9F0HMD

Transferir imagem

content = client.files.content(image_file_id)

image= content.write_to_file("sinewave.png")

Abra a imagem localmente depois de baixada:

from PIL import Image

# Display the image in the default image viewer
image = Image.open("sinewave.png")
image.show()

Captura de tela do interpretador de código gerado onda senodal.

Faça uma pergunta de acompanhamento no tópico

Como o assistente não seguiu nossas instruções e incluiu o código que foi executado na parte de texto de sua resposta, vamos pedir explicitamente essas informações.

# Add a new user question to the thread
message = client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="Show me the code you used to generate the sinewave"
)

Novamente, precisaremos executar e recuperar o status do thread:

run = client.beta.threads.runs.create(
  thread_id=thread.id,
  assistant_id=assistant.id,
  #instructions="New instructions" #You can optionally provide new instructions  but these will override the default instructions
)

# Retrieve the status of the run
run = client.beta.threads.runs.retrieve(
  thread_id=thread.id,
  run_id=run.id
)

status = run.status
print(status)


completed

Quando o status da execução chegar concluído, listaremos as mensagens no thread novamente, que agora devem incluir a resposta à nossa última pergunta.

messages = client.beta.threads.messages.list(
  thread_id=thread.id
)

print(messages.model_dump_json(indent=2))

{
  "data": [
    {
      "id": "msg_oaF1PUeozAvj3KrNnbKSy4LQ",
      "assistant_id": "asst_eHwhP4Xnad0bZdJrjHO2hfB4",
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Certainly, here is the code I used to generate the sine wave visualization:\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Generating data for the sinewave\nx = np.linspace(0, 4 * np.pi, 1000)  # Generate values from 0 to 4*pi\ny = np.sin(x)  # Compute the sine of these values\n\n# Plotting the sine wave\nplt.plot(x, y)\nplt.title('Sine Wave')\nplt.xlabel('x')\nplt.ylabel('sin(x)')\nplt.grid(True)\nplt.show()\n```\n\nThis code snippet uses `numpy` to generate an array of x values and then computes the sine for each x value. It then uses `matplotlib` to plot these values and display the resulting graph."
          },
          "type": "text"
        }
      ],
      "created_at": 1705969710,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "assistant",
      "run_id": "run_oDS3fH7NorCUVwROTZejKcZN",
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_moYE3aNwFYuRq2aXpxpt2Wb0",
      "assistant_id": null,
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Show me the code you used to generate the sinewave"
          },
          "type": "text"
        }
      ],
      "created_at": 1705969678,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "user",
      "run_id": null,
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_M5pz73YFsJPNBbWvtVs5ZY3U",
      "assistant_id": "asst_eHwhP4Xnad0bZdJrjHO2hfB4",
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Is there anything else you would like to visualize or any additional features you'd like to add to the sine wave plot?"
          },
          "type": "text"
        }
      ],
      "created_at": 1705967782,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "assistant",
      "run_id": "run_AGQHJrrfV3eM0eI9T3arKgYY",
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_oJbUanImBRpRran5HSa4Duy4",
      "assistant_id": "asst_eHwhP4Xnad0bZdJrjHO2hfB4",
      "content": [
        {
          "image_file": {
            "file_id": "assistant-1YGVTvNzc2JXajI5JU9F0HMD"
          },
          "type": "image_file"
        },
        {
          "text": {
            "annotations": [],
            "value": "Here is the visualization of a sine wave: \n\nThe wave is plotted using values from 0 to \\( 4\\pi \\) on the x-axis, and the corresponding sine values on the y-axis. I've also added grid lines for easier reading of the plot."
          },
          "type": "text"
        }
      ],
      "created_at": 1705967044,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "assistant",
      "run_id": "run_8PsweDFn6gftUd91H87K0Yts",
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_Pu3eHjM10XIBkwqh7IhnKKdG",
      "assistant_id": null,
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Create a visualization of a sinewave"
          },
          "type": "text"
        }
      ],
      "created_at": 1705966634,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "user",
      "run_id": null,
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    }
  ],
  "object": "list",
  "first_id": "msg_oaF1PUeozAvj3KrNnbKSy4LQ",
  "last_id": "msg_Pu3eHjM10XIBkwqh7IhnKKdG",
  "has_more": false
}

Para extrair apenas a resposta à nossa última pergunta:

data = json.loads(messages.model_dump_json(indent=2))
code = data['data'][0]['content'][0]['text']['value']
print(code)

Certamente, aqui está o código que usei para gerar a visualização de onda senoidal :

import numpy as np
import matplotlib.pyplot as plt

# Generating data for the sinewave
x = np.linspace(0, 4 * np.pi, 1000)  # Generate values from 0 to 4*pi
y = np.sin(x)  # Compute the sine of these values

# Plotting the sine wave
plt.plot(x, y)
plt.title('Sine Wave')
plt.xlabel('x')
plt.ylabel('sin(x)')
plt.grid(True)
plt.show()

Modo escuro

Vamos adicionar uma última pergunta ao thread para ver se o interpretador de código pode trocar o gráfico para o modo escuro para nós.

# Add a user question to the thread
message = client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="I prefer visualizations in darkmode can you change the colors to make a darkmode version of this visualization."
)

# Run the thread
run = client.beta.threads.runs.create(
  thread_id=thread.id,
  assistant_id=assistant.id,
)

# Retrieve the status of the run
run = client.beta.threads.runs.retrieve(
  thread_id=thread.id,
  run_id=run.id
)

status = run.status
print(status)

completed

messages = client.beta.threads.messages.list(
  thread_id=thread.id
)

print(messages.model_dump_json(indent=2))

{
  "data": [
    {
      "id": "msg_KKzOHCArWGvGpuPo0pVZTHgV",
      "assistant_id": "asst_eHwhP4Xnad0bZdJrjHO2hfB4",
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "You're viewing the dark mode version of the sine wave visualization in the image above. The plot is set against a dark background with a cyan colored sine wave for better contrast and visibility. If there's anything else you'd like to adjust or any other assistance you need, feel free to let me know!"
          },
          "type": "text"
        }
      ],
      "created_at": 1705971199,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "assistant",
      "run_id": "run_izZFyTVB1AlFM1VVMItggRn4",
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_30pXFVYNgP38qNEMS4Zbozfk",
      "assistant_id": null,
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "I prefer visualizations in darkmode can you change the colors to make a darkmode version of this visualization."
          },
          "type": "text"
        }
      ],
      "created_at": 1705971194,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "user",
      "run_id": null,
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_3j31M0PaJLqO612HLKVsRhlw",
      "assistant_id": "asst_eHwhP4Xnad0bZdJrjHO2hfB4",
      "content": [
        {
          "image_file": {
            "file_id": "assistant-kfqzMAKN1KivQXaEJuU0u9YS"
          },
          "type": "image_file"
        },
        {
          "text": {
            "annotations": [],
            "value": "Here is the dark mode version of the sine wave visualization. I've used the 'dark_background' style in Matplotlib and chosen a cyan color for the plot line to ensure it stands out against the dark background."
          },
          "type": "text"
        }
      ],
      "created_at": 1705971123,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "assistant",
      "run_id": "run_B91erEPWro4bZIfryQeIDDlx",
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_FgDZhBvvM1CLTTFXwgeJLdua",
      "assistant_id": null,
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "I prefer visualizations in darkmode can you change the colors to make a darkmode version of this visualization."
          },
          "type": "text"
        }
      ],
      "created_at": 1705971052,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "user",
      "run_id": null,
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_oaF1PUeozAvj3KrNnbKSy4LQ",
      "assistant_id": "asst_eHwhP4Xnad0bZdJrjHO2hfB4",
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Certainly, here is the code I used to generate the sine wave visualization:\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# Generating data for the sinewave\nx = np.linspace(0, 4 * np.pi, 1000)  # Generate values from 0 to 4*pi\ny = np.sin(x)  # Compute the sine of these values\n\n# Plotting the sine wave\nplt.plot(x, y)\nplt.title('Sine Wave')\nplt.xlabel('x')\nplt.ylabel('sin(x)')\nplt.grid(True)\nplt.show()\n```\n\nThis code snippet uses `numpy` to generate an array of x values and then computes the sine for each x value. It then uses `matplotlib` to plot these values and display the resulting graph."
          },
          "type": "text"
        }
      ],
      "created_at": 1705969710,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "assistant",
      "run_id": "run_oDS3fH7NorCUVwROTZejKcZN",
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_moYE3aNwFYuRq2aXpxpt2Wb0",
      "assistant_id": null,
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Show me the code you used to generate the sinewave"
          },
          "type": "text"
        }
      ],
      "created_at": 1705969678,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "user",
      "run_id": null,
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_M5pz73YFsJPNBbWvtVs5ZY3U",
      "assistant_id": "asst_eHwhP4Xnad0bZdJrjHO2hfB4",
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Is there anything else you would like to visualize or any additional features you'd like to add to the sine wave plot?"
          },
          "type": "text"
        }
      ],
      "created_at": 1705967782,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "assistant",
      "run_id": "run_AGQHJrrfV3eM0eI9T3arKgYY",
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_oJbUanImBRpRran5HSa4Duy4",
      "assistant_id": "asst_eHwhP4Xnad0bZdJrjHO2hfB4",
      "content": [
        {
          "image_file": {
            "file_id": "assistant-1YGVTvNzc2JXajI5JU9F0HMD"
          },
          "type": "image_file"
        },
        {
          "text": {
            "annotations": [],
            "value": "Here is the visualization of a sine wave: \n\nThe wave is plotted using values from 0 to \\( 4\\pi \\) on the x-axis, and the corresponding sine values on the y-axis. I've also added grid lines for easier reading of the plot."
          },
          "type": "text"
        }
      ],
      "created_at": 1705967044,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "assistant",
      "run_id": "run_8PsweDFn6gftUd91H87K0Yts",
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    },
    {
      "id": "msg_Pu3eHjM10XIBkwqh7IhnKKdG",
      "assistant_id": null,
      "content": [
        {
          "text": {
            "annotations": [],
            "value": "Create a visualization of a sinewave"
          },
          "type": "text"
        }
      ],
      "created_at": 1705966634,
      "file_ids": [],
      "metadata": {},
      "object": "thread.message",
      "role": "user",
      "run_id": null,
      "thread_id": "thread_ow1Yv29ptyVtv7ixbiKZRrHd"
    }
  ],
  "object": "list",
  "first_id": "msg_KKzOHCArWGvGpuPo0pVZTHgV",
  "last_id": "msg_Pu3eHjM10XIBkwqh7IhnKKdG",
  "has_more": false
}

Extraia o novo ID do arquivo de imagem e baixe e exiba a imagem:

data = json.loads(messages.model_dump_json(indent=2))  # Load JSON data into a Python object
image_file_id = data['data'][0]['content'][0]['image_file']['file_id'] # index numbers can vary if you have had a different conversation over the course of the thread.

print(image_file_id)

content = client.files.content(image_file_id)
image= content.write_to_file("dark_sine.png")

# Display the image in the default image viewer
image = Image.open("dark_sine.png")
image.show()

Captura de tela do interpretador de código gerado onda senoidal no modo escuro.

Referência adicional

Executar definições de status

Estado Definição
queued Quando as execuções são criadas pela primeira vez ou quando você conclui a required_action, elas são movidas para um status de fila. Eles devem se mudar quase imediatamente para in_progress.
in_progress Enquanto in_progress, o Assistente usa o modelo e as ferramentas para executar etapas. Você pode visualizar o progresso que está sendo feito pela Execução examinando as Etapas de Execução.
completed A Corrida foi concluída com sucesso! Agora você pode visualizar todas as mensagens que o Assistente adicionou ao thread e todas as etapas que a execução tomou. Você também pode continuar a conversa adicionando mais Mensagens de usuário ao Thread e criando outro Run.
requires_action Ao usar a ferramenta de chamada de função, a execução será movida para um estado required_action quando o modelo determinar os nomes e argumentos das funções a serem chamadas. Em seguida, você deve executar essas funções e enviar as saídas antes que a execução prossiga. Se as saídas não forem fornecidas antes que o carimbo de data/hora do expires_at passe (aproximadamente 10 minutos após a criação), a execução será movida para um status expirado.
expired Isso acontece quando as saídas de chamada de função não foram enviadas antes de expires_at e a execução expira. Além disso, se as execuções levarem muito tempo para serem executadas e ultrapassarem o tempo indicado em expires_at, nossos sistemas expirarão a execução.
cancelling Você pode tentar cancelar uma in_progress executar usando o ponto de extremidade Cancelar execução. Quando a tentativa de cancelamento for bem-sucedida, o status da Execução será movido para cancelado. O cancelamento é tentado, mas não garantido.
cancelled A execução foi cancelada com êxito.
failed Você pode exibir o motivo da falha examinando o last_error objeto em Executar. O carimbo de data/hora da falha será registrado em failed_at.

Anotações de mensagem

As anotações de mensagem do assistente são diferentes das anotações de filtragem de conteúdo que estão presentes nas respostas da API de conclusão e conclusão do chat. As anotações do assistente podem ocorrer dentro da matriz de conteúdo do objeto. As anotações fornecem informações sobre como você deve anotar o texto nas respostas ao usuário.

Quando as anotações estiverem presentes na matriz de conteúdo Mensagem, você verá substrings ilegíveis geradas por modelo no texto que precisa substituir pelas anotações corretas. Essas cadeias de caracteres podem se parecer com 【13†source】 ou sandbox:/mnt/data/file.csv. Aqui está um trecho de código Python do OpenAI que substitui essas cadeias de caracteres com as informações presentes nas anotações.


from openai import AzureOpenAI
    
client = AzureOpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
    api_version="2024-05-01-preview",
    azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
    )

# Retrieve the message object
message = client.beta.threads.messages.retrieve(
  thread_id="...",
  message_id="..."
)

# Extract the message content
message_content = message.content[0].text
annotations = message_content.annotations
citations = []

# Iterate over the annotations and add footnotes
for index, annotation in enumerate(annotations):
    # Replace the text with a footnote
    message_content.value = message_content.value.replace(annotation.text, f' [{index}]')

    # Gather citations based on annotation attributes
    if (file_citation := getattr(annotation, 'file_citation', None)):
        cited_file = client.files.retrieve(file_citation.file_id)
        citations.append(f'[{index}] {file_citation.quote} from {cited_file.filename}')
    elif (file_path := getattr(annotation, 'file_path', None)):
        cited_file = client.files.retrieve(file_path.file_id)
        citations.append(f'[{index}] Click <here> to download {cited_file.filename}')
        # Note: File download functionality not implemented above for brevity

# Add footnotes to the end of the message before displaying to user
message_content.value += '\n' + '\n'.join(citations)
Anotação de mensagem Description
file_citation As citações de arquivo são criadas pela ferramenta de recuperação e definem referências a uma citação específica em um arquivo específico que foi carregado e usado pelo Assistente para gerar a resposta.
file_path As anotações de caminho de arquivo são criadas pela ferramenta code_interpreter e contêm referências aos arquivos gerados pela ferramenta.

Consulte também