Agently
v3.4.0.5
[Important] Die chinesische Homepage des Agently AI-Entwicklungsframeworks wurde überarbeitet und die neuen Tutorial-Dokumente für Modellwechsel, AgenticRequest und Workflow wurden vollständig aktualisiert. Bitte besuchen Sie: Agently.cn
[Important] Wir werden die Repo-Homepage bald umschreiben, um Ihnen mehr über unsere aktuelle Arbeit zu erzählen. Bitte warten Sie darauf.
[Showcase Repo]Agently Daily News Collector: Englisch |. Open-Source-Projekt zum Generieren von Nachrichtenzusammenfassungsberichten
[hot] Chinesische Version des Entwicklungsdokuments von der Tiefe zur Tiefe: Klicken Sie hier, um Schritt für Schritt auf komplexe LLMs-Anwendungsentwicklungsfähigkeiten zuzugreifen und diese freizuschalten
? Verwendung:
pip install -U AgentlyIdeen/Fehlerbericht: Melden Sie hier Probleme
? Schicken Sie uns eine E-Mail an: [email protected]
? Discord-Gruppe:
Klicken Sie hier, um beizutreten, oder scannen Sie den QR-Code unten
WeChat-Gruppe (WeChat-Gruppe beitreten):
Klicken Sie hier, um den QR-Code unten anzuwenden oder zu scannen
Wenn Ihnen dieses Projekt gefällt, bitte ️, danke.
Colab-Dokumente:
Codebeispiele:
So bauen Sie Agenten in vielen verschiedenen Bereichen auf:
Oder um die Fähigkeiten von Agenteninstanzen in der Codelogik aufzurufen, um zu helfen:
Entdecken Sie mehr: Besuchen Sie den Demo-Spielplatz
Installieren Sie das Agently Python-Paket:
pip install -U AgentlyDann sind wir startklar!
Agently ist ein Entwicklungsframework, das Entwicklern dabei hilft, sehr schnell native KI-Agent-Anwendungen zu erstellen.
Sie können KI-Agenten auf äußerst einfache Weise in Ihrem Code verwenden und erstellen.
Sie können eine KI-Agenteninstanz erstellen und dann mit ihr interagieren, als würden Sie in sehr wenigen Codes wie dem folgenden eine Funktion aufrufen.
Klicken Sie unten auf die Schaltfläche „Ausführen“ und erleben Sie die Magie. So einfach ist das:
# 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']
Und Sie werden vielleicht bemerken, dass, wenn wir den Wert von result ausgeben, der Wert eine list ist, genau wie das Format des Parameters, den wir in .output() eingefügt haben.
Im Agently-Framework haben wir viel Arbeit wie diese geleistet, um es Anwendungsentwicklern zu erleichtern, Agent-Instanzen in ihren Geschäftscode zu integrieren. Dadurch können sich Anwendungsentwickler auf den Aufbau ihrer Geschäftslogik konzentrieren, anstatt herauszufinden, wie sie sie bedienen zu Sprachmodellen oder wie man Modelle zufriedenstellt.
Wenn wir anfangen, KI-Agenten im Code zu verwenden, um uns bei der Handhabung der Geschäftslogik zu helfen, können wir leicht erkennen, dass es einige Unterschiede zur herkömmlichen Softwareentwicklungsmethode geben muss. Aber was genau sind die Unterschiede?
Ich denke, der entscheidende Punkt besteht darin, einen KI-Agenten zur Lösung des Problems zu verwenden, anstatt künstliche Codelogik.
In einer nativen KI-Agent-Anwendung fügen wir eine KI-Agent-Instanz in unseren Code ein und fordern ihn dann auf, das Problem mit natürlicher Sprache oder natursprachlichen Ausdrücken auszuführen/zu lösen.
„Ask-Get Response“ ersetzt das traditionelle „Problem definieren – programmieren – Code, um es möglich zu machen“.
Kann das wahr und so einfach sein, wie wir sagen?
Klar! Das Agently-Framework bietet eine einfache Möglichkeit zur Interaktion mit der KI-Agenteninstanz und macht die Entwicklung von Anwendungsmodulen schnell und einfach.
Unten finden Sie zwei CLI-Anwendungsdemos, die sich in zwei völlig unterschiedlichen Domänen befinden, aber beide mit 64 Codezeilen erstellt werden, die von Agently bereitgestellt werden.
DEMO-VIDEO
CODE
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~" )Der Beitrag über LLM Powered Autonomous Agents von Lilian Weng von OpenAI hat ein wirklich gutes Konzept der Grundstruktur von KI-Agenten vermittelt, aber der Beitrag enthielt keine Erklärung, wie man einen KI-Agenten erstellt.
Einige großartige Projekte wie LangChain und Camel-AI stellen ihre Ideen zum Aufbau von KI-Agenten vor. In diesen Projekten werden Agenten entsprechend der Aufgabe des Agenten oder dem Denkprozess des Agenten in viele verschiedene Typen eingeteilt.
Aber wenn wir diesen Ideen folgen, um Agenten zu erstellen, bedeutet das, dass wir einen völlig neuen Agenten erstellen müssen, wenn wir einen neuen Agenten haben wollen, der in einer anderen Domäne arbeitet, auch wenn alle Projekte immer noch eine ChatAgent-Basisklasse oder ähnliches bereitstellen Es werden neue Agenten-Unterklassen erstellt und immer mehr spezifische Agententypen werden produziert. Eines Tages wird es zu viele Agententypen geben, als dass Entwickler und Agentenplattformen sie auswählen könnten zu verwalten. Sie werden schwer zu finden sein zu wählen, schwer zu verwalten und schwer zu aktualisieren.
Daher kann das Team von Agently nicht aufhören, sich zu fragen, ob es eine bessere Möglichkeit gibt, Agenten zu verbessern und allen Entwicklern die Teilnahme zu erleichtern.
Auch die Struktur und die Komponenten des KI-Agenten scheinen derzeit einfach und leicht zu erstellen. Wenn wir jedoch weiter in die Zukunft blicken, wird jede Komponente komplexer (z. B. Speicherverwaltung) und es werden immer mehr neue Komponenten hinzugefügt (z. B. Sensoren). .
Was wäre, wenn wir den Agenten nicht mehr wie ein ungeteiltes Ganzes aufbauen würden, sondern ihn in eine zentrale Struktur aufteilen, die die Laufzeitkontextdaten und den Laufzeitprozess verwaltet, und ihn mit verschiedenen Plugins verbinden, um seine Fähigkeiten im Laufzeitprozess zu verbessern und ihn für verschiedene Nutzungsszenarien geeignet zu machen? „Teile und herrsche“, so lautet das berühmte Motto der Ingenieurskunst.
Wir haben es in Agently 3.0 geschafft, und als Agently 3.0 im Alpha-Test war, waren wir froh, dass dieses Plugin-zu-Erweiterungs-Design nicht nur das Problem der Neuerstellung eines völlig neuen Agenten löste, sondern auch den Entwicklern jeder Komponente dabei half, sich auf das Ziel zu konzentrieren und stellt nur Fragen, die für die Komponente relevant sind, ohne Ablenkung. Das macht die Entwicklung von Komponenten-Plugins und den Code einfach.
Hier ist ein Beispiel, das zeigt, wie man ein Agent-Komponenten-Plugin im Agently-Framework entwickelt. Da das Framework die Laufzeitkontextdatenverwaltung durchgeführt hat, können Plugin-Entwickler viele Laufzeittools verwenden, um die Arbeit zu erleichtern ziemlich einfach.
️ : Der folgende Code ist ein Plugin-Codebeispiel, er funktioniert im Framework und kann nicht separat ausgeführt werden.
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 )Mit dem Agently-Framework können Plugin-Entwickler ihr Plugin auch außerhalb des Hauptpakets des Frameworks packen und ihr Plugin-Paket individuell für andere Entwickler freigeben. Wer ein bestimmtes Plugin verwenden möchte, kann einfach das Plugin-Paket herunterladen und die Dateien dann in seinen Arbeitsordner entpacken Installieren Sie das Plugin einfach.
Die folgenden Codes zeigen, wie einfach diese Installation sein kann.
️ : Der folgende Code ist ein Plugin-Installationsbeispiel. Er funktioniert nur, wenn Sie einen Plugin-Ordner in Ihrem Arbeitsordner entpacken.
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 pluginHier ist auch ein realer Fall, bei dem Agently v3.0.1 ein Problem hatte, das dazu führte, dass die Sitzungskomponente nicht verfügbar war. Mit der Plugin-Paketaktualisierung kann der Fehler behoben werden, ohne das gesamte Framework-Paket zu aktualisieren.
OK. Das ist die allgemeine Einführung zum Agently AI Agent Development Framework.
Wenn Sie tiefer eintauchen möchten, können Sie auch diese Dokumente/Links besuchen:
Vergessen Sie dieses Repo nicht, wenn Ihnen unsere Arbeit gefällt.
Vielen Dank und viel Spaß beim Codieren!
