Providentia Network is een Django-gebaseerde backend die multi-tak redeneren orkestreert met Google's Gemini-modellen, een native C++ co-processor en optionele visualisaties van de denkgraaf. Dit document vat de huidige architectuur samen en geeft de benodigde commando's om het systeem lokaal te bouwen en uit te voeren.

https://www.promptingguide.ai/techniques/tot

 Yao et al. (2023) en Long (2023)

hebben recentelijk Tree of Thoughts (ToT) voorgesteld, een raamwerk dat generaliseert over chain-of-thought prompting en verkenning aanmoedigt van gedachten die dienen als tussenstappen voor algemene probleemoplossing met taalmodellen.

ToT onderhoudt een boom van gedachten, waarbij gedachten coherente taalreeksen vertegenwoordigen die dienen als tussenstappen naar het oplossen van een probleem. Deze aanpak stelt een LM in staat om de voortgang door tussenliggende gedachten richting het oplossen van een probleem zelf te evalueren via een weloverwogen redeneerproces. Het vermogen van het LM om gedachten te genereren en te evalueren wordt vervolgens gecombineerd met zoekalgoritmen (bijv. breadth-first search en depth-first search) om systematische verkenning van gedachten met vooruitkijken en terugkeren mogelijk te maken.

Systeemarchitectuur

Gegevensstroom op Hoog Niveau

Client -> /speech/simple_response (Django REST-view)
      -> Python ThinkingManager (speech/context_manager/ThinkingManager.py)
      -> C++ "Kievan Rus"-denker (speech/context_manager/Kievan Rus/*.cpp)
      -> Gemini API (JSON via HTTPS)
      -> Binair payload (status + context + samenvatting)
      -> Python-deserialisator & takuitbreiding
      -> Optionele PNG-graaf (speech/context_manager/graphs/)
      -> Django-antwoordtekst

Kerncomponenten

Django REST-endpoint (speech/views.py)
Accepteert een gebruikersprompt, instantieert een ThinkingManager en stuurt de uiteindelijke instructietekst door die door de agent wordt geretourneerd.
Python Thinking Manager (speech/context_manager/ThinkingManager.py)
Onderhoudt de denkboom en handhaaft architectuurregels:
- Start de native C++-helper als een subproces met het huidige bericht, taklabel en iteratiemetadata.
- Parseert het binaire antwoord (1 byte status, 4 byte lengtes, UTF-8 payloads) en valideert de JSON tegen ContextStruct (Pydantic).
- Registreert per tak probability_of_success, incrementele potential_score, possible_setbacks en taklabels.
- Garandeert ten minste twee takverkenningen per niveau en aggregeert een cumulatieve potentiële score.
- Genereert een tekstuele boom en optioneel een PNG-diagram (zie hieronder).
C++ "Kievan Rus"-denker (speech/context_manager/Kievan Rus/)
Gemodulariseerd in headers/bronnen voor argumentparsing, omgevingsladen, Gemini-HTTP-aanroepen (libcurl), promptconstructie en binaire serialisatie.
- Leest de Gemini API-sleutel uit de procesomgeving of .env.
- Doet twee Gemini-verzoeken: één voor gestructureerde analyse, één voor narratieve samenvatting.
- Codeert de gestructureerde context en samenvatting in een draagbaar binair formaat dat door Python wordt verbruikt.
- Het root Makefile-doel build-thinker hercompileert de module (g++17, -lcurl) en wordt automatisch gekoppeld bij het uitvoeren van de server.
Graafweergave (plotting/graphing.py)
Gebruikt Matplotlib (Agg-backend) om de uiteindelijke denkboom te visualiseren. Elk knooppunt bevat taklabel, ingepakte plantekst, kansen, potentiële delta's per stap, cumulatieve potentie en markeringen voor "finale" of "betreurde" toestanden. Afbeeldingen komen terecht in speech/context_manager/graphs/.
Gemini-agent (speech/gemini/agent.py)
Lichtgewicht wrapper rond Google's genai-client. De C++-module spiegelt deze functionaliteit voor latentiekritisch redeneren.

Tak- & Score-Semantiek

ThinkingManager houdt de boomdiepte begrensd (max_iterations = 8) maar zorgt ervoor dat elk knooppunt ten minste twee gelabelde takken genereert (bijv. Primary-A, Primary-B), tenzij begrensd door de iteratielimiet.
Elke tak draagt:
- probability_of_success — float begrensd tot [0.0, 1.0].
- potential_score — ondertekende delta toegevoegd aan cumulative_potential.
- possible_setbacks — tekstuele risicobeoordeling ingebed in logs, console-uitvoer en visualisaties.
Logs worden gegenereerd voor elke takcreatie, numerieke evaluatie en graafweergavestap om het debuggen te vergemakkelijken.

Installatie & Gebruik

Vereisten

Python 3 (een virtualenv- of Conda-omgeving wordt aanbevolen).
g++ met C++17-ondersteuning en ontwikkelheaders voor libcurl.
Toegang tot een Gemini API-sleutel (GEMINI_API_KEY) geplaatst in .env of de procesomgeving.
(Optioneel) Matplotlib voor PNG-graafgeneratie; zonder dit logt het systeem een waarschuwing en slaat het plotten over.

Omgeving Creëren

make update              # gebruikt environment.yml via conda/micromamba

Standaardwaarden overschrijven:

make update CONDA_ENV=mijn-omgevingsnaam
make update ENV_FILE=envs/dev.yml
make update CONDA=~/.local/bin/micromamba

Bouwen & Uitvoeren

make run                 # hercompileert de C++-denker en voert vervolgens `python manage.py runserver` uit

Zelfstandige compilatie (indien nodig):

make build-thinker       # cd speech/context_manager/Kievan\ Rus && g++ ... -lcurl

De server verwacht .env in de projectroot, tenzij KIEVAN_RUS_ENV_PATH is ingesteld.

Veelvoorkomende Make-doelen

Doel	Beschrijving
`make run`	Bouw C++-helper en start Django-ontwikkelserver
`make migrate`	Voer migraties uit (`makemigrations` + `migrate`)
`make prepare`	Maak Conda-omgeving van `environment.yml`
`make update`	Werk Conda-omgeving bij/aan met opschoning
`make build-thinker`	Hercompileer de C++-redeneermodule
`make help`	Toon beschikbare doelen (indien gedefinieerd in Makefile)

Gebruik PY=... om naar een specifieke interpreter te verwijzen, of overschrijf DJANGO_SETTINGS_MODULE indien nodig.

Configuratie-opmerkingen

.env

GEMINI_API_KEY=jouw-sleutel
# optionele Django-instellingen...

KIEVAN_RUS_ENV_PATH (omgevingsvariabele) kan de .env-locatie voor het C++-proces overschrijven.
Grafen worden geschreven naar speech/context_manager/graphs/thought_graph_<root-id>.png. Verwijder de map om artefacten op te schonen.

Test- & Debugtips

Het binaire protocol is strikt; misvormde antwoorden van Gemini (bijv. ontbrekende text-velden) veroorzaken duidelijke uitzonderingen die door zowel Python- als C++-lagen worden gelogd.
Takcreatie, kansberekeningen en graafweergave loggen allemaal gedetailleerde voortgang via [ThinkingManager]-voorvoegsels. Houd de Django-console in de gaten tijdens ontwikkeling om de redeneerstroom te volgen.
Als Matplotlib ontbreekt, gaat het systeem verder zonder PNG-uitvoer maar logt het de importfout.

Repository-indeling (selectie)

speech/
├── context_manager/
│   ├── ThinkingManager.py     # Python-orkestrator
│   └── Kievan Rus/            # C++ native denker (gemodulariseerde bronnen)
├── gemini/
│   └── agent.py               # Python Gemini-clientwrapper
plotting/
├── graphing.py                # Matplotlib-renderer voor denkbomen
README.md
Makefile

De backend van Providentia Network is ontworpen voor iteratieve experimenten: werk de prompts bij, pas scoreheuristieken aan of breid het binaire formaat uit indien nodig. make run houdt de C++-helper gesynchroniseerd zodat u zich kunt concentreren op de redeneerlogica. Veel plezier met hacken!

Providence