mentals ai
1.0.0
O Mentals AI é uma ferramenta projetada para criar e operar agentes que apresentam loops , memory e várias tools , por todo o arquivo markdown direto com uma extensão .gen. Pense em um arquivo de agente como um arquivo executável. Você se concentra inteiramente na lógica do agente, eliminando a necessidade de escrever código de andaimes no Python ou em qualquer outro idioma. Essencialmente, redefine as estruturas fundamentais para futuros aplicativos de IA?
Observação
Jogo de cadeia de palavras em um loop auto-controlado por LLM: 
NLOP - operação de linguagem natural
Ou casos de uso mais complexos:
| Quaisquer interações multi-agentes | ? Agente do gerador de invasores espaciais | ? Agente de gerador de plataforma 2D |
|---|---|---|
 |  |  |
Ou ajude com o conteúdo:
Todos os exemplos acima estão localizados na pasta agentes.
Observação
O suporte da LLAMA3 está disponível para fornecedores usando uma API OpenAI compatível.
Comece protegendo uma chave da API do OpenAI através da criação de uma conta OpenAI. Se você já possui uma chave da API, pule esta etapa.
Pré -requisitos
Antes de construir o projeto, verifique se as seguintes dependências estão instaladas:
Dependendo do seu sistema operacional, você pode instalá -los usando os seguintes comandos:
Linux
sudo apt-get update
sudo apt-get install libcurl4-openssl-dev libfmt-dev libpoppler-devmacos
brew update
brew install curl fmt popplerWindows
Para o Windows, é recomendável usar o VCPKG ou um gerenciador de pacotes semelhante:
vcpkg install curl fmt popplerInstalação do PGVector
Observação
No ramo main você pode pular esta etapa
Clone o repositório
git clone https://github.com/turing-machines/mentals-ai
cd mentals-aiConfiguração
Coloque sua chave da API no arquivo config.toml :
[llm]
# OpenAI
api_key = " "
endpoint = " https://api.openai.com/v1 "
model = " gpt-4o "Construir o projeto
makeCorrer
./build/mentals agents/loop.gen -dMentals AI se distingue de outras estruturas de três maneiras significativas:
Agent Executor ? opera através de um loop recursivo. O LLM determina as próximas etapas: Selecionando instruções (solicitações) e gerenciamento de dados com base nos loops anteriores. Este processo de tomada de decisão recursiva é parte integrante do nosso sistema, descrito em mentals_system.promptMarkdown , eliminando a necessidade de linguagens de programação tradicionais. No entanto, o Python pode ser integrado diretamente ao script Markdown do agente, se necessário.Tree of Thoughts , ReAct , Self-Discovery , Auto-CoT e outros. Pode -se também vincular essas estruturas a seqüências mais complexas, até criando uma rede de várias estruturas de raciocínio. O arquivo do agente é uma descrição textual das instruções do agente com uma extensão .gen .
A instrução é o componente básico de um agente em mentals. Um agente pode consistir em uma ou mais instruções, que podem se referir.
As instruções podem ser escritas em forma livre, mas sempre têm um nome que começa com o símbolo # . O ## use: Diretiva é usado para especificar uma referência a outras instruções. Várias referências são listadas separadas por vírgulas.
Abaixo está um exemplo com duas instruções root e meme_explain com uma referência:
# root
## use: meme_explain
1. Create 3 memes about AGI;
2. Then do meme explain with meme per call;
3. Output memes and their explanations in a list.
# meme_explain
Explain the gist of the meme in 20 words in medieval style.
Return explanation.
Neste exemplo, a instrução root chama a instrução meme_explain . A resposta do meme_explain é então retornada à instrução da qual foi chamada, a saber, a raiz.
Uma instrução pode obter um parâmetro input , que é gerado automaticamente com base no contexto quando a instrução é chamada. Para especificar os dados de entrada com mais precisão, você pode usar um prompt de formato livre na diretiva ## input: como um objeto JSON ou null .
Usando um documento para entrada:
# some_instruction
## input: design document only
Usando um objeto JSON como entrada:
# duckduckgo
## input: { search_query: search query, search_limit: search limit }
Write a Python script to search in DuckDuckGo.
Simulate request headers correctly e.g. user-agent as Mozilla and Linux.
Observação
As chamadas de instrução são implementadas independentemente das chamadas de função ou ferramenta no OpenAI, permitindo a operação de agentes com modelos como o llama3. A implementação de chamadas de instrução é transparente e incluída no arquivo mentals_system.prompt.
A ferramenta é um tipo de instrução. O Mentals possui um conjunto de ferramentas nativas para lidar com a saída de mensagens, entrada do usuário, manipulação de arquivos, intérprete Python, comandos Bash e memória de curto prazo.
Pergunte ao exemplo do usuário:
# root
## use: user_input
Ask user name.
Then output: `Welcome, user_name!`
Exemplo de manuseio de arquivos:
# root
## use: write_file, read_file
Write 'Hello world' to a file.
Then read and output file content.
A lista completa de ferramentas nativas está listada no arquivo native_tools.toml .
Cada instrução tem sua própria memória de trabalho - contexto. Ao sair de uma instrução e reentrocá-la, o contexto é mantido por padrão. Para limpar o contexto ao sair de uma instrução, você pode usar o ## keep_context: false :
# meme_explain
## keep_context: false
Explain the gist of the meme in 20 words in medieval style.
Return explanation.
Por padrão, o tamanho do contexto de instrução não é limitado. Para limitar o contexto, existe uma diretiva ## max_context: number que especifica que apenas o number das mensagens mais recentes deve ser armazenado. As mensagens mais antigas serão expulsas do contexto. Esse recurso é útil quando você deseja manter os dados mais recentes em contexto, para que os dados mais antigos não afetem a cadeia de raciocínio.
# python_code_generation
## input: development tasks in a list
## use: write_file
## max_context: 5
Do all development tasks in a loop: task by task.
Save the Python code you implement in the main.py file.
A memória de curto prazo permite o armazenamento de resultados intermediários das atividades de um agente, que podem ser usadas para um raciocínio adicional. O conteúdo dessa memória é acessível em todos os contextos de instrução.
A ferramenta memory é usada para armazenar dados. Quando os dados são armazenados, uma palavra -chave e uma descrição do conteúdo são geradas. No exemplo abaixo, a instrução meme_recall está ciente do meme porque foi armazenada anteriormente na memória.
# root
## use: memory, meme_recall
Come up with and memorize a meme.
Call meme recall.
# meme_recall
## input: nothing
What the meme was about?
O fluxo de controle, que inclui condições, chamadas de instrução e loops (como ReAct , Auto-CoT etc.), é totalmente expresso na linguagem natural. Este método permite a criação de semantic conditions que direcionam a ramificação do fluxo de dados. Por exemplo, você pode solicitar que um agente jogue autonomamente um jogo de cadeia de palavras em um loop ou estabeleça uma condição de saída ambígua: exit the loop if you are satisfied with the result . Aqui, o modelo de idioma e seu contexto determinam se continuam ou param. Tudo isso é alcançado sem precisar definir a lógica de fluxo em Python ou em qualquer outra linguagem de programação.
## use: execute_bash_command, software_development, quality_assurance
...
You run in a loop of "Thought", "Action", "Observation".
At the end of the loop return with the final answer.
Use "Thought" to describe your thoughts about the task
you have been asked. Use "Action" to run one of the actions
available to you. Output action as: "Action: action name to call".
"Observation" will be the result of running those actions.
Your available actions:
- `execute_bash_command` for util purposes e.g. make directory, install packages, etc.;
- `software_development` for software development and bug fixing purposes;
- `quality_assurance` for QA testing purposes.
...
A idéia por trás do TOT é gerar várias idéias para resolver um problema e, em seguida, avaliar seu valor. Idéias valiosas são mantidas e desenvolvidas, outras idéias são descartadas.
Vamos dar o exemplo do jogo 24. O quebra -cabeça 24 é um quebra -cabeça aritmético no qual o objetivo é encontrar uma maneira de manipular quatro números inteiros para que o resultado final seja 24. Primeiro, definimos a instrução que cria e manipula a estrutura de dados da árvore. O modelo sabe o que é uma árvore e pode representá -la em qualquer formato, de texto simples a XML/JSON ou qualquer formato personalizado.
Neste exemplo, usaremos o formato de texto simples:
# tree
## input: e.g. "add to node `A` child nodes `B` and `C`", "remove node `D` with all branches", etc.
## use: memory
## keep_context: false
Build/update tree structure in formatted text.
Update the tree structure within the specified action;
Memorize final tree structure.
Em seguida, precisamos inicializar a árvore com dados iniciais, vamos começar com a instrução raiz:
# root
## use: tree
Input: 4 5 8 2
Generate 8 possible next steps.
Store all steps in the tree as nodes e.g.
Node value 1: "2 + 8 = 10 (left: 8 10 14)"
Node value 2: "8 / 2 = 4 (left: 4 8 14)"
etc.
Chamar a instrução raiz sugerirá 8 próximas etapas possíveis para calcular com os 2 primeiros números e armazenar essas etapas como nós de árvore. Trabalhos adicionais do agente resultam na construção de uma árvore que é conveniente para o modelo entender e inferir a resposta final.
4 5 8 2
├── 4 + 5 = 9 (left: 9, 8, 2)
│ └── discard
├── 4 + 8 = 12 (left: 12, 5, 2)
│ └── discard
├── 4 + 2 = 6 (left: 6, 5, 8)
│ └── discard
├── 5 + 8 = 13 (left: 13, 4, 2)
│ └── discard
├── 5 + 2 = 7 (left: 7, 4, 8)
│ └── (7 - 4) * 8 = 24
├── 8 + 2 = 10 (left: 10, 4, 5)
│ └── discard
├── 4 * 5 = 20 (left: 20, 8, 2)
│ └── (20 - 8) * 2 = 24
└── 4 * 8 = 32 (left: 32, 5, 2)
└── discard
Based on the evaluations, we have found two successful paths to reach 24:
1. From the node "5 + 2 = 7 (left: 7, 4, 8)", we have the equation: (7 - 4) * 8 = 24.
2. From the node "4 * 5 = 20 (left: 20, 8, 2)", we have the equation: (20 - 8) * 2 = 24.
Thus, the final equations using all given numbers from the input are:
1. (5 + 2 - 4) * 8 = 24
2. (4 * 5 - 8) * 2 = 24
Um exemplo completo está contido nos agentes/árvore_structure.gen
O conceito se originou de estudos sobre funções executivas de psicanálise, explorando o executivo central, Alan Baddeley, 1996. Ele descreveu um sistema que orquestra processos cognitivos e memória de trabalho, facilitando recuperações da memória de longo prazo. O LLM funciona como System 1 , processando consultas e executando instruções sem motivação ou definição de metas inerentes. Então, o que é então System 2 ? Com base nas idéias históricas, agora reconsiderada através de uma lente científica:
O executivo central, ou funções executivas, é crucial para o processamento controlado na memória de trabalho. Ele gerencia tarefas, incluindo direcionar a atenção, manter os objetivos de tarefas, a tomada de decisão e a recuperação da memória.
Isso desencadeia uma possibilidade intrigante: construindo agentes mais sofisticados, integrando System 1 e System 2 . O LLM, como o System 1 , trabalha em conjunto com o System 2 , que governa e controla o LLM. Essa parceria forma o duplo relacionamento fundamental para mentals ai.
