Sie haben wahrscheinlich von den neuesten Innovationen von OpenAI gehört, ihren neuen Tools zum Erstellen von Agents. Diese Tools, die von der OpenAI API betrieben werden, revolutionieren die Art und Weise, wie Entwickler intelligente, reaktionsfähige Systeme erstellen. Egal, ob Sie ein erfahrener Programmierer sind oder gerade erst anfangen, dieser Blogbeitrag führt Sie durch alles, was Sie wissen müssen, um die Angebote von OpenAI zu nutzen und Ihre eigenen Agents zu erstellen.
Warum die neuen Tools von OpenAI zum Erstellen von Agents bahnbrechend sind
OpenAI kündigte die Integration von Websuchfunktionen in die OpenAI API an. Dieses Update führt schnelle, aktuelle Antworten mit Links zu relevanten Webquellen ein, die alle von demselben Modell hinter der ChatGPT-Suche betrieben werden. Es ist ein riesiger Sprung für Entwickler, die agentenartige Systeme erstellen möchten, denken Sie an KI-Assistenten, die komplexe Aufgaben bewältigen, Echtzeitdaten abrufen und nahtlos mit Benutzern interagieren können.
OpenAI führte die Responses API, Websuchfunktionen, Dateisuchtools, Computerverwendungsfunktionen und das Agents SDK ein. Zusammen bilden sie einen robusten Rahmen für die Erstellung von Agents, die sich intelligenter und autonomer anfühlen als je zuvor. Die neuen Tools wurden entwickelt, um Entwicklern zu helfen, sichere, effiziente und leistungsstarke Agents zu erstellen.
Was sind Agents überhaupt? Eine kurze Auffrischung
Agents sind im Kontext von KI autonome Systeme oder Programme, die ihre Umgebung wahrnehmen, Entscheidungen treffen und Maßnahmen ergreifen können, um bestimmte Ziele zu erreichen. Stellen Sie sie sich als Ihre digitalen Sidekicks vor, die in der Lage sind, Fragen zu beantworten, Aufgaben auszuführen oder sogar aus Interaktionen zu lernen.
Die neuen Tools von OpenAI ermöglichen es Entwicklern, diese Agents mithilfe der OpenAI API zu erstellen, wodurch sie intelligenter, schneller und stärker mit dem Web verbunden werden.
Erste Schritte: Die Responses API von OpenAI verstehen
Die Responses API ist ein Game-Changer, der die besten Funktionen der Chat Completions und Assistants APIs von OpenAI in einem einfacheren, leistungsstärkeren Tool kombiniert. Wenn Sie mit den vorherigen APIs von OpenAI vertraut sind, werden Sie es zu schätzen wissen, wie dies den Prozess der Erstellung von Agents rationalisiert.
Um zu beginnen, gehen Sie zu OpenAIs Entwicklerdokumentation. Mit der Responses API können Sie mehrere Tools und Modelle integrieren, um komplexe Aufgaben auszuführen, was sie perfekt für die Erstellung von KI-Agents macht, die alles bewältigen können, von der Beantwortung von Fragen bis zur Orchestrierung von mehrstufigen Workflows.
So können Sie beginnen:
Die OpenAI API bietet eine einfache Schnittstelle zu hochmodernen KI-Modellen für Texterstellung, Verarbeitung natürlicher Sprache, Computer Vision und mehr. Dieses Beispiel generiert Textausgabe aus einer Eingabeaufforderung, wie Sie sie möglicherweise mit ChatGPT verwenden.
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
input: "Write a one-sentence bedtime story about a unicorn."
});
console.log(response.output_text);Bildeingaben analysieren
Sie können dem Modell auch Bildeingaben bereitstellen. Scannen Sie Quittungen, analysieren Sie Screenshots oder finden Sie Objekte in der realen Welt mit Computer Vision.
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
input: [
{ role: "user", content: "What two teams are playing in this photo?" },
{
role: "user",
content: [
{
type: "input_image",
image_url: "https://upload.wikimedia.org/wikipedia/commons/3/3b/LeBron_James_Layup_%28Cleveland_vs_Brooklyn_2018%29.jpg",
}
],
},
],
});
console.log(response.output_text);Erweitern Sie das Modell mit Tools
Geben Sie dem Modell mithilfe von Tools Zugriff auf neue Daten und Funktionen. Sie können entweder Ihren eigenen benutzerdefinierten Code aufrufen oder eines der leistungsstarken integrierten Tools von OpenAI verwenden. Dieses Beispiel verwendet Web Search, um dem Modell Zugriff auf die neuesten Informationen im Internet zu geben.
import OpenAI from "openai";
const client = new OpenAI();
const response = await client.responses.create({
model: "gpt-4o",
tools: [ { type: "web_search_preview" } ],
input: "What was a positive news story from today?",
});
console.log(response.output_text);Liefern Sie blitzschnelle KI-Erlebnisse
Mithilfe der neuen Realtime API oder serverseitig gesendeten Streaming-Ereignissen können Sie Hochleistungs-Erlebnisse mit geringer Latenz für Ihre Benutzer erstellen.
import { OpenAI } from "openai";
const client = new OpenAI();
const stream = await client.responses.create({
model: "gpt-4o",
input: [
{
role: "user",
content: "Say 'double bubble bath' ten times fast.",
},
],
stream: true,
});
for await (const event of stream) {
console.log(event);
}Erstellen Sie Agents
Verwenden Sie die OpenAI-Plattform, um Agents zu erstellen, die in der Lage sind, Aktionen auszuführen – wie z. B. die Steuerung von Computern – im Namen Ihrer Benutzer. Verwenden Sie das Agent SDK für Python, um Orchestrierungslogik im Backend zu erstellen.
from agents import Agent, Runner
import asyncio
spanish_agent = Agent(
name="Spanish agent",
instructions="You only speak Spanish.",
)
english_agent = Agent(
name="English agent",
instructions="You only speak English",
)
triage_agent = Agent(
name="Triage agent",
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(triage_agent, input="Hola, ¿cómo estás?")
print(result.final_output)
if __name__ == "__main__":
asyncio.run(main())
# ¡Hola! Estoy bien, gracias por preguntar. ¿Y tú, cómo estás?Die integrierten Tools der API führen diese Aufgaben nahtlos aus und sparen Ihnen Zeit und Mühe. Außerdem ist sie auf Sicherheit und Zuverlässigkeit ausgelegt, was ein großer Gewinn für Entwickler ist.
Web Search für intelligentere Agents
Das Websuchtool von OpenAI, das von Modellen wie GPT-4o Search und GPT-4o Mini Search betrieben wird, ermöglicht es Ihren Agents, aktuelle Informationen aus dem Internet abzurufen und Quellen zu zitieren. Dies ist besonders nützlich für die Erstellung von Agents, die genaue Echtzeitantworten liefern müssen.
Das Websuchtool ist über die OpenAI API in der Vorschau verfügbar und bietet eine beeindruckende Genauigkeit. Auf dem SimpleQA-Benchmark von OpenAI erzielt GPT-4o Search 90 %, während GPT-4o Mini Search 88 % erzielt. Das ist eine ernsthafte Präzision!
Um die Websuche in Ihrem Agent zu implementieren, lesen Sie OpenAIs Anleitung. Hier ist eine kurze Zusammenfassung:
- Tool integrieren: Verwenden Sie die Responses API, um Websuchfunktionen in Ihrem Agent zu aktivieren.
- Abfragen erstellen: Entwerfen Sie Ihren Agent so, dass er bestimmte Abfragen an das Websuchtool sendet, das dann relevante Ergebnisse abruft.
- Ergebnisse anzeigen: Ihr Agent kann die Ergebnisse den Benutzern präsentieren, komplett mit Links zu Quellen für Transparenz.
Stellen Sie sich vor, Sie erstellen einen Kundendienst-Bot, der die Websuche verwendet, um Fragen zur Produktverfügbarkeit oder zu Branchentrends zu beantworten. Mit der Websuche von OpenAI kann Ihr Agent zeitnahe, genaue Antworten liefern und so das Vertrauen und die Zufriedenheit der Benutzer steigern.
Dateisuche für effizienten Datenzugriff meistern
Ein weiteres leistungsstarkes Tool im Arsenal von OpenAI ist die Dateisuche. Mit dieser Funktion können Ihre KI-Agents schnell Dateien in den Datenbanken eines Unternehmens durchsuchen, um Informationen abzurufen. Es ist ideal für Unternehmensanwendungen, bei denen Agents auf interne Dokumente, Berichte oder Datensätze zugreifen müssen.
OpenAI betont, dass es seine Modelle nicht anhand dieser Dateien trainieren wird, um Datenschutz und Sicherheit zu gewährleisten – ein entscheidender Aspekt für Unternehmen. Sie können mehr über die Dateisuche in der Dokumentation erfahren.
So integrieren Sie die Dateisuche in Ihren Agent:
- Dateien hochladen: Verwenden Sie die OpenAI API, um Ihre Dateien auf die Plattform hochzuladen.
- Agent konfigurieren: Richten Sie Ihren Agent so ein, dass er das Dateisuchtool innerhalb der Responses API verwendet.
- Daten abfragen: Ihr Agent kann nach bestimmten Informationen innerhalb der Dateien suchen und relevante Ergebnisse zurückgeben.
Sie könnten beispielsweise einen HR-Agenten erstellen, der Mitarbeiterdatensätze durchsucht, um Gehaltsabrechnungsdetails oder Urlaubsguthaben bereitzustellen. Dieses Automatisierungsniveau kann Stunden manueller Arbeit einsparen und die Effizienz in allen Abteilungen verbessern.
Automatisierung von Aufgaben mit Computerverwendungsfunktionen
Das Computer-Using Agent (CUA)-Modell von OpenAI, das das Operator-Produkt antreibt, ermöglicht es Agents, Maus- und Tastaturaktionen zu generieren. Dies bedeutet, dass Ihre Agents Aufgaben wie Dateneingabe, App-Workflows und Website-Navigation automatisieren können.
Dieses Tool befindet sich derzeit in der Forschungsvorschau, zeigt aber bereits vielversprechendes Potenzial für Entwickler. Sie können seine Fähigkeiten in der Dokumentation erkunden. Die Consumer-Version von CUA, die in Operator verfügbar ist, konzentriert sich auf webbasierte Aktionen, aber Unternehmen können sie lokal ausführen, um breitere Anwendungen zu ermöglichen.
So können Sie beginnen:
- Auf die Vorschau zugreifen: Melden Sie sich für die Forschungsvorschau an, um das CUA-Modell zu testen.
- Aufgaben definieren: Programmieren Sie Ihren Agent so, dass er bestimmte Computeraufgaben ausführt, z. B. Formulare ausfüllen oder auf Schaltflächen klicken.
- Leistung überwachen: Verwenden Sie die Tools von OpenAI, um die Aktionen Ihres Agents zu debuggen und zu optimieren.
Stellen Sie sich vor, Sie erstellen einen Agenten, der sich wiederholende Büroaufgaben automatisiert, z. B. das Aktualisieren von Tabellenkalkulationen oder das Planen von Besprechungen. Mit Computerverwendungsfunktionen kann Ihr Agent diese Aufgaben autonom erledigen und menschliche Mitarbeiter für kreativere Aufgaben freisetzen.
1. Senden Sie eine Anfrage an das Modell
Zuerst möchten Sie möglicherweise den OpenAI-Schlüssel einrichten
import openai
import os
# Set API key
openai.api_key = os.environ.get("OPENAI_API_KEY")
Senden Sie eine Anfrage, um eine Antwort mit dem Modell computer-use-preview zu erstellen, das mit dem Tool computer_use_preview ausgestattet ist. Diese Anfrage sollte Details zu Ihrer Umgebung sowie eine erste Eingabeaufforderung enthalten.
Optional können Sie einen Screenshot des Anfangszustands der Umgebung einfügen.
Um das Tool computer_use_preview verwenden zu können, müssen Sie den Parameter truncation auf "auto" setzen (standardmäßig ist die Kürzung deaktiviert).
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="computer-use-preview",
tools=[{
"type": "computer_use_preview",
"display_width": 1024,
"display_height": 768,
"environment": "browser" # other possible values: "mac", "windows", "ubuntu"
}],
input=[
{
"role": "user",
"content": "Check the latest OpenAI news on bing.com."
}
# Optional: include a screenshot of the initial state of the environment
# {
# type: "input_image",
# image_url: f"data:image/png;base64,{screenshot_base64}"
# }
],
truncation="auto"
)
print(response.output)2. Erhalten Sie eine vorgeschlagene Aktion
Das Modell gibt eine Ausgabe zurück, die entweder ein computer_call-Element, nur Text oder andere Toolaufrufe enthält, je nach Zustand der Konversation.
Beispiele für computer_call-Elemente sind ein Klick, ein Scrollen, ein Tastendruck oder ein anderes Ereignis, das in der API-Referenz definiert ist. In unserem Beispiel ist das Element eine Klickaktion:
"output": [
{
"type": "reasoning",
"id": "rs_67cc...",
"content": []
},
{
"type": "computer_call",
"id": "cu_67cc...",
"call_id": "call_zw3...",
"action": {
"type": "click",
"button": "left",
"x": 156,
"y": 50
},
"pending_safety_checks": [],
"status": "completed"
}
]Das Modell kann in der Antwortausgabe für einige Aktionen ein reasoning-Element zurückgeben. Wenn dies der Fall ist, sollten Sie die Reasoning-Elemente immer einbeziehen, wenn Sie die nächste Anfrage an das CUA-Modell senden.
Die Reasoning-Elemente sind nur mit demselben Modell kompatibel, das sie erzeugt hat. Wenn Sie einen Ablauf implementieren, bei dem Sie mehrere Modelle mit demselben Konversationsverlauf verwenden, sollten Sie diese Reasoning-Elemente aus dem Eingabearray herausfiltern, das Sie an andere Modelle senden.
3. Führen Sie die Aktion in Ihrer Umgebung aus
Führen Sie die entsprechenden Aktionen auf Ihrem Computer oder in Ihrem Browser aus. Wie Sie einen Computeraufruf über Code Aktionen zuordnen, hängt von Ihrer Umgebung ab. Dieser Code zeigt Beispielimplementierungen für die gängigsten Computeraktionen.
def handle_model_action(page, action):
"""
Given a computer action (e.g., click, double_click, scroll, etc.),
execute the corresponding operation on the Playwright page.
"""
action_type = action.type
try:
match action_type:
case "click":
x, y = action.x, action.y
button = action.button
print(f"Action: click at ({x}, {y}) with button '{button}'")
# Not handling things like middle click, etc.
if button != "left" and button != "right":
button = "left"
page.mouse.click(x, y, button=button)
case "scroll":
x, y = action.x, action.y
scroll_x, scroll_y = action.scroll_x, action.scroll_y
print(f"Action: scroll at ({x}, {y}) with offsets (scroll_x={scroll_x}, scroll_y={scroll_y})")
page.mouse.move(x, y)
page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")
case "keypress":
keys = action.keys
for k in keys:
print(f"Action: keypress '{k}'")
# A simple mapping for common keys; expand as needed.
if k.lower() == "enter":
page.keyboard.press("Enter")
elif k.lower() == "space":
page.keyboard.press(" ")
else:
page.keyboard.press(k)
case "type":
text = action.text
print(f"Action: type text: {text}")
page.keyboard.type(text)
case "wait":
print(f"Action: wait")
time.sleep(2)
case "screenshot":
# Nothing to do as screenshot is taken at each turn
print(f"Action: screenshot")
# Handle other actions here
case _:
print(f"Unrecognized action: {action}")
except Exception as e:
print(f"Error handling action {action}: {e}")4. Erfassen Sie den aktualisierten Screenshot
Erfassen Sie nach dem Ausführen der Aktion den aktualisierten Zustand der Umgebung als Screenshot, der sich ebenfalls je nach Umgebung unterscheidet.
def get_screenshot(page):
"""
Take a full-page screenshot using Playwright and return the image bytes.
"""
return page.screenshot()5. Wiederholen
Sobald Sie den Screenshot haben, können Sie ihn als computer_call_output zurück an das Modell senden, um die nächste Aktion zu erhalten. Wiederholen Sie diese Schritte, solange Sie ein computer_call-Element in der Antwort erhalten.
import time
import base64
from openai import OpenAI
client = OpenAI()
def computer_use_loop(instance, response):
"""
Run the loop that executes computer actions until no 'computer_call' is found.
"""
while True:
computer_calls = [item for item in response.output if item.type == "computer_call"]
if not computer_calls:
print("No computer call found. Output from model:")
for item in response.output:
print(item)
break # Exit when no computer calls are issued.
# We expect at most one computer call per response.
computer_call = computer_calls[0]
last_call_id = computer_call.call_id
action = computer_call.action
# Execute the action (function defined in step 3)
handle_model_action(instance, action)
time.sleep(1) # Allow time for changes to take effect.
# Take a screenshot after the action (function defined in step 4)
screenshot_bytes = get_screenshot(instance)
screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")
# Send the screenshot back as a computer_call_output
response = client.responses.create(
model="computer-use-preview",
previous_response_id=response.id,
tools=[
{
"type": "computer_use_preview",
"display_width": 1024,
"display_height": 768,
"environment": "browser"
}
],
input=[
{
"call_id": last_call_id,
"type": "computer_call_output",
"output": {
"type": "input_image",
"image_url": f"data:image/png;base64,{screenshot_base64}"
}
}
],
truncation="auto"
)
return responseOrchestrierung von Agents mit dem Agents SDK
OpenAIs Open-Source-Toolkit zum Erstellen und Verwalten von Multi-Agent-Workflows. Dieses SDK baut auf OpenAIs früheres Framework, Swarm, auf und bietet Entwicklern kostenlose Tools zur Integration von Modellen, zur Implementierung von Sicherheitsvorkehrungen und zur Überwachung von Agent-Aktivitäten.
Das Agents SDK ist Python-First und enthält Funktionen wie integrierte Agent-Schleifen und Sicherheitsüberprüfungen. Es ist perfekt für die Erstellung komplexer Systeme, in denen mehrere Agents zusammenarbeiten, um Probleme zu lösen.
So verwenden Sie das Agents SDK:
- Laden Sie das SDK herunter: Greifen Sie auf den Open-Source-Code von OpenAIs GitHub-Repository zu.
- Richten Sie Multi-Agent-Workflows ein: Verwenden Sie das SDK, um Aufgaben zwischen Agents zu orchestrieren und basierend auf ihren Fähigkeiten zu delegieren.
- Sicherheitsvorkehrungen hinzufügen: Implementieren Sie Sicherheitsüberprüfungen, um sicherzustellen, dass Ihre Agents verantwortungsbewusst und zuverlässig arbeiten.
Sie könnten beispielsweise ein Verkaufsteam von KI-Agents erstellen, bei dem ein Agent Webrecherchen durchführt, ein anderer Dateien verwaltet und ein dritter Computeraufgaben automatisiert. Das Agents SDK verbindet sie miteinander und schafft so ein nahtloses, effizientes System.
Fazit
Von der Responses API über die Websuche, Dateisuche, Computernutzung bis hin zum Agents SDK hat OpenAI Entwickler mit allem ausgestattet, was sie zur Erstellung autonomer, intelligenter Systeme benötigen. Egal, ob Sie Geschäftsprozesse automatisieren, den Kundenservice verbessern oder neue Forschungsbereiche erkunden, diese Tools eröffnen eine Welt voller Möglichkeiten.
Also, worauf warten Sie noch? Tauchen Sie in die OpenAI API ein, experimentieren Sie mit ihren neuen Tools und beginnen Sie mit dem Erstellen von Agents, die Ihre Benutzer begeistern. Und vergessen Sie nicht, Apidog kostenlos herunterzuladen, um Ihre API-Entwicklung zu optimieren und Ihre Reise noch reibungsloser zu gestalten!
