Agently
v3.4.0.5
[Important] A revisão da página inicial chinesa da estrutura de desenvolvimento do Agently AI foi concluída e os novos documentos do tutorial para troca de modelo, AgenticRequest e Workflow foram totalmente atualizados. Visite: Agently.cn para visualizá-lo.
[Important] Em breve reescreveremos a página inicial do repositório para contar mais sobre nosso trabalho recente, aguarde.
[Showcase Repo]Agently Daily News Collector: Inglês | Projeto de código aberto gerador de resumo de notícias
[hot] Versão chinesa do documento de desenvolvimento do mais superficial ao mais profundo: clique aqui para acessar e desbloquear habilidades complexas de desenvolvimento de aplicativos LLMs passo a passo
? Como usar:
pip install -U AgentlyRelatório de ideias/bugs: relate problemas aqui
? Envie-nos um e-mail: [email protected]
?Grupo de discórdia:
Clique aqui para participar ou escaneie o código QR abaixo
Grupo WeChat (junte-se ao grupo WeChat):
Clique aqui para se inscrever ou escaneie o código QR abaixo
Se você gosta deste projeto, por favor ️, obrigado.
Documentos Colab:
Exemplos de código:
Para construir agente em muitos campos diferentes:
Ou, para chamar habilidades de instância do agente na lógica do código para ajudar:
Explore mais: Visite o Demostration Playground
Instale o pacote Agently Python:
pip install -U AgentlyEntão estamos prontos para ir!
Agently é uma estrutura de desenvolvimento que ajuda os desenvolvedores a criar aplicativos nativos de agentes de IA muito rapidamente.
Você pode usar e construir um agente de IA em seu código de uma forma extremamente simples.
Você pode criar uma instância de agente de IA e interagir com ela como se estivesse chamando uma função em poucos códigos como este abaixo.
Clique no botão executar abaixo e testemunhe a mágica.
# 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']
E você pode notar que quando imprimimos o valor de result , o valor é uma list exatamente como o formato do parâmetro que colocamos em .output() .
Na estrutura Agently, fizemos muitos trabalhos como esse para facilitar aos desenvolvedores de aplicativos a integração de instâncias de agente em seu código de negócios. Isso permitirá que os desenvolvedores de aplicativos se concentrem em como construir sua lógica de negócios em vez de descobrir como atender. aos modelos de linguagem ou como manter os modelos satisfeitos.
Quando começamos a usar o agente de IA no código para nos ajudar a lidar com a lógica de negócios, podemos facilmente sentir que deve haver algumas diferenças em relação à forma tradicional de desenvolvimento de software. Mas quais são exatamente as diferenças?
Acho que o ponto principal é usar um agente de IA para resolver o problema, em vez da lógica de código feita pelo homem.
No aplicativo nativo do agente de IA, colocamos uma instância do agente de IA em nosso código e, em seguida, solicitamos que ele execute/resolva o problema com linguagem natural ou expressões semelhantes à linguagem natural.
"Perguntar-Obter Resposta" substitui o tradicional "Definir Problema - Programa - Código para Fazer Acontecer".
Isso pode ser verdade e tão fácil como dizemos?
Claro! A estrutura Agently fornece uma maneira fácil de interagir com a instância do agente de IA, tornando o desenvolvimento do módulo de aplicativo rápido e fácil.
Abaixo estão duas demonstrações de aplicativos CLI que estão em dois domínios totalmente diferentes, mas ambas são construídas por 64 linhas de códigos alimentadas por Agently.
VÍDEO DE DEMONSTRAÇÃO
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~" )A postagem sobre LLM Powered Autonomous Agents, de Lilian Weng, da OpenAI, forneceu um conceito muito bom da estrutura básica do agente de IA, mas a postagem não deu a explicação sobre como construir um agente de IA.
Alguns projetos incríveis como LangChain e Camel-AI apresentam suas ideias sobre como construir um agente de IA. Nesses projetos, os agentes são classificados em muitos tipos diferentes de acordo com a tarefa do agente ou o processo de pensamento do agente.
Mas se seguirmos essas ideias para construir agentes, isso significa que devemos construir um agente totalmente novo se quisermos ter um novo agente para trabalhar em um domínio diferente. Mesmo que todos os projetos forneçam uma classe básica ChatAgent ou algo parecido, ainda assim. novas subclasses de agentes serão construídas e mais e mais tipos específicos de agentes serão produzidos. Com o número de tipos de agentes aumentando, um dia, boom! Haverá muitos tipos de agentes para o desenvolvedor escolher e para a plataforma de agente. para gerenciar. Eles serão difíceis de pesquisar, difíceis escolher, difícil de gerenciar e difícil de atualizar.
Portanto, a equipe do Agently não para de se perguntar se existe uma maneira melhor de aprimorar o agente e facilitar a participação de todos os desenvolvedores.
Além disso, a estrutura e os componentes do agente de IA parecem simples e fáceis de construir atualmente, mas se olharmos mais adiante, cada componente será mais complexo (gerenciamento de memória, por exemplo) e mais e mais componentes novos serão adicionados (sensores, por exemplo). .
E se pararmos de construir o agente como um todo indiviso, mas separá-lo em uma estrutura central que gerencia os dados de contexto do tempo de execução e o processo de tempo de execução e conectar-se com diferentes plug-ins para aprimorar suas habilidades no processo de tempo de execução para torná-lo adequado para diferentes cenários de uso? “Dividir para conquistar”, como dizia o famoso lema da engenharia.
Fizemos isso acontecer no Agently 3.0 e quando o Agently 3.0 estava em seu teste alfa, ficamos felizes em ver que esse design de plug-in para aprimorar não apenas resolveu o problema de reconstrução de um agente totalmente novo, mas também ajudou cada desenvolvedor de componente a se concentrar no alvo e perguntas apenas com as quais o componente se preocupa, sem distração. Isso torna o desenvolvimento do plug-in do componente muito fácil e o código simples.
Aqui está um exemplo que mostra como desenvolver um plug-in de componente de agente na estrutura Agently. Como o trabalho de gerenciamento de dados de contexto de tempo de execução foi realizado pela estrutura, os desenvolvedores de plug-ins podem usar muitas ferramentas de tempo de execução para ajudar a construir o plug-in de componente de agente. muito fácil.
️ : O código abaixo é um exemplo de código de plugin, funciona no framework e não pode ser executado separadamente.
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 )A estrutura Agently também permite que os desenvolvedores de plug-ins empacotem seus plug-ins fora do pacote principal da estrutura e compartilhem seu pacote de plug-ins individualmente com outros desenvolvedores. Os desenvolvedores que desejam usar um plug-in específico podem simplesmente baixar o pacote de plug-ins, descompactar os arquivos em sua pasta de trabalho e, em seguida,. instale o plugin facilmente.
Os códigos abaixo mostrarão como essa instalação pode ser fácil.
️ : O código abaixo é um exemplo de instalação de plugin, ele só funciona quando você descompacta uma pasta de plugin em sua pasta de trabalho.
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 pluginAqui também está um caso real em que o Agently v3.0.1 teve um problema que tornou o componente Session indisponível. Usamos a atualização do pacote de plug-ins para corrigir o bug sem atualizar todo o pacote da estrutura.
OK. Essa é a introdução geral sobre a estrutura de desenvolvimento de agentes Agently AI.
Se quiser se aprofundar, você também pode visitar estes documentos/links:
Não se esqueça deste repositório se você gosta do nosso trabalho.
Obrigado e boa codificação!
