Jegyzet
Az oldalhoz való hozzáférés engedélyezést igényel. Próbálhatod be jelentkezni vagy könyvtárat váltani.
Az oldalhoz való hozzáférés engedélyezést igényel. Megpróbálhatod a könyvtár váltását.
A Szemantikus Kernel
Fontos
Ez a funkció a kísérleti fázisban van. Az ebben a szakaszban található funkciók fejlesztés alatt állnak, és változhatnak, mielőtt továbblépnek az előzetes verzióra vagy a kiadásra jelölt fázisra.
A
OpenAIResponsesAgenthamarosan elérkezik.
Jótanács
A jelen vitafórumhoz kapcsolódó részletes API-dokumentáció a következő címen érhető el:
A funkció jelenleg nem érhető el a Javában.
Mi az a válaszügynök?
Az OpenAI Responses API az OpenAI legfejlettebb felülete a modellválaszok létrehozásához. Támogatja a szöveg- és képbemeneteket, valamint a szöveges kimeneteket. Állapotalapú interakciókat hozhat létre a modellel, a korábbi válaszok kimenetét használva bemenetként. A modell képességeit a beépített fájlkeresési, webes keresési, számítógép-használati és más eszközökkel is bővítheti.
A fejlesztési környezet előkészítése
A OpenAIResponsesAgentfejlesztésének folytatásához konfigurálja a fejlesztői környezetet a megfelelő csomagokkal.
A
OpenAIResponsesAgenthamarosan elérkezik.
Telepítse a semantic-kernel csomagot:
pip install semantic-kernel
Fontos
A(z) OpenAIResponsesAgent támogatott a Szemantikus Kernel Python 1.27.0-s és újabb verzióiban.
A funkció jelenleg nem érhető el a Javában.
Egy OpenAIResponsesAgent létrehozása
Egy OpenAIResponsesAgent létrehozásához először létre kell hoznia egy ügyfelet, amely képes kommunikálni egy távoli szolgáltatással.
A
OpenAIResponsesAgenthamarosan elérkezik.
Az OpenAI vagy az Azure OpenAI Responses API által használt modell konfigurálásához új környezeti változók jelennek meg:
OPENAI_RESPONSES_MODEL_ID=""
AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=""
Állítsa be a megfelelő változót attól függően, hogy melyik szolgáltatót használja.
Jótanács
Az Azure OpenAI API minimálisan engedélyezett verziója a .2025-03-01-preview A régió elérhetőségét, a modelltámogatást és a további részleteket az alábbi hivatkozásra kattintva tekintheti meg.
Azure OpenAI-modellekhez használható eszköz létrehozása AzureResponsesAgent :
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",
)
Alternatív megoldásként hozzon létre egy OpenAIResponsesAgent, amelyet az OpenAI-modellekhez használhat.
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",
)
A funkció jelenleg nem érhető el a Javában.
OpenAIResponsesAgent használata
A
OpenAIResponsesAgenthamarosan elérkezik.
Az OpenAI Responses API támogatja a beszélgetések opcionális távoli tárolását. Alapértelmezés szerint, amikor egy ResponsesAgentThread-t használnak, a válaszok távolról vannak tárolva. Ez lehetővé teszi a Responses API-k previous_response_id használatát a környezet meghívások közötti fenntartásához.
Minden beszélgetés szálként van kezelve, amelyet egy egyedi sztringazonosító azonosít. Az OpenAIResponsesAgent-nel folytatott összes interakció csak ezzel a szálazonosítóval vannak korlátozva.
A Responses API-szál alapjául szolgáló mechanikát az ResponsesAgentThread osztály absztrakciója végzi, amely implementálja az interfészt AgentThread .
A OpenAIResponsesAgent jelenleg csak a ResponsesAgentThreadtípusú szálakat támogatja.
A OpenAIResponsesAgent-t AgentThreadmegadása nélkül is meghívhatja, ha új szálat szeretne elindítani, és a válasz részeként egy új AgentThread-t ad vissza.
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
A funkció jelenleg nem érhető el a Javában.
Köztes üzenetek kezelése a(z) OpenAIResponsesAgent használatával
A Szemantikus Kernel OpenAIResponsesAgent egy olyan ügynök meghívására lett kialakítva, amely megfelel a felhasználói lekérdezéseknek vagy kérdéseknek. A meghívás során az ügynök végrehajthat eszközöket a végső válasz lehívásához. A folyamat során létrehozott köztes üzenetek eléréséhez a hívók megadhatnak egy visszahívási függvényt, amely kezeli a FunctionCallContent vagy FunctionResultContent példányokat.
A
OpenAIResponsesAgenthamarosan elérkezik.
A on_intermediate_message vagy agent.invoke(...) visszahívás konfigurálása lehetővé teszi a hívó számára az ügynök végső válaszának kialakítása során generált köztes üzenetek fogadását.
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())
Az alábbiak az ügynökhívási folyamatból származó mintakimenetet szemléltetik:
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!
A funkció jelenleg nem érhető el a Javában.
Deklaratív specifikáció
Hamarosan megjelenik a deklaratív specifikációk használatára vonatkozó dokumentáció.
Fontos
Ez a funkció a kísérleti fázisban van. Az ebben a szakaszban található funkciók fejlesztés alatt állnak, és változhatnak, mielőtt továbblépnek az előzetes verzióra vagy a kiadásra jelölt fázisra.
OpenAIResponsesAgent támogatja a példányosítást YAML deklaratív specifikációból. A deklaratív megközelítés lehetővé teszi az ügynök tulajdonságainak, utasításainak, modellkonfigurációjának, eszközeinek és egyéb beállításainak meghatározását egyetlen, naplózható dokumentumban. Így az ügynökök összetétele hordozhatóvá és könnyen kezelhetővé válik a környezetek között.
Megjegyzés:
A deklaratív YAML-ben felsorolt eszközöknek, függvényeknek vagy beépülő moduloknak a építéskor elérhetővé kell lenniük az ügynök számára. A kernelalapú beépülő modulok esetében ez azt jelenti, hogy regisztrálva kell lenniük a Kernelben. Az olyan beépített eszközökhöz, mint a Kódértelmező vagy a Fájlkeresés, a megfelelő konfigurációt és hitelesítő adatokat kell megadni. Az ügynökbetöltő nem hoz létre függvényeket a semmiből. Ha hiányzik egy szükséges összetevő, az ügynök létrehozása sikertelen lesz.
A deklaratív specifikáció használata
Ahelyett, hogy minden lehetséges YAML-konfigurációt számba vesz, ez a szakasz felvázolja a fő alapelveket, és olyan koncepciómintákra mutató hivatkozásokat tartalmaz, amelyek az egyes eszköztípusok teljes kódját mutatják be. Tekintse meg ezeket a koncepció példákat egy OpenAIResponsesAgent végponttól végpontig deklaratív specifikációval rendelkező implementációkhoz.
AzureResponsesAgent Minták:
OpenAIResponsesAgent Minták:
Példa: AzureAIAgent létrehozása a YAML-ből
Egy minimális YAML deklaratív specifikáció az alábbihoz hasonlóan nézhet ki:
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
Az ügynök lekötésére vonatkozó részletekért tekintse meg a fenti kódmintákat.
Kulcsfontosságú pontok
- A deklaratív specifikációk lehetővé teszik az ügynök szerkezetének, eszközeinek és viselkedésének meghatározását a YAML-ben.
- Minden hivatkozott eszköznek és beépülő modulnak regisztrálva vagy elérhetőnek kell lennie futásidőben.
- Az olyan beépített eszközök, mint a Bing, a Fájlkeresés és a Kódértelmező, megfelelő konfigurációt és hitelesítő adatokat igényelnek (gyakran környezeti változókon vagy explicit argumentumokon keresztül).
- Átfogó példákért tekintse meg a rendelkezésre álló mintahivatkozásokat, amelyek gyakorlati forgatókönyveket mutatnak be, beleértve a beépülő modulregisztrációt, az Azure-identitáskonfigurációt és a speciális eszközhasználatot.
Ez a funkció nem érhető el.