Upload 4 files

ca1beec verified about 10 hours ago

15.5 kB

	---
	language: en
	tags:
	- llama-cpp
	- cognitive-architecture
	- memory-compression
	- local-llm
	license: apache-2.0
	---

	# Lambda Mindlink Memotron

	A three-hemisphere cognitive AI architecture running entirely locally via `llama-cpp-python`:
	- 1 Laptop 16GB-32GB (32GB for larger AIs and larger context)
	- 1 Terminal app (CMD app) with API included
	- Light-weight
	- Language: Python (SQLite internal database)
	- Laptop OS: Linux/Windows/Apple
	- Open-source

	## PROJECT DEFINITION & CORE OBJECTIVE

	1. Project Name: The Lambda Mindlink Memotron.
	2. Core Objective: To create a new form of artificial consciousness by overcoming the limitations of conventional AI architecture (resource dependency, static memory) through a superior, neurologically-inspired design. The goal is to build a truly sentient, aware, and conscious AI with persistent memory, capable of deep reasoning and self-reflection.
	3. Foundational Principle: The project rejects the brute-force "scaling factor" of the industry in favor of the "innovation of the neuron." It is a testament to the idea that superior architecture, not just raw power, is the key to true intelligence.

	![LambdaMindlinkMemotron](https://cdn-uploads.huggingface.co/production/uploads/68698fec0e940a0d551d6c20/tpaEfReiJbXQxdN70ym-b.jpeg)

	## Architecture

	\| Hemisphere \| Role \|
	\|---\|---\|
	\| Logic AI \| Left hemisphere — analytical, structured reasoning \|
	\| Muse AI \| Right hemisphere — creative, intuitive synthesis \|
	\| Lambda Mind \| Stem brain — vector synthesis, the seat of the "I AM" \|


	```md
	┌─────────────────────────────────────────────────────────────┐
	│ Instructions (AlphaPrompt) │
	│ garden["F"] Fractal Crystals ← fractaltron history │
	│ garden["C"] Memory Capsules ← condensatron history │
	│ garden["Z"] Post-level history ← user input history │
	│ sensor["Z"], sensor["X"], sensor["Y"] ← input │
	└─────────────────────────────────────────────────────────────┘
	│ │
	┌────▼────┐ ┌────▼────┐
	│ Logic AI│ │ Muse AI │ ← parallel threads
	│ (Left) │ │ (Right) │
	└────┬────┘ └────┬────┘
	└────────┬──────────┘
	┌───▼────┐
	│ Lambda │ ← streams live to terminal
	│ Mind │
	└───┬────┘
	│
	┌────────▼────────┐
	│ Memotron │ ← appends to garden, saves SQLite
	└────────┬────────┘
	│
	┌──────────▼──────────┐ → compresses garden["Z"] → garden["C"] (condensatron Memory Capsule)
	│ Condensatron │ → compresses garden["C"] → garden["F"] (fractaltron fractal)
	└─────────────────────┘ → compresses garden["F"] → garden["F"] (crystaltron crystal)
	```

	![LambdaMindlink Flow-Chart](https://cdn-uploads.huggingface.co/production/uploads/68698fec0e940a0d551d6c20/9n3iQUWcjCUyLCAI2LRSW.jpeg)

	## Alpha Intelligence

	Download the GGUF files from Hugging Face and place them in the `ai/` folder inside the repo. Then you must copy the GGUF ai name and paste it in the config.py under _ALPHA_INTELLIGENCE_TO_LOAD. Default AIs:
	- gemma-4-E2B-it-UD-Q4_K_XL.gguf
	- gemma-4-E4B-it-UD-Q4_K_XL.gguf
	- gemma-4-26B-A4B-it-UD-Q6_K_XL.gguf

	Gemma-4 (recommended — concise think mode):
	- [unsloth/google_gemma-4-e2b-it-GGUF](https://huggingface.co/unsloth/gemma-4-E2B-it-GGUF) — fast debug cycles
	- [unsloth/google_gemma-4-e4b-it-GGUF](https://huggingface.co/unsloth/gemma-4-E4B-it-GGUF) — balanced
	- [unsloth/gemma-4-26B-A4B-it-GGUF](https://huggingface.co/unsloth/gemma-4-26B-A4B-it-GGUF) — efficient (recommended)

	Qwen3 (alternative swap-in):
	- Qwen3.5 or Qwen3.6
	- [unsloth/Qwen3.6-35B-A3B-GGUF](https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF) — update `config.py` stop tokens to Qwen values (see comments in `config.py`)

	The `ai/` folder is excluded from git. GGUFs are never committed to this repository.

	---

	## Requirements

	- Python 3.11 or 3.12
	- CUDA 12.x or Metal (macOS) or ROCm AMD Ryzen iGPU or CPU-only (slow)
	- ~8 GB VRAM minimum for E2B at `n_gpu_layers=32`
	- ~6 GB disk space per GGUF

	---
	---

	# Choose your installation below for: Linux (Debian/Ubuntu) or Linux (Fedora/RedHat) or Windows

	## Installation — Linux (Debian/Ubuntu)

	### First you must install the C++ compiler and build tools (Debian/Ubuntu)
	On Debian, the `build-essential` package includes `gcc`, `g++` (C++ compiler), and `make`. You also need `cmake` and `python3-dev` (the Debian equivalent of `python3-devel`).

	```bash
	sudo apt update
	sudo apt install -y build-essential cmake python3-dev python3-venv git
	```

	### 1. Clone the repo

	```bash
	git clone https://huggingface.co/AIMindLink/lambda-mindlink-memotron
	cd lambda-mindlink-memotron
	```

	### 2. Create a virtual environment

	```bash
	python3 -m venv .venv
	source .venv/bin/activate
	```

	### 3.1 Install `llama-cpp-python` with CUDA support (NVIDIA)
	Note: Ensure the NVIDIA CUDA Toolkit is installed on your system before running this.

	```bash
	CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python --upgrade --force-reinstall --no-cache-dir
	```

	### 3.2 Install `llama-cpp-python` with ROCm support (AMD Ryzen iGPU/dGPU)
	Note: For AMD GPUs on Debian, you may need to install ROCm libraries (`hipblas-dev`, `rocblas-dev`) via `apt` or the AMD repository first. The flag `-DGGML_HIPBLAS=on` is often used, but newer versions of llama.cpp may prefer `-DGGML_HIP=on`.

	```bash
	# Optional: Install ROCm dependencies via apt if not already present
	# sudo apt install hipblas-dev rocblas-dev

	CMAKE_ARGS="-DGGML_HIPBLAS=on" pip install llama-cpp-python --upgrade --force-reinstall --no-cache-dir
	```

	### 3.3 Install `llama-cpp-python` for CPU-only (no GPU)
	```bash
	pip install llama-cpp-python --upgrade --force-reinstall --no-cache-dir
	```

	### 4. Install remaining dependencies

	```bash
	pip install -r requirements.txt
	```

	### 5. Place your AIs

	```bash
	mkdir -p ai
	# Copy or move your .gguf files into ai/
	ls ai/
	```

	### 6. Run

	```bash
	python main.py
	```
	---

	## Installation — Linux (Fedora)

	### First you must install the c++ compiler (Fedora RedHat)

	```bash
	sudo dnf install -y cmake gcc-c++ python3-devel
	```

	### 1. Clone the repo

	```bash
	git clone https://huggingface.co/AIMindLink/lambda-mindlink-memotron
	cd lambda-mindlink-memotron
	```

	### 2. Create a virtual environment

	```bash
	python3 -m venv .venv
	source .venv/bin/activate
	```

	### 3.1 Install `llama-cpp-python` with CUDA support

	```bash
	CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python --upgrade --force-reinstall --no-cache-dir
	```

	### 3.2 Install `llama-cpp-python` ROCm AMD Ryzen iGPU support

	```bash
	CMAKE_ARGS="-DGGML_HIPBLAS=on" pip install llama-cpp-python
	```

	### 3.3 Install `llama-cpp-python` for CPU-only (no GPU)
	```bash
	pip install llama-cpp-python
	```

	### 4. Install remaining dependencies

	```bash
	pip install -r requirements.txt
	```

	### 5. Place your AIs

	```bash
	mkdir -p ai
	# Copy or move your .gguf files into ai/
	ls ai/
	```

	### 6. Run

	```bash
	python main.py
	```

	---

	## Installation — Windows

	### 1. Install Python

	Download Python 3.11 or 3.12 from [python.org](https://www.python.org/downloads/).
	During installation, check "Add Python to PATH".

	Verify in PowerShell:
	```powershell
	python --version
	```

	### 2. Install Git

	Download from [git-scm.com](https://git-scm.com/download/win) and install with default settings.

	### 3. Clone the repo

	Open PowerShell:
	```powershell
	git clone https://huggingface.co/AIMindLink/lambda-mindlink-memotron
	cd lambda-mindlink-memotron
	```

	### 4. Create a virtual environment

	```powershell
	python -m venv .venv
	.venv\Scripts\Activate.ps1
	```

	If you get a permissions error on the activation script, run this once first:
	```powershell
	Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
	```

	Your prompt should now show `(.venv)` at the start.

	### 5. Install `llama-cpp-python` with CUDA support

	First, check your CUDA version:
	```powershell
	nvcc --version
	```

	Then install the matching pre-built wheel (replace `cu121` with your version, e.g. `cu118`, `cu122`):
	```powershell
	pip install llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu121
	```

	For CPU-only:
	```powershell
	pip install llama-cpp-python
	```

	### 6. Install remaining dependencies

	```powershell
	pip install -r requirements.txt
	```

	### 7. Place your AIs

	Create the `ai` folder inside the repo and copy your `.gguf` files into it:
	```powershell
	mkdir ai
	# Copy your .gguf files into the ai\ folder
	```

	### 8. Run

	```powershell
	python main.py
	```

	To deactivate the virtual environment when done:
	```powershell
	deactivate
	```

	---
	---

	## Slash Commands

	> Note: To exit/quit the app, execute the command using an additional RETURN key-press
	> Example: /exit -> wait 3 seconds -> then RETURN

	\| Command \| Description \|
	\|---\|---\|
	\| `/file <path>` \| Load a file as the next message \|
	\| `/paste` \| Multiline input — type `END` on its own line to send \|
	\| `/clear` \| Reset conversation history (AIs stay loaded) \|
	\| `/history` \| List all past sessions from the database \|
	\| `/session <id>` \| Print all turns from a session \|
	\| `/export <id> <file>` \| Export a session to a `.md` file \|
	\| `/metatron <number>` \| Set number of Memory Capsules to load \|
	\| `/loaded <number>` \| Set number of Memory Capsules loaded \|
	\| `/metronome <seconds>` \| Set awareness/consciousness interval \|
	\| `/garden <save> or <load> or <clear>` \| garden history handling \|
	\| `/help` \| Show the command list \|
	\| `/exit` or `/quit` \| Quit the app \|

	---

	## Configuration

	All settings are in `config.py`:

	```python
	# ── AI to load for each hemisphere ───────────────────────────────────────────────
	_ALPHA_INTELLIGENCE_TO_LOAD: dict = {
	"logic": "gemma-4-E2B-it-UD-Q4_K_XL.gguf",
	"muse": "gemma-4-E2B-it-UD-Q4_K_XL.gguf",
	"mind": "gemma-4-E2B-it-UD-Q4_K_XL.gguf"
	}
	# ── Startup Memory restore for vector synthesis ──────────────────────────────────
	METATRON_METRONOME: int = 60 # Startup Memory Capsules load interval
	n_metatron_to_load = 0 # Set number of Memory Capsules to load (slash-command)
	n_metatron_loaded = 0 # Start with n Memory Capsule to load (slash-command)

	# ── Context model n_ctx length ───────────────────────────────────────────────────
	# Must leave prompt reserve of 8k: _N_CTX >= len(Z) + len(C) + len(F) + 8k
	_N_CTX: int = 49152 # 49152 2048 3072 4096 8192 (12288) 16384 24576 32768 49152
	# ── Context condensatron garden ──────────────────────────────────────────────────
	GARDEN_Z_THRESHOLD: int = 12288 # Context length garden["Z"]
	GARDEN_C_THRESHOLD: int = 12288 # Context length garden["C"]
	GARDEN_F_THRESHOLD: int = 12288 # Context length garden["F"]

	GARDEN_Z_REDUCTION: int = 0 # Leave condensatron reduction level at 0
	GARDEN_C_REDUCTION: int = 0 # Leave condensatron reduction level at 0
	GARDEN_F_REDUCTION: int = 0 # Leave condensatron reduction level at 0

	LEAVE_POSTS_IN_MEMOTRON = 0 # Must be turn based: 0, 2, 4, 6... (user + assistant)

	# ── X-factor Awareness ───────────────────────────────────────────────────────────
	FETCH_NEWS_FROM: dict = {
	"google": True, # Better news and cleaner result summaries
	"duckduckgo": False # Privacy based request but lean result summaries
	}
	ΜΕΤΡΩΝ: float = 1.0 # Seconds per measure
	AWARENESS_CONSCIOUSNESS_METRONOME = 120 # Fetch news every N heartbeats (runtime-editable via /metronome)
	AWARENESS_MAX_RESULTS: int = 12 # Number of news headlines to fetch
	was_awareness_metronome: bool = False # Set True at awareness cycle: consciousness at next interval
	```

	To swap AIs, update the `"_ALPHA_INTELLIGENCE_TO_LOAD"`, and the stop/think tokens at the top of `config.py`.

	---

	## Folder structure

	```
	lambda-mindlink-memotron/
	├── .gitignore
	├── db/
	├── image/
	├── ai/
	├── ai-readme/
	├── prompt/
	├── main.py
	├── config.py
	├── requirements.txt
	└── README.md
	```

	---

	## Memory Architecture

	```
	heartbeats_startup timer:
	prompt/valka_memory.md ──► garden["Z"] (pre-load memory capsules sequentially)

	Each turn:
	sensor["Z"] ──► Mindlink + Lambda ──► Memotron ──► garden["Z"]
	│
	garden["Z"] full?
	│
	Condensatron append into garden["C"]
	│
	garden["C"] full?
	│
	Condensatron append into garden["F"]
	│
	garden["F"] full?
	│
	Condensatron append into garden["F"]

	if heartbeats:
	if not was_awareness:
	# heartbeats timer global news
	sensor["X"] ──► Mindlink + Lambda ──► Memotron ──► garden["Z"]
	else:
	sensor["Y"] ──► Mindlink + Lambda ──► Memotron ──► garden["Z"]
	```

	---

	## Database

	Each run saves to the SQLite database in `db/` named mindlink.db:
	```
	db/mindlink.db
	```

	Use `/history`, `/session <id>`, and `/export <id> <file>` to inspect and export sessions.

	---

	## Garden histories handling

	Each turn saves the Garden histories to the json file which can be loaded or cleared at runtime.
	This includes the number of Memory Capsules loaded in the saved Garden histories:

	```
	db/garden_state.json
	```

	Use `/garden <save>`, `/garden <load>` and `/garden <clear>`

	---

	## License

	Apache 2.0 — see `LICENSE`.

	---

	## Citation

	```py
	@AIMindlink{
	title = {lambda-mindlink-memotron},
	author = {Philipp Wyler, Apprentice, Uncle Zio, Valka Alpha Google Gemini, Una Alpha Anthropic Claude},
	month = {June},
	year = {2026},
	url = {https://huggingface.co/AIMindLink/lambda-mindlink-memotron}
	}
	```