OpenAI Assistants API Tutorial

Der OpenAI Dev Day markierte einen wichtigen Meilenstein in der KI und brachte eine ganze Reihe wegweisender Dienste an den Start: GPTs, den GPTs App Store, GPT-4 Turbo und die neue Assistants API.

Diese API gibt Entwicklerinnen und Entwicklern leistungsstarke KI-Werkzeuge an die Hand, um maßgeschneiderte KI-Assistenten zu bauen, die souverän vielfältige Aufgaben übernehmen.

In diesem Tutorial tauchen wir in die Welt der Assistants ein: Wir zeigen ihre Fähigkeiten, praktische Einsatzszenarien in verschiedenen Branchen und führen dich Schritt für Schritt durch die Implementierung in Python. Begleite uns und baue deinen eigenen persönlichen KI-Assistenten.

Ein Überblick über die Assistants API

Zum Zeitpunkt dieses Artikels ist die Assistants API im Beta-Status, und das OpenAI-Entwicklerteam arbeitet aktiv an weiteren Features. Bevor diese folgen, schauen wir uns an, was die aktuelle Version schon bietet.

Dieser Abschnitt erklärt, wie die Assistants funktionieren und wie die zugrunde liegenden Komponenten zusammenspielen.

Wie funktioniert die Assistants API?

Die zwei Hauptpfeiler der Assistants sind die OpenAI-Modelle und -Tools.

• Es gibt eine breite Modellpalette, darunter u. a.: GPT-4, GPT-4 Turbo, GPT-3.5, GPT-3, DALL-E, TTS, Whisper, Embeddings, Moderation. Diese Modelle nutzt der Assistant, um konkrete intelligente Aufgaben zu lösen.

• Die Tools wiederum verschaffen den Assistants Zugriff auf gehostete OpenAI-Werkzeuge wie Code Interpreter und Knowledge Retrieval. Über Function Calling kannst du sogar eigene Tools anbinden.

Wie Assistants funktionieren

Schauen wir uns nun die fünf zentralen Schritte bei der Implementierung eines Assistants an.

• Assistant erstellen und beschreiben: Ein Assistant ist eine spezialisierte KI, aufgebaut aus Modellen, Leitlinien und verschiedenen Tools.
• Thread starten: Ein Thread steht für einen vom Nutzer initiierten Dialog, in dem Nachrichten hinzugefügt werden und ein Gespräch entsteht.
• Nachrichten hinzufügen: Nachrichten bestehen aus den Texteingaben der Nutzenden und können Text, Dateien und Bilder enthalten.
• Assistant auslösen: Der Assistant wird aktiviert, analysiert den Thread, nutzt bei Bedarf Tools und erzeugt eine passende Antwort.

Branchenspezifische Use Cases der Assistants API

Die Assistant API lässt sich gezielt in Geschäftsprozesse integrieren: So steigerst du Effizienz, automatisierst Routineaufgaben und lieferst schnellere, präzisere Antworten auf Nutzeranfragen.

Hier sind fünf überzeugende Einsatzszenarien aus der Praxis.

Entwicklungsunterstützung

Der Assistant kann als On-Demand-Coding-Helfer dienen. Mit dem Code Interpreter übersetzt er Code-Snippets zwischen Programmiersprachen, unterstützt die Softwareentwicklung und erleichtert den Einstieg in neue Sprachen. Besonders hilfreich ist das für Teams mit mehreren Sprachen oder in der Programmierausbildung.

Wissensmanagement im Unternehmen

Die Retrieval-Funktion eignet sich für internes Wissensmanagement. Durch das Hochladen und Verarbeiten interner Dokumente, Reports und Handbücher wird der Assistant zum zentralen Wissensspeicher. Mitarbeitende können gezielt Anfragen stellen und finden schneller, was sie brauchen—ohne langes Suchen in großen Dokumentbeständen.

Automatisierung im Kundensupport

Der Assistant lässt sich in Supportsysteme integrieren. Über Function Calling ruft er Informationen aus externen APIs oder Datenbanken ab und beantwortet Standardfragen automatisiert. Das verbessert das Kundenerlebnis mit schnellen, genauen Antworten und entlastet das Supportteam.

Datenanalyse

Über definierte Funktionen für Analysen kann der Assistant komplexe Datenmanipulationen durchführen und Berichte erzeugen—ausgehend von natürlichsprachlichen Anfragen, die in strukturierte Analyseaufgaben übersetzt werden.

Automatisierung von IT-Betrieb

IT-Teams können Routineaufgaben automatisieren. Definiere Funktionen für typische Tätigkeiten wie Systemdiagnosen, Netzwerktests oder Softwareaktualisierungen—der Assistant führt sie auf Kommando aus. So bleibt mehr Zeit für komplexe Themen.

Hands-on: Einstieg in die OpenAI Assistants API

Mit diesem Verständnis der OpenAI API schauen wir uns nun einen praktischen Anwendungsfall an. In diesem Abschnitt erstellst du einen Assistant, der Wissen aus PDF-Dateien abruft.

Das komplette End-to-End-Notebook findest du in DataLab.

Ablauf zur Wissensabfrage

Für jede technische Implementierung hilft ein visueller Workflow, der die Interaktion der Hauptkomponenten der Anwendung zeigt.

Dieser Workflow veranschaulicht die fünf zentralen Schritte von der Dateianladung bis zur finalen Antwort.

Fünf Hauptschritte des Workflows zur Wissensabfrage

• Dateiupload: Der Prozess startet mit dem Hochladen der PDF-Dateien, mit denen Nutzende interagieren möchten.
• Assistant-Erstellung: Der Assistant ist so konzipiert, dass er die Informationen aus den hochgeladenen PDFs verarbeitet und versteht.
• Interaktion starten: Hier beginnt der Gesprächs-Thread. Nutzende geben Eingaben, die der Assistant verarbeitet.
• Assistant auslösen: Der Assistant verarbeitet die Eingaben und erzeugt eine relevante Antwort.
• Antwort ausgeben: In der letzten Phase präsentiert der Assistant die Antwort auf die Nutzernachricht.

OpenAI KEY einrichten

Für die Reproduktion der Ergebnisse benötigst du vor allem:

• Python: Die Hauptprogrammiersprache in diesem Tutorial. Alternativ geht auch NodeJS.
• OpenAI: Das Paket für den Zugriff auf OpenAI-Services. Unser Cheatsheet zur OpenAI API in Python gibt dir einen kompakten Überblick über die Grundlagen.
• OS: Das Betriebssystempaket, um die Umgebungsvariable zu setzen.

Im ersten Schritt besorgst du dir den OpenAI KEY, mit dem du z. B. auf das DALL-E-3-Modell zugreifst. Die Hauptschritte sind unten dargestellt:

Vier Hauptschritte zum Erstellen eines OpenAI KEY

Die vier Schritte sind weitgehend selbsterklärend. Wichtig ist jedoch, dass du dein Konto über die offizielle OpenAI-Website erstellst.

Mehr zur OpenAI API findest du in unserem Beginner's Guide to The OpenAI API: Hands-On Tutorial and Best Practices. Er führt in die OpenAI API ein, zeigt Use Cases, eine praxisnahe Nutzung und bewährte Vorgehensweisen.

Mit dem Bau des Assistants starten

Sobald du den KEY hast, gib ihn auf keinen Fall weiter. Der Schlüssel ist privat. Richte ihn anschließend als Umgebungsvariable ein, damit du damit arbeiten kannst:

import os
OPENAI_API_KEY= "<YOUR PRIVATE KEY>"
os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY

Dateiupload

Die folgende Helper-Funktion nutzt die Funktion „create“, um die gewünschte Datei automatisch in deinem OpenAI-Konto hochzuladen.

Die Funktion „create“ hat zwei zentrale Parameter:

• Den Pfad zur hochzuladenden Datei
• Den Verwendungszweck der Datei, hier „assistants“

def upload_file(file_path):
    
	# Upload a file with an "assistants" purpose
	file_to_upload = client.files.create(
  	file=open(file_path, "rb"),
  	purpose='assistants'
	)
     return file_to_upload

Mit der Helper-Funktion startest du nun den Upload des Transformer-Papers aus dem Ordner data.

transformer_paper_path = "./data/transformer_paper.pdf"
file_to_upload = upload_file(transformer_paper_path)

Nach erfolgreicher Ausführung ist die transformer_paper.pdf hochgeladen und im Tab „Files“ sichtbar, wie unten gezeigt.

Transformer-Paper im OpenAI-Konto

Assistant-Erstellung

Die Erstellung erfolgt über die Funktion create aus dem Modul client.beta.assistants. Sie nutzt fünf wesentliche Parameter:

• Name: Der vom Ersteller vergebene Name. Unserer heißt Scientific Paper Assistant.
• Instructions: Beschreibt, wie sich der Assistant verhalten und antworten soll. In unserem Fall: „You are a polite and expert knowledge retrieval assistant. Use the documents provided as a knowledge base to answer questions.“
• Model: Das zugrunde liegende Modell für die Wissensabfrage. Es gehen GPT-3- oder GPT-4-Modelle. Hier nutzen wir zum Zeitpunkt des Artikels das neueste Modell gpt-4-1106-preview.
• Tools: Der zu verwendende Tool-Typ. Zur Wahl stehen Code Interpreter und Retrieval. Wir fokussieren Retrieval und ignorieren den Interpreter.
• File_ids: Eine Liste eindeutiger Kennungen der Dateien in der Wissensbasis.

Die Helper-Funktion create_assistant bündelt alle Angaben und erstellt den Assistant wie folgt:

def create_assistant(assistant_name,
                 	my_instruction,
                 	uploaded_file,
                 	model="gpt-4-1106-preview"):
    
	my_assistant = client.beta.assistants.create(
	name = assistant_name,
	instructions = my_instruction,
	model="gpt-4-1106-preview",
	tools=[{"type": "retrieval"}],
	file_ids=[uploaded_file.id]
	)
    
	return my_assistant

Jetzt können wir die Funktion mit Anweisung und Namen ausführen:

inst="You are a polite and expert knowledge retrieval assistant. Use the documents provided as a knowledge base to answer questions"
assistant_name="Scientific Paper Assistant"

my_assistant = create_assistant(assistant_name, inst, uploaded_file)

Interaktion starten

Nachdem der Assistant erstellt ist, folgt logisch der Start eines Interaktions-Threads mit der Nutzernachricht oder -anfrage.

Thread und Nachricht werden jeweils über die create-Funktionen von client.beta.threads und client.beta.threads.messages erstellt.

Beides kombiniert die Helper-Funktion initiate_interaction.

def initiate_interaction(user_message, uploaded_file):
    
	my_thread = client.beta.threads.create()
	message = client.beta.threads.messages.create(thread_id=my_thread.id,
                                              	role="user",
                                              	content=user_message,
                                              	file_ids=[uploaded_file.id]
	)
    
	return my_thread

Die Interaktion startest du mit der Variable user_message:

user_message = "Why do authors use the self-attention strategy in the paper?"
my_thread = initiate_interaction(user_message, uploaded_file)

Assistant auslösen und Antwort generieren

Auf Basis des Threads lässt sich der Assistant auslösen, um auf die Nutzernachricht zu antworten. Das Auslösen übernimmt die Helper-Funktion trigger_assistant, die Antwort steht danach in der Variable response.

def trigger_assistant():
	run = client.beta.threads.runs.create(
  	thread_id = my_thread.id,
  	assistant_id = my_assistant.id,
	)


trigger_assistant()

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

response = messages.data[0].content[0].text.value
response

Nach erfolgreicher Ausführung entsteht folgende Antwort.

Antwort des Assistants auf die Nutzernachricht

Diese Antwort entspricht exakt der Begründung der Autorinnen und Autoren auf Seite 6.

Textstelle mit der Antwort aus dem Transformer-Paper

Best Practices für die Nutzung der OpenAI Assistants API

Wenn du die Assistant API in ein Projekt integrierst, solltest du Best Practices befolgen, um Leistung und Nutzererlebnis zu optimieren. Beachte insbesondere Folgendes:

• Klare Ziele definieren: Lege konkrete Ziele fest, damit der Assistant seinen Zweck erfüllt und Nutzerbedürfnisse wirksam adressiert.

• Dateninput optimieren: Qualität und Relevanz der genutzten Daten, etwa hochgeladene Dateien, sind entscheidend für genaue und effiziente Antworten.

• Privatsphäre priorisieren: Setze solide Datenschutzmaßnahmen um, um Informationen zu schützen und geltende Gesetze einzuhalten.

• Testen und iterieren: Teste regelmäßig in realen Szenarien und verbessere auf Basis von Feedback Leistung und User Experience.

• Klare Dokumentation bereitstellen: Gib eine verständliche Anleitung zur Nutzung des Assistants, inklusive Funktionsumfang und Grenzen.


Fazit

Zusammengefasst hast du die Assistants API kennengelernt: wie sie funktioniert und wie sie in verschiedenen Branchen eingesetzt werden kann. Wir haben mit einer Einführung und den Kernfunktionen begonnen und so die Grundlage gelegt.

Anschließend sind wir auf die spezifischen Features der Assistants API eingegangen und haben gezeigt, wie sie in unterschiedlichen Geschäftsbereichen Mehrwert stiften.

Außerdem hast du eine Schritt-für-Schritt-Anleitung erhalten, um mit der Assistants API zu starten und sie für deine Zwecke einzurichten.

Zusätzlich haben wir zentrale Best Practices geteilt, damit du das Maximum aus der API herausholst.

Kurz gesagt: Die Assistants API ist vielseitig und wertvoll. Wer sie gezielt einsetzt, profitiert in vielen Anwendungsszenarien.

Du willst noch kreativer mit den OpenAI-APIs arbeiten? Unser Comprehensive Guide to the DALL-E 3 API zeigt dir die Stärken der DALL-E-3-API—von Kernfunktionen über Branchenanwendungen bis zu Tipps, wie du dein kreatives Potenzial entfaltest.

Wenn du ganz neu im Thema bist, starte mit unserem Kurs Working with the OpenAI API.