Agently
v3.4.0.5
[Important] Se completó la revisión de la página de inicio china del marco de desarrollo de Agently AI y los nuevos documentos tutoriales para el cambio de modelo, AgenticRequest y Workflow se actualizaron por completo. Visite: Agently.cn para verlos.
[Important] Pronto reescribiremos la página de inicio del repositorio para brindarle más información sobre nuestro trabajo reciente, espérelo.
[Repositorio de escaparate] Agently Daily News Collector: Inglés | Proyecto de código abierto del generador de informes resumidos de noticias
[hot] Versión china del documento de desarrollo de lo más superficial a lo más profundo: haga clic aquí para acceder y desbloquear habilidades complejas de desarrollo de aplicaciones LLM paso a paso
¿Cómo utilizar:
pip install -U AgentlyIdeas/Informe de errores: informe problemas aquí
? Envíenos un correo electrónico: [email protected]
? Grupo de discordia:
Haga clic aquí para unirse o escanear el código QR a continuación
Grupo WeChat (únete al grupo WeChat):
Haga clic aquí para solicitar o escanear el código QR a continuación
Si te gusta este proyecto, por favor ️, gracias.
Documentos de colaboración:
Ejemplos de código:
Para crear agentes en muchos campos diferentes:
O bien, para llamar a las capacidades de instancia del agente en la lógica del código para ayudar:
Explora más: visita el patio de juegos de demostración
Instale el paquete Agently Python:
pip install -U Agently¡Entonces estamos listos para partir!
Agently es un marco de desarrollo que ayuda a los desarrolladores a crear aplicaciones nativas de agentes de IA muy rápidamente.
Puede utilizar y crear un agente de IA en su código de una manera extremadamente sencilla.
Puede crear una instancia de agente de IA y luego interactuar con ella como llamar a una función en muy pocos códigos como este a continuación.
Haga clic en el botón Ejecutar a continuación y sea testigo de la magia. Es así de simple:
# 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']
Y puede notar que cuando imprimimos el valor del result , el valor es una list similar al formato del parámetro que ingresamos en .output() .
En el marco de Agently, hemos realizado mucho trabajo como este para facilitar a los desarrolladores de aplicaciones la integración de instancias de Agent en su código comercial. Esto permitirá a los desarrolladores de aplicaciones concentrarse en cómo construir su lógica comercial en lugar de descubrir cómo atenderlas. a los modelos de lenguaje o cómo mantener satisfechos a los modelos.
Cuando comenzamos a utilizar el agente de IA en el código para ayudarnos a manejar la lógica empresarial, podemos sentir fácilmente que debe haber algunas diferencias con respecto a la forma tradicional de desarrollo de software, pero ¿cuáles son exactamente las diferencias?
Creo que el punto clave es utilizar un agente de inteligencia artificial para resolver el problema en lugar de una lógica de código creada por el hombre.
En la aplicación nativa del agente de IA, colocamos una instancia del agente de IA en nuestro código, luego le pedimos que ejecute/resuelva el problema con lenguaje natural o expresiones similares al lenguaje natural.
"Preguntar-Obtener respuesta" reemplaza al tradicional "Definir problema - Programa - Código para hacerlo realidad".
¿Puede ser eso cierto y tan fácil como decimos?
¡Claro! El marco Agently proporciona una manera fácil de interactuar con la instancia del agente de IA y hará que el desarrollo del módulo de aplicaciones sea rápido y sencillo.
A continuación se muestran dos demostraciones de aplicaciones CLI que se encuentran en dos dominios totalmente diferentes, pero que ambos están construidos con 64 líneas de códigos impulsados por Agently.
VÍDEO DE DEMOSTRACIÓN
CÓDIGO
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~" )La publicación sobre agentes autónomos con tecnología LLM de Lilian Weng de OpenAI brindó un concepto realmente bueno de la estructura básica del agente de IA, pero la publicación no brindó la explicación sobre cómo construir un agente de IA.
Algunos proyectos increíbles como LangChain y Camel-AI presentan sus ideas sobre cómo construir agentes de IA. En estos proyectos, los agentes se clasifican en muchos tipos diferentes según la tarea del agente o el proceso de pensamiento del agente.
Pero si seguimos estas ideas para crear agentes, eso significa que debemos crear un agente completamente nuevo si queremos tener un nuevo agente para trabajar en un dominio diferente. Aunque todos los proyectos proporcionan una clase básica ChatAgent o algo así, aún así. Se crearán nuevas subclases de agentes y se producirán cada vez más tipos de agentes específicos. Con el aumento del número de tipos de agentes, un día, ¡boom! Habrá demasiados tipos de agentes para que los desarrolladores elijan y para la plataforma de agentes. Serán difíciles de buscar, difíciles. de elegir, difíciles de gestionar y difíciles de actualizar.
Por eso, el equipo de Agently no puede dejar de preguntarse si existe una mejor manera de mejorar el agente y facilitar la participación de todos los desarrolladores.
Además, la estructura y los componentes del agente de IA parecen simples y fáciles de construir en la actualidad, pero si miramos más adelante, cada componente será más complejo (gestión de memoria, por ejemplo) y se agregarán cada vez más componentes nuevos (sensores, por ejemplo). .
¿Qué pasa si dejamos de construir el agente como un todo indiviso y lo separamos en una estructura central que administra los datos del contexto de tiempo de ejecución y el proceso de tiempo de ejecución y lo conectamos con diferentes complementos para mejorar sus capacidades en el proceso de tiempo de ejecución y hacerlo adecuado para diferentes escenarios de uso? "Divide y vencerás", como decía el famoso lema de la ingeniería.
Lo hicimos realidad en Agently 3.0 y cuando Agently 3.0 en su prueba alfa, nos alegró ver que este diseño de complemento para mejorar no solo resolvió el problema de reconstruir un agente completamente nuevo, sino que también ayudó a los desarrolladores de cada componente a centrarse en el objetivo. y cuestiona solo el componente que le interesa sin distracciones. Eso hace que el desarrollo del complemento del componente sea realmente fácil y el código simple.
A continuación se muestra un ejemplo que muestra cómo desarrollar un complemento de componente de agente en el marco Agently. Debido a que el marco ha realizado el trabajo de administración de datos del contexto de tiempo de ejecución, los desarrolladores de complementos pueden usar muchas herramientas de tiempo de ejecución para ayudar a construir el complemento del componente de agente. bastante fácil.
️ : El siguiente código es un ejemplo de código de complemento, funciona en el marco y no se puede ejecutar por separado.
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 )Agently Framework también permite a los desarrolladores de complementos empaquetar su complemento fuera del paquete principal de Framework y compartir su paquete de complementos individualmente con otros desarrolladores. Aquellos que deseen utilizar un complemento específico pueden simplemente descargar el paquete de complementos, descomprimir los archivos en su carpeta de trabajo y luego. Instale el complemento fácilmente.
Estos códigos a continuación presentarán lo fácil que puede ser esta instalación.
️ : El siguiente código es un ejemplo de instalación de complemento, solo funciona cuando descomprime una carpeta de complemento en su carpeta de trabajo.
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 pluginAquí también hay un caso real en el que Agently v3.0.1 tuvo un problema que hizo que el componente de sesión no estuviera disponible. Usamos la actualización del paquete de complementos para corregir el error sin actualizar todo el paquete del marco.
Bien, esa es la introducción general sobre el marco de desarrollo de agentes Agently AI.
Si desea profundizar más, también puede visitar estos documentos/enlaces:
No olvides ️ este repositorio si te gusta nuestro trabajo.
¡Gracias y feliz codificación!
