ai-agents-for-beginners

Meneroka Rangka Kerja Ejen AI

(Klik imej di atas untuk menonton video pelajaran ini)

Meneroka Rangka Kerja Ejen AI

Rangka kerja ejen AI adalah platform perisian yang direka untuk mempermudah penciptaan, penyebaran, dan pengurusan ejen AI. Rangka kerja ini menyediakan komponen pra-bina, abstraksi, dan alat kepada pembangun untuk mempercepat pembangunan sistem AI yang kompleks.

Rangka kerja ini membantu pembangun memberi tumpuan kepada aspek unik aplikasi mereka dengan menyediakan pendekatan standard kepada cabaran biasa dalam pembangunan ejen AI. Ia meningkatkan skalabiliti, kebolehcapaian, dan kecekapan dalam membina sistem AI.

Pengenalan

Pelajaran ini akan merangkumi:

Matlamat Pembelajaran

Matlamat pelajaran ini adalah untuk membantu anda memahami:

Apa itu Rangka Kerja Ejen AI dan apa yang dapat dicapai oleh pembangun dengannya?

Rangka kerja AI tradisional boleh membantu anda mengintegrasikan AI ke dalam aplikasi anda dan menjadikan aplikasi ini lebih baik dalam cara berikut:

Kedengarannya hebat, jadi mengapa kita memerlukan Rangka Kerja Ejen AI?

Rangka kerja ejen AI mewakili sesuatu yang lebih daripada sekadar rangka kerja AI. Ia direka untuk membolehkan penciptaan ejen pintar yang boleh berinteraksi dengan pengguna, ejen lain, dan persekitaran untuk mencapai matlamat tertentu. Ejen ini boleh menunjukkan tingkah laku autonomi, membuat keputusan, dan menyesuaikan diri dengan keadaan yang berubah. Mari kita lihat beberapa keupayaan utama yang diaktifkan oleh Rangka Kerja Ejen AI:

Secara ringkasnya, ejen membolehkan anda melakukan lebih banyak perkara, membawa automasi ke tahap seterusnya, mencipta sistem yang lebih pintar yang boleh menyesuaikan diri dan belajar daripada persekitarannya.

Bagaimana untuk membuat prototaip, mengulangi, dan meningkatkan keupayaan ejen dengan cepat?

Ini adalah landskap yang bergerak pantas, tetapi terdapat beberapa perkara yang biasa di kebanyakan Rangka Kerja Ejen AI yang boleh membantu anda membuat prototaip dan mengulangi dengan cepat, iaitu komponen modular, alat kolaboratif, dan pembelajaran masa nyata. Mari kita selami ini:

Gunakan Komponen Modular

SDK seperti Microsoft Semantic Kernel dan LangChain menawarkan komponen pra-bina seperti penyambung AI, templat arahan, dan pengurusan memori.

Bagaimana pasukan boleh menggunakannya: Pasukan boleh dengan cepat memasang komponen ini untuk mencipta prototaip berfungsi tanpa bermula dari awal, membolehkan eksperimen dan pengulangan yang pantas.

Bagaimana ia berfungsi dalam amalan: Anda boleh menggunakan parser pra-bina untuk mengekstrak maklumat daripada input pengguna, modul memori untuk menyimpan dan mendapatkan data, dan penjana arahan untuk berinteraksi dengan pengguna, semuanya tanpa perlu membina komponen ini dari awal.

Contoh kod. Mari kita lihat contoh bagaimana anda boleh menggunakan Penyambung AI pra-bina dengan Semantic Kernel Python dan .Net yang menggunakan panggilan fungsi automatik untuk membolehkan model bertindak balas terhadap input pengguna:

# Semantic Kernel Python Example

import asyncio
from typing import Annotated

from semantic_kernel.connectors.ai import FunctionChoiceBehavior
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureChatPromptExecutionSettings
from semantic_kernel.contents import ChatHistory
from semantic_kernel.functions import kernel_function
from semantic_kernel.kernel import Kernel

# Define a ChatHistory object to hold the conversation's context
chat_history = ChatHistory()
chat_history.add_user_message("I'd like to go to New York on January 1, 2025")


# Define a sample plugin that contains the function to book travel
class BookTravelPlugin:
    """A Sample Book Travel Plugin"""

    @kernel_function(name="book_flight", description="Book travel given location and date")
    async def book_flight(
        self, date: Annotated[str, "The date of travel"], location: Annotated[str, "The location to travel to"]
    ) -> str:
        return f"Travel was booked to {location} on {date}"

# Create the Kernel
kernel = Kernel()

# Add the sample plugin to the Kernel object
kernel.add_plugin(BookTravelPlugin(), plugin_name="book_travel")

# Define the Azure OpenAI AI Connector
chat_service = AzureChatCompletion(
    deployment_name="YOUR_DEPLOYMENT_NAME", 
    api_key="YOUR_API_KEY", 
    endpoint="https://<your-resource>.azure.openai.com/",
)

# Define the request settings to configure the model with auto-function calling
request_settings = AzureChatPromptExecutionSettings(function_choice_behavior=FunctionChoiceBehavior.Auto())


async def main():
    # Make the request to the model for the given chat history and request settings
    # The Kernel contains the sample that the model will request to invoke
    response = await chat_service.get_chat_message_content(
        chat_history=chat_history, settings=request_settings, kernel=kernel
    )
    assert response is not None

    """
    Note: In the auto function calling process, the model determines it can invoke the 
    `BookTravelPlugin` using the `book_flight` function, supplying the necessary arguments. 
    
    For example:

    "tool_calls": [
        {
            "id": "call_abc123",
            "type": "function",
            "function": {
                "name": "BookTravelPlugin-book_flight",
                "arguments": "{'location': 'New York', 'date': '2025-01-01'}"
            }
        }
    ]

    Since the location and date arguments are required (as defined by the kernel function), if the 
    model lacks either, it will prompt the user to provide them. For instance:

    User: Book me a flight to New York.
    Model: Sure, I'd love to help you book a flight. Could you please specify the date?
    User: I want to travel on January 1, 2025.
    Model: Your flight to New York on January 1, 2025, has been successfully booked. Safe travels!
    """

    print(f"`{response}`")
    # Example AI Model Response: `Your flight to New York on January 1, 2025, has been successfully booked. Safe travels! ✈️🗽`

    # Add the model's response to our chat history context
    chat_history.add_assistant_message(response.content)


if __name__ == "__main__":
    asyncio.run(main())

// Semantic Kernel C# example

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using System.ComponentModel;
using Microsoft.SemanticKernel.Connectors.AzureOpenAI;

ChatHistory chatHistory = [];
chatHistory.AddUserMessage("I'd like to go to New York on January 1, 2025");

var kernelBuilder = Kernel.CreateBuilder();
kernelBuilder.AddAzureOpenAIChatCompletion(
    deploymentName: "NAME_OF_YOUR_DEPLOYMENT",
    apiKey: "YOUR_API_KEY",
    endpoint: "YOUR_AZURE_ENDPOINT"
);
kernelBuilder.Plugins.AddFromType<BookTravelPlugin>("BookTravel"); 
var kernel = kernelBuilder.Build();

var settings = new AzureOpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

var chatCompletion = kernel.GetRequiredService<IChatCompletionService>();

var response = await chatCompletion.GetChatMessageContentAsync(chatHistory, settings, kernel);

/*
Behind the scenes, the model recognizes the tool to call, what arguments it already has (location) and (date)
{

"tool_calls": [
    {
        "id": "call_abc123",
        "type": "function",
        "function": {
            "name": "BookTravelPlugin-book_flight",
            "arguments": "{'location': 'New York', 'date': '2025-01-01'}"
        }
    }
]
*/

Console.WriteLine(response.Content);
chatHistory.AddMessage(response!.Role, response!.Content!);

// Example AI Model Response: Your flight to New York on January 1, 2025, has been successfully booked. Safe travels! ✈️🗽

// Define a plugin that contains the function to book travel
public class BookTravelPlugin
{
    [KernelFunction("book_flight")]
    [Description("Book travel given location and date")]
    public async Task<string> BookFlight(DateTime date, string location)
    {
        return await Task.FromResult( $"Travel was booked to {location} on {date}");
    }
}

Apa yang anda boleh lihat daripada contoh ini ialah bagaimana anda boleh memanfaatkan parser pra-bina untuk mengekstrak maklumat utama daripada input pengguna, seperti asal, destinasi, dan tarikh permintaan tempahan penerbangan. Pendekatan modular ini membolehkan anda memberi tumpuan kepada logik peringkat tinggi.

Manfaatkan Alat Kolaboratif

Rangka kerja seperti CrewAI, Microsoft AutoGen, dan Semantic Kernel memudahkan penciptaan pelbagai ejen yang boleh bekerjasama.

Bagaimana pasukan boleh menggunakannya: Pasukan boleh mereka bentuk ejen dengan peranan dan tugas tertentu, membolehkan mereka menguji dan memperbaiki aliran kerja kolaboratif serta meningkatkan kecekapan sistem keseluruhan.

Bagaimana ia berfungsi dalam amalan: Anda boleh mencipta pasukan ejen di mana setiap ejen mempunyai fungsi khusus, seperti pengambilan data, analisis, atau membuat keputusan. Ejen ini boleh berkomunikasi dan berkongsi maklumat untuk mencapai matlamat bersama, seperti menjawab pertanyaan pengguna atau menyelesaikan tugas.

Contoh kod (AutoGen):

# creating agents, then create a round robin schedule where they can work together, in this case in order

# Data Retrieval Agent
# Data Analysis Agent
# Decision Making Agent

agent_retrieve = AssistantAgent(
    name="dataretrieval",
    model_client=model_client,
    tools=[retrieve_tool],
    system_message="Use tools to solve tasks."
)

agent_analyze = AssistantAgent(
    name="dataanalysis",
    model_client=model_client,
    tools=[analyze_tool],
    system_message="Use tools to solve tasks."
)

# conversation ends when user says "APPROVE"
termination = TextMentionTermination("APPROVE")

user_proxy = UserProxyAgent("user_proxy", input_func=input)

team = RoundRobinGroupChat([agent_retrieve, agent_analyze, user_proxy], termination_condition=termination)

stream = team.run_stream(task="Analyze data", max_turns=10)
# Use asyncio.run(...) when running in a script.
await Console(stream)

Apa yang anda lihat dalam kod sebelumnya ialah bagaimana anda boleh mencipta tugas yang melibatkan pelbagai ejen bekerjasama untuk menganalisis data. Setiap ejen melaksanakan fungsi tertentu, dan tugas itu dilaksanakan dengan menyelaraskan ejen untuk mencapai hasil yang diinginkan. Dengan mencipta ejen berdedikasi dengan peranan khusus, anda boleh meningkatkan kecekapan dan prestasi tugas.

Belajar dalam Masa Nyata

Rangka kerja maju menyediakan keupayaan untuk pemahaman konteks masa nyata dan penyesuaian.

Bagaimana pasukan boleh menggunakannya: Pasukan boleh melaksanakan gelung maklum balas di mana ejen belajar daripada interaksi dan menyesuaikan tingkah laku mereka secara dinamik, membawa kepada peningkatan berterusan dan penambahbaikan keupayaan.

Bagaimana ia berfungsi dalam amalan: Ejen boleh menganalisis maklum balas pengguna, data persekitaran, dan hasil tugas untuk mengemas kini pangkalan pengetahuan mereka, menyesuaikan algoritma membuat keputusan, dan meningkatkan prestasi dari masa ke masa. Proses pembelajaran berulang ini membolehkan ejen menyesuaikan diri dengan keadaan yang berubah dan keutamaan pengguna, meningkatkan keberkesanan sistem keseluruhan.

Apakah perbezaan antara rangka kerja AutoGen, Semantic Kernel dan Azure AI Agent Service?

Terdapat banyak cara untuk membandingkan rangka kerja ini, tetapi mari kita lihat beberapa perbezaan utama dari segi reka bentuk, keupayaan, dan kes penggunaan sasaran:

AutoGen

AutoGen adalah rangka kerja sumber terbuka yang dibangunkan oleh Microsoft Research’s AI Frontiers Lab. Ia memberi tumpuan kepada aplikasi agentic yang didorong oleh peristiwa dan diedarkan, membolehkan pelbagai LLM dan SLM, alat, dan corak reka bentuk ejen berbilang maju.

AutoGen dibina di sekitar konsep teras ejen, iaitu entiti autonomi yang boleh memahami persekitarannya, membuat keputusan, dan mengambil tindakan untuk mencapai matlamat tertentu. Ejen berkomunikasi melalui mesej tak segerak, membolehkan mereka bekerja secara bebas dan selari, meningkatkan skalabiliti dan responsif sistem.

Ejen adalah berdasarkan model pelakon. Menurut Wikipedia, pelakon adalah blok binaan asas pengiraan serentak. Sebagai tindak balas kepada mesej yang diterima, pelakon boleh: membuat keputusan tempatan, mencipta lebih banyak pelakon, menghantar lebih banyak mesej, dan menentukan cara bertindak balas terhadap mesej seterusnya yang diterima.

Kes Penggunaan: Mengautomasi penjanaan kod, tugas analisis data, dan membina ejen tersuai untuk fungsi perancangan dan penyelidikan.

Berikut adalah beberapa konsep teras penting AutoGen:

Semantic Kernel + Rangka Kerja Ejen

Semantic Kernel adalah SDK Orkestrasi AI yang sedia untuk perusahaan. Ia terdiri daripada penyambung AI dan memori, bersama dengan Rangka Kerja Ejen.

Mari kita mula-mula merangkumi beberapa komponen teras:

Fakta-fakta ini kemudian disimpan dalam koleksi memori SummarizedAzureDocs. Ini adalah contoh yang sangat ringkas, tetapi anda dapat melihat bagaimana maklumat boleh disimpan dalam memori untuk digunakan oleh LLM.

Jadi, itulah asas rangka kerja Semantic Kernel, bagaimana pula dengan Agent Framework?

Azure AI Agent Service

Azure AI Agent Service adalah tambahan yang lebih baru, diperkenalkan di Microsoft Ignite 2024. Ia membolehkan pembangunan dan penyebaran agen AI dengan model yang lebih fleksibel, seperti memanggil LLM sumber terbuka secara langsung seperti Llama 3, Mistral, dan Cohere.

Azure AI Agent Service menyediakan mekanisme keselamatan perusahaan yang lebih kuat dan kaedah penyimpanan data, menjadikannya sesuai untuk aplikasi perusahaan.

Ia berfungsi secara langsung dengan rangka kerja orkestrasi multi-agen seperti AutoGen dan Semantic Kernel.

Perkhidmatan ini kini dalam Public Preview dan menyokong Python dan C# untuk membina agen.

Menggunakan Semantic Kernel Python, kita boleh mencipta Azure AI Agent dengan plugin yang ditentukan oleh pengguna:

import asyncio
from typing import Annotated

from azure.identity.aio import DefaultAzureCredential

from semantic_kernel.agents import AzureAIAgent, AzureAIAgentSettings, AzureAIAgentThread
from semantic_kernel.contents import ChatMessageContent
from semantic_kernel.contents import AuthorRole
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"


async def main() -> None:
    ai_agent_settings = AzureAIAgentSettings.create()

    async with (
        DefaultAzureCredential() as creds,
        AzureAIAgent.create_client(
            credential=creds,
            conn_str=ai_agent_settings.project_connection_string.get_secret_value(),
        ) as client,
    ):
        # Create agent definition
        agent_definition = await client.agents.create_agent(
            model=ai_agent_settings.model_deployment_name,
            name="Host",
            instructions="Answer questions about the menu.",
        )

        # Create the AzureAI Agent using the defined client and agent definition
        agent = AzureAIAgent(
            client=client,
            definition=agent_definition,
            plugins=[MenuPlugin()],
        )

        # Create a thread to hold the conversation
        # If no thread is provided, a new thread will be
        # created and returned with the initial response
        thread: AzureAIAgentThread | None = None

        user_inputs = [
            "Hello",
            "What is the special soup?",
            "How much does that cost?",
            "Thank you",
        ]

        try:
            for user_input in user_inputs:
                print(f"# User: '{user_input}'")
                # Invoke the agent for the specified thread
                response = await agent.get_response(
                    messages=user_input,
                    thread_id=thread,
                )
                print(f"# {response.name}: {response.content}")
                thread = response.thread
        finally:
            await thread.delete() if thread else None
            await client.agents.delete_agent(agent.id)


if __name__ == "__main__":
    asyncio.run(main())

Konsep Teras

Azure AI Agent Service mempunyai konsep teras berikut:

Kes Penggunaan: Azure AI Agent Service direka untuk aplikasi perusahaan yang memerlukan penyebaran agen AI yang selamat, boleh diskalakan, dan fleksibel.

Apakah perbezaan antara rangka kerja ini?

Memang nampaknya terdapat banyak persamaan antara rangka kerja ini, tetapi terdapat beberapa perbezaan utama dari segi reka bentuk, keupayaan, dan kes penggunaan sasaran:

Masih tidak pasti mana yang perlu dipilih?

Kes Penggunaan

Mari kita lihat jika kita boleh membantu anda dengan melalui beberapa kes penggunaan biasa:

S: Saya sedang bereksperimen, belajar, dan membina aplikasi agen bukti konsep, dan saya mahu dapat membina dan bereksperimen dengan cepat

J: AutoGen akan menjadi pilihan yang baik untuk senario ini, kerana ia memberi tumpuan kepada aplikasi agenik yang didorong oleh acara, diedarkan, dan menyokong corak reka bentuk multi-agen yang maju.

S: Apa yang menjadikan AutoGen pilihan yang lebih baik daripada Semantic Kernel dan Azure AI Agent Service untuk kes penggunaan ini?

J: AutoGen direka khusus untuk aplikasi agenik yang didorong oleh acara, diedarkan, menjadikannya sesuai untuk mengautomasikan tugas penjanaan kod dan analisis data. Ia menyediakan alat dan keupayaan yang diperlukan untuk membina sistem multi-agen yang kompleks dengan cekap.

S: Nampaknya Azure AI Agent Service juga boleh berfungsi di sini, ia mempunyai alat untuk penjanaan kod dan banyak lagi?

J: Ya, Azure AI Agent Service adalah perkhidmatan platform untuk agen dan menambah keupayaan terbina dalam untuk pelbagai model, Azure AI Search, Bing Search, dan Azure Functions. Ia memudahkan pembinaan agen anda di Foundry Portal dan menyebarkannya pada skala besar.

S: Saya masih keliru, berikan saya satu pilihan sahaja

J: Pilihan yang baik adalah membina aplikasi anda dalam Semantic Kernel terlebih dahulu dan kemudian menggunakan Azure AI Agent Service untuk menyebarkan agen anda. Pendekatan ini membolehkan anda menyimpan agen anda dengan mudah sambil memanfaatkan kuasa untuk membina sistem multi-agen dalam Semantic Kernel. Selain itu, Semantic Kernel mempunyai penyambung dalam AutoGen, menjadikannya mudah untuk menggunakan kedua-dua rangka kerja bersama-sama.

Mari kita ringkaskan perbezaan utama dalam jadual:

Rangka Kerja Fokus Konsep Teras Kes Penggunaan
AutoGen Aplikasi agenik yang didorong oleh acara, diedarkan Agen, Persona, Fungsi, Data Penjanaan kod, tugas analisis data
Semantic Kernel Memahami dan menjana kandungan teks seperti manusia Agen, Komponen Modular, Kolaborasi Pemahaman bahasa semula jadi, penjanaan kandungan
Azure AI Agent Service Model fleksibel, keselamatan perusahaan, Penjanaan kod, Panggilan alat Modulariti, Kolaborasi, Orkestrasi Proses Penyebaran agen AI yang selamat, boleh diskalakan, dan fleksibel

Apakah kes penggunaan ideal untuk setiap rangka kerja ini?

Bolehkah saya mengintegrasikan alat ekosistem Azure sedia ada saya secara langsung, atau adakah saya memerlukan penyelesaian yang berdiri sendiri?

Jawapannya adalah ya, anda boleh mengintegrasikan alat ekosistem Azure sedia ada anda secara langsung dengan Azure AI Agent Service, terutamanya kerana ia telah dibina untuk berfungsi dengan lancar dengan perkhidmatan Azure lain. Sebagai contoh, anda boleh mengintegrasikan Bing, Azure AI Search, dan Azure Functions. Terdapat juga integrasi mendalam dengan Azure AI Foundry.

Untuk AutoGen dan Semantic Kernel, anda juga boleh mengintegrasikan dengan perkhidmatan Azure, tetapi ia mungkin memerlukan anda memanggil perkhidmatan Azure dari kod anda. Cara lain untuk mengintegrasikan adalah dengan menggunakan SDK Azure untuk berinteraksi dengan perkhidmatan Azure dari agen anda. Selain itu, seperti yang disebutkan, anda boleh menggunakan Azure AI Agent Service sebagai pengatur untuk agen anda yang dibina dalam AutoGen atau Semantic Kernel, yang akan memberikan akses mudah kepada ekosistem Azure.

Ada Lagi Soalan tentang Rangka Kerja Agen AI?

Sertai Azure AI Foundry Discord untuk bertemu dengan pelajar lain, menghadiri waktu pejabat, dan mendapatkan jawapan kepada soalan anda tentang Agen AI.

Rujukan

Pelajaran Sebelumnya

Pengenalan kepada Agen AI dan Kes Penggunaan Agen

Pelajaran Seterusnya

Memahami Corak Reka Bentuk Agenik

Penafian:
Dokumen ini telah diterjemahkan menggunakan perkhidmatan terjemahan AI Co-op Translator. Walaupun kami berusaha untuk memastikan ketepatan, sila ambil perhatian bahawa terjemahan automatik mungkin mengandungi kesilapan atau ketidaktepatan. Dokumen asal dalam bahasa asalnya harus dianggap sebagai sumber yang berwibawa. Untuk maklumat yang kritikal, terjemahan manusia profesional adalah disyorkan. Kami tidak bertanggungjawab atas sebarang salah faham atau salah tafsir yang timbul daripada penggunaan terjemahan ini.

This site is open source. Improve this page.