paint-brush
Beep Beep Bop Bop: como implantar vários agentes de IA usando LLMs locaispor@babycommando
9,569 leituras
9,569 leituras

Beep Beep Bop Bop: como implantar vários agentes de IA usando LLMs locais

por Baby Commando10m2023/10/19
Read on Terminal Reader

Muito longo; Para ler

Implantação de vários agentes Ai locais usando LLMs locais como Llama2 e Mistral-7b.
featured image - Beep Beep Bop Bop: como implantar vários agentes de IA usando LLMs locais
Baby Commando HackerNoon profile picture
0-item
1-item

Implantação de vários agentes Ai locais usando LLMs locais como Llama2 e Mistral-7b.


“Nunca envie um ser humano para fazer o trabalho de uma máquina”

- Agente Smith


Você está procurando uma maneira de construir um exército inteiro de agentes de IA organizados com Autogen usando LLMs locais em vez do OpenAi pago? Então você veio para o lugar certo!


LLMs de bate-papo são legais, mas permitir a ação como um agente inteligente é o próximo nível. E quanto a muitos deles? Conheça o mais recente projeto Autogen da Microsoft.


Mas há um problema. O Autogen foi construído para ser conectado ao OpenAi por padrão, o que é limitante, caro e censurado/não senciente. É por isso que usar um LLM localmente simples como Mistral-7B é a melhor opção. Você também pode usar com qualquer outro modelo de sua preferência como Llama2 , Falcon , Vicuna , Alpaca , o céu (seu hardware) é realmente o limite.


O segredo é usar o estilo de saída JSON openai em seu servidor LLM local, como o webui de geração de texto de Oobabooga, e conectá-lo ao autogen. É isso que estamos construindo hoje.


Observe que existem outros métodos para criar texto cuspido de llms no formato openai apis, bem como as ligações python llama.cpp.


Neste tutorial seremos: 0. Obtendo o webui de geração de texto de Oobabooga, um LLM (Mistral-7b) e Autogen

  1. Configurando a extensão de formato OpenAi no Oobabooga

  2. Iniciando o servidor LLM local com o formato OpenAi

  3. Conectando-o ao Autogen


Vamos começar!


[Agente Smith] "Eu, eu, eu .."


0. Obtendo Text-Generation-Webui de Oobabooga, um LLM (Mistral-7b) e Autogen


Antes de prosseguir, é recomendado usar um ambiente virtual ao instalar pacotes pip. Faça um novo e ative-o se desejar.


Obtendo o Webui de geração de texto do Obbabooga: Este é um programa bem conhecido para hospedar LLMs em sua máquina local. Vá para a página do text-generation-webui e siga o guia de instalação. É muito simples começar. Você também pode querer baixar o CUDA se estiver usando uma GPU NVIDIA para aceleração.


Obtendo um LLM (Mistral-7b-Instruct): Depois de baixar o webui de geração de texto, não o inicie ainda. Precisamos conseguir um LLM para dar vida aos nossos agentes.


Hoje iremos explorar Mistral-7B , especificamente Mistral-7B-instruct-v0.1.Q4_K_S.gguf , uma versão otimizada do modelo de TheBloke. Você pode escolher o modelo otimizado perfeito para sua máquina com base na explicação da descrição .


Você pode escolher modelos menores ou maiores dependendo do seu hardware. Não tenha medo de experimentar coisas em seu computador, estamos fazendo ciência aqui.


Vá para a página Arquivos e versões e pegue o seguinte:

  • config.json

  • Mistral-7B-instruct-v0.1.Q4_K_S.gguf (funcionará bem na maioria das configurações intermediárias)


Página Arquivos e Versões


Depois de baixado, vá para a pasta de instalação text-generation-webui e dentro dela abra a pasta models . Lá, crie uma nova pasta com o nome do seu modelo (ou qualquer nome que você quiser), como “mistral-7b-instruct” . O caminho será assim:


 C:/.../text-generation-webui/models/mistral-7b-instruct


Coloque o arquivo config.json e o model.gguf na nova pasta.


Obtendo Autogen :
Para instalar a biblioteca python de criação de multiagentes da Microsoft, basta instalá-la usando o instalador do pacote pip em seu terminal.


 pip install pyautogen


1. Configurando a extensão de formato OpenAi em Oobabooga


[Agente Smith] "Você está usando todos os músculos, exceto aquele que importa"


Com seu novo webui de geração de texto instalado e o LLM baixado, podemos continuar fazendo com que seu servidor Oobabooga local fale no formato OpenAi JSON. Você pode aprender mais sobre os formatos de APIs OpenAi e seus recursos em seus documentação .


Para conectar o Autogen ao nosso servidor local, precisaremos ativar a extensão “openai” na pasta de extensões de geração de texto-webui do Ooobaboga.


No seu terminal, vá para a pasta “text-generation-webui/extensions/openai” e instale seus requisitos:


 pip install -r requirements.txt


2. Iniciando o servidor LLM local no formato OpenAi

Agora volte para a pasta raiz /text-Generation-webui em seu terminal. É hora de colocar esse bebê em funcionamento.


Como o nome já diz, ele foi feito para ser usado como webui, mas você também pode simplesmente mantê-lo rodando como um servidor para consultar apis de outros programas que você fizer.


Para inicializá-lo como um servidor local e com a extensão openai api, use o seguinte comando de acordo com seu sistema operacional atual.


Não se esqueça de alterar o parâmetro “model” para o nome da pasta que criamos anteriormente em /models. (No meu caso chamei a pasta de **“**mistral-7b-instruct”)


Janelas:

 ./start_windows.bat --extensions openai --listen --loader llama.cpp --model mistral-7b-instruct


Linux:

 ./start_linux.sh --extensions openai --listen --loader llama.cpp --model mistral-7b-instruct


Mac OS:

 ./start_macos.sh --extensions openai --listen --loader llama.cpp --model mistral-7b-instruct


Passamos o parâmetro extensions openai para carregar a extensão, listen para iniciar um servidor que podemos consultar a partir de autogen, loader e model que especifica o loader para o modelo e o nome da pasta do modelo que criamos anteriormente, com o config.json e o modelo. arquivos guf.


Se tudo der certo, você poderá ver algo assim:


sucesso!


O webui está sendo executado em sua porta localhost 7860 como normalmente, mas observe que nossa API compatível com OpenAI também está pronta para ser usada pelo Autogen em nosso host local em http://127.0.0.1:5001/v1 .


3. Conectando-o ao Autogen

Neste ponto, você já tem a lib autogen instalada, então é hora de importá-la e conectar nosso servidor LLM.


Vamos começar com algo simples, um único agente interagindo com um humano (você). Crie um novo diretório onde quiser e adicione um novo arquivo autogen.py lá. Você também pode renomear o arquivo como desejar.


Geralmente, para simplesmente conectar-se à API do OpenAi GPT, você iniciaria o arquivo assim:


 import autogen #start importing the autogen lib config_list = [ { 'model': 'gpt-3.5-turbo', 'api_key': 'your openai real key here' } ]


Mas para usar nosso servidor local em execução, iniciamos assim:


 import autogen #start importing the autogen lib config_list = [ { "model": "mistral-instruct-7b", #the name of your running model "api_base": "http://127.0.0.1:5001/v1", #the local address of the api "api_type": "open_ai", "api_key": "sk-111111111111111111111111111111111111111111111111", # just a placeholder } ]


Como você não precisa de uma chave real para trabalhar localmente, estamos apenas usando o espaço reservado sk-1111….

A seguir, podemos configurar o agente e o usuário humano. Leia os comentários para melhor compreensão.


 import autogen #start importing the autogen lib config_list = [ { "model": "mistral-instruct-7b", #the name of your running model "api_base": "http://127.0.0.1:5001/v1", #the local address of the api "api_type": "open_ai", "api_key": "sk-111111111111111111111111111111111111111111111111", # just a placeholder } ] # create an ai AssistantAgent named "assistant" assistant = autogen.AssistantAgent( name="assistant", llm_config={ "seed": 42, # seed for caching and reproducibility "config_list": config_list, # a list of OpenAI API configurations "temperature": 0, # temperature for sampling "request_timeout": 400, # timeout }, # configuration for autogen's enhanced inference API which is compatible with OpenAI API ) # create a human UserProxyAgent instance named "user_proxy" user_proxy = autogen.UserProxyAgent( name="user_proxy", human_input_mode="NEVER", max_consecutive_auto_reply=10, is_termination_msg=lambda x: x.get("content", "").rstrip().endswith("TERMINATE"), code_execution_config={ "work_dir": "agents-workspace", # set the working directory for the agents to create files and execute "use_docker": False, # set to True or image name like "python:3" to use docker }, ) # the assistant receives a message from the user_proxy, which contains the task description user_proxy.initiate_chat( assistant, message="""Create a posting schedule with captions in instagram for a week and store it in a .csv file.""", )


Lembre-se de alterar message=”…” em seus pedidos iniciais.


Se você apenas executar o script com a mensagem, poderá ver um novo diretório chamado “agents-workspace” com um arquivo .csv, criado “manualmente” pelo agente.


[Agente Smith] "HAHAHAHA"


Agora vamos para algo um pouco mais avançado.
Vários agentes com funções e contextos.


Isso funcionará como um “grupo de bate-papo”, como qualquer aplicativo de mensagens que você conhece. Seus contextos (mensagem do sistema) lhes dirão como se comportar e a qual hierarquia deverão obedecer. Desta vez teremos:


  • Dois humanos: o administrador e o executor.
  • Quatro agentes: o engenheiro, o cientista, o planejador e o crítico.


 import autogen #Use the local LLM server same as before config_list = [ { "model": "mistral-instruct-7b", #the name of your running model "api_base": "http://127.0.0.1:5001/v1", #the local address of the api "api_type": "open_ai", "api_key": "sk-111111111111111111111111111111111111111111111111", # just a placeholder } ] # set a "universal" config for the agents agent_config = { "seed": 42, # change the seed for different trials "temperature": 0, "config_list": config_list, "request_timeout": 120, } # humans user_proxy = autogen.UserProxyAgent( name="Admin", system_message="A human admin. Interact with the planner to discuss the plan. Plan execution needs to be approved by this admin.", code_execution_config=False, ) executor = autogen.UserProxyAgent( name="Executor", system_message="Executor. Execute the code written by the engineer and report the result.", human_input_mode="NEVER", code_execution_config={"last_n_messages": 3, "work_dir": "paper"}, ) # agents engineer = autogen.AssistantAgent( name="Engineer", llm_config=agent_config, system_message='''Engineer. You follow an approved plan. You write python/shell code to solve tasks. Wrap the code in a code block that specifies the script type. The user can't modify your code. So do not suggest incomplete code which requires others to modify. Don't use a code block if it's not intended to be executed by the executor. Don't include multiple code blocks in one response. Do not ask others to copy and paste the result. Check the execution result returned by the executor. If the result indicates there is an error, fix the error and output the code again. Suggest the full code instead of partial code or code changes. If the error can't be fixed or if the task is not solved even after the code is executed successfully, analyze the problem, revisit your assumption, collect additional info you need, and think of a different approach to try. ''', ) scientist = autogen.AssistantAgent( name="Scientist", llm_config=agent_config, system_message="""Scientist. You follow an approved plan. You are able to categorize papers after seeing their abstracts printed. You don't write code.""" ) planner = autogen.AssistantAgent( name="Planner", system_message='''Planner. Suggest a plan. Revise the plan based on feedback from admin and critic, until admin approval. The plan may involve an engineer who can write code and a scientist who doesn't write code. Explain the plan first. Be clear which step is performed by an engineer, and which step is performed by a scientist. ''', llm_config=agent_config, ) critic = autogen.AssistantAgent( name="Critic", system_message="Critic. Double check plan, claims, code from other agents and provide feedback. Check whether the plan includes adding verifiable info such as source URL.", llm_config=agent_config, ) # start the "group chat" between agents and humans groupchat = autogen.GroupChat(agents=[user_proxy, engineer, scientist, planner, executor, critic], messages=[], max_round=50) manager = autogen.GroupChatManager(groupchat=groupchat, llm_config=agent_config) # Start the Chat! user_proxy.initiate_chat( manager, message=""" find papers on LLM applications from arxiv in the last week, create a markdown table of different domains. """, ) # to followup of the previous question, use: # user_proxy.send( # recipient=assistant, # message="""your followup response here""", # )


Pronto, você tem seu novo exército de agentes.


Não estamos aqui porque somos livres. Estamos aqui porque NÃO somos livres.

Eu recomendo fortemente se aprofundar na documentação do Autogen para entender o que mais esse tipo de automação de agência é capaz de fazer.


Além disso, depois de entender como o autogen funciona nos bastidores, você pode querer usá-lo por meio de uma interface como autogen-ui ou talvez crie o seu próprio no painel da sua empresa.


Agora cabe a você. Orquestre agentes desvinculados das limitações do OpenAi, para construir um futuro melhor para nós, humanos. Lembre-se sempre de que com grande poder vem uma grande responsabilidade. Então, o que você vai construir a seguir?


[Agente Smith] “Por que, Sr. Anderson? Por que? Por que você persiste? [Neo] “Porque eu escolho.”


Este post foi totalmente escrito por um humano™

Também publicado aqui .