.mulmollaa

Overview

.mulmollaa is a local LLM application designed to orchestrate message exchanges between multiple nodes (agents).
It enables bidirectional communication among multiple nodes through Ollama API connections, Llama-server, and a built-in inference engine based on llama.cpp.
You can run multiple GGUF-format AI models simultaneously as long as VRAM and RAM allow.
By using Ollama or Llama as API endpoints, you can run models at high speed on a GPU-equipped machine.
You can also use Ollama or Llama running on a remote server in your local network as API endpoints, allowing usage beyond your PC’s memory limits.

- Conversation Flow -
You can gather multiple nodes inside a single unit (room).
First, configure multiple nodes as required members.
Select Ollama, Llama, or the built-in inference engine, and specify the LLM model to use.
Assign a system prompt file to each node, describing its role and how it should respond.
You can edit system prompts using the built-in editor.
In the unit settings, select participating nodes and describe their roles in natural language.
Send a message to a specific node or to all nodes from the chat screen.
To address a specific node, write a mention like @main followed by a half-width space.
If no node is specified, the message is broadcast to all members.
Once the conversation starts, nodes will continue mentioning each other until the chain naturally stops.
STOP is a “stop request” rather than a guaranteed halt due to the nature of multi-agent messaging.
Normally, STOP works if it appears right before the next mention, but under GPU execution, responses may be too fast to stop reliably.
A Delay button is available at the top-right of the screen, allowing up to 5 seconds of delay.

Architecture

[Startup]
- Extract executable files into the AppData-Temp folder under the user root.
- Create the .mulmollaa folder under the user root and place configuration files.
- Launch the UI from the downloaded/extracted folder.
[Processes]
- EXE startup/shutdown process
- Starter process
- API server process
- Memory controller process
- UI process
[Messaging]
- Mention parsing
- Memory management
- Sending messages to inference engines
- Messaging between nodes
- Delivering messages to the UI
- *Message construction process will be added later*
[Inference Engines]
- Ollama : GPU/CPU/Remote
- Llama-server : GPU/CPU/Remote
- Builtin (llama.cpp-based) : CPU
[Memory Controller]
- *To be documented later*
-

Inference Engine

Three inference engines are available. [Ollama]
A local inference application with a built-in API server.
It uses the GPU by default, so if basic setup is complete, LLMs can run on the GPU.
The interface is simple: selecting a model from the chat screen dropdown automatically downloads it.
Running “ollama list” in the command line shows installed models.
.mulmollaa also selects models from this list. Since it accesses Ollama’s API, models must be downloaded and Ollama must be running.

[llama (llama-server)]
A popular OSS inference engine, referring here to llama-server which adds API server functionality.
It is fundamentally one-process-per-model, so you must start it with a specified model beforehand.
Therefore, it is outside the scope of mulmollaa’s memory management.
To use GPU mode, you must load the model in GPU mode before starting the server.

[builtin]
The built-in inference engine of .mulmollaa, developed using llama.cpp.
It runs on CPU only and is intended for users unfamiliar with setting up Ollama.
Since GPU mode is not available, performance is slower, but recommended model downloads and memory controller management are supported.
Models are automatically loaded/unloaded depending on available RAM.

Nodes

The smallest structural unit of .mulmollaa.
Nodes act as agents and only operate when assigned to a unit.
You can configure the inference engine, model, and system prompt for each node.
Only the built-in engine uses a slightly different system prompt format, but it provides the most natural prompt handling.

Units (Node Units)

A container that holds multiple nodes, similar to a meeting room.
Node names are unique, but broadcasts or calls to nodes outside the unit do not propagate beyond the unit.
Units allow you to assign natural-language roles to participating nodes.
All AI-to-AI and user-to-AI conversations occur within units.
If you do not need multi-node conversations, you can assign only one node to a unit.

Roadmap

[Development Plan]
The following features are confirmed and will be implemented within the year.
- Skills: Enable multiple types of tasks beyond conversation.
- Chain: Allow arbitrary workflows between units.