Älyverkko CLI application

Problem Statement:

Analyze a set of customer reviews to determine overall sentiment and extract key features that customers appreciate or dislike about a product.

Usage Procedure:

1. User collects customer reviews in plain text format within the configured tasks directory. Lets say, about 150 kilobytes of reviews per input file (this is dictated by AI model available context size).
2. Each review file starts with special "TOCOMPUTE:". (See: Task file format)
3. The Älyverkko CLI application processes these files, generating sentiment analysis results and feature extraction insights.
4. Results are appended to the original files in org-mode syntax, indicating AI responses.

Problem Statement:

Generate code snippets for a new software module based on detailed specifications provided by the developer.

Usage Procedure:

1. Developer writes specifications in a text file within the tasks directory. Text file also contains relevant parts of the program source code and documentation. Älyverkko CLI "joinfiles" command can be used to facilitate such text file preparation.
2. The Älyverkko CLI application processes this file and generates the corresponding code snippets. The generated code is appended to the original specifications file, organized using org-mode syntax.
3. Developer can review proposed changes and then integrate them back into original program source code.

Note: Large part of the Älyverkko CLI program code is written in such a way by AI.

Problem Statement:

Draft an outline for a book on science fiction or improve its plot.

Usage Procedure:

1. The book author writes a brief describing the outline of the plot and his book main idea for the novel.
2. Älyverkko CLI processes this description and generates more detailed outline with suggested headings and suggests possible improvements to the plot.

Here is example sci-fi book that was written with the help of Älyverkko CLI.

• What: Install JDK 21+ and Apache Maven
• Why: Älyverkko CLI is written in Java - these tools let you build and run the application.

  • Don't worry: On Debian/Ubuntu, it's just

    sudo apt install openjdk-21-jdk maven
    

Key insight: Java was chosen because it's cross-platform, memory-safe, and perfect for long-running background processes like our AI task processor.

• What: Download and compile the llama.cpp project from GitHub.
• Why: This is the actual "brain" that runs large language models on your CPU. We build from source (rather than using rebuilt binaries) so it can optimize for your specific CPU - squeezing out maximum performance from your hardware.

• What: Download GGUF format model files (typically 4-30GB each)
• Where: From Hugging Face Hub (search "GGUF").
• Why: These contain the actual neural networks that power the AI.
• Don't worry: Start with one model (like Mistral 7B) - you can add more later.
• Key insight: GGUF format was created specifically for CPU inference.

❓ Why not smaller models? Larger models (even running slowly on CPU) produce significantly better results for complex tasks - it's worth the wait.

• What: Launch the configuration wizard that asks simple questions.
• Why: To connect all the pieces without you needing to edit complex YAML files.
• Don't worry: It's interactive! You'll answer questions like "Where did you put your AI models?" with easy prompts.
• Key insight: This creates your personal ~/.config/alyverkko-cli.yaml file.

🌟 Pro tip: The wizard automatically detects your models and suggests reasonable defaults - you're not starting from scratch.

• What: Create simple YAML files defining how the AI should behave for different tasks.
• Why: So you don't have to rewrite instructions every time ("be a coding assistant" vs "be a writing editor").
• Don't worry: Start with sample skills (default.yaml, summary.yaml) - you can modify them gradually.
• Key insight: Skills let you create specialized AI personas without changing models.

Idea: Your writer.yaml skill might instruct the AI to "always provide well-reasoned responses in academic tone"

• What: Create a text file with your request, prefixed with TOCOMPUTE:
• Why: This triggers the background processing system
• Key insight: File-based interaction isn't primitive - it's intentional design for batch processing.

The application is configured using a YAML-formatted configuration file. Below is an example of how the configuration file might look:

tasks_directory: "/home/user/AI/tasks"
models_directory: "/home/user/AI/models"
skills_directory: "/home/user/AI/skills"
llama_cli_path: "/home/user/AI/llama.cpp/build/bin/llama-cli"

# Generation parameters
default_temperature: 0.7
default_top_p: 0.9
default_repeat_penalty: 1.0

# Performance tuning
thread_count: 6
batch_thread_count: 10

# Model definitions
models:
  - alias: "default"
    filesystem_path: "model.gguf"
    context_size_tokens: 64000
    temperature: 0.8
    top_p: 0.9
    repeat_penalty: 1.1

  - alias: "mistral"
    filesystem_path: "Mistral-Large-Instruct-2407.Q8_0.gguf"
    context_size_tokens: 32768

For temperature, top_p, top_k, min_p and repeat_penalty parameters, values are determined using this priority order (highest to lowest):

1. Skill-specific value (from skill's YAML file)
2. Model-specific value (from model configuration)
3. Global default value (from main configuration)

This allows fine-grained control where more specific configurations override broader ones.

Once Älyverkko CLI is installed and properly configured, you can run following command at commandline to see what models are available to it:

alyverkko-cli listmodels

Note: Models that reference missing files will be automatically marked with "-missing" suffix in their alias by configuration wizard. You can manually remove this suffix after fixing the model file path.

The selftest command performs a series of checks to ensure the system is configured correctly:

alyverkko-cli selftest

It verifies:

• Configuration file integrity.
• Model directory existence.
• The presence of the llama.cpp executable.

Skills are defined in YAML files stored in the skills_directory.

Each skill file contains:

prompt: "Full system prompt text here"
temperature: 0.8       # Optional
top_p: 0.9             # Optional
top_k: 0.5             # Optional
min_p: 0.5             # Optional
repeat_penalty: 1.1    # Optional

The system prompt must contain <TASK-FILE> which gets replaced with the actual user prompt during execution.

writer.yaml

temperature: 0.9
top_p: 0.95
prompt: |
  <|im_start|>system
  User will provide you with task that needs to be solved along with
  existing relevant information.

  You are artificial general intelligence system that always provides well reasoned responses.
  <|im_end|>
  <|im_start|>user
  /think Solve following problem:

  <TASK-FILE>

  <|im_end|>
  <|im_start|>assistant

See more example skills: default.yaml, summary.yaml

1. Open your terminal.

2. Run the command:

   alyverkko-cli process
   

3. The application will start monitoring the configured mail directory for incoming messages and process them accordingly in endless loop.
4. To terminate Älyverkko CLI, just hit CTRL+c on the keyboard, or close terminal window.

1. Access the application launcher or application menu on your desktop environment.
2. Search for "Älyverkko CLI".
3. Click on the icon to start the application. It will open its own terminal.
4. If you want to stop Älyverkko CLI, just close terminal window.

During Älyverkko CLI installation, installation script will prompt you if you want to install systemd service. If you chose Y, Alyverkko CLI would be immediately started in the background as a system service. Also it will be automatically started on every system reboot.

To view service status, use:

systemctl -l status alyverkko-cli

If you want to stop or disable service, you can do so using systemd facilities:

sudo systemctl stop alyverkko-cli
sudo systemctl disable alyverkko-cli

The first line must begin with exactly TOCOMPUTE: followed by space-separated key-value pairs:

TOCOMPUTE: skill=default model=mistral priority=10

Valid parameters in the header:

• skill[name]=: Specifies which skill to use (defaults to "default")
• model[alias]=: Specifies which AI model to use (defaults to "default")
• priority[integer]=: Higher integers mean higher priority (default: 0)

After AI processing completes, a new file is created with:

1. First line: DONE: skill[name] model=[alias] duration=[time]=
2. * USER: section containing original user prompt
3. * ASSISTANT: section containing AI response

DONE: skill=writer model=default duration=5m
...

Example DONE file:

DONE: skill=default model=default duration=2m
* USER:

If numbers had personalities,
what kind of personality might the number 'zero' have?

* ASSISTANT:

1. Personality traits based on mathematical properties:
   - Neutral and unchanging unless influenced
   - Control over magnitude through multiplication
   - Neither positive/negative (impartial)
   - Foundational yet seemingly insignificant at times

2. Symbolism and metaphors:
   - Balance point between opposites
   - Container for infinite possibilities (potential)
   - Cycle of beginning/endpoints
   - Quiet supporter behind the scenes

3. Social dynamics:
   - Values community/cooperation
   - May feel undervalued but persists regardless
   - Adaptable depending on situation/placement

4. Philosophical/spiritual parallels:
   - Emptiness equates to purity/clean slate
   - Potential without action = dormant power

5. Gender and self-identity:
   - Ambiguous/genderless

6. Emotional characteristics:
   - Patient; allows time for events/actions to unfold
   - Resilient when facing neglect or misunderstanding
   - Persistent in fulfilling its purpose

7. Behavioral tendencies:
   - Fosters growth indirectly rather than directly contributing
     measurable output
   - Encourages exploration beyond limits via abstract reasoning
     innovations

Note: See also alternative solution with similar goal: prelude.

The joinfiles command is a utility for aggregating the contents of multiple files into a single document, which can then be processed by AI. This is particularly useful for preparing comprehensive problem statements from various source files, such as software project directories or collections of text documents.

The Elisp function ai-new-topic facilitates the creation and opening of a new Org-mode file dedicated to a user-defined topic within a specified directory. Now you can use this file within emacs to compose you problem statement to AI.

When ai-new-topic function triggered, it first prompts the user to input a topic name. This name will serve as the basis for the filename and the title within the document.

The function then constructs a file path by concatenating the pre-defined alyverkko-topic-files-directory (which should be set to your topics directory), the topic name, and the .org extension. If a file with this path does not already exist, the function will create a new file and open it for editing.

(defvar alyverkko-task-files-directory "/home/user/my-ai-tasks-directory/"
  "Directory where task files are stored.")

(defun alyverkko-new-task ()
  "Create and open a task file in the specified directory."
  (interactive)
  (let ((task (read-string "Enter task name: ")))
    (let ((file-path (concat alyverkko-task-files-directory task ".org")))
      (if (not (file-exists-p file-path))
          (with-temp-file file-path
            ))
      (find-file file-path)
      (goto-char (point-max))
      (org-mode))))

The function alyverkko-compute is designed to enhance the workflow of users working with the Älyverkko CLI application by automating the process of marking text files for computation with a specific AI model and prompt.

When function is invoked, it detects available prompts and allows user to select one.

Thereafter function detects available models from Älyverkko CLI configuration file and allows user to select one.

Finally function inserts at the beginning of currently opened file something like this:

TOCOMPUTE: prompt=<chosen-prompt> model=<chosen-model> priority=<chosen-priority>

• Adjust prompt-dir variable to point to your prompts directory.
• Adjust config-file variable to point to your Älyverkko CLI configuration file path.

(defun alyverkko-compute ()
  "Interactively pick a skill, model, and priority, then insert a
TOCOMPUTE line at the top of the current buffer.

Adjust `skill-dir` and `config-file` to match your setup."
  (interactive)
  (let ((skill-dir "~/.config/alyverkko-cli/skills/")
        (config-file "~/.config/alyverkko-cli/alyverkko-cli.yaml")
        models)

    ;; Harvest model aliases from the Älyverkko CLI config
    (with-temp-buffer
      (insert-file-contents config-file)
      (goto-char (point-min))
      (when (search-forward-regexp "^models:" nil t)
        (while (search-forward-regexp "^\\s-+- alias: \"\\([^\"]+\\)\"" nil t)
          (push (match-string 1) models))))

    (if (file-exists-p skill-dir)
        (let* ((files   (directory-files skill-dir t "\\`[^.].*\\.yaml\\'"))
               (aliases (mapcar #'file-name-base files)))
          (if aliases
              (let* ((selected-alias (completing-read "Select skill: " aliases))
                     (model         (completing-read "Select AI model: " models))
                     (priority      (number-to-string
                                     (read-number "Priority (integer, default 0): " 0))))
                (alyverkko-insert-tocompute-line selected-alias model priority))
            (message "No skill files found.")))
      (message "Skill directory not found."))))

(defun alyverkko-insert-tocompute-line (skill-alias model &optional priority)
  "Insert a TOCOMPUTE line with SKILL-ALIAS, MODEL, and PRIORITY at
the top of the current buffer."
  (save-excursion
    (goto-char (point-min))
    (insert (format "TOCOMPUTE: skill=%s model=%s priority=%s\n"
                    skill-alias model (or priority "0")))
    (save-buffer)))