Panduan: Bagaimana untuk membina Ejen AI untuk Pasukan SRE

Latar belakang

Pasukan kejuruteraan di Aptible AI telah menghabiskan ~4 bulan terakhir membina Ejen AI untuk membantu pasukan SRE kami menyiasat dan menyelesaikan isu pengeluaran. Oleh kerana kami telah bercakap dengan begitu ramai penguji awal dan rakan kongsi reka bentuk yang sedang membina Ejen mereka sendiri untuk tujuan yang sama, kami memutuskan untuk mengumpulkan panduan yang menerangkan perkara yang telah kami lakukan dengan Ejen kami sendiri dan cara anda boleh membina satu sendiri.

Apa yang ada dalam panduan ini

Dalam tutorial langkah demi langkah berikut, kami akan menunjukkan kepada anda cara untuk:

1. Sediakan Ejen dalam Chainlit
2. Sambungkan Ejen anda kepada LLM (dalam kes ini, gpt-4o)
3. Jadikan Ejen anda lebih pantas dan tambahkan "menaip" masa nyata (serupa dengan ChatGPT)
4. Berikan Ejen anda keperibadian dan pengkhususan
5. Beri Ejen anda keupayaan untuk mencari koleksi fail
6. Sepadukan Ejen anda dengan alatan luaran (dalam kes ini, PagerDuty)

Tetapi pertama, beberapa pertimbangan dan petua profesional.

Pertimbangan dan petua profesional

Adakah sudah ada alat untuk itu?

? Pertimbangan: Jika anda tidak perlu membina sesuatu yang baharu, maka anda tidak sepatutnya. Ada begitu. ramai. alatan di pasaran. Dan bergantung pada kes penggunaan khusus anda, anda mungkin dapat mencari yang sesuai untuk anda.

Pendorong untuk pencarian Aptible dan akhirnya perkembangan tindak balas insiden kami sendiri ialah kami bergelut dengan silo pengetahuan dan mempunyai kecenderungan untuk bergantung pada tiga atau empat pakar subjek pada bila-bila masa kami menghadapi masalah dengan sistem tertentu.

Jadi, kami mulakan dengan alat sumber terbuka yang dipanggil Danswer untuk meningkatkan perolehan maklumat (serupa dengan pesaing komersialnya yang popular, Glean). Ia dipalamkan terus ke dalam Slack dan boleh mendapatkan jawapan kepada soalan bahasa semula jadi daripada pelbagai sumber maklumat. Masalahnya ialah ia terhad kepada data yang diindeks sahaja (iaitu, hanya dokumen kami dan sejarah sembang kami).

⚒️ Apa yang kami bina: Apa yang kami perlukan ialah alat yang boleh disepadukan dengan semua sistem kami yang lain (bukan hanya dokumen dan Slack). Kami perlu mendapatkan semula log dan metrik, status kesihatan aplikasi dan menjana laporan serta bedah siasat selepas insiden kami selesai. Oleh itu, kami mereka bentuk Ejen AI yang pada asasnya dibina berdasarkan siri penyepaduan yang membolehkan anda berhubung dengan kedua-dua data masa nyata dan diindeks. Lebih lanjut mengenainya kemudian!

? Petua Pro: Sebelum anda membuat keputusan untuk membina produk anda sendiri, lihat perkara yang sudah tersedia. Tempat yang bagus untuk bermula mungkin sumber ramai daripada Reddit (lihat utas ini, untuk satu) atau semak beberapa alat sumber terbuka di luar sana (ini adalah tempat yang baik untuk bermula di github jika anda sedang mencari alat tindak balas insiden secara khusus ). Terdapat juga senarai panjang Ejen AI sumber terbuka yang anda boleh mula gunakan esok.

Apakah strategi penyepaduan anda?

? Pertimbangan: Seperti yang dinyatakan di atas, pertimbangan terbesar di sini ialah: apakah jenis maklumat yang anda perlukan untuk diakses oleh Ejen anda? Anda mungkin boleh lari dengan hanya menyepadukannya dengan penyedia pihak ketiga melalui API, tetapi jika anda memerlukan penyepaduan untuk lebih khusus kepada keperluan anda, maka anda perlu lebih bertimbang rasa dengan cara penyepaduan anda berfungsi.

Dengan mempertimbangkan dengan teliti perkara yang anda perlukan untuk disepadukan sebelum anda mula membina, anda akan menyelamatkan diri anda daripada sakit kepala di kemudian hari. Adakah anda memerlukan Ejen anda untuk dapat melaksanakan skrip tersuai untuk menanyakan pangkalan data anda? Adakah anda memerlukan mendapatkan semula log dan metrik masa nyata, dan bagaimana anda akan mereka bentuk Ejen untuk mendapatkan semula maklumat tersebut? Adakah ia akan mengembalikan pautan kepada sumber? Adakah ia akan mengembalikan sebahagian daripada baris log yang anda masih perlu menapis secara manual atau adakah ia dapat menyimpulkan di mana anomali itu mungkin?

⚒️ Apa yang kami bina: Pada terasnya, Aptible AI dibina berdasarkan siri penyepaduan. Penyepaduan adalah lebih daripada sekadar sambungan kepada penyedia pihak ketiga, ia juga merupakan koleksi konfigurasi yang unik kepada cara pasukan kami menggunakan penyedia tersebut. Sebagai contoh, Aptible AI menyokong berbilang penyepaduan untuk pembekal yang sama memandangkan kami mungkin mahu menggunakan penyedia itu dengan cara yang berbeza. Pasukan yang berbeza menggunakan Datadog secara berbeza dan mengambil berat tentang metrik yang berbeza atau menggunakan teg yang berbeza, jadi setiap pasukan boleh menggunakan penyepaduan kepada alat yang sama mengikut cara yang mereka perlukan.

Aptible AI menyokong pelbagai alatan SRE biasa, termasuk:

• Sembang dan komunikasi sangat segerak lain
• Dokumentasi dan repositori pengetahuan lain
• Kebolehperhatian
• Memberitahu

Pelaksanaan sebenar penyepaduan ini sesuai dengan salah satu daripada tiga kategori kebolehsesuaian:

Sebagai permulaan, anda mempunyai integrasi asas yang tidak memerlukan penyesuaian (PagerDuty ialah satu contoh). Memandangkan ia hanya menarik data daripada PagerDuty dan menambahkannya pada konteks AI, setiap pasukan yang memanfaatkan integrasi PagerDuty menggunakannya dengan cara yang sama.

Seterusnya, kami mempunyai lebih banyak penyepaduan yang boleh disesuaikan (seperti contoh Datadog dari sebelumnya) yang dibina di atas penyepaduan InfluxDB generik tetapi disesuaikan dengan kes penggunaan khusus mencari metrik kontena dan mencari aktiviti mulakan semula.

Akhir sekali, terdapat alatan tersuai sepenuhnya yang berkemungkinan tidak masuk akal kepada sesiapa di luar Aptible (contoh di sini ialah penyepaduan kami yang mendapatkan bekas untuk aplikasi). Ini adalah khusus sepenuhnya kepada cara kami menjalankan infrastruktur kami dan boleh dilaksanakan sama ada oleh antara muka PubSub yang ringan atau proksi "selamat" berasaskan soket web.

? Petua pro: Kurang lebih! Jika anda memberikan model terlalu banyak alat untuk dipilih, ia boleh mula memilih alat yang salah dan mengelirukan dirinya sendiri. Lebih lanjut mengenainya dalam bahagian seterusnya

Begitu banyak model, bagaimana anda memilih satu?!

? Pertimbangan: Inilah perkara dengan model… model baharu muncul setiap hari dan terdapat beberapa pertimbangan yang perlu diingat semasa memilih satu (terutamanya berkaitan dengan kes penggunaan khusus anda). Sekiranya anda menjadi hos sendiri? Adakah anda memerlukan Ejen anda untuk menjadi perbualan atau berasaskan tugas atau kedua-duanya? Adakah ia akan menjalankan tugas yang mudah atau kompleks? Adakah anda memerlukan prestasi masa nyata?

Kami tidak perlu meneliti semua model yang wujud kerana kandungan itu sudah ada di mana-mana (jika anda mahukan penyelaman yang mendalam, ini adalah sumber yang hebat), tetapi kami boleh meneruskan keputusan yang kami ada untuk dibuat apabila membina Aptible AI dan pilihan yang kami pertimbangkan.

Ini adalah proses yang rumit kerana anda tidak boleh benar-benar mengelakkan pertukaran. Jika anda memerlukan Ejen anda untuk menjalankan tugas yang rumit, maka anda perlu berkorban sedikit pada kelajuan dan kos.

Saiz, keupayaan dan seni bina model sangat bergantung pada sama ada tugasan memerlukan pengelasan mudah atau penaakulan dan interaksi yang sangat kompleks. Jika mudah, model yang lebih kecil dan ringan seperti pokok keputusan, hutan rawak atau rangkaian saraf ringkas sudah memadai. Jika lebih kompleks, maka anda boleh mempertimbangkan model yang lebih berkuasa seperti GPT-4, BERT atau seni bina berasaskan pengubah yang serupa.

Jika anda memilih untuk menjadi hos sendiri untuk mengelakkan masalah keselamatan, anda mungkin perlu berkorban pada ciri dan fungsi kerana versi hos sendiri anda akan ketinggalan daripada pilihan yang dihoskan.

Jika anda memerlukan Ejen anda dilatih tentang pengetahuan khusus domain, maka anda perlu menyusun atau membuat set data anda sendiri untuk penalaan halus. Lihat sama ada anda boleh lari dengan menggunakan model pra-latihan yang telah dilatih pada set data yang besar untuk mengelakkan isu kualiti data (walaupun ini mungkin mustahil bergantung pada data yang anda perlukan untuk diakses oleh Ejen anda).

⚒️ Apa yang kami bina: Kami sedang menggunakan GPT-4o untuk Aptible AI kerana kami percaya bahawa ia berkemungkinan besar memberikan jawapan berkualiti tinggi kepada kami. Walau bagaimanapun, kami menyedari bahawa pelanggan yang menggunakan Aptible AI mungkin mahu menggunakan model mereka sendiri (termasuk model yang dihoskan sendiri). Oleh itu, kami sentiasa mengingati perkara itu semasa kami membina.

? Petua Pro: Ejen anda hanya akan bijak seperti maklumat yang anda berikan. LLM memerlukan bantuan untuk memahami cara dan masa untuk menggunakan maklumat yang anda berikan, dan jika anda tidak memberikannya arahan tentang cara mentafsir maklumat, ia hanya akan membuat sesuatu. Luangkan usaha sebenar terlebih dahulu untuk memilih maklumat yang anda suapkan kepada LLM anda!

Bagaimana pula dengan teknik dorongan?

? Pertimbangan: Anda mungkin tergoda untuk mendapatkan sebanyak mungkin data (dokumentasi, perbualan Slack, repositori kod, penjejak isu, dll.), buang semuanya pada aplikasi RAG*, * dan tanya soalan. Tetapi dalam pengalaman kami, hampir selalu terdapat terlalu banyak bunyi untuk ini berguna. Di situlah kejuruteraan segera datang.

Kami telah pun merujuk kepada perkara ini, tetapi kejuruteraan segera adalah bahagian penting dalam teka-teki di sini (untuk gambaran keseluruhan yang hebat tentang teknik dorongan, lihat ini). Lebih baik kejuruteraan segera anda, lebih baik Ejen anda.

Untuk konteks, berikut adalah beberapa yang kami pertimbangkan (dari semasa ke semasa) semasa membina Aptible AI:

Gesaan sifar tangkapan: inilah yang kebanyakan orang lakukan apabila mereka bercakap dengan ChatGPT; mereka hanya bertanya soalan kemudian mereka mendapat jawapan. Jika jawapannya buruk, maka mereka hanya bertanya soalan secara berbeza.

Gesaan beberapa pukulan: inilah yang dilakukan oleh orang yang lebih berpengalaman sedikit apabila bercakap dengan ChatGPT; mereka bertanya soalan dan menyertakan contoh output yang mereka mahukan. Anda mungkin menggunakan gesaan sifar dan/atau beberapa pukulan untuk tugasan yang sangat mudah yang model asasnya sudah tahu cara melakukannya.

Retrieval Augmented Generation (RAG): ini ialah teknik yang membolehkan model mendapatkan semula konteks tambahan dan menggunakannya untuk menjawab soalan. Ini amat berguna untuk carian dokumen berkuasa AI (lihat juga: Glean dan Danswer).

ReAct: teknik ini membolehkan ejen menjana "pemikiran" dan mengambil "tindakan" dengan cara berulang untuk menyelesaikan masalah, paling serupa dengan penaakulan manusia. ReAct bagus untuk masalah yang sederhana kompleks, seperti menavigasi rujukan melalui dokumentasi dan alatan dalam masa nyata untuk mengarang jawapan.

Perkara penting yang perlu diingat ialah anda boleh mencampur dan memadankan teknik ini (kami akan membincangkan pendekatan berbilang ejen seterusnya). Inilah yang kami lakukan…

⚒️ Apa yang kami bina: Oleh kerana Aptible AI mempunyai struktur berbilang ejen (lebih lanjut mengenainya kemudian), kami telah melaksanakan gabungan ReAct dan RAG bergantung pada kerumitan tugas/soalan.

Jadi apabila anda bertanya soalan kepada AI, kami menyerahkan semua penyepaduan (dengan arahan tentang cara menggunakannya) kepada AI. AI kemudiannya membuat keputusan tentang alat yang hendak dipanggil berdasarkan maklumat yang tersedia untuknya. Selepas setiap panggilan penyepaduan, AI mempunyai pilihan untuk memutuskan ia mempunyai maklumat yang mencukupi untuk memberikan jawapan atau memutuskan bahawa penyepaduan tambahan adalah relevan dan berpotensi menghasilkan maklumat tambahan.

Sepanjang proses ini, kami cuba membantu AI membuat keputusan yang lebih baik tentang penyepaduan yang akan dimanfaatkan melalui beberapa mekanisme berbeza:

Kejuruteraan pantas yang meluas untuk penyepaduan, untuk memastikan ia benar-benar jelas masa dan cara menggunakan setiap penyepaduan, serta cara mentafsir output.

Kami telah membina sistem penilaian sendiri yang meminta AI menilai sendiri nilai respons daripada penyepaduan. Walaupun AI membuat keputusan bodoh dalam memanggil penyepaduan (atau menyediakan input yang tidak baik), ia biasanya dapat mengenalinya selepas fakta itu jika anda memintanya untuk menilai sendiri sama ada output penyepaduan itu berguna atau tidak. Kita kemudian boleh menggunakannya untuk mempengaruhi berapa banyak faktor keluaran tertentu ke dalam tindak balas. Kami juga boleh menyekat AI daripada meneruskan jika ia secara konsisten membuat keputusan yang salah.

Kami telah melaksanakan Naïve Bayes berdasarkan pengalaman lalu. Sebagai contoh, jika kebanyakan masa anda memanggil penyepaduan A dan kemudian B, dan itu menghasilkan hasil yang berguna, mungkin berguna untuk terus berbuat demikian. Ejen juga boleh menggunakan perkara seperti membandingkan dengan insiden serupa sebelum ini untuk mengecilkan lagi penyepaduan yang berguna dan bila, dalam senario tertentu.

? Petua Pro: Untuk mengelakkan jawapan karut yang kedengaran betul tetapi tidak, pastikan anda mengambil langkah ke belakang dan pertimbangkan dari mana maklumat anda yang paling berguna biasanya datang untuk masalah yang anda cuba selesaikan dengan AI – kemudian reka Ejen anda berdasarkan itu.

Pelbagai ejen atau ejen tunggal?

? Pertimbangan: Pendekatan berbilang ejen semakin popular, tetapi ia boleh menjadi rumit dan mungkin tidak diperlukan bergantung pada kes penggunaan anda. Ia boleh menjadi sangat berguna untuk mempunyai pasukan ejen yang bekerja bersama-sama dengan teknik yang berbeza untuk menyelesaikan masalah yang rumit.

Sebagai contoh, jika anda bertanya kepada bot anda soalan dalam Slack yang tiada kaitan dengan infrastruktur khusus anda (mungkin anda hanya ingin tahu siapa yang memenangi Siri Dunia pada tahun 1995), anda boleh mempunyai Ejen yang dibina pada sifar pukulan menggesa untuk bertindak sebagai ChatGPT yang disepadukan dengan Slack anda (atau di mana sahaja anda memilikinya).

Tetapi jika soalan atau keperluan anda rumit, adalah berguna untuk mempunyai pasukan Ejen yang pada asasnya bertindak sebagai pasukan penyelidik kecil anda, mengumpul dan menganalisis data daripada sumber yang berbeza dengan cara yang bijak.

⚒️ Apa yang kami bina: Aptible AI menggunakan pendekatan berbilang ejen, bermula dengan Ejen broker yang menentukan jenis soalan atau tugas yang perlu ditangani.

? Petua Pro: Lebih mudah untuk memfaktorkan semula pendekatan berbilang ejen daripada melakukannya! Jadi pastikan anda memerlukannya sebelum anda mula membina Ejen anda dengan cara itu.

Tidak boleh lupa tentang keselamatan...

? Pertimbangan: Berikut ialah topik yang sering timbul apabila kami berbual dengan pengguna awal Aptible AI. Kebanyakan pasukan kejuruteraan akhirnya terpaksa berhadapan dengan pasukan keselamatan mereka apabila ia datang untuk melaksanakan alatan baharu, dan adalah penting untuk memastikan data tersebut selamat (terutamanya jika anda bekerja dalam industri yang sangat dikawal selia). Jadi perkara pertama yang anda perlu lakukan ialah mengetahui dasar keselamatan AI organisasi anda, kemudian terdapat beberapa perkara yang boleh anda lakukan untuk melindungi daripada kemungkinan kebocoran data atau ancaman luaran.

⚒️ Apa yang kami bina: Sebagai permulaan, kami menggunakan model yang tidak melatih data kami. Kami masih melakukan banyak penemuan tentang perkara yang pelanggan perlukan berkaitan keselamatan, sama ada pengehosan sendiri atau sesuatu yang lain! Nantikan.

? Petua Pro: Berhati-hati dengan data yang anda berikan AI anda akses atau sertakan dalam gesaan, terutamanya jika data tersebut tidak sepatutnya dikongsi dengan pengguna akhir! Jika anda perlu memasukkan data yang tidak dapat diramalkan seperti log, pertimbangkan untuk menggunakan alat seperti Nightfall untuk memastikan perkara yang dihantar kepada LLM dan pengguna akhir dibersihkan

Oh, dan sudah tentu, ia perlu boleh digunakan!

? Pertimbangan: Bagaimana anda merancang untuk menggunakan Ejen anda? Adakah ia perlu mempunyai UI? Adakah ia akan digunakan di seluruh organisasi?

Anda mungkin tidak perlu meluangkan masa mencipta semula roda apabila ia berkaitan dengan UX di sekeliling bot anda. Rangka kerja seperti Chainlit, Gradio dan Streamlit memberi anda alatan luar biasa untuk membina antara muka pengguna dan/atau menyepadukan dengan alatan aliran kerja anda yang lain seperti Slack. Gunakan salah satu alatan ini untuk bermula supaya anda boleh memberi tumpuan untuk mendapatkan jawapan yang baik daripada Ejen anda!

⚒️ Apa yang kami bina: Kerana Ejen kami dibina khusus untuk tindak balas insiden — dan kerana kami mengendalikan insiden dalam Slack — kami menggunakan Slack sebagai UI kami terutamanya. Ia mempunyai hadnya, namun, jadi kami melakukan yang terbaik untuk mengatasinya (iaitu daripada menunjukkan bahawa Ejen bertindak balas dengan meniru menaip seperti yang dilihat dalam ChatGPT, bot sebaliknya bertindak balas kepada soalan dalam Slack dengan ? emoji). Kami juga mereka bentuk UI web untuk konfigurasi, pelaporan, pengauditan dan analitis.

? Petua Pro: Pastikan kod LLM anda dipisahkan sebaik mungkin, supaya anda boleh memfaktorkan semula dengan mudah ke UX lain jika perlu.

Baiklah, mari beralih daripada perbincangan teori tentang model, teknik dan rangka kerja! Masa untuk mengotorkan tangan anda dan mula membina Ejen anda sendiri.

Makmal praktikal: Bina Ejen AI anda sendiri

1. Sediakan aplikasi Chainlit

Sebelum kita mendalami lubang arnab yang tidak berkesudahan untuk membina AI, kita akan menyediakan diri untuk berjaya dengan menyediakan Chainlit, rangka kerja yang popular untuk membina antara muka pembantu perbualan.

Mengapa Chainlit?

Chainlit menyediakan set blok binaan berpandangan pendapat untuk memodelkan interaksi perbualan — seperti urutan, mesej dan langkah — serta antara muka pengguna seperti ChatGPT untuk berinteraksi dengan LLM.

Ia juga menawarkan integrasi luar biasa dengan alatan sembang popular seperti Slack dan Teams, serta perpustakaan untuk antara muka dengan alatan popular seperti React dan FastAPI, supaya anda boleh membinanya menjadi aplikasi yang lebih besar, jika anda mahu .

Ringkasnya: Chainlit akan menghapuskan banyak kerja perancah dan dengusan untuk kami supaya kami dapat menumpukan pada membangunkan pembantu AI kami dan mendapatkan maklum balas daripada pengguna kami, dan bukannya bermain-main dengan UI dan konfigurasi.

Matlamat

Menjelang akhir makmal ini, anda akan mempunyai aplikasi Chainlit yang berfungsi yang hanya akan mengulangi apa yang anda katakan. Kami akan beralih ke integrasi AI dalam artikel seterusnya.

Prasyarat

Sebelum kami bermula, anda perlu menyediakan beberapa perkara:

1. Persekitaran Python 3.12 yang berfungsi. Kami mengesyorkan menggunakan pyenv.
2. Pengurus pakej Python. Kami akan menggunakan Puisi, tetapi anda boleh menggunakan apa sahaja yang anda rasa selesa.

Setelah anda bersedia, teruskan.

Persediaan Projek

Mula-mula, sediakan projek anda dan tambahkan cahaya rantai sebagai kebergantungan:

mkdir roger
cd roger
poetry init --no-interaction
poetry add chainlit

Plat dandang berlampu rantai

Seterusnya, buat fail app.py dalam akar projek anda dengan kandungan berikut:

import chainlit as cl


@cl.on_message
async def handle_message(message: cl.Message) -> None:
    # Echo the message back to the user.
    await cl.Message(
        content=f"Received: {message.content}",
    ).send()

Kod di atas sedang mendaftarkan fungsi handle_message dengan Chainlit, supaya bila-bila masa mesej diterima, fungsi ini akan dijalankan.

Buat masa ini, fungsi kami hanya menggemakan mesej kembali kepada pengguna, diawali dengan "Diterima: ".

Cubalah

Akhir sekali, putarkannya! Anda boleh menggunakan --watch untuk hot-reload kod anda apabila anda membuat perubahan.

poetry run chainlit run app.py --watch

Menjalankan arahan ini akan memulakan apl Chainlit anda dan membuka penyemak imbas anda ke UInya, tempat anda boleh menghantar mesej dan mendapatkan balasan kembali:

2. Jadikan aplikasi anda lebih pintar dengan menyambungkan LLM

Dengan apl Chainlit kami yang dirangkai, kami boleh menyambungkannya ke LLM supaya kami boleh bercakap dengannya dan mendapat respons seperti manusia.

Kami akan menggunakan model gpt-4o yang dihoskan OpenAI untuk kesederhanaan, tetapi menggunakan penyedia lain hanyalah soal sintaks.

Matlamat

Menjelang akhir artikel ini, anda akan dapat menggesa model gpt-4o dan mendapat respons, sama seperti cara anda berinteraksi dengan ChatGPT. Kami juga akan memastikan bahawa bot mengekalkan konteks perbualan supaya anda boleh bertanya soalan susulan.

Prasyarat

Sebelum anda bermula, anda memerlukan:

Akaun OpenAI dan kunci API

Konfigurasikan klien API OpenAI

Pertama, kami akan mengkonfigurasi klien API untuk antara muka dengan API OpenAI. Tambahkan kod berikut pada bahagian atas app.py anda:

mkdir roger
cd roger
poetry init --no-interaction
poetry add chainlit

Hantar Mesej kepada LLM

Seterusnya, kami perlu mengemas kini fungsi handle_message kami untuk menghantar mesej pengguna kepada OpenAI dan mendapatkan respons dan bukannya mengulanginya semula. Gantikan fungsi handle_message anda dengan yang ini:

import chainlit as cl


@cl.on_message
async def handle_message(message: cl.Message) -> None:
    # Echo the message back to the user.
    await cl.Message(
        content=f"Received: {message.content}",
    ).send()

Cubalah

Sekarang, jika anda menjalankan aplikasi anda (atau jika anda membiarkannya berjalan dengan bendera --watch), anda akan dapat bertanya soalan dan mendapat jawapan.

Menyembuhkan Amnesia

Jika anda telah bermain-main sedikit dan bertanya soalan susulan, anda mungkin perasan bahawa bot tidak "mengingat" apa-apa yang anda bincangkan. Contohnya:

Ini berlaku kerana setiap kali kami menghantar mesej, kami hanya menghantar satu mesej itu kepada LLM, yang tidak mempunyai tanggapan tentang "perbualan" secara lalai.

Untuk menyembuhkan amnesia ini, kami perlu menghantar semua mesej dalam perbualan setiap kali kami menghantar mesej baharu.

Chainlit memudahkan kami dengan menyediakan pembantu cl.chat_context.to_openai(), yang memberikan kami semua mesej yang ditukar setakat ini, dengan mudah dalam format yang OpenAI (dan kebanyakan penyedia lain) jangkakan.

Kemas kini fungsi handle_message anda untuk menambah mesej sejarah sebelum yang terkini:

poetry run chainlit run app.py --watch

Kini kami boleh bertanya soalan susulan!

3. Maklum balas yang lebih pantas ?️

Selepas melengkapkan beberapa langkah pertama dari Bahagian 1, anda mungkin perasan bahawa apabila anda bertanya soalan yang memerlukan jawapan yang panjang, terdapat kelewatan sebelum anda melihat apa-apa.

Ini boleh menyebabkan pengalaman pengguna yang buruk (terutamanya kemudian dalam bahagian 3, apabila kami mula menambah panggilan alat yang berjalan lama) jadi mari kita perbaikinya.

Matlamat

Pada penghujung langkah ini, anda akan dapat melihat "taip" bot anda dalam masa nyata, serupa dengan ChatGPT.

Strimkannya

Untuk mendapatkan kemas kini mesej masa nyata, kami perlu mengemas kini pelaksanaan kami untuk menggunakan "strim". Pada asasnya, setiap kali kami menerima mesej, kami akan membalas serta-merta dengan mesej kosong, memulakan strim dengan LLM dan mengemas kini mesej kosong kami setiap kali kami menerima sebahagian baru respons daripada strim.

Ini mungkin kedengaran rumit, tetapi ia sangat mudah! Kemas kini fungsi handle_message anda seperti berikut:

mkdir roger
cd roger
poetry init --no-interaction
poetry add chainlit

?? Jadi, inilah kod lengkap setakat ini:

import chainlit as cl


@cl.on_message
async def handle_message(message: cl.Message) -> None:
    # Echo the message back to the user.
    await cl.Message(
        content=f"Received: {message.content}",
    ).send()

Cubalah

Sekarang, apabila anda bertanya soalan, anda sepatutnya melihat bot anda "menaip" dalam masa nyata!

4. Berikan Ejen anda pengkhususan dan personaliti ?‍♂️

Pada ketika ini, kami telah membina klon ringan ChatGPT. Itu bagus dan semuanya, tetapi apa yang kami mahukan ialah pembantu yang akan membantu kami melaksanakan tugas tertentu: dalam kes ini, kami mahu ia menyelesaikan masalah, seperti yang dilakukan oleh SRE.

Untuk sampai ke sana, kami akan mulakan dengan memfaktorkan semula ejen kami menjadi Pembantu OpenAI tersuai, yang akan memberi kami kawalan ke atas gesaan sistem (serta keupayaan untuk memberikan LLM akses kepada alatan seperti carian fail dan panggilan fungsi, yang akan kami bincangkan kemudian).

Matlamat

Menjelang akhir langkah ini, anda akan memfaktorkan semula bot anda menjadi "Pembantu" tersuai dan menyesuaikan gesaan sistemnya untuk memberikan "personaliti" tersendiri. Kod anda juga akan menggunakan "benang", yang akan mengekalkan mesej menggunakan API OpenAI, dan bukannya perlu menghantar semua mesej setiap kali kami menerima mesej baharu.

Buat Assistant & Thread

Membuat Assistant adalah mudah: kita hanya perlu memanggil OpenAI Assistants API. Walau bagaimanapun, kami hanya mahu melakukan ini sekali apabila aplikasi dimulakan, jadi kami tidak boleh meletakkan panggilan API itu dalam fungsi handle_message.

Sebaliknya, kami akan menggunakan cangkuk Chainlit yang lain — on_chat_start, yang hanya akan dijalankan sekali apabila aplikasi mula-mula dimulakan — untuk menyediakan pembantu kami.

Tambahkan ini pada app.py anda:

poetry run chainlit run app.py --watch

Nota: secara teknikalnya mungkin untuk memberi pembantu gesaan sistem tersuai dengan menyediakan mesej jenis sistem awal dalam sejarah mesej dalam handle_message. Walau bagaimanapun, kami memfaktorkan semula menjadi pembantu dengan arahan tersuai kerana ia membuka kunci beberapa keupayaan lain yang akan kami gunakan dalam masa terdekat.

Pengendalian Mesej Refactor untuk menggunakan Assistant

Sekarang kami mempunyai Assistant dan Thread untuk perbualan, kami boleh memfaktorkan semula pengendali mesej kami untuk menggunakannya.

Pertama, kami memerlukan AssistantEventHandler untuk memberitahu objek Assistant baharu kami cara mengendalikan pelbagai acara yang berlaku semasa perbualan.

Tambah yang berikut pada app.py anda:

import os
from openai import AsyncOpenAI


##
# Settings
#
try:
    OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
except KeyError as ex:
    raise LookupError(f"Missing required environment variable: {ex}")


client = AsyncOpenAI(api_key=OPENAI_API_KEY)


# ...

Kini, kami hanya perlu melaraskan fungsi handle_message kami untuk menggunakan semua mainan baharu kami! Kemas kini fungsi handle_message anda kepada yang berikut:

# ...


@cl.on_message
async def handle_message(message: cl.Message) -> None:
    # Retrieve the response from the LLM
    response = await client.chat.completions.create(
        messages=[{"content": message.content, "role": "user"}],
        model="gpt-4o",
    )


    await cl.Message(content=response.choices[0].message.content).send()

?? Sekarang inilah kod lengkap setakat ini:

mkdir roger
cd roger
poetry init --no-interaction
poetry add chainlit

5. Berikan Ejen anda akses kepada dokumen anda

Sekarang kami menggunakan Assistant dan Thread, kami boleh mula menyesuaikan gelagat. Untuk bermula, kami akan memberikan Assistant kami akses kepada beberapa dokumentasi dalaman kami supaya ia dapat memberikan respons yang lebih disesuaikan dengan kes penggunaan kami.

Matlamat

Menjelang akhir bahagian ini, anda akan memberikan bot anda keupayaan untuk mencari koleksi fail (cth., buku panduan SRE anda dan dokumentasi dalaman yang lain) apabila membalas gesaan.

Untuk memudahkan, kami akan melaksanakan ini sebagai folder yang penuh dengan fail yang dimuat naik ke kedai vektor dan diberikan kepada Pembantu kami.

Mencipta Kedai Vektor

Perkara pertama yang perlu kami lakukan ialah mencipta kedai vektor dan memberikannya kepada Pembantu kami.

Mula-mula, kemas kini permulaan fungsi handle_chat_start kami untuk memasukkan perkara berikut:

import chainlit as cl


@cl.on_message
async def handle_message(message: cl.Message) -> None:
    # Echo the message back to the user.
    await cl.Message(
        content=f"Received: {message.content}",
    ).send()

Seterusnya, kemas kini panggilan kepada client.beta.assistants.update() untuk memberi pembantu akses kepada stor vektor dan mendayakan alat carian_fail.

poetry run chainlit run app.py --watch

Muat Naik Dokumentasi

Akhir sekali, kami perlu memuat naik dokumentasi kami yang kami mahu pembantu kami rujukan semasa menjawab gesaan.

Pertama, kami perlu mencipta folder tempat kami akan meletakkan dokumen kami:

import os
from openai import AsyncOpenAI


##
# Settings
#
try:
    OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
except KeyError as ex:
    raise LookupError(f"Missing required environment variable: {ex}")


client = AsyncOpenAI(api_key=OPENAI_API_KEY)


# ...

Seterusnya, kami akan mengumpul dokumentasi kami dan memasukkannya ke dalam folder itu. Untuk tujuan ujian, saya telah menambahkan dokumen palsu berikut pada folder saya:

# ...


@cl.on_message
async def handle_message(message: cl.Message) -> None:
    # Retrieve the response from the LLM
    response = await client.chat.completions.create(
        messages=[{"content": message.content, "role": "user"}],
        model="gpt-4o",
    )


    await cl.Message(content=response.choices[0].message.content).send()

Akhir sekali, kami akan mengemas kini fungsi handle_chat_start kami untuk memuat naik dokumen kami secara automatik ke kedai vektor yang kami buat sebelum ini. Tambahkan kod berikut sejurus selepas tempat kami mencipta kedai vektor:

# ...


@cl.on_message
async def handle_message(message: cl.Message) -> None:
    # Retrieve the response from the LLM
    response = await client.chat.completions.create(
        messages=[
            # Prepend all previous messages to maintain the conversation.
            *cl.chat_context.to_openai(),
                {"content": message.content, "role": "user"}
            ],
        model="gpt-4o",
    )


    await cl.Message(content=response.choices[0].message.content).send()

ℹ️ Nota: Buat masa ini, kami hanya akan menyokong fail .md, tetapi OpenAI menyokong banyak jenis fail yang berbeza, jadi jangan ragu untuk mengemas kini corak glob kepada apa sahaja yang masuk akal untuk kes penggunaan anda!

Ini akan memuat naik secara automatik semua fail dalam folder ./docs dan menambahkannya ke kedai vektor kami.

Tambah penunjuk

Carian fail kadangkala boleh mengambil sedikit masa, terutamanya untuk set data yang lebih besar. Dalam kes tersebut, anda mungkin ingin memberitahu pengguna apa yang sedang berlaku supaya mereka tidak kecewa.

Nasib baik, Chainlit memudahkan perkara ini dengan menyediakan kelas Step yang boleh kami gunakan untuk memberitahu pengguna bahawa sesuatu sedang berlaku di latar belakang. Kita boleh menggunakan kelas Step bersama-sama dengan MessageEventHandler yang kami bina sebelum ini dan menambah penunjuk pada bila-bila masa alat dipanggil.

Tambah yang berikut pada MessageEventHandler anda:

# ...
@cl.on_message
async def handle_message(message: cl.Message) -> None:
    # Send an empty initial message that we can update with a streaming
    # response.
    message = cl.Message(content="")
    await message.send()

    # Stream the response from the LLM
    stream = await client.chat.completions.create(
        messages=[
            # Prepend all previous messages to maintain the conversation.
            *cl.chat_context.to_openai(),
                {"content": message.content, "role": "user"}
            ],
        model="gpt-4o",
        stream=True,
    )
    # Update the existing (initially-empty) message with new content
    # from each "chunk" in the stream.
    async for chunk in stream:
        if token := chunk.choices[0].delta.content:
            await message.stream_token(token)
    # Send a final update to let the message know it's complete.
    await message.update()

Cubalah

Sekarang anda telah memuat naik beberapa dokumentasi anda sendiri, cuba tanya beberapa soalan yang lebih khusus untuk kes penggunaan anda dan lihat apa yang anda dapat!

Untuk kes ujian kami, ia merujuk buku panduan kami dengan betul apabila ditanya tentang penggunaan CPU yang tinggi pada pangkalan data pelanggan:

?? Untuk rujukan, berikut ialah kod lengkap setakat ini:

mkdir roger
cd roger
poetry init --no-interaction
poetry add chainlit

6. Sambungkan Ejen anda kepada alatan luaran

Ejen kami kini boleh mendapatkan semula data daripada dokumentasi dalaman kami yang dipilih susun, yang berguna jika anda mempunyai dokumentasi yang baik. Walau bagaimanapun, banyak masa dalam pengurusan insiden sering digunakan untuk menyiasat perkara yang tidak diliputi oleh dokumen: amaran mengimbas, membaca log, mentafsir metrik, dsb.

Untuk perkara itu, kami ingin memberikan pembantu kami keupayaan untuk memanggil API luaran — dan secara lebih meluas, laksanakan fungsi yang kami takrifkan — supaya ia boleh mengumpulkan lebih banyak konteks mengikut keperluan.

Untuk melakukan ini, kami akan memanfaatkan keupayaan "panggilan fungsi" model untuk melaksanakan fungsi yang kami tentukan.

Matlamat

Menjelang akhir bahagian ini, anda akan memberikan bot anda keupayaan untuk menggunakan alat luaran (alat PagerDuty palsu) untuk mendapatkan maklumat apabila menjawab gesaan.

Tentukan Alat (palsu).

Mula-mula, mari tambahkan fungsi baharu pada app.py kami yang dipanggil get_pagerduty_alert_details.

import chainlit as cl


@cl.on_message
async def handle_message(message: cl.Message) -> None:
    # Echo the message back to the user.
    await cl.Message(
        content=f"Received: {message.content}",
    ).send()

Beritahu LLM cara menggunakannya

Seterusnya, kami perlu memberitahu LLM cara memanggil alat kami. OpenAI mengharapkan definisi alat dalam format JSONSchema.

Kemas kini panggilan anda kepada client.beta.assistants.update() untuk memasukkan definisi alat baharu selepas alat carian_fail yang telah kami miliki.

poetry run chainlit run app.py --watch

Kemas kini pengendali mesej untuk mengendalikan panggilan alat

MessageEventHandler kami pada masa ini mengendalikan acara mesej berulang-alik, tetapi alat panggilan memerlukan beberapa pengendalian khas.

Apabila membalas gesaan anda, LLM akan memutuskan alat yang patut dipanggil (jika ada) dan mengembalikan kepada anda satu atau lebih definisi "panggilan alat" dalam muatan respons dan memberitahu anda bahawa respons "memerlukan tindakan". Untuk benar-benar melaksanakan fungsi, kita perlu mengendalikan respons "memerlukan tindakan" ini.

Kami boleh melakukan ini dengan mengemas kini kelas MessageEventHandler kami untuk melaksanakan kaedah on_event, bersama-sama dengan kaedah handle_requires_action baharu untuk melaksanakan panggilan fungsi kami dan menambahkan hasilnya pada utas yang sedang berjalan:

import os
from openai import AsyncOpenAI


##
# Settings
#
try:
    OPENAI_API_KEY = os.environ["OPENAI_API_KEY"]
except KeyError as ex:
    raise LookupError(f"Missing required environment variable: {ex}")


client = AsyncOpenAI(api_key=OPENAI_API_KEY)


# ...

Tweak gesaan

Lazimnya boleh membantu untuk mengingatkan LLM bahawa ia harus cuba menggunakan alatan yang anda sediakan apabila berkenaan. Tambahkan baris seperti ini pada penghujung gesaan anda:

Gunakan alatan yang disediakan untuk mengumpulkan konteks tambahan tentang kejadian itu, jika berkenaan.

Cubalah

Dengan alatan anda dikonfigurasikan, anda akan dapat memasukkan pautan PagerDuty dalam gesaan anda dan LLM akan menggunakan alatan tersebut untuk mengumpulkan konteks sebelum menjawab:

?? Ini kod lengkapnya:

mkdir roger
cd roger
poetry init --no-interaction
poetry add chainlit

Membungkus

Kini anda sudah bersedia untuk membina Ejen AI yang berguna untuk pasukan SRE anda! Jika anda mempunyai sebarang soalan tentang apa-apa sahaja yang telah kami bincangkan dalam panduan ini, sila hubungi kami dan kami berbesar hati untuk membantu. Sementara itu, jika terdapat apa-apa yang hilang atau perkara lain berkaitan Ejen AI yang anda ingin pelajari, beritahu kami!

Jika anda ingin tahu untuk mencuba Aptible AI untuk diri sendiri daripada membina Ejen anda sendiri, anda boleh melawati www.aptible.ai untuk mendaftar.

Atas ialah kandungan terperinci Panduan: Bagaimana untuk membina Ejen AI untuk Pasukan SRE. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!