Bagikan melalui

Agen AI

  • Artikel

Agen AI dirancang untuk melakukan tugas tertentu, menjawab pertanyaan, dan mengotomatiskan proses bagi pengguna. Agen-agen ini sangat bervariasi dalam kompleksitas. Mereka berkisar dari chatbot sederhana, hingga salinan, hingga asisten AI canggih dalam bentuk sistem digital atau robotik yang dapat menjalankan alur kerja kompleks secara otonom.

Artikel ini memberikan gambaran umum konseptual dan sampel implementasi terperinci untuk agen AI.

Apa itu agen AI?

Tidak seperti model bahasa besar mandiri (LLM) atau sistem perangkat lunak/perangkat keras berbasis aturan, agen AI memiliki fitur umum ini:

  • Perencanaan: Agen AI dapat merencanakan dan urutan tindakan untuk mencapai tujuan tertentu. Integrasi LLM telah merevolusi kemampuan perencanaan mereka.
  • Penggunaan alat: Agen AI tingkat lanjut dapat menggunakan berbagai alat, seperti eksekusi kode, pencarian, dan kemampuan komputasi, untuk melakukan tugas secara efektif. Agen AI sering menggunakan alat melalui panggilan fungsi.
  • Persepsi: Agen AI dapat melihat dan memproses informasi dari lingkungan mereka, untuk membuatnya lebih interaktif dan sadar konteks. Informasi ini mencakup data visual, pendiringan, dan sensori lainnya.
  • Memori: Agen AI memiliki kemampuan untuk mengingat interaksi sebelumnya (penggunaan alat dan persepsi) dan perilaku (penggunaan dan perencanaan alat). Mereka menyimpan pengalaman ini dan bahkan melakukan refleksi diri untuk menginformasikan tindakan di masa mendatang. Komponen memori ini memungkinkan kelangsungan dan peningkatan performa agen dari waktu ke waktu.

Catatan

Penggunaan istilah memori dalam konteks agen AI berbeda dari konsep memori komputer (seperti volatil, nonvolatile, dan memori persisten).

Copilot

Salinan adalah jenis agen AI. Mereka bekerja bersama pengguna daripada beroperasi secara independen. Tidak seperti agen yang sepenuhnya otomatis, salinan salinan memberikan saran dan rekomendasi untuk membantu pengguna dalam menyelesaikan tugas.

Misalnya, saat pengguna menulis email, salinan dapat menyarankan frasa, kalimat, atau paragraf. Pengguna mungkin juga meminta salinan untuk menemukan informasi yang relevan di email atau file lain untuk mendukung saran (lihat pengambilan-augmented generation). Pengguna dapat menerima, menolak, atau mengedit bagian yang disarankan.

Agen otonom

Agen otonom dapat beroperasi lebih independen. Saat Anda menyiapkan agen otonom untuk membantu komposisi email, Anda dapat mengaktifkannya untuk melakukan tugas-tugas berikut:

  • Lihat email, obrolan, file, dan informasi internal dan publik lainnya yang terkait dengan subjek.
  • Lakukan analisis kualitatif atau kuantitatif pada informasi yang dikumpulkan, dan menarik kesimpulan yang relevan dengan email.
  • Tulis email lengkap berdasarkan kesimpulan dan masukkan bukti pendukung.
  • Lampirkan file yang relevan ke email.
  • Tinjau email untuk memastikan bahwa semua informasi yang dimasukkan secara faktual akurat dan bahwa pernyataan tersebut valid.
  • Pilih penerima yang sesuai untuk Kepada, Cc, dan Bcc, dan cari alamat email mereka.
  • Jadwalkan waktu yang tepat untuk mengirim email.
  • Lakukan tindak lanjut jika respons diharapkan tetapi tidak diterima.

Anda dapat mengonfigurasi agen untuk melakukan setiap tugas sebelumnya dengan atau tanpa persetujuan manusia.

Sistem multi-agen

Strategi populer untuk mencapai agen otonom berkinerja adalah penggunaan sistem multi-agen. Dalam sistem multi-agen, beberapa agen otonom, baik dalam bentuk digital atau robotik, berinteraksi atau bekerja sama untuk mencapai tujuan individu atau kolektif. Agen dalam sistem dapat beroperasi secara independen dan memiliki pengetahuan atau informasi mereka sendiri. Setiap agen mungkin juga memiliki kemampuan untuk memahami lingkungannya, membuat keputusan, dan menjalankan tindakan berdasarkan tujuannya.

Sistem multi-agen memiliki karakteristik utama ini:

  • Otonom: Setiap agen berfungsi secara independen. Ini membuat keputusan sendiri tanpa intervensi manusia langsung atau kontrol oleh agen lain.
  • Interaktif: Agen berkomunikasi dan berkolaborasi satu sama lain untuk berbagi informasi, bernegosiasi, dan mengoordinasikan tindakan mereka. Interaksi ini dapat terjadi melalui berbagai protokol dan saluran komunikasi.
  • Berorientasi pada tujuan: Agen dalam sistem multi-agen dirancang untuk mencapai tujuan tertentu, yang dapat diselaraskan dengan tujuan individu atau tujuan bersama di antara agen.
  • Terdistribusi: Sistem multi-agen beroperasi secara terdistribusi, tanpa satu titik kontrol pun. Distribusi ini meningkatkan ketahanan, skalabilitas, dan efisiensi sumber daya sistem.

Sistem multi-agen memberikan keuntungan berikut daripada salinan atau satu instans inferensi LLM:

  • Penalaran dinamis: Dibandingkan dengan pemikiran rantai pemikiran atau permintaan pemikiran, sistem multi-agen memungkinkan navigasi dinamis melalui berbagai jalur penalaran.
  • Kemampuan canggih: Sistem multi-agen dapat menangani masalah kompleks atau skala besar dengan melakukan proses pengambilan keputusan yang menyeluruh dan mendistribusikan tugas di antara beberapa agen.
  • Memori yang ditingkatkan: Sistem multi-agen dengan memori dapat mengatasi jendela konteks LLM untuk memungkinkan pemahaman dan retensi informasi yang lebih baik.

Implementasi agen AI

Penalaran dan perencanaan

Penalaran dan perencanaan yang kompleks adalah ciri khas agen otonom tingkat lanjut. Kerangka kerja populer untuk agen otonom menggabungkan satu atau beberapa metodologi berikut (dengan tautan ke halaman arsip arXiv) untuk penalaran dan perencanaan:

  • TanyaKan Sendiri

    Tingkatkan rantai pemikiran dengan meminta model secara eksplisit mengajukan pertanyaan tindak lanjut (dan menjawab) sebelum menjawab pertanyaan awal.

  • Alasan dan Tindakan (React)

    Gunakan LLM untuk menghasilkan jejak penalaran dan tindakan khusus tugas secara bergantian. Jejak penalaran membantu model menginduksi, melacak, dan memperbarui rencana tindakan, bersama dengan menangani pengecualian. Tindakan memungkinkan model terhubung dengan sumber eksternal, seperti basis pengetahuan atau lingkungan, untuk mengumpulkan informasi tambahan.

  • Rencanakan dan Selesaikan

    Menyusun rencana untuk membagi seluruh tugas menjadi subtugas yang lebih kecil, dan kemudian melakukan subtugas sesuai dengan rencana. Pendekatan ini mengurangi kesalahan perhitungan, kesalahan langkah yang hilang, dan kesalahan kesalahpahaman semantik yang sering ada dalam perintah rantai pemikiran tanpa bidikan.

  • Refleksi/Kritik mandiri

    Gunakan agen refleksion yang secara verbal merefleksikan sinyal umpan balik tugas. Agen-agen ini mempertahankan teks reflektif mereka sendiri dalam buffer memori episodik untuk mendorong pengambilan keputusan yang lebih baik dalam percobaan berikutnya.

Kerangka kerja

Berbagai kerangka kerja dan alat dapat memfasilitasi pengembangan dan penyebaran agen AI.

Untuk penggunaan alat dan persepsi yang tidak memerlukan perencanaan dan memori canggih, beberapa kerangka kerja orkestrator LLM populer adalah LangChain, LlamaIndex, Prompt Flow, dan Semantic Kernel.

Untuk alur kerja perencanaan dan eksekusi tingkat lanjut dan otonom, AutoGen mendorong gelombang multi-agen yang dimulai pada akhir 2022. Assistants API OpenAI memungkinkan penggunanya untuk membuat agen secara asli dalam ekosistem GPT. Agen LangChain dan Agen LlamaIndex juga muncul sekitar waktu yang sama.

Tip

Sampel implementasi nanti dalam artikel ini menunjukkan cara membangun sistem multi-agen sederhana dengan menggunakan salah satu kerangka kerja populer dan sistem memori agen terpadu.

Sistem memori agen AI

Praktik yang lazim untuk bereksperimen dengan aplikasi yang disempurnakan AI dari 2022 hingga 2024 telah menggunakan sistem manajemen database mandiri untuk berbagai alur kerja atau jenis data. Misalnya, Anda dapat menggunakan database dalam memori untuk penembolokan, database relasional untuk data operasional (termasuk log pelacakan/aktivitas dan riwayat percakapan LLM), dan database vektor murni untuk manajemen penyematan.

Namun, praktik penggunaan web kompleks database mandiri ini dapat merusak performa agen AI. Mengintegrasikan semua database yang berbeda ini ke dalam sistem memori yang kohesif, dapat dioperasikan, dan tangguh bagi agen AI adalah tantangannya sendiri.

Selain itu, banyak layanan database yang sering digunakan tidak optimal untuk kecepatan dan skalabilitas yang dibutuhkan sistem agen AI. Kelemahan individu database ini diperburuk dalam sistem multi-agen.

Database dalam memori

Database dalam memori sangat baik untuk kecepatan tetapi mungkin berjuang dengan persistensi data skala besar yang dibutuhkan agen AI.

Database Relasional

Database relasional tidak ideal untuk berbagai modalitas dan skema fluida data yang ditangani agen. Database relasional memerlukan upaya manual dan bahkan waktu henti untuk mengelola provisi, partisi, dan sharding.

Database vektor murni

Database vektor murni cenderung kurang efektif untuk operasi transaksi, pembaruan real time, dan beban kerja terdistribusi. Database vektor murni yang populer saat ini biasanya menawarkan:

  • Tidak ada jaminan pada bacaan dan tulis.
  • Throughput penyerapan terbatas.
  • Ketersediaan rendah (di bawah 99,9%, atau pemadaman tahunan 9 jam atau lebih).
  • Satu tingkat konsistensi (akhirnya).
  • Indeks vektor dalam memori intensif sumber daya.
  • Opsi terbatas untuk multitenansi.
  • Keamanan terbatas.

Karakteristik sistem memori agen AI yang kuat

Sama halnya dengan sistem manajemen database yang efisien sangat penting bagi performa aplikasi perangkat lunak, sangat penting untuk menyediakan informasi yang relevan dan berguna kepada agen yang didukung LLM untuk memandu inferensi mereka. Sistem memori yang kuat memungkinkan pengorganisasian dan penyimpanan berbagai jenis informasi yang dapat diambil agen pada waktu inferensi.

Saat ini, aplikasi yang didukung LLM sering menggunakan pembuatan retrieval-augmented yang menggunakan pencarian semantik dasar atau pencarian vektor untuk mengambil bagian atau dokumen. Pencarian vektor dapat berguna untuk menemukan informasi umum. Tetapi pencarian vektor mungkin tidak menangkap konteks, struktur, atau hubungan tertentu yang relevan untuk tugas atau domain tertentu.

Misalnya, jika tugasnya adalah menulis kode, pencarian vektor mungkin tidak dapat mengambil pohon sintaks, tata letak sistem file, ringkasan kode, atau tanda tangan API yang penting untuk menghasilkan kode yang koheren dan benar. Demikian pula, jika tugasnya adalah bekerja dengan data tabular, pencarian vektor mungkin tidak dapat mengambil skema, kunci asing, prosedur tersimpan, atau laporan yang berguna untuk mengkueri atau menganalisis data.

Menenun bersama web database dalam memori, relasional, dan vektor mandiri (seperti yang dijelaskan sebelumnya) bukanlah solusi optimal untuk jenis data yang bervariasi. Pendekatan ini mungkin berfungsi untuk sistem agen prototipe. Namun, ini menambah kompleksitas dan hambatan performa yang dapat menghambat performa agen otonom canggih.

Sistem memori yang kuat harus memiliki karakteristik berikut.

Multimodal

Sistem memori agen AI harus menyediakan koleksi yang menyimpan metadata, hubungan, entitas, ringkasan, atau jenis informasi lain yang dapat berguna untuk berbagai tugas dan domain. Koleksi ini dapat didasarkan pada struktur dan format data, seperti dokumen, tabel, atau kode. Atau mereka dapat didasarkan pada konten dan arti data, seperti konsep, asosiasi, atau langkah prosedural.

Sistem memori tidak hanya penting bagi agen AI. Mereka juga penting bagi manusia yang mengembangkan, memelihara, dan menggunakan agen-agen ini.

Misalnya, manusia mungkin perlu mengawasi alur kerja perencanaan dan eksekusi agen hampir secara real time. Saat mengawasi, manusia mungkin terinterjeksi dengan panduan atau melakukan pengeditan dialog atau monolog agen secara sebaris. Manusia mungkin juga perlu mengaudit penalaran dan tindakan agen untuk memverifikasi validitas output akhir.

Interaksi manusia/agen kemungkinan dalam bahasa alami atau pemrograman, sedangkan agen "berpikir," "belajar," dan "ingat" melalui penyematan. Perbedaan ini menimbulkan persyaratan lain pada konsistensi sistem memori di seluruh modalitas data.

Operasional

Sistem memori harus menyediakan bank memori yang menyimpan informasi yang relevan untuk interaksi dengan pengguna dan lingkungan. Informasi tersebut mungkin termasuk riwayat obrolan, preferensi pengguna, data sensorik, keputusan yang dibuat, fakta yang dipelajari, atau data operasional lainnya yang diperbarui dengan frekuensi tinggi dan pada volume tinggi.

Bank memori ini dapat membantu agen mengingat informasi jangka pendek dan jangka panjang, menghindari pengulangan atau bertentangan dengan diri mereka sendiri, dan mempertahankan koherensi tugas. Persyaratan ini harus berlaku bahkan jika agen melakukan banyak tugas yang tidak terkait secara berturut-turut. Dalam kasus lanjutan, agen mungkin juga menguji banyak rencana cabang yang berbeda atau bertemu di titik yang berbeda.

Dapat dibagikan tetapi juga dapat dipisahkan

Pada tingkat makro, sistem memori harus memungkinkan beberapa agen AI untuk berkolaborasi pada masalah atau memproses berbagai aspek masalah dengan menyediakan memori bersama yang dapat diakses oleh semua agen. Memori bersama dapat memfasilitasi pertukaran informasi dan koordinasi tindakan di antara agen.

Pada saat yang sama, sistem memori harus memungkinkan agen untuk mempertahankan persona dan karakteristik mereka sendiri, seperti koleksi prompt dan kenangan unik mereka.

Membangun sistem memori agen AI yang kuat

Karakteristik sebelumnya mengharuskan sistem memori agen AI sangat dapat diskalakan dan cepat. Dengan susah payah menenun bersama-sama berbeda dalam database dalam memori, relasional, dan vektor (seperti yang dijelaskan sebelumnya) mungkin berfungsi untuk aplikasi berkemampuan AI tahap awal. Namun, pendekatan ini menambah kompleksitas dan hambatan performa yang dapat menghambat performa agen otonom canggih.

Sebagai pengganti semua database mandiri, Azure Cosmos DB dapat berfungsi sebagai solusi terpadu untuk sistem memori agen AI. Ketahanannya berhasil mengaktifkan layanan ChatGPT OpenAI untuk menskalakan secara dinamis dengan keandalan tinggi dan pemeliharaan rendah. Didukung oleh mesin atom-record-sequence, ini adalah layanan database NoSQL, relasional, dan vektor pertama di dunia yang menawarkan mode tanpa server. Agen AI yang dibangun di atas Azure Cosmos DB menawarkan kecepatan, skala, dan kesederhanaan.

Kecepatan

Azure Cosmos DB menyediakan latensi milidetik satu digit. Kemampuan ini membuatnya cocok untuk proses yang memerlukan akses dan manajemen data yang cepat. Proses ini termasuk penembolokan (penembolokan tradisional dan semantik), transaksi, dan beban kerja operasional.

Latensi rendah sangat penting bagi agen AI yang perlu melakukan penalaran kompleks, membuat keputusan real time, dan memberikan respons langsung. Selain itu, penggunaan layanan algoritma DiskANN menyediakan pencarian vektor yang akurat dan cepat dengan konsumsi memori minimal.

Sisik

Azure Cosmos DB direkayasa untuk distribusi global dan skalabilitas horizontal. Ini menawarkan dukungan untuk I/O beberapa wilayah dan multitenansi.

Layanan ini membantu memastikan bahwa sistem memori dapat berkembang dengan mulus dan mengikuti agen yang berkembang pesat dan data terkait. Jaminan ketersediaan dalam perjanjian tingkat layanan (SLA) diterjemahkan menjadi kurang dari 5 menit waktu henti per tahun. Layanan database vektor murni, sebaliknya, dilengkapi dengan waktu henti 9 jam atau lebih. Ketersediaan ini memberikan fondasi yang kuat untuk beban kerja misi penting. Pada saat yang sama, berbagai model layanan di Azure Cosmos DB, seperti Kapasitas Cadangan atau Tanpa Server, dapat membantu mengurangi biaya keuangan.

Kesederhanaan

Azure Cosmos DB dapat menyederhanakan manajemen dan arsitektur data dengan mengintegrasikan beberapa fungsi database ke dalam satu platform kohesif.

Kemampuan database vektor terintegrasinya dapat menyimpan, mengindeks, dan mengkueri penyematan bersama data yang sesuai dalam bahasa alami atau pemrograman. Kemampuan ini memungkinkan konsistensi, skala, dan performa data yang lebih besar.

Fleksibilitasnya mendukung berbagai modalitas dan skema cairan metadata, hubungan, entitas, ringkasan, riwayat obrolan, preferensi pengguna, data sensorik, keputusan, fakta yang dipelajari, atau data operasional lainnya yang terlibat dalam alur kerja agen. Database secara otomatis mengindeks semua data tanpa memerlukan skema atau manajemen indeks, yang membantu agen AI melakukan kueri kompleks dengan cepat dan efisien.

Azure Cosmos DB dikelola sepenuhnya, yang menghilangkan overhead tugas administrasi database seperti penskalaan, patching, dan pencadangan. Tanpa overhead ini, pengembang dapat fokus membangun dan mengoptimalkan agen AI tanpa khawatir tentang infrastruktur data yang mendasar.

Fitur tingkat lanjut

Azure Cosmos DB menggabungkan fitur canggih seperti umpan perubahan, yang memungkinkan pelacakan dan merespons perubahan data secara real time. Kemampuan ini berguna untuk agen AI yang perlu segera bereaksi terhadap informasi baru.

Selain itu, dukungan bawaan untuk penulisan multi-master memungkinkan ketersediaan dan ketahanan tinggi untuk membantu memastikan pengoperasian agen AI yang berkelanjutan, bahkan setelah kegagalan regional.

Lima tingkat konsistensi yang tersedia (dari yang kuat hingga akhirnya) juga dapat memenuhi berbagai beban kerja terdistribusi, tergantung pada persyaratan skenario.

Tip

Anda dapat memilih dari dua API Azure Cosmos DB untuk membangun sistem memori agen AI Anda:

  • Azure Cosmos DB for NoSQL, yang menawarkan jaminan ketersediaan 99,999% dan menyediakan tiga algoritma pencarian vektor: IVF, HNSW, dan DiskANN
  • Azure Cosmos DB for MongoDB berbasis vCore, yang menawarkan jaminan ketersediaan 99,995% dan menyediakan dua algoritma pencarian vektor: IVF dan HNSW (DiskANN akan datang)

Untuk informasi tentang jaminan ketersediaan untuk API ini, lihat SLA layanan.

Sampel implementasi

Bagian ini mengeksplorasi implementasi agen otonom untuk memproses pertanyaan dan pemesanan wisatawan dalam aplikasi perjalanan untuk jalur pelayaran.

Chatbots adalah konsep yang sudah lama ada, tetapi agen AI maju melampaui percakapan dasar manusia untuk melakukan tugas berdasarkan bahasa alami. Tugas-tugas ini secara tradisional memerlukan logika berkode. Agen perjalanan AI dalam sampel implementasi ini menggunakan kerangka kerja Agen LangChain untuk perencanaan agen, penggunaan alat, dan persepsi.

Sistem memori terpadu agen perjalanan AI menggunakan database vektor dan kemampuan penyimpanan dokumen Azure Cosmos DB untuk mengatasi pertanyaan wisatawan dan memfasilitasi pemesanan perjalanan. Menggunakan Azure Cosmos DB untuk tujuan ini membantu memastikan kecepatan, skala, dan kesederhanaan, seperti yang dijelaskan sebelumnya.

Agen sampel beroperasi dalam back end Python FastAPI. Ini mendukung interaksi pengguna melalui antarmuka pengguna React JavaScript.

Prasyarat

  • Langganan Azure. Jika Anda tidak memilikinya, Anda dapat mencoba Azure Cosmos DB secara gratis selama 30 hari tanpa membuat akun Azure. Uji coba gratis tidak memerlukan kartu kredit, dan tidak ada komitmen mengikuti periode uji coba.
  • Akun untuk OpenAI API atau Azure OpenAI Service.
  • Kluster vCore di Azure Cosmos DB untuk MongoDB. Anda dapat membuatnya dengan mengikuti mulai cepat ini.
  • Lingkungan pengembangan terintegrasi, seperti Visual Studio Code.
  • Python 3.11.4 diinstal di lingkungan pengembangan.

Mengunduh proyek

Semua himpunan data kode dan sampel tersedia di repositori GitHub ini. Repositori mencakup folder ini:

  • loader: Folder ini berisi kode Python untuk memuat dokumen sampel dan penyematan vektor di Azure Cosmos DB.
  • api: Folder ini berisi proyek Python FastAPI untuk menghosting agen perjalanan AI.
  • web: Folder ini berisi kode untuk antarmuka web React.

Memuat dokumen perjalanan ke Azure Cosmos DB

Repositori GitHub berisi proyek Python di direktori pemuat . Ini ditujukan untuk memuat sampel dokumen perjalanan ke Azure Cosmos DB.

Menyiapkan lingkungan

Siapkan lingkungan virtual Python Anda di direktori pemuat dengan menjalankan perintah berikut:

    python -m venv venv

Aktifkan lingkungan Anda dan instal dependensi di direktori pemuat :

    venv\Scripts\activate
    python -m pip install -r requirements.txt

Buat file bernama .env di direktori pemuat , untuk menyimpan variabel lingkungan berikut:

    OPENAI_API_KEY="<your OpenAI key>"
    MONGO_CONNECTION_STRING="mongodb+srv:<your connection string from Azure Cosmos DB>"

Memuat dokumen dan vektor

File Python main.py berfungsi sebagai titik masuk pusat untuk memuat data ke Azure Cosmos DB. Kode ini memproses sampel data perjalanan dari repositori GitHub, termasuk informasi tentang kapal dan tujuan. Kode ini juga menghasilkan paket rencana perjalanan untuk setiap kapal dan tujuan, sehingga pelancong dapat memesannya dengan menggunakan agen AI. Alat CosmosDBLoader bertanggung jawab untuk membuat koleksi, penyematan vektor, dan indeks dalam instans Azure Cosmos DB.

Berikut adalah isi main.py:

from cosmosdbloader import CosmosDBLoader
from itinerarybuilder import ItineraryBuilder
import json


cosmosdb_loader = CosmosDBLoader(DB_Name='travel')

#read in ship data
with open('documents/ships.json') as file:
        ship_json = json.load(file)

#read in destination data
with open('documents/destinations.json') as file:
        destinations_json = json.load(file)

builder = ItineraryBuilder(ship_json['ships'],destinations_json['destinations'])

# Create five itinerary packages
itinerary = builder.build(5)

# Save itinerary packages to Cosmos DB
cosmosdb_loader.load_data(itinerary,'itinerary')

# Save destinations to Cosmos DB
cosmosdb_loader.load_data(destinations_json['destinations'],'destinations')

# Save ships to Cosmos DB, create vector store
collection = cosmosdb_loader.load_vectors(ship_json['ships'],'ships')

# Add text search index to ship name
collection.create_index([('name', 'text')])

Muat dokumen, muat vektor, dan buat indeks dengan menjalankan perintah berikut dari direktori pemuat :

    python main.py

Berikut adalah output main.py:

--build itinerary--
--load itinerary--
--load destinations--
--load vectors ships--

Membangun agen perjalanan AI dengan menggunakan Python FastAPI

Agen perjalanan AI dihosting di API ujung belakang melalui Python FastAPI, yang memfasilitasi integrasi dengan antarmuka pengguna front-end. Proyek API memproses permintaan agen dengan membumikan permintaan LLM terhadap lapisan data, khususnya vektor dan dokumen di Azure Cosmos DB.

Agen menggunakan berbagai alat, terutama fungsi Python yang disediakan di lapisan layanan API. Artikel ini berfokus pada kode yang diperlukan untuk agen AI dalam kode API.

Proyek API di repositori GitHub disusun sebagai berikut:

  • Komponen pemodelan data menggunakan model Pydantic.
  • Komponen lapisan web bertanggung jawab untuk merutekan permintaan dan mengelola komunikasi.
  • Komponen lapisan layanan bertanggung jawab atas logika bisnis utama dan interaksi dengan lapisan data, Agen LangChain, dan alat agen.
  • Komponen lapisan data bertanggung jawab untuk berinteraksi dengan Azure Cosmos DB untuk penyimpanan dokumen MongoDB dan pencarian vektor.

Menyiapkan lingkungan untuk API

Kami menggunakan Python versi 3.11.4 untuk pengembangan dan pengujian API.

Siapkan lingkungan virtual Python Anda di direktori api :

    python -m venv venv

Aktifkan lingkungan Anda dan instal dependensi dengan menggunakan file persyaratan di direktori api :

    venv\Scripts\activate
    python -m pip install -r requirements.txt

Buat file bernama .env di direktori api , untuk menyimpan variabel lingkungan Anda:

    OPENAI_API_KEY="<your Open AI key>"
    MONGO_CONNECTION_STRING="mongodb+srv:<your connection string from Azure Cosmos DB>"

Sekarang setelah Anda mengonfigurasi lingkungan dan menyiapkan variabel, jalankan perintah berikut dari direktori api untuk memulai server:

    python app.py

Server FastAPI dimulai pada loopback localhost 127.0.0.1 port 8000 secara default. Anda dapat mengakses dokumen Swagger dengan menggunakan alamat localhost berikut: http://127.0.0.1:8000/docs.

Menggunakan sesi untuk memori agen AI

Sangat penting bagi agen perjalanan untuk dapat mereferensikan informasi yang diberikan sebelumnya dalam percakapan yang sedang berlangsung. Kemampuan ini umumnya dikenal sebagai memori dalam konteks LLM.

Untuk mencapai tujuan ini, gunakan riwayat pesan obrolan yang disimpan dalam instans Azure Cosmos DB. Riwayat untuk setiap sesi obrolan disimpan melalui ID sesi untuk memastikan bahwa hanya pesan dari sesi percakapan saat ini yang dapat diakses. Kebutuhan ini adalah alasan di balik keberadaan Get Session metode dalam API. Ini adalah metode tempat penampung untuk mengelola sesi web untuk mengilustrasikan penggunaan riwayat pesan obrolan.

Pilih Cobalah untuk /session/.

Cuplikan layar penggunaan metode Dapatkan Sesi di Python FastAPI, dengan tombol untuk mencobanya. 

{
  "session_id": "0505a645526f4d68a3603ef01efaab19"
}

Untuk agen AI, Anda hanya perlu mensimulasikan sesi. Metode stubbed-out hanya mengembalikan ID sesi yang dihasilkan untuk melacak riwayat pesan. Dalam implementasi praktis, sesi ini akan disimpan di Azure Cosmos DB dan berpotensi di React localStorage.

Berikut adalah konten web/session.py:

    @router.get("/")
    def get_session():
        return {'session_id':str(uuid.uuid4().hex)}

Memulai percakapan dengan agen perjalanan AI

Gunakan ID sesi yang Anda peroleh dari langkah sebelumnya untuk memulai dialog baru dengan agen AI, sehingga Anda dapat memvalidasi fungsionalitasnya. Lakukan tes dengan mengirimkan frasa berikut: "Saya ingin mengambil liburan santai."

Pilih Cobalah untuk /agent/agent_chat.

Cuplikan layar penggunaan metode Obrolan Agen di Python FastAPI, dengan tombol untuk mencobanya.

Gunakan parameter contoh ini:

{
  "input": "I want to take a relaxing vacation.",
  "session_id": "0505a645526f4d68a3603ef01efaab19"
}

Eksekusi awal menghasilkan rekomendasi untuk Tranquil Breeze Cruise dan Fantasy Seas Adventure Cruise, karena agen mengantisipasi bahwa mereka adalah kapal pesiar paling santai yang tersedia melalui pencarian vektor. Dokumen-dokumen ini memiliki skor tertinggi untuk similarity_search_with_score dipanggil dalam lapisan data API, data.mongodb.travel.similarity_search().

Skor pencarian kesamaan muncul sebagai output dari API untuk tujuan penelusuran kesalahan. Berikut adalah output setelah panggilan ke data.mongodb.travel.similarity_search():

0.8394561085977978
0.8086545112328692
2

Tip

Jika dokumen tidak dikembalikan untuk pencarian vektor, ubah similarity_search_with_score batas atau nilai filter skor sesuai kebutuhan ([doc for doc, score in docs if score >=.78]) di data.mongodb.travel.similarity_search().

Memanggil agent_chat untuk pertama kalinya membuat koleksi baru bernama history di Azure Cosmos DB untuk menyimpan percakapan berdasarkan sesi. Panggilan ini memungkinkan agen mengakses riwayat pesan obrolan yang disimpan sesuai kebutuhan. Eksekusi agent_chat berikutnya dengan parameter yang sama menghasilkan hasil yang bervariasi, karena menarik dari memori.

Menelusuri agen AI

Saat Anda mengintegrasikan agen AI ke DALAM API, komponen pencarian web bertanggung jawab untuk memulai semua permintaan. Komponen pencarian web diikuti oleh layanan pencarian, dan akhirnya komponen data.

Dalam kasus khusus ini, Anda menggunakan pencarian data MongoDB yang tersambung ke Azure Cosmos DB. Lapisan memfasilitasi pertukaran komponen model, dengan agen AI dan kode alat agen AI yang berada di lapisan layanan. Pendekatan ini memungkinkan pertukaran sumber data yang mulus. Ini juga memperluas kemampuan agen AI dengan fungsionalitas atau alat tambahan yang lebih rumit.

Diagram lapisan FastAPI dari agen perjalanan AI.

Lapisan layanan

Lapisan layanan membentuk landasan logika bisnis inti. Dalam skenario khusus ini, lapisan layanan memainkan peran penting sebagai repositori untuk kode Agen LangChain. Ini memfasilitasi integrasi permintaan pengguna yang mulus dengan data Azure Cosmos DB, memori percakapan, dan fungsi agen untuk agen AI.

Lapisan layanan menggunakan modul pola singleton untuk menangani inisialisasi terkait agen dalam file init.py . Berikut adalah konten layanan/init.py:

from dotenv import load_dotenv
from os import environ
from langchain.globals import set_llm_cache
from langchain_openai import ChatOpenAI
from langchain_mongodb.chat_message_histories import MongoDBChatMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain.agents import AgentExecutor, create_openai_tools_agent
from service import TravelAgentTools as agent_tools

load_dotenv(override=False)


chat : ChatOpenAI | None=None
agent_with_chat_history : RunnableWithMessageHistory | None=None

def LLM_init():
    global chat,agent_with_chat_history
    chat = ChatOpenAI(model_name="gpt-3.5-turbo-16k",temperature=0)
    tools = [agent_tools.vacation_lookup, agent_tools.itinerary_lookup, agent_tools.book_cruise ]

    prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You are a helpful and friendly travel assistant for a cruise company. Answer travel questions to the best of your ability providing only relevant information. In order to book a cruise you will need to capture the person's name.",
        ),
        MessagesPlaceholder(variable_name="chat_history"),
        ("user", "Answer should be embedded in html tags. {input}"),
         MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
    )

    #Answer should be embedded in HTML tags. Only answer questions related to cruise travel, If you can not answer respond with \"I am here to assist with your travel questions.\". 


    agent = create_openai_tools_agent(chat, tools, prompt)
    agent_executor  = AgentExecutor(agent=agent, tools=tools, verbose=True)

    agent_with_chat_history = RunnableWithMessageHistory(
        agent_executor,
        lambda session_id: MongoDBChatMessageHistory( database_name="travel",
                                                 collection_name="history",
                                                   connection_string=environ.get("MONGO_CONNECTION_STRING"),
                                                   session_id=session_id),
        input_messages_key="input",
        history_messages_key="chat_history",
)

LLM_init()

File init.py memulai pemuatan variabel lingkungan dari file .env dengan menggunakan load_dotenv(override=False) metode . Kemudian, variabel global bernama agent_with_chat_history dibuat untuk agen. Agen ini ditujukan untuk digunakan oleh TravelAgent.py.

Metode LLM_init() ini dipanggil selama inisialisasi modul untuk mengonfigurasi agen AI untuk percakapan melalui lapisan web API. Objek OpenAI chat dibuat melalui model GPT-3.5 dan menggabungkan parameter tertentu seperti nama model dan suhu. Objek chat , daftar alat, dan templat perintah digabungkan untuk menghasilkan AgentExecutor, yang beroperasi sebagai agen perjalanan AI.

Agen dengan riwayat, agent_with_chat_history, didirikan melalui RunnableWithMessageHistory dengan riwayat obrolan (MongoDBChatMessageHistory). Tindakan ini memungkinkannya mempertahankan riwayat percakapan lengkap melalui Azure Cosmos DB.

Prompt

Prompt LLM awalnya dimulai dengan pernyataan sederhana "Anda adalah asisten perjalanan yang membantu dan ramah untuk perusahaan pesiar." Namun, pengujian menunjukkan bahwa Anda dapat memperoleh hasil yang lebih konsisten dengan menyertakan instruksi "Jawab pertanyaan perjalanan sebaik mungkin, hanya memberikan informasi yang relevan. Untuk memesan kapal pesiar, mengambil nama orang tersebut sangat penting." Hasilnya muncul dalam format HTML untuk meningkatkan banding visual antarmuka web.

Alat agen

Alat adalah antarmuka yang dapat digunakan agen untuk berinteraksi dengan dunia, sering kali melalui panggilan fungsi.

Saat membuat agen, Anda harus melengkungkannya dengan sekumpulan alat yang dapat digunakannya. Dekorator @tool menawarkan pendekatan paling mudah untuk menentukan alat kustom.

Secara default, dekorator menggunakan nama fungsi sebagai nama alat, meskipun Anda dapat menggantinya dengan menyediakan string sebagai argumen pertama. Dekorator menggunakan docstring fungsi sebagai deskripsi alat, sehingga memerlukan provisi docstring.

Berikut adalah konten layanan/TravelAgentTools.py:

from langchain_core.tools import tool
from langchain.docstore.document import Document
from data.mongodb import travel
from model.travel import Ship


@tool
def vacation_lookup(input:str) -> list[Document]:
    """find information on vacations and trips"""
    ships: list[Ship] = travel.similarity_search(input)
    content = ""

    for ship in ships:
        content += f" Cruise ship {ship.name}  description: {ship.description} with amenities {'/n-'.join(ship.amenities)} "

    return content

@tool
def itinerary_lookup(ship_name:str) -> str:
    """find ship itinerary, cruise packages and destinations by ship name"""
    it = travel.itnerary_search(ship_name)
    results = ""

    for i in it:
        results += f" Cruise Package {i.Name} room prices: {'/n-'.join(i.Rooms)} schedule: {'/n-'.join(i.Schedule)}"

    return results


@tool
def book_cruise(package_name:str, passenger_name:str, room: str )-> str:
    """book cruise using package name and passenger name and room """
    print(f"Package: {package_name} passenger: {passenger_name} room: {room}")

    # LLM defaults empty name to John Doe 
    if passenger_name == "John Doe":
        return "In order to book a cruise I need to know your name."
    else:
        if room == '':
            return "which room would you like to book"            
        return "Cruise has been booked, ref number is 343242"

File TravelAgentTools.py mendefinisikan tiga alat:

  • vacation_lookup melakukan pencarian vektor terhadap Azure Cosmos DB. Ini menggunakan similarity_search untuk mengambil materi terkait perjalanan yang relevan.
  • itinerary_lookup mengambil detail dan jadwal paket pesiar untuk kapal pesiar tertentu.
  • book_cruise memesan paket pelayaran untuk penumpang.

Instruksi khusus ("Untuk memesan kapal pesiar, saya perlu mengetahui nama Anda") mungkin diperlukan untuk memastikan penangkapan nama penumpang dan nomor kamar untuk pemesanan paket pelayaran, meskipun Anda menyertakan instruksi tersebut dalam prompt LLM.

Agen AI

Konsep dasar yang mendasar agen adalah menggunakan model bahasa untuk memilih urutan tindakan yang akan dijalankan.

Berikut adalah konten layanan/TravelAgent.py:

from .init import agent_with_chat_history
from model.prompt import PromptResponse
import time
from dotenv import load_dotenv

load_dotenv(override=False)


def agent_chat(input:str, session_id:str)->str:

    start_time = time.time()

    results=agent_with_chat_history.invoke(
    {"input": input},
    config={"configurable": {"session_id": session_id}},
    )

    return  PromptResponse(text=results["output"],ResponseSeconds=(time.time() - start_time))

File TravelAgent.py mudah, karena agent_with_chat_history dan dependensinya (alat, prompt, dan LLM) diinisialisasi dan dikonfigurasi dalam file init.py . File ini memanggil agen dengan menggunakan input yang diterima dari pengguna, bersama dengan ID sesi untuk memori percakapan. Setelah itu, PromptResponse (model/prompt) dikembalikan dengan output dan waktu respons agen.

Integrasi agen AI dengan antarmuka pengguna React

Dengan keberhasilan pemuatan data dan aksesibilitas agen AI melalui API, Anda sekarang dapat menyelesaikan solusi dengan membuat antarmuka pengguna web (dengan menggunakan React) untuk situs web perjalanan Anda. Menggunakan kemampuan React membantu mengilustrasikan integrasi agen AI yang mulus ke dalam situs perjalanan. Integrasi ini meningkatkan pengalaman pengguna dengan asisten perjalanan percakapan untuk pertanyaan dan pemesanan.

Menyiapkan lingkungan untuk React

Instal Node.js dan dependensi sebelum menguji antarmuka React.

Jalankan perintah berikut dari direktori web untuk melakukan penginstalan dependensi proyek yang bersih. Penginstalan mungkin memakan waktu.

    npm ci

Selanjutnya, buat file bernama .env dalam direktori web untuk memfasilitasi penyimpanan variabel lingkungan. Sertakan detail berikut dalam file .env yang baru dibuat:

REACT_APP_API_HOST=http://127.0.0.1:8000

Sekarang, jalankan perintah berikut dari direktori web untuk memulai antarmuka pengguna web React:

    npm start

Menjalankan perintah sebelumnya akan membuka aplikasi web React.

Menelusuri antarmuka web React

Proyek web repositori GitHub adalah aplikasi yang mudah untuk memfasilitasi interaksi pengguna dengan agen AI. Komponen utama yang diperlukan untuk berkomunikasi dengan agen TravelAgent.js dan ChatLayout.js. File Main.js berfungsi sebagai modul pusat atau halaman arahan pengguna.

Cuplikan layar antarmuka web React JavaScript.

Utama

Komponen utama berfungsi sebagai manajer pusat aplikasi. Ini bertindak sebagai titik masuk yang ditunjuk untuk perutean. Dalam fungsi render, ia menghasilkan kode JSX untuk menguraikan tata letak halaman utama. Tata letak ini mencakup elemen tempat penampung untuk aplikasi, seperti logo dan tautan, bagian yang menampung komponen agen perjalanan, dan footer yang berisi sampel penafian tentang sifat aplikasi.

Berikut adalah konten main.js:

    import React, {  Component } from 'react'
import { Stack, Link, Paper } from '@mui/material'
import TravelAgent from './TripPlanning/TravelAgent'

import './Main.css'

class Main extends Component {
  constructor() {
    super()

  }

  render() {
    return (
      <div className="Main">
        <div className="Main-Header">
          <Stack direction="row" spacing={5}>
            <img src="/mainlogo.png" alt="Logo" height={'120px'} />
            <Link
              href="#"
              sx={{ color: 'white', fontWeight: 'bold', fontSize: 18 }}
              underline="hover"
            >
              Ships
            </Link>
            <Link
              href="#"
              sx={{ color: 'white', fontWeight: 'bold', fontSize: 18 }}
              underline="hover"
            >
              Destinations
            </Link>
          </Stack>
        </div>
        <div className="Main-Body">
          <div className="Main-Content">
            <Paper elevation={3} sx={{p:1}} >
            <Stack
              direction="row"
              justifyContent="space-evenly"
              alignItems="center"
              spacing={2}
            >
              
                <Link href="#">
                  <img
                    src={require('./images/destinations.png')} width={'400px'} />
                </Link>
                <TravelAgent ></TravelAgent>
                <Link href="#">
                  <img
                    src={require('./images/ships.png')} width={'400px'} />
                </Link>
              
              </Stack>
              </Paper>
          </div>
        </div>
        <div className="Main-Footer">
          <b>Disclaimer: Sample Application</b>
          <br />
          Please note that this sample application is provided for demonstration
          purposes only and should not be used in production environments
          without proper validation and testing.
        </div>
      </div>
    )
  }
}

export default Main

Agen perjalanan

Komponen agen perjalanan memiliki tujuan mudah: menangkap input pengguna dan menampilkan respons. Ini memainkan peran kunci dalam mengelola integrasi dengan agen AI back-end, terutama dengan menangkap sesi dan meneruskan permintaan pengguna ke layanan FastAPI. Respons yang dihasilkan disimpan dalam array untuk ditampilkan, difasilitasi oleh komponen tata letak obrolan.

Berikut adalah konten TripPlanning/TravelAgent.js:

import React, { useState, useEffect } from 'react'
import { Button, Box, Link, Stack, TextField } from '@mui/material'
import SendIcon from '@mui/icons-material/Send'
import { Dialog, DialogContent } from '@mui/material'
import ChatLayout from './ChatLayout'
import './TravelAgent.css'

export default function TravelAgent() {
  const [open, setOpen] = React.useState(false)
  const [session, setSession] = useState('')
  const [chatPrompt, setChatPrompt] = useState(
    'I want to take a relaxing vacation.',
  )
  const [message, setMessage] = useState([
    {
      message: 'Hello, how can I assist you today?',
      direction: 'left',
      bg: '#E7FAEC',
    },
  ])

  const handlePrompt = (prompt) => {
    setChatPrompt('')
    setMessage((message) => [
      ...message,
      { message: prompt, direction: 'right', bg: '#E7F4FA' },
    ])
    console.log(session)
    fetch(process.env.REACT_APP_API_HOST + '/agent/agent_chat', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ input: prompt, session_id: session }),
    })
      .then((response) => response.json())
      .then((res) => {
        setMessage((message) => [
          ...message,
          { message: res.text, direction: 'left', bg: '#E7FAEC' },
        ])
      })
  }

  const handleSession = () => {
    fetch(process.env.REACT_APP_API_HOST + '/session/')
      .then((response) => response.json())
      .then((res) => {
        setSession(res.session_id)
      })
  }

  const handleClickOpen = () => {
    setOpen(true)
  }

  const handleClose = (value) => {
    setOpen(false)
  }

  useEffect(() => {
    if (session === '') handleSession()
  }, [])

  return (
    <Box>
      <Dialog onClose={handleClose} open={open} maxWidth="md" fullWidth="true">
        <DialogContent>
          <Stack>
            <Box sx={{ height: '500px' }}>
              <div className="AgentArea">
                <ChatLayout messages={message} />
              </div>
            </Box>
            <Stack direction="row" spacing={0}>
              <TextField
                sx={{ width: '80%' }}
                variant="outlined"
                label="Message"
                helperText="Chat with AI Travel Agent"
                defaultValue="I want to take a relaxing vacation."
                value={chatPrompt}
                onChange={(event) => setChatPrompt(event.target.value)}
              ></TextField>
              <Button
                variant="contained"
                endIcon={<SendIcon />}
                sx={{ mb: 3, ml: 3, mt: 1 }}
                onClick={(event) => handlePrompt(chatPrompt)}
              >
                Submit
              </Button>
            </Stack>
          </Stack>
        </DialogContent>
      </Dialog>
      <Link href="#" onClick={() => handleClickOpen()}>
        <img src={require('.././images/planvoyage.png')} width={'400px'} />
      </Link>
    </Box>
  )
}

Pilih Rencanakan perjalanan Anda dengan mudah untuk membuka asisten perjalanan.

Tata letak obrolan

Komponen tata letak obrolan mengawasi pengaturan obrolan. Ini secara sistematis memproses pesan obrolan dan mengimplementasikan pemformatan yang ditentukan dalam message objek JSON.

Berikut adalah isi TripPlanning/ChatLayout.py:

import React from 'react'
import {  Box, Stack } from '@mui/material'
import parse from 'html-react-parser'
import './ChatLayout.css'

export default function ChatLayout(messages) {
  return (
    <Stack direction="column" spacing="1">
      {messages.messages.map((obj, i = 0) => (
        <div className="bubbleContainer" key={i}>
          <Box
            key={i++}
            className="bubble"
            sx={{ float: obj.direction, fontSize: '10pt', background: obj.bg }}
          >
            <div>{parse(obj.message)}</div>
          </Box>
        </div>
      ))}
    </Stack>
  )
}

Permintaan pengguna berada di sisi kanan dan biru berwarna. Respons dari agen perjalanan AI berada di sisi kiri dan berwarna hijau. Seperti yang ditunjukkan gambar berikut, respons berformat HTML diperhitungkan dalam percakapan.

Cuplikan layar obrolan.

Ketika agen AI Anda siap untuk masuk ke produksi, Anda dapat menggunakan penembolokan semantik untuk meningkatkan performa kueri sebesar 80% dan untuk mengurangi inferensi LLM dan biaya panggilan API. Untuk menerapkan penembolokan semantik, lihat posting ini di blog Stochastic Coder.

Diagram penembolokan semantik.

Konten terkait