Agently
v3.4.0.5
[Important] Revisi beranda Tiongkok kerangka pengembangan Agently AI telah selesai, dan dokumen tutorial baru untuk peralihan model, AgenticRequest, dan Alur Kerja telah diperbarui sepenuhnya. Silakan kunjungi: Agently.cn untuk melihatnya
[Important] Kami akan segera menulis ulang beranda repo untuk memberi tahu Anda lebih banyak tentang pekerjaan terbaru kami, harap tunggu.
[Showcase Repo] Kolektor Berita Harian Agen: Bahasa Inggris |. Proyek sumber terbuka pembuat laporan ringkasan berita
[hot] Dokumen pengembangan versi China dari yang dangkal hingga yang lebih dalam: klik di sini untuk mengakses dan membuka keterampilan pengembangan aplikasi LLM yang kompleks langkah demi langkah
? Cara menggunakan:
pip install -U AgentlyIde / Laporan Bug: Laporkan Masalah Di Sini
? Email Kami: [email protected]
? Grup Perselisihan:
Klik Di Sini untuk Bergabung atau Pindai Kode QR di Bawah
Grup WeChat (bergabung dengan grup WeChat):
Klik Di Sini untuk Mendaftar atau Memindai Kode QR di Bawah
Jika Anda menyukai proyek ini, silakan ️, terima kasih.
Dokumen Kolab:
Contoh Kode:
Untuk membangun agen di berbagai bidang:
Atau, untuk memanggil kemampuan instans agen dalam logika kode untuk membantu:
Jelajahi Lebih Lanjut: Kunjungi Taman Bermain Demostrasi
Instal Paket Agently Python:
pip install -U AgentlyKalau begitu kita siap berangkat!
Agently adalah kerangka pengembangan yang membantu pengembang membangun aplikasi asli agen AI dengan sangat cepat.
Anda dapat menggunakan dan membangun agen AI dalam kode Anda dengan cara yang sangat sederhana.
Anda dapat membuat instance agen AI lalu berinteraksi dengannya seperti memanggil fungsi dalam beberapa kode seperti di bawah ini.
Klik tombol jalankan di bawah dan saksikan keajaibannya.
# Import and Init Settings
import Agently
agent = Agently . create_agent ()
agent
. set_settings ( "current_model" , "OpenAI" )
. set_settings ( "model.OpenAI.auth" , { "api_key" : "" })
# Interact with the agent instance like calling a function
result = agent
. input ( "Give me 3 words" )
. output ([( "String" , "one word" )])
. start ()
print ( result ) ['apple', 'banana', 'carrot']
Dan Anda mungkin memperhatikan bahwa ketika kita mencetak nilai result , nilainya adalah list seperti format parameter yang kita masukkan ke dalam .output() .
Dalam kerangka Agently kami telah melakukan banyak pekerjaan seperti ini untuk memudahkan pengembang aplikasi mengintegrasikan instance Agen ke dalam kode bisnis mereka. Hal ini akan memungkinkan pengembang aplikasi untuk fokus pada cara membangun logika bisnis mereka daripada mencari cara untuk melayani ke model bahasa atau bagaimana menjaga kepuasan model.
Saat kita mulai menggunakan agen AI dalam kode untuk membantu kita menangani logika bisnis, kita dapat dengan mudah merasakan bahwa pasti ada beberapa perbedaan dari cara pengembangan perangkat lunak tradisional. Namun apa sebenarnya perbedaannya?
Saya pikir poin kuncinya adalah menggunakan agen AI untuk menyelesaikan masalah, bukan logika kode buatan manusia.
Dalam aplikasi asli agen AI, kami memasukkan instance agen AI ke dalam kode kami, lalu kami memintanya untuk mengeksekusi/menyelesaikan masalah dengan bahasa alami atau ekspresi mirip bahasa alami.
"Ask-Get Response" menggantikan "Tentukan Masalah - Program - Kode untuk Mewujudkannya" secara tradisional.
Apakah itu benar dan semudah yang kita katakan?
Tentu! Kerangka kerja Agently menyediakan cara mudah untuk berinteraksi dengan instance agen AI akan membuat pengembangan modul aplikasi menjadi cepat dan mudah.
Di bawah ini adalah dua demo aplikasi CLI yang berada di dua domain yang sangat berbeda tetapi keduanya dibuat oleh 64 baris kode yang didukung oleh Agently.
VIDEO DEMO
KODE
import Agently
agent_factory = Agently . AgentFactory ( is_debug = False )
agent_factory
. set_settings ( "current_model" , "OpenAI" )
. set_settings ( "model.OpenAI.auth" , { "api_key" : "" })
agent = agent_factory . create_agent ()
meta_data = {
"table_meta" : [
{
"table_name" : "user" ,
"columns" : [
{ "column_name" : "user_id" , "desc" : "identity of user" , "value type" : "Number" },
{ "column_name" : "gender" , "desc" : "gender of user" , "value type" : [ "male" , "female" ] },
{ "column_name" : "age" , "desc" : "age of user" , "value type" : "Number" },
{ "column_name" : "customer_level" , "desc" : "level of customer account" , "value type" : [ 1 , 2 , 3 , 4 , 5 ] },
]
},
{
"table_name" : "order" ,
"columns" : [
{ "column_name" : "order_id" , "desc" : "identity of order" , "value type" : "Number" },
{ "column_name" : "customer_user_id" , "desc" : "identity of customer, same value as user_id" , "value type" : "Number" },
{ "column_name" : "item_name" , "desc" : "item name of this order" , "value type" : "String" },
{ "column_name" : "item_number" , "desc" : "how many items to buy in this order" , "value type" : "Number" },
{ "column_name" : "price" , "desc" : "how much of each item" , "value type" : "Number" },
{ "column_name" : "date" , "desc" : "what date did this order happend" , "value type" : "Date" },
]
},
]
}
is_finish = False
while not is_finish :
question = input ( "What do you want to know: " )
show_thinking = None
while str ( show_thinking ). lower () not in ( "y" , "n" ):
show_thinking = input ( "Do you want to observe the thinking process? [Y/N]: " )
show_thinking = False if show_thinking . lower () == "n" else True
print ( "[Generating...]" )
result = agent
. input ({
"table_meta" : meta_data [ "table_meta" ],
"question" : question
})
. instruct ([
"output SQL to query the database according meta data:{table_meta} that can anwser the question:{question}" ,
"output language: English" ,
])
. output ({
"thinkings" : [ "String" , "Your problem solving thinking step by step" ],
"SQL" : ( "String" , "final SQL only" ),
})
. start ()
if show_thinking :
thinking_process = " n " . join ( result [ "thinkings" ])
print ( "[Thinking Process] n " , thinking_process )
print ( "[SQL] n " , result [ "SQL" ])
while str ( is_finish ). lower () not in ( "y" , "n" ):
is_finish = input ( "Do you want to quit？[Y to quit / N to continue]: " )
is_finish = False if is_finish . lower () == "n" else True import Agently
agent_factory = Agently . AgentFactory ( is_debug = False )
agent_factory
. set_settings ( "current_model" , "OpenAI" )
. set_settings ( "model.OpenAI.auth" , { "api_key" : "" })
writer_agent = agent_factory . create_agent ()
roleplay_agent = agent_factory . create_agent ()
# Create Character
character_desc = input ( "Describe the character you want to talk to with a few words: " )
is_accepted = ""
suggestions = ""
last_time_character_setting = {}
while is_accepted . lower () != "y" :
is_accepted = ""
input_dict = { "character_desc" : character_desc }
if suggestions != "" :
input_dict . update ({ "suggestions" : suggestions })
input_dict . update ({ "last_time_character_setting" : last_time_character_setting })
setting_result = writer_agent
. input ( input_dict )
. instruct ([
"Design a character based on {input.character_desc}." ,
"if {input.suggestions} exist, rewrite {input.last_time_character_setting} followed {input.suggestions}."
])
. output ({
"name" : ( "String" ,),
"age" : ( "Number" ,),
"character" : ( "String" , "Descriptions about the role of this character, the actions he/she likes to take, his/her behaviour habbits, etc." ),
"belief" : ( "String" , "Belief or mottos of this character" ),
"background_story" : [( "String" , "one part of background story of this character" )],
"response_examples" : [{ "Question" : ( "String" , "question that user may ask this character" ), "Response" : ( "String" , "short and quick response that this character will say." ) }],
})
. on_delta ( lambda data : print ( data , end = "" ))
. start ()
while is_accepted . lower () not in ( "y" , "n" ):
is_accepted = input ( "Are you satisfied with this character role setting? [Y/N]: " )
if is_accepted . lower () == "n" :
suggestions = input ( "Do you have some suggestions about this setting? (leave this empty will redo all the setting): " )
if suggestions != "" :
last_time_character_settings = setting_result
print ( "[Start Loading Character Setting to Agent...]" )
# Load Character to Agent then Chat with It
for key , value in setting_result . items ():
roleplay_agent . set_role ( key , value )
print ( "[Loading is Done. Let's Start Chatting](input '#exit' to quit)" )
roleplay_agent . active_session ()
chat_input = ""
while True :
chat_input = input ( "YOU: " )
if chat_input == "#exit" :
break
print ( f" { setting_result [ 'name' ] } : " , end = "" )
roleplay_agent
. input ( chat_input )
. instruct ( "Response {chat_input} follow your {ROLE} settings. Response like in a CHAT not a query or request!" )
. on_delta ( lambda data : print ( data , end = "" ))
. start ()
print ( "" )
print ( "Bye~" )Postingan tentang Agen Otonomi Bertenaga LLM oleh Lilian Weng dari OpenAI telah memberikan konsep yang sangat bagus tentang struktur dasar agen AI. Namun postingan tersebut tidak memberikan penjelasan tentang cara membangun agen AI.
Beberapa proyek luar biasa seperti LangChain dan Camel-AI menyajikan ide mereka tentang cara membangun agen AI. Dalam proyek ini, agen diklasifikasikan ke dalam berbagai jenis sesuai dengan tugas agen atau proses berpikir agen.
Namun jika kita mengikuti ide-ide ini untuk membangun agen, itu berarti kita harus membangun agen yang benar-benar baru jika kita ingin memiliki agen baru untuk bekerja di domain yang berbeda, tetap saja semua proyek menyediakan kelas dasar ChatAgent atau semacamnya sub-kelas agen baru akan dibangun dan jenis agen yang lebih spesifik akan diproduksi. Dengan bertambahnya jumlah jenis agen, suatu hari nanti, boom! Akan ada terlalu banyak jenis agen untuk dipilih oleh pengembang dan untuk platform agen untuk dikelola. Mereka akan sulit dicari, sulit untuk memilih, sulit dikelola dan sulit diperbarui.
Jadi tim Agently tidak bisa berhenti bertanya-tanya apakah ada cara yang lebih baik untuk meningkatkan agen dan membuat semua pengembang mudah untuk berpartisipasi.
Selain itu, struktur dan komponen agen AI tampak sederhana dan mudah dibuat saat ini. Namun jika kita melihat lebih jauh ke depan, setiap komponen akan menjadi lebih kompleks (misalnya manajemen memori) dan akan semakin banyak komponen baru yang ditambahkan (misalnya sensor). .
Bagaimana jika kita berhenti membangun agen seperti keseluruhan yang tidak terbagi tetapi memisahkannya menjadi struktur pusat yang mengelola data konteks runtime dan proses runtime dan terhubung dengan plugin yang berbeda untuk meningkatkan kemampuannya dalam proses runtime agar cocok untuk skenario penggunaan yang berbeda? "Membagi dan menaklukkan", seperti moto teknik terkenal.
Kami mewujudkannya di Agently 3.0 dan ketika Agently 3.0 dalam pengujian alfa, kami senang melihat desain plugin-untuk-penyempurnaan ini tidak hanya menyelesaikan masalah dalam membangun kembali agen yang benar-benar baru, namun juga membantu setiap pengembang komponen fokus pada target. dan hanya mempertanyakan komponen yang dipedulikan tanpa gangguan. Itu membuat pengembangan plugin komponen sangat mudah dan kode sederhana.
Berikut adalah contoh yang menunjukkan cara mengembangkan plugin komponen agen dalam kerangka Agently. Karena pekerjaan pengelolaan data konteks waktu proses telah dilakukan oleh kerangka kerja, pengembang plugin dapat menggunakan banyak alat waktu proses untuk membantu membangun plugin komponen agen cukup mudah.
️ : Kode di bawah ini adalah contoh kode plugin, ia bekerja dalam kerangka kerja dan tidak dapat dijalankan secara terpisah.
from . utils import ComponentABC
from Agently . utils import RuntimeCtxNamespace
# Create Plugin Class comply with Abstract Basic Class
class Role ( ComponentABC ):
def __init__ ( self , agent : object ):
self . agent = agent
# Framework pass runtime_ctx and storage through and component can use them
self . role_runtime_ctx = RuntimeCtxNamespace ( "role" , self . agent . agent_runtime_ctx )
self . role_storage = self . agent . global_storage . table ( "role" )
# Defined methods of this component
# Update runtime_ctx which follow the agent instance lifetime circle
def set_name ( self , name : str , * , target : str ):
self . role_runtime_ctx . set ( "NAME" , name )
return self . agent
def set ( self , key : any , value : any = None , * , target : str ):
if value is not None :
self . role_runtime_ctx . set ( key , value )
else :
self . role_runtime_ctx . set ( "DESC" , key )
return self . agent
def update ( self , key : any , value : any = None , * , target : str ):
if value is not None :
self . role_runtime_ctx . update ( key , value )
else :
self . role_runtime_ctx . update ( "DESC" , key )
return self . agent
def append ( self , key : any , value : any = None , * , target : str ):
if value is not None :
self . role_runtime_ctx . append ( key , value )
else :
self . role_runtime_ctx . append ( "DESC" , key )
return self . agent
def extend ( self , key : any , value : any = None , * , target : str ):
if value is not None :
self . role_runtime_ctx . extend ( key , value )
else :
self . role_runtime_ctx . extend ( "DESC" , key )
return self . agent
# Or save to / load from storage which keep the data in file storage or database
def save ( self , role_name : str = None ):
if role_name == None :
role_name = self . role_runtime_ctx . get ( "NAME" )
if role_name != None and role_name != "" :
self . role_storage
. set ( role_name , self . role_runtime_ctx . get ())
. save ()
return self . agent
else :
raise Exception ( "[Agent Component: Role] Role attr 'NAME' must be stated before save. Use .set_role_name() to specific that." )
def load ( self , role_name : str ):
role_data = self . role_storage . get ( role_name )
for key , value in role_data . items ():
self . role_runtime_ctx . update ( key , value )
return self . agent
# Pass the data to request standard slots on Prefix Stage
def _prefix ( self ):
return {
"role" : self . role_runtime_ctx . get (),
}
# Export component plugin interface to be called in agent runtime process
def export ( self ):
return {
"early" : None , # method to be called on Early Stage
"prefix" : self . _prefix , # method to be called on Prefix Stage
"suffix" : None , # mothod to be called on Suffix Stage
# Alias that application developers can use in agent instance
# Example:
# "alias": { "set_role_name": { "func": self.set_name } }
# => agent.set_role_name("Alice")
"alias" : {
"set_role_name" : { "func" : self . set_name },
"set_role" : { "func" : self . set },
"update_role" : { "func" : self . update },
"append_role" : { "func" : self . append },
"extend_role" : { "func" : self . extend },
"save_role" : { "func" : self . save },
"load_role" : { "func" : self . load },
},
}
# Export to Plugins Dir Auto Scaner
def export ():
return ( "Role" , Role )Kerangka kerja Agently juga memungkinkan pengembang plugin mengemas plugin mereka di luar paket kerangka utama dan membagikan paket plugin mereka satu per satu ke pengembang lain. Pengembang yang ingin menggunakan plugin tertentu cukup mengunduh paket plugin, membongkar file ke dalam folder kerja mereka, lalu instal plugin dengan mudah.
Kode-kode di bawah ini akan menunjukkan betapa mudahnya instalasi ini.
️ : Kode di bawah ini adalah contoh pemasangan plugin, ini hanya berfungsi ketika Anda membongkar folder plugin di folder kerja Anda.
import Agently
# Import install method from plugin folder
from session_plugin import install
# Then install
install ( Agently )
# That's all
# Now your agent can use new abilities enhanced by new pluginBerikut juga kasus nyata ketika Agently v3.0.1 mengalami masalah yang membuat komponen Sesi tidak tersedia. Kami menggunakan pembaruan paket plugin yang dapat memperbaiki bug tanpa memperbarui seluruh paket kerangka kerja.
Oke, itulah pengenalan umum tentang framework pengembangan agen Agently AI.
Jika ingin mendalami lebih dalam, Anda juga dapat mengunjungi dokumen/link berikut:
Jangan lupa ️ repo ini jika Anda menyukai pekerjaan kami.
Terima kasih dan selamat coding!
