Erste Schritte mit Azure OpenAI-Assistenten (Vorschau) (klassisch)

Gilt nur für:Foundry (klassisches) Portal. Dieser Artikel ist für das neue Foundry-Portal nicht verfügbar. Erfahren Sie mehr über das neue Portal.

Hinweis

Links in diesem Artikel können Inhalte in der neuen Microsoft Foundry-Dokumentation anstelle der jetzt angezeigten Foundry-Dokumentation (klassisch) öffnen.

Hinweis

Die Assistenten-API ist veraltet und wird am 26. August 2026 außer Betrieb genommen. Nutzen Sie den allgemein verfügbaren Service Microsoft Foundry Agents. Folgen Sie dem Migrationsleitfaden, um Ihre Arbeitslasten zu aktualisieren. Weitere Informationen.

Azure OpenAI Assistants (Preview) ermöglicht Es Ihnen, KI-Assistenten zu erstellen, die auf Ihre Anforderungen zugeschnitten sind, durch benutzerdefinierte Anweisungen und erweitert durch erweiterte Tools wie Codedolmetscher und benutzerdefinierte Funktionen. In diesem Artikel finden Sie eine ausführliche exemplarische Vorgehensweise für die ersten Schritte mit der Assistenten-API.

Unterstützung von Assistenten

Unterstützung für Region, Modell und API

Die Modelle-Seite enthält die aktuellsten Informationen zu Regionen/Modellen, in denen Assistenten derzeit unterstützt werden. Assistenten können in Version 2024-02-15-preview und höher der Azure OpenAI-Inference preview-API verwendet werden. Eine vollständige Liste früherer API-Versionen finden Sie unter GitHub.

Unterstützte Dateitypen

Dateiformat MIME-Typ Codedolmetscher
.c text/x-c ✅
.cpp text/x-c++ ✅
.csv application/csv ✅
.docx application/vnd.openxmlformats-officedocument.wordprocessingml.document ✅
.html text/html ✅
.java text/x-java ✅
.json application/json ✅
.md Text/Markdown ✅
.pdf anwendung/pdf ✅
.php text/x-php ✅
.pptx application/vnd.openxmlformats-officedocument.presentationml.presentation ✅
.Py text/x-python ✅
.Py text/x-script.python ✅
.rb text/x-ruby ✅
.tex text/x-tex ✅
.txt text/plain ✅
.css text/css ✅
.jpeg image/jpeg ✅
.jpg image/jpeg ✅
.js text/javascript ✅
.gif Bild/GIF ✅
.png Bild/PNG ✅
.tar application/x-tar ✅
.ts application/typescript ✅
.xlsx application/vnd.openxmlformats-officedocument.spreadsheetml.sheet ✅
.xml application/xml oder "text/xml" ✅
.zip application/zip ✅

Werkzeuge

Tipp

Wir haben Unterstützung für den tool_choice Parameter hinzugefügt, der verwendet werden kann, um die Verwendung eines bestimmten Tools (wie file_search, code_interpreteroder a function) in einer bestimmten Ausführung zu erzwingen.

Ein einzelner Assistent kann auf bis zu 128 Tools zugreifen, einschließlich Codedolmetscher und Dateisuche, aber Sie können auch eigene benutzerdefinierte Tools über Funktionen definieren.

Dateien

Dateien können über Studio oder programmgesteuert hochgeladen werden. Der file_ids Parameter ist erforderlich, um Tools wie code_interpreter den Zugriff auf Dateien zu gewähren. Bei Verwendung des Dateiuploadendpunkts müssen Sie den purpose auf assistants festgelegt haben, die mit der Assistants-API verwendet werden sollen.

Assistentenkomponenten

Komponente Beschreibung
Assistent Benutzerdefinierte KI, die Azure OpenAI-Modelle in Verbindung mit Tools verwendet.
Thread Eine Unterhaltungssitzung zwischen einem Assistenten und einem Benutzer. Threads speichern Nachrichten und behandeln automatisch das Abschneiden, um Inhalte in den Kontext eines Modells einzupassen.
Nachricht Eine Nachricht, die von einem Assistenten oder einem Benutzer erstellt wurde. Nachrichten können Text, Bilder und andere Dateien enthalten. Nachrichten werden als Liste im Thread gespeichert.
Ausführen Aktivierung eines Assistenten, der basierend auf dem Inhalt des Threads mit der Ausführung beginnen soll. Der Assistent verwendet seine Konfiguration und die Nachrichten des Threads, um Aufgaben durch Aufrufen von Modellen und Tools auszuführen. Als Teil einer Ausführung fügt der Assistent Nachrichten an den Thread an.
Schritt ausführen Eine detaillierte Liste der Schritte, die der Assistent als Teil eines Laufs durchgeführt hat. Ein Assistent kann Tools aufrufen oder während der Ausführung Nachrichten erstellen. Wenn Sie die Ausführungsschritte untersuchen, können Sie verstehen, wie der Assistent zu seinen endgültigen Ergebnissen gelangt.

Einrichten Ihres ersten Assistenten

Erstellen eines Assistenten

In diesem Beispiel erstellen wir einen Assistenten, der Code schreibt, um Visualisierungen mithilfe der Funktionen des code_interpreter Tools zu generieren. Die folgenden Beispiele sollen sequenziell in einer Umgebung wie Jupyter-Notizbüchern ausgeführt werden.

import os
import json
from openai import AzureOpenAI
    
client = AzureOpenAI(
    api_key=os.getenv("AZURE_OPENAI_API_KEY"),  
    api_version="2024-08-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.
)

Es gibt ein paar Details, die Sie aus der obigen Konfiguration beachten sollten:

  • Wir ermöglichen diesem Assistenten den Zugriff auf Codedolmetscher mit der Zeile tools=[{"type": "code_interpreter"}],. Dadurch erhält das Modell Zugriff auf eine isolierte Python-Umgebung, um Code auszuführen, damit es Antworten auf die Fragen eines Benutzers formulieren kann.
  • In den Anweisungen erinnern wir das Modell daran, dass es Code ausführen kann. Manchmal benötigt das Modell Hilfe bei der Anleitung zum richtigen Tool, um eine bestimmte Abfrage zu lösen. Wenn Sie wissen, dass Sie eine bestimmte Bibliothek verwenden möchten, um eine bestimmte Antwort zu erstellen, die Teil des Code-Interpreters ist, kann es hilfreich sein, eine Anweisung wie "Verwenden Sie Matplotlib, um x zu tun" zu geben.
  • Da dies Azure OpenAI ist, muss der von Ihnen eingegebene Wert model=mit dem Bereitstellungsnamen übereinstimmen.

Als Nächstes werden wir den Inhalt des Assistenten drucken, den wir soeben erstellt haben, um zu bestätigen, dass die Erstellung erfolgreich war:

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"
    }
  ]
}

Erstellen eines Threads

Jetzt erstellen wir einen Thread.

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

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

Ein Thread ist im Wesentlichen die Dokumentation des Dialogs zwischen dem Assistenten und dem Benutzer. Es ähnelt dem Nachrichtenarray/der Liste in einem typischen Chatabschluss-API-Aufruf. Einer der Hauptunterschiede besteht darin, dass Sie im Gegensatz zu einem Array mit Chat-Abschlussnachrichten nicht bei jedem Aufruf Token verfolgen müssen, um sicherzustellen, dass Sie unter der Kontextlänge des Modells bleiben. Threads abstrahieren dieses Verwaltungsdetail und komprimieren den Threadverlauf nach Bedarf, damit die Unterhaltung fortgesetzt werden kann. Die Möglichkeit für Threads, dies mit größeren Unterhaltungen zu erreichen, wird verbessert, wenn sie die neuesten Modelle verwenden, die größere Kontextlängen und Unterstützung für die neuesten Features aufweisen.

Erstellen Sie als Nächstes die erste Benutzerfrage, die Sie dem Thread hinzufügen möchten.

# 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"
)

Threadnachrichten auflisten

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
}

Thread ausführen

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
)

Wir könnten hier auch einen instructions Parameter übergeben, aber dies würde die vorhandenen Anweisungen außer Kraft setzen, die wir bereits für den Assistenten bereitgestellt haben.

Threadstatus abrufen

# 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

Je nach Komplexität der ausgeführten Abfrage kann der Thread länger ausgeführt werden. In diesem Fall können Sie eine Schleife erstellen, um den Ausführungsstatus des Threads mit Code wie dem folgenden Beispiel zu überwachen:

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))

Wenn ein Run sich in in_progress oder in anderen Nichtterminalzuständen befindet, ist der Thread gesperrt. Wenn ein Thread gesperrt ist, können keine neuen Nachrichten hinzugefügt werden, und neue Läufe können nicht erstellt werden.

Threadnachrichten nach der Ausführung auflisten

Sobald der Laufstatus den erfolgreichen Abschluss anzeigt, können Sie den Inhalt des Threads erneut auflisten, um die Antworten des Modells und der Tools abzurufen.

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
}

Datei-ID abrufen

Wir hatten gefordert, dass das Modell ein Bild einer Sinuswelle erzeugt. Um das Bild herunterzuladen, müssen wir zuerst die Bilddatei-ID abrufen.

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

Bild herunterladen

content = client.files.content(image_file_id)

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

Öffnen Sie das Bild lokal, nachdem es heruntergeladen wurde:

from PIL import Image

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

Screenshot der vom Code-Interpreter generierten Sinuswelle.

Stelle eine Anschlussfrage im Thread

Da der Assistent unsere Anweisungen nicht ganz befolgt hat und den im Textteil seiner Antwort ausgeführten Code nicht enthalten hat, sollten wir diese Informationen explizit anfordern.

# 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"
)

Auch hier müssen wir den Status des Threads ausführen und abrufen:

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

Sobald der Status des Ausführungslaufs abgeschlossen ist, werden wir die Nachrichten in dem Thread erneut auflisten, die jetzt die Antwort auf unsere neueste Frage enthalten werden.

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
}

Um nur die Antwort auf unsere neueste Frage zu extrahieren:

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

Sicher, hier ist der Code, den ich zum Generieren der Sinuswellenvisualisierung verwendet habe:

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()

Dunkler Modus

Fügen wir dem Thread eine letzte Frage hinzu, um festzustellen, ob der Code-Interpreter das Diagramm in den Dunkelmodus umschalten kann.

# 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
}

Extrahieren Sie die neue Bilddatei-ID, und laden Sie das Bild herunter und zeigen Sie es an:

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()

Screenshot der durch den Code-Interpreter generierten Sinuswelle im Dunkelmodus.

Zusätzliche Referenz

Statusdefinitionen ausführen

Status Definition
queued Wenn Ausführungen zum ersten Mal erstellt werden, oder wenn Sie die required_action abschließen, werden sie in einen Status „Warteschlange“ verschoben. Sie sollten fast sofort zu in_progress wechseln.
in_progress Während in_progress verwendet der Assistent das Modell und die Werkzeuge, um Schritte auszuführen. Sie können den Fortschritt eines Laufs anzeigen, indem Sie die Lauf-Schritte untersuchen.
completed Die Ausführung wurde erfolgreich abgeschlossen! Sie können jetzt alle Nachrichten sehen, die der Assistent dem Thread hinzugefügt hat, und alle Schritte, die der Lauf durchlaufen hat. Sie können die Unterhaltung auch fortsetzen, indem Sie dem Thread weitere Benutzernachrichten hinzufügen und eine weitere Ausführung erstellen.
requires_action Bei Verwendung des Funktionsaufruftools wechselt die Ausführung zu einem required_action Zustand, sobald das Modell die Namen und Argumente der aufgerufenen Funktionen bestimmt. Anschließend müssen Sie diese Funktionen ausführen und die Ausgaben übermitteln, bevor die Ausführung fortgesetzt wird. Wenn die Ausgaben nicht vor Ablauf des Zeitstempels „expires_at“ bereitgestellt werden (ca. 10 Minuten nach der Erstellung), wird die Ausführung in einen Status „abgelaufen“ verschoben.
expired Dies geschieht, wenn die Ausgaben des Funktionsaufrufs nicht vor „expires_at“ übermittelt wurden und die Ausführung abläuft. Zusätzlich werden unsere Systeme den Lauf beenden, wenn die Ausführung zu lange dauert und über die in expires_at angegebene Zeit hinausgeht.
cancelling Sie können versuchen, eine laufende Ausführung über den API-Endpunkt "Lauf abbrechen" abzubrechen. Sobald der Versuch, den Vorgang abzubrechen, erfolgreich ist, wechselt der Status der Ausführung zu "abgebrochen". Der Versuch einer Stornierung wird unternommen, ist jedoch nicht garantiert.
cancelled Die Ausführung wurde erfolgreich abgebrochen.
failed Sie können den Grund für den Fehler einsehen, indem Sie das last_error Objekt im Ausführungslauf betrachten. Der Zeitstempel für den Fehler wird unter failed_at aufgezeichnet.

Nachrichtenanmerkungen

Anmerkungen zu Assistentennachrichten unterscheiden sich von den Inhaltsfilteranmerkungen , die in Abschluss- und Chatabschluss-API-Antworten vorhanden sind. Assistentenanmerkungen können innerhalb des Inhaltsarrays des Objekts auftreten. Anmerkungen enthalten Informationen dazu, wie Sie den Text in den Antworten an den Benutzer kommentieren sollten.

Wenn Anmerkungen im Nachrichteninhaltsarray vorhanden sind, werden unlesbare modellgenerierte Teilzeichenfolgen im Text angezeigt, den Sie durch die richtigen Anmerkungen ersetzen müssen. Diese Zeichenfolgen können zum Beispiel wie 【13†source】 oder sandbox:/mnt/data/file.csv aussehen. Hier ist ein Python Codeausschnitt aus OpenAI, der diese Zeichenfolgen durch die informationen ersetzt, die in den Anmerkungen vorhanden sind.


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)
Nachrichtenanmerkung Beschreibung
file_citation Dateizitate werden vom Abruftool erstellt und definieren Verweise auf ein bestimmtes Zitat in einer bestimmten Datei, die vom Assistenten zum Generieren der Antwort hochgeladen und verwendet wurde.
file_path Dateipfadanmerkungen werden vom tool code_interpreter erstellt und enthalten Verweise auf die vom Tool generierten Dateien.

Siehe auch

  • Last updated on