Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Erforschung des semantischen Kerns
Von Bedeutung
Dieses Feature befindet sich in der experimentellen Phase. Features in dieser Phase befinden sich in der Entwicklung und können sich ändern, bevor Sie zur Vorschau- oder Veröffentlichungskandidatenstufe wechseln.
Dies
OpenAIResponsesAgentwird in Kürze verfügbar sein.
Tipp
Detaillierte API-Dokumentation zu dieser Diskussion finden Sie unter:
Das Feature ist derzeit in Java nicht verfügbar.
Was ist ein Antwort-Agent?
Die OpenAI-Antwort-API ist die fortschrittlichste Schnittstelle von OpenAI zum Generieren von Modellantworten. Es unterstützt Text- und Bildeingaben sowie Textausgaben. Sie können zustandsbehaftete Interaktionen mit dem Modell erstellen, indem Sie die Ausgabe früherer Antworten als Eingabe verwenden. Es ist auch möglich, die Funktionen des Modells mit integrierten Tools für die Dateisuche, die Websuche, die Computerverwendung und vieles mehr zu erweitern.
So bereiten Sie Ihre Entwicklungsumgebung vor
Um mit der Entwicklung einer OpenAIResponsesAgentfortzufahren, konfigurieren Sie Ihre Entwicklungsumgebung mit den entsprechenden Paketen.
Dies
OpenAIResponsesAgentwird in Kürze verfügbar sein.
Installieren Sie das Paket semantic-kernel:
pip install semantic-kernel
Von Bedeutung
Dies OpenAIResponsesAgent wird in semantischen Kernel Python-Paketen 1.27.0 und höher unterstützt.
Das Feature ist derzeit in Java nicht verfügbar.
Erstellen eines OpenAIResponsesAgent
Zum Erstellen eines OpenAIResponsesAgent muss zuerst ein Client erstellt werden, um mit einem Remotedienst kommunizieren zu können.
Dies
OpenAIResponsesAgentwird in Kürze verfügbar sein.
Um das von der OpenAI- oder Azure OpenAI-Antwort-API verwendete Modell zu konfigurieren, werden neue Umgebungsvariablen eingeführt:
OPENAI_RESPONSES_MODEL_ID=""
AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=""
Legen Sie die entsprechende Variable abhängig davon fest, welchen Anbieter Sie verwenden.
Tipp
Die mindestens zulässige Azure OpenAI-API-Version ist 2025-03-01-preview. Bitte besuchen Sie den folgenden Link , um die Verfügbarkeit von Regionen, den Modellsupport und weitere Details anzuzeigen.
Um ein AzureResponsesAgent zur Verwendung mit Azure OpenAI-Modellen zu erstellen:
from semantic_kernel.agents import AzureResponsesAgent
from semantic_kernel.connectors.ai.open_ai import AzureOpenAISettings, OpenAISettings
# Set up the client and model using Azure OpenAI Resources
client = AzureResponsesAgent.create_client()
# Create the AzureResponsesAgent instance using the client and the model
agent = AzureResponsesAgent(
ai_model_id=AzureOpenAISettings().responses_deployment_name,
client=client,
instructions="your instructions",
name="name",
)
Alternativ können Sie eine OpenAIResponsesAgent für die Verwendung mit OpenAI-Modellen erstellen:
from semantic_kernel.agents import OpenAIResponsesAgent
# Set up the client and model using OpenAI Resources
client = OpenAIResponsesAgent.create_client()
# Create the OpenAIResponsesAgent instance using the client and the model
agent = OpenAIResponsesAgent(
ai_model_id=OpenAISettings().responses_model_id,
client=client,
instructions="your instructions",
name="name",
)
Das Feature ist derzeit in Java nicht verfügbar.
Verwenden eines OpenAIResponsesAgent
Dies
OpenAIResponsesAgentwird in Kürze verfügbar sein.
Die OpenAI-Antwort-API unterstützt optionalen Remotespeicher von Unterhaltungen. Wenn Sie eine ResponsesAgentThreadAntwort verwenden, werden antworten standardmäßig remote gespeichert. Dies ermöglicht die Verwendung der Antwort-API previous_response_id für die Aufrechterhaltung des Kontexts über Aufrufe hinweg.
Jede Unterhaltung wird als Thread behandelt, der durch eine eindeutige Zeichenfolgen-ID identifiziert wird. Alle Interaktionen mit Ihrem OpenAIResponsesAgent sind auf diese Thread-Kennung beschränkt.
Die zugrunde liegende Mechanik des Antwort-API-Threads wird von der ResponsesAgentThread Klasse abstrahiert, die die AgentThread Schnittstelle implementiert.
Die OpenAIResponsesAgent unterstützt derzeit nur Threads vom Typ ResponsesAgentThread.
Ohne dass Sie ein OpenAIResponsesAgent angeben, können Sie die AgentThread aufrufen, um einen neuen Thread zu starten, sodass ein neues AgentThread als Teil der Antwort zurückgegeben wird.
from semantic_kernel.agents import AzureResponsesAgent
# Set up the client and model using Azure OpenAI Resources
client = AzureResponsesAgent.create_client()
# Create the AzureResponsesAgent instance using the client and the model
agent = AzureResponsesAgent(
ai_model_id=AzureOpenAISettings().responses_deployment_name,
client=client,
instructions="your instructions",
name="name",
)
USER_INPUTS = [
"My name is John Doe.",
"Tell me a joke",
"Explain why this is funny.",
"What have we been talking about?",
]
thread = None
# Generate the agent response(s)
for user_input in USER_INPUTS:
print(f"# User: '{user_input}'")
# Invoke the agent for the current message and print the response
response = await agent.get_response(messages=user_input, thread=thread)
print(f"# {response.name}: {response.content}")
# Update the thread so the previous response id is used
thread = response.thread
# Delete the thread when it is no longer needed
await thread.delete() if thread else None
Das Feature ist derzeit in Java nicht verfügbar.
Bearbeitung von Zwischennachrichten mit einem OpenAIResponsesAgent
Der semantische Kernel OpenAIResponsesAgent wurde entwickelt, um einen Agent aufzurufen, der Benutzerabfragen oder -fragen erfüllt. Während des Aufrufs kann der Agent Tools ausführen, um die endgültige Antwort abzuleiten. Um auf zwischengeschaltete Nachrichten zuzugreifen, die während dieses Prozesses erstellt werden, können Caller eine Rückruffunktion bereitstellen, die Instanzen von FunctionCallContent oder FunctionResultContent behandelt.
Dies
OpenAIResponsesAgentwird in Kürze verfügbar sein.
Konfigurieren des on_intermediate_message Rückrufs innerhalb agent.invoke(...) oder agent.invoke_stream(...) ermöglicht es dem Anrufer, Zwischennachrichten zu empfangen, die während des Prozesses der Erstellung der endgültigen Antwort des Agents generiert wurden.
import asyncio
from typing import Annotated
from semantic_kernel.agents import AzureResponsesAgent
from semantic_kernel.contents import AuthorRole, FunctionCallContent, FunctionResultContent
from semantic_kernel.contents.chat_message_content import ChatMessageContent
from semantic_kernel.functions import kernel_function
# Define a sample plugin for the sample
class MenuPlugin:
"""A sample Menu Plugin used for the concept sample."""
@kernel_function(description="Provides a list of specials from the menu.")
def get_specials(self) -> Annotated[str, "Returns the specials from the menu."]:
return """
Special Soup: Clam Chowder
Special Salad: Cobb Salad
Special Drink: Chai Tea
"""
@kernel_function(description="Provides the price of the requested menu item.")
def get_item_price(
self, menu_item: Annotated[str, "The name of the menu item."]
) -> Annotated[str, "Returns the price of the menu item."]:
return "$9.99"
# This callback function will be called for each intermediate message,
# which will allow one to handle FunctionCallContent and FunctionResultContent.
# If the callback is not provided, the agent will return the final response
# with no intermediate tool call steps.
async def handle_intermediate_steps(message: ChatMessageContent) -> None:
for item in message.items or []:
if isinstance(item, FunctionResultContent):
print(f"Function Result:> {item.result} for function: {item.name}")
elif isinstance(item, FunctionCallContent):
print(f"Function Call:> {item.name} with arguments: {item.arguments}")
else:
print(f"{item}")
async def main():
# 1. Create the client using Azure OpenAI resources and configuration
client = AzureResponsesAgent.create_client()
# 2. Create a Semantic Kernel agent for the OpenAI Responses API
agent = AzureResponsesAgent(
ai_model_id=AzureOpenAISettings().responses_deployment_name,
client=client,
name="Host",
instructions="Answer questions about the menu.",
plugins=[MenuPlugin()],
)
# 3. Create a thread for the agent
# If no thread is provided, a new thread will be
# created and returned with the initial response
thread = None
user_inputs = ["Hello", "What is the special soup?", "What is the special drink?", "How much is that?", "Thank you"]
try:
for user_input in user_inputs:
print(f"# {AuthorRole.USER}: '{user_input}'")
async for response in agent.invoke(
messages=user_input,
thread=thread,
on_intermediate_message=handle_intermediate_steps,
):
thread = response.thread
print(f"# {response.name}: {response.content}")
finally:
await thread.delete() if thread else None
if __name__ == "__main__":
asyncio.run(main())
Das Folgende zeigt die Beispielausgabe des Agentenaufrufprozesses:
AuthorRole.USER: 'Hello'
Host: Hi there! How can I assist you with the menu today?
AuthorRole.USER: 'What is the special soup?'
Function Call:> MenuPlugin-get_specials with arguments: {}
Function Result:>
Special Soup: Clam Chowder
Special Salad: Cobb Salad
Special Drink: Chai Tea
for function: MenuPlugin-get_specials
Host: The special soup is Clam Chowder. Would you like to know more about any other specials?
AuthorRole.USER: 'What is the special drink?'
Host: The special drink is Chai Tea. Would you like any more information?
AuthorRole.USER: 'How much is that?'
Function Call:> MenuPlugin-get_item_price with arguments: {"menu_item":"Chai Tea"}
Function Result:> $9.99 for function: MenuPlugin-get_item_price
Host: The Chai Tea is $9.99. Is there anything else you would like to know?
AuthorRole.USER: 'Thank you'
Host: You're welcome! If you have any more questions, feel free to ask. Enjoy your day!
Das Feature ist derzeit in Java nicht verfügbar.
Deklarative Spezifikation
Die Dokumentation zur Verwendung deklarativer Spezifikationen wird in Kürze verfügbar sein.
Von Bedeutung
Dieses Feature befindet sich in der experimentellen Phase. Features in dieser Phase befinden sich in der Entwicklung und können sich ändern, bevor Sie zur Vorschau- oder Veröffentlichungskandidatenstufe wechseln.
OpenAIResponsesAgent unterstützt die Instanziierung aus einer YAML-deklarativen Spezifikation. Mit dem deklarativen Ansatz können Sie die Eigenschaften, Anweisungen, Modellkonfiguration, Tools und andere Optionen in einem einzigen, auditierbaren Dokument definieren. Dies macht die Agentkomposition übertragbar und einfach umgebungsübergreifend verwaltet.
Hinweis
Alle Tools, Funktionen oder Plug-Ins, die im deklarativen YAML aufgeführt sind, müssen dem Agenten zur Bauzeit zur Verfügung stehen. Für kernelbasierte Plug-Ins bedeutet dies, dass sie im Kernel registriert werden müssen. Für integrierte Tools wie Codedolmetscher oder Dateisuche müssen die richtige Konfiguration und Anmeldeinformationen angegeben werden. Der Agent-Loader wird keine Funktionen von Grund auf neu erstellen. Wenn eine erforderliche Komponente fehlt, schlägt die Agenterstellung fehl.
Anleitung zur Verwendung der deklarativen Spezifikation
Anstatt jede mögliche YAML-Konfiguration aufzählen zu müssen, beschreibt dieser Abschnitt die wichtigsten Prinzipien und enthält Links zu Konzeptbeispielen, die vollständigen Code für jeden Tooltyp anzeigen. In den folgenden Konzeptbeispielen finden Sie End-to-End-Implementierungen einer OpenAIResponsesAgent mit deklarativen Spezifikationen:
AzureResponsesAgent proben:
OpenAIResponsesAgent proben:
Beispiel: Erstellen eines AzureAIAgent aus YAML
Eine minimale deklarative YAML-Spezifikation könnte wie folgt aussehen:
type: openai_responses
name: Host
instructions: Respond politely to the user's questions.
model:
id: ${OpenAI:ChatModelId}
tools:
- id: MenuPlugin.get_specials
type: function
- id: MenuPlugin.get_item_price
type: function
Ausführliche Informationen zum Verbinden des Agents finden Sie in den oben aufgeführten vollständigen Codebeispielen.
Die wichtigsten Punkte
- Deklarative Spezifikationen ermöglichen das Definieren von Agentstruktur, Tools und Verhalten in YAML.
- Alle referenzierten Tools und Plug-Ins müssen zur Laufzeit registriert oder zugänglich sein.
- Integrierte Tools wie Bing, Dateisuche und Codedolmetscher erfordern eine ordnungsgemäße Konfiguration und Anmeldeinformationen (häufig über Umgebungsvariablen oder explizite Argumente).
- Umfassende Beispiele finden Sie in den bereitgestellten Beispiellinks, die praktische Szenarien veranschaulichen, einschließlich Plug-In-Registrierung, Azure-Identitätskonfiguration und erweiterter Toolverwendung.
Dieses Feature ist nicht verfügbar.