Agently
v3.4.0.5
[Important] La révision de la page d'accueil chinoise du cadre de développement Agently AI a été terminée et les nouveaux documents de didacticiel pour le changement de modèle, AgenticRequest et Workflow ont été entièrement mis à jour. Veuillez visiter : Agently.cn pour les consulter.
[Important] Nous réécrirons bientôt la page d'accueil du dépôt pour vous en dire plus sur nos travaux récents, veuillez patienter.
[Showcase Repo]Agently Daily News Collector : anglais | Projet open source de générateur de rapports de synthèse d'actualités
[hot] Version chinoise du document de développement du moins profond au plus profond : cliquez ici pour accéder et débloquer étape par étape les compétences de développement d'applications LLM complexes
Comment utiliser :
pip install -U AgentlyIdées / Rapport de bug : signaler les problèmes ici
? Envoyez-nous un e-mail : dé[email protected]
? Groupe Discorde :
Cliquez ici pour vous inscrire ou scanner le code QR ci-dessous
Groupe WeChat (rejoindre le groupe WeChat) :
Cliquez ici pour postuler ou scannez le code QR ci-dessous
Si vous aimez ce projet, s'il vous plaît ️, merci.
Documents Colab :
Exemples de codes :
Pour créer un agent dans de nombreux domaines différents :
Ou, pour appeler les capacités de l'instance d'agent dans la logique du code pour vous aider :
Explorez davantage : visitez le terrain de jeu de démonstration
Installez le package Agently Python :
pip install -U AgentlyAlors nous sommes prêts à partir !
Agently est un framework de développement qui aide les développeurs à créer très rapidement des applications natives d'agent IA.
Vous pouvez utiliser et créer un agent IA dans votre code d'une manière extrêmement simple.
Vous pouvez créer une instance d'agent IA puis interagir avec elle comme en appelant une fonction dans très peu de codes comme celui-ci ci-dessous.
Cliquez sur le bouton Exécuter ci-dessous et soyez témoin de la magie. C'est aussi simple que cela :
# 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']
Et vous remarquerez peut-être que lorsque nous imprimons la valeur de result , la valeur est une list tout comme le format du paramètre que nous mettons dans le .output() .
Dans le framework Agently, nous avons effectué beaucoup de travail comme celui-ci pour permettre aux développeurs d'applications d'intégrer plus facilement les instances d'agent dans leur code métier. Cela permettra aux développeurs d'applications de se concentrer sur la façon de construire leur logique métier au lieu de comprendre comment y répondre. aux modèles de langage ou comment garder les modèles satisfaits.
Lorsque nous commençons à utiliser l'agent IA dans le code pour nous aider à gérer la logique métier, nous pouvons facilement sentir qu'il doit y avoir des différences par rapport à la méthode traditionnelle de développement de logiciels. Mais quelles sont exactement les différences ?
Je pense que le point clé est d'utiliser un agent IA pour résoudre le problème au lieu d'une logique de code créée par l'homme.
Dans l'application native d'agent IA, nous insérons une instance d'agent IA dans notre code, puis nous lui demandons d'exécuter/pour résoudre le problème avec le langage naturel ou des expressions de type langage naturel.
"Ask-Get Response" remplace le traditionnel "Définir le problème - Programmer - Coder pour y arriver".
Est-ce que cela peut être vrai et aussi simple qu’on le dit ?
Bien sûr ! Le framework Agently fournit un moyen simple d'interagir avec l'instance d'agent IA et rendra le développement de modules d'application rapide et facile.
Ci-dessous se trouvent deux démos d'applications CLI qui dans deux domaines totalement différents mais toutes deux construites par 64 lignes de codes alimentées par Agently.
VIDÉO DE DÉMO
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~" )L'article sur les agents autonomes propulsés par LLM par Lilian Weng d'OpenAI a donné une très bonne idée de la structure de base de l'agent IA, mais l'article n'a pas expliqué comment créer un agent IA.
Certains projets géniaux comme LangChain et Camel-AI présentent leurs idées sur la façon de créer un agent IA. Dans ces projets, les agents sont classés en plusieurs types différents en fonction de la tâche de l'agent ou du processus de réflexion de l'agent.
Mais si nous suivons ces idées pour créer des agents, cela signifie que nous devons créer un tout nouvel agent si nous voulons qu'un nouvel agent travaille dans un domaine différent. Même si tous les projets fournissent toujours une classe de base ChatAgent ou quelque chose comme ça. De nouvelles sous-classes d'agents seront créées et de plus en plus de types d'agents spécifiques seront produits. Avec l'augmentation du nombre de types d'agents, un jour, boum, il y aura trop de types d'agents pour que les développeurs puissent choisir et pour la plateforme d'agents ! à gérer. Ils seront difficiles à trouver, difficiles à choisir, difficile à gérer et difficile à mettre à jour.
L'équipe Agently ne peut donc pas cesser de se demander s'il existe un meilleur moyen d'améliorer l'agent et de faciliter la participation de tous les développeurs.
De plus, la structure et les composants de l'agent IA semblent simples et faciles à construire à l'heure actuelle. Mais si l'on regarde plus loin, chaque composant sera plus complexe (gestion de la mémoire par exemple) et de plus en plus de nouveaux composants seront ajoutés (sencors par exemple). .
Et si nous arrêtions de construire l'agent comme un tout indivisé mais le séparions en une structure centrale qui gère les données de contexte d'exécution et le processus d'exécution et nous connections avec différents plugins pour améliorer ses capacités dans le processus d'exécution afin de le rendre adapté à différents scénarios d'utilisation ? « Diviser pour régner », comme le dit la célèbre devise de l’ingénierie.
Nous y sommes parvenus dans Agently 3.0 et lorsque Agently 3.0 dans son test alpha, nous étions heureux de voir cette conception de plugin pour améliorer non seulement résolu le problème de la reconstruction d'un tout nouvel agent, mais a également aidé les développeurs de chaque composant à se concentrer sur la cible. et les questions dont seuls les composants se soucient sans distraction. Cela rend le développement du plugin de composants vraiment facile et le code simple.
Voici un exemple qui montre comment développer un plugin de composant d'agent dans le framework Agently. En raison du travail de gestion des données de contexte d'exécution qui a été effectué par le framework, les développeurs de plugins peuvent utiliser de nombreux outils d'exécution pour aider à créer le plugin de composant d'agent qui fait le travail. assez facile.
️ : Le code ci-dessous est un exemple de code de plugin, il fonctionne dans le framework et ne peut pas être exécuté séparément.
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 )Le framework Agently permet également aux développeurs de plugins d'emballer leur plugin en dehors du package principal du framework et de partager leur package de plugin individuellement avec d'autres développeurs. Les développeurs qui souhaitent utiliser un plugin spécifique peuvent simplement télécharger le package de plugin, décompresser les fichiers dans leur dossier de travail, puis. installez le plugin facilement.
Ces codes ci-dessous montreront à quel point cette installation peut être facile.
️ : Le code ci-dessous est un exemple d'installation de plugin, il ne fonctionne que lorsque vous décompressez un dossier de plugin dans votre dossier de travail.
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 pluginVoici également un cas réel où Agently v3.0.1 a rencontré un problème qui rend le composant de session indisponible. Nous utilisons la mise à jour du package de plug-in pour corriger le bogue sans mettre à jour l'ensemble du package de framework.
OK. C'est l'introduction générale du cadre de développement d'agents Agently AI.
Si vous souhaitez approfondir, vous pouvez également visiter ces documents/liens :
N'oubliez pas ️ ce repo si vous aimez notre travail.
Merci et bon codage !
