Bagikan melalui

Menjelajahi Kernel Semantik OpenAIResponsesAgent

Penting

Fitur ini dalam tahap eksperimental. Fitur pada tahap ini sedang dalam pengembangan dan dapat berubah sebelum maju ke tahap pratinjau atau kandidat rilis.

OpenAIResponsesAgent akan segera datang.

Petunjuk / Saran

Dokumentasi API terperinci yang terkait dengan diskusi ini tersedia di:

Fitur saat ini tidak tersedia di Java.

Apa itu Agen Respons?

OPENAI Responses API adalah antarmuka OpenAI yang paling canggih untuk menghasilkan respons model. Ini mendukung input teks dan gambar, dan output teks. Anda dapat membuat interaksi berstatus dengan model, menggunakan output dari respons sebelumnya sebagai input. Dimungkinkan juga untuk memperluas kemampuan model dengan alat bawaan untuk pencarian file, pencarian web, penggunaan komputer, dan banyak lagi.

Menyiapkan lingkungan pengembangan Anda

Untuk melanjutkan pengembangan OpenAIResponsesAgent, konfigurasikan lingkungan pengembangan Anda dengan paket yang sesuai.

OpenAIResponsesAgent akan segera datang.

Instal paket semantic-kernel:

pip install semantic-kernel

Penting

OpenAIResponsesAgent didukung dalam paket Semantic Kernel Python 1.27.0 dan yang lebih baru.

Fitur saat ini tidak tersedia di Java.

Membuat OpenAIResponsesAgent

Membuat OpenAIResponsesAgent memerlukan pembuatan klien terlebih dahulu untuk dapat berkomunikasi dengan layanan jarak jauh.

OpenAIResponsesAgent akan segera datang.

Untuk mengonfigurasi model yang digunakan oleh OpenAI atau Azure OpenAI Responses API, variabel lingkungan baru diperkenalkan:

OPENAI_RESPONSES_MODEL_ID=""
AZURE_OPENAI_RESPONSES_DEPLOYMENT_NAME=""

Atur variabel yang sesuai tergantung pada penyedia mana yang Anda gunakan.

Petunjuk / Saran

Versi api Azure OpenAI minimum yang diizinkan adalah 2025-03-01-preview. Silakan kunjungi tautan berikut untuk melihat ketersediaan wilayah, dukungan model, dan detail lebih lanjut.

Untuk membuat AzureResponsesAgent yang digunakan dengan model Azure OpenAI:

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

Atau, untuk membuat OpenAIResponsesAgent yang dapat digunakan dengan model OpenAI:

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

Fitur saat ini tidak tersedia di Java.

Menggunakan OpenAIResponsesAgent

OpenAIResponsesAgent akan segera datang.

OPENAI Responses API mendukung penyimpanan percakapan jarak jauh opsional. Secara default, saat menggunakan ResponsesAgentThread, respons disimpan dari jarak jauh. Ini memungkinkan penggunaan API Respons previous_response_id untuk mempertahankan konteks di seluruh pemanggilan.

Setiap percakapan diperlakukan sebagai utas, yang diidentifikasi oleh string ID yang unik. Semua interaksi dengan OpenAIResponsesAgent Anda tercakup pada pengidentifikasi utas ini.

Mekanisme mendasar dari utas API Respons diabstraksikan oleh kelas ResponsesAgentThread, yang mengimplementasikan antarmuka AgentThread.

OpenAIResponsesAgent saat ini hanya mendukung utas jenis ResponsesAgentThread.

Anda dapat memanggil OpenAIResponsesAgent tanpa menentukan AgentThread, untuk memulai utas baru dan AgentThread baru akan dikembalikan sebagai bagian dari respons.

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

Fitur saat ini tidak tersedia di Java.

Menangani Pesan Perantara dengan OpenAIResponsesAgent

Semantic Kernel OpenAIResponsesAgent dirancang untuk memanggil sebuah agen yang memenuhi kueri atau pertanyaan pengguna. Selama pemanggilan, agen dapat menjalankan alat untuk mendapatkan jawaban akhir. Untuk mengakses pesan perantara yang dihasilkan selama proses ini, penelepon dapat menyediakan fungsi panggilan balik yang menangani instans FunctionCallContent atau FunctionResultContent.

OpenAIResponsesAgent akan segera datang.

Mengonfigurasi on_intermediate_message panggilan balik dalam agent.invoke(...) atau agent.invoke_stream(...) memungkinkan pemanggil untuk menerima pesan perantara yang dihasilkan selama proses merumuskan respons akhir agen.

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

Berikut ini menunjukkan sampel output dari proses pemanggilan agen:

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!

Fitur saat ini tidak tersedia di Java.

Spesifikasi Deklaratif

Dokumentasi tentang menggunakan spesifikasi deklaratif akan segera hadir.

Penting

Fitur ini dalam tahap eksperimental. Fitur pada tahap ini sedang dalam pengembangan dan dapat berubah sebelum maju ke tahap pratinjau atau kandidat rilis.

OpenAIResponsesAgent mendukung instansiasi dari spesifikasi deklaratif YAML. Pendekatan deklaratif memungkinkan Anda menentukan properti agen, instruksi, konfigurasi model, alat, dan opsi lainnya dalam satu dokumen yang dapat diaudit. Hal ini membuat komposisi agen portabel dan mudah dikelola di seluruh lingkungan.

Nota

Setiap alat, fungsi, atau plugin yang tercantum dalam YAML deklaratif harus tersedia untuk agen pada waktu konstruksi. Untuk plugin berbasis kernel, ini berarti plugin harus terdaftar di Kernel. Untuk alat bawaan seperti Penerjemah Kode atau Pencarian File, konfigurasi dan kredensial yang benar harus disediakan. Loader agen tidak akan membuat fungsi dari awal. Jika komponen yang diperlukan hilang, pembuatan agen akan gagal.

Cara Menggunakan Spesifikasi Deklaratif

Daripada menghitung setiap kemungkinan konfigurasi YAML, bagian ini menguraikan prinsip-prinsip utama dan menyediakan tautan ke sampel konsep yang menunjukkan kode lengkap untuk setiap jenis alat. Lihat sampel-sampel konsep ini untuk implementasi end-to-end dari OpenAIResponsesAgent dengan spesifikasi deklaratif.

AzureResponsesAgent Sampel:

OpenAIResponsesAgent Sampel:

Contoh: Membuat AzureAIAgent dari YAML

Spesifikasi deklaratif YAML minimal mungkin terlihat seperti berikut:

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

Untuk detail tentang cara menyambungkan agen, lihat sampel kode lengkap di atas.

Poin Penting

  • Spesifikasi deklaratif memungkinkan menentukan struktur, alat, dan perilaku agen dalam YAML.
  • Semua alat dan plugin yang direferensikan harus terdaftar atau dapat diakses pada runtime.
  • Alat bawaan seperti Bing, Pencarian File, dan Penerjemah Kode memerlukan konfigurasi dan kredensial yang tepat (seringkali melalui variabel lingkungan atau argumen eksplisit).
  • Untuk contoh komprehensif, lihat tautan sampel yang disediakan yang menunjukkan skenario praktis, termasuk pendaftaran plugin, konfigurasi identitas Azure, dan penggunaan alat tingkat lanjut.

Fitur ini tidak tersedia.

Langkah Selanjutnya

Menjelajahi Orkestrasi Agen

  • Last updated on