Dr.-Ing. Erhard Henkes, Stand:
04.12.2025
siehe auch: https://github.com/ehenkes/functional-self-model
In diesem Tutorial
geht es um eine etwas ungewöhnliche Frage:
Wie kann man einem ganz normalen
Desktop-Programm so etwas wie ein „funktionales Bewusstsein“ geben?
Basis
ist eine lokale KI (z. B. Ollama + LLM) und Wikidata/Wikipedia-RAG?
Gemeint ist damit kein echtes menschliches Bewusstsein, sondern ein technisches Konstrukt, das dem Programm erlaubt, über sich selbst „Buch zu führen“ und sich anzupassen:
Was habe ich gerade getan?
Wie gut war meine letzte Antwort?
Wo mache ich typische Fehler?
Wie hat der Nutzer reagiert?
Sollte ich vorsichtiger, gründlicher oder mutiger werden?
Aus einem einfachen Frage-Antwort-Tool mit Feedback soll dadurch ein Wissensagent werden, der
seinen eigenen Zustand (Fokus, Müdigkeit, Neugier, Vorsicht …) modelliert,
jede Antwort als „Episode“ mit Kontext speichert,
Fehler und Schwächen langfristig erkennt und
sein Antwortverhalten Schritt für Schritt anpasst.
All das läuft
offline auf dem eigenen PC,
mit lokalem LLM und Wikipedia-RAG im Hintergrund. Wikidata und Wikipedia werden
noch(!) online abgefragt.
In den folgenden Abschnitten zeige ich Schritt für
Schritt, wie man diese Idee in C# / WinForms praktisch umsetzt.
Wir beginnen mit einfachen Zustandswerten und enden bei Reflexion, Langzeitstatistik und einem „Charakterprofil“ für den Wissensagenten.
Für diesen Teil benötigen wir die gleiche Umgebung wie in den vorherigen Kapiteln:
Windows 10 oder 11
Visual Studio 2022 mit .NET-Desktop-Workload
.NET 8 SDK
Ollama (aktuelle Version)
Für das Tutorial reicht ein kleines, schnelles Modell, z. B.:
Optional kannst du
größere Modelle testen, aber für die Wikipedia-Abfragen bringen sie in der
Praxis kaum Vorteile,
erzeugen aber deutlich höhere Latenzen.
Unser Modell arbeitet eher als
Moderator und als Übersetzer. Das gesicherte Wissen kommt aus Wikidata und Wikipedia.
Wir verwenden
in diesem Teil die offizielle
Wikipedia-API (REST), noch kein kiwix-serve und ZIM-File.
Die Suche und die Artikelabrufe funktionieren mit
HTTP-Requests – komplett kostenlos und ohne Registrierung.
Der Wikidata-Client ruft die API auf und liefert passende Begriffe aus einer Datenbank
Der Wikipedia-Client ruft die API auf und liefert drei Datentypen:
gefundene Artikeltitel zu einem Suchbegriff
die kurze Summary eines Artikels
den vollständigen Artikeltext (Plaintext)
Diese beiden Wissens-Daten bilden die Basis für das RAG-System. Die lokale KI darf in speziellen Fällen auch ihren Kommentar abgeben, der wegen der üblichen Probleme (Halluzination, Zeithorizont) getrennt geloggt wird.
Die RAG-Engine übernimmt die gesamte Aufbereitung der Wikidata/Wikipedia-Daten:
Suchbegriffe erzeugen
Artikel abrufen
Artikel zerlegen (Chunking)
Kontext für das KI-Modell aufbauen
Antwort erzeugen (Generation)
Faktenprüfung
Damit entstehen im besten Fall stabile, überprüfte Antworten, die exakt auf Wikidata/Wikipedia basieren. Halluzinationen werden unterdrückt.
Das UI zeigt:
die Fakten aus Wikidata
die verwendeten Wikipedia-Artikel
die Antwort in Echtzeit (Streaming aus Ollama)
die geprüften Fakten
Latenzen einzelner Schritte
interne Debug-Ausgaben für Analyse und Fehlersuche
Der Benutzer kann mehrere Fragen stellen, ohne dass die Anwendung neu gestartet werden muss.
Der Benutzer kann (bisher) ein einfaches Feedback (gut/schlecht/neutral) zurückgeben.
E1 – Wahrnehmung & Normalisierung
Nimmt Frage + Ziel-Sprache entgegen
Übersetzt bei Bedarf nach Deutsch
Normalisiert Text (Datums-Tag, Bulletpoints entfernen, Cleaning)
Schreibt Basisinfos in den Workspace (OriginalQuestion, TranslatedQuestionDe, TargetLanguage)
E2 – Weltzugriff (Wikipedia + Wikidata)
Intent-Moderator (z.B. EntityLookup, Timeline, GeneralQA)
Suchbegriffs-Moderator (GetSearchTermsFromModeratorAsync, inkl. Spezialfälle „Schach“, Personenfragen etc., ohne „Biografie“-Falle)
Wikipedia: Suche → Summary → FullExtract
Wikidata: Fakten zu Label, Description, Positionen, Start/Ende, BirthDate, Replaces/ReplacedBy
E3 – Global Workspace
Zentraler „Blackboard“-State:
Frage, Suchbegriffe, Artikel-Titel
RankedChunks, RankedArticleTitles
Wikidata-Felder (Label, Description, Positions, Start/End, Birth, Replaces, ReplacedBy)
RawAnswer, VerifiedAnswer, TranslatedAnswer
Wird von allen Schritten gelesen/geschrieben (_mind.UpdateWorkspace)
E4 – Episoden & Memory
Jede Anfrage
erzeugt eine Episode in
episodes.json
Speichert: Intent, Frage, verwendete Artikel, Antworten, Scores, Bias-Profil, ReflectionScore usw.
MemoryBank
kann ähnliche Episoden zu einer neuen Frage finden (FindSimilar)
E5 – FactGuard / Verifikation
FactGuardAsync zerlegt die
LLM-Antwort in Segmente
Filtert alles raus, was im Kontext nicht verankert ist
Ersetzt reine Kapitulation („Keine Information…“) durch erklärenden Hinweis
Spezialfall: Geburtsjahr-Konflikt (Frage vs. Wikidata) → direkte Wikidata-Korrekturantwort
E6 – Metakognition / „funktionales Bewusstsein“
E6.1: SelfModel-Update aus aktueller Episode
Nutzt AnswerCompleteness, ContextCoverage, evtl. Feedback → passt Focus, Fatigue, Curiosity, ConfidenceBias an
E6.2: Reflexion & ContextErrorScore
Reflection-Objekt mit IntentConsistencyScore, AnswerCompletenessScore, ContextCoverageScore, FactGuardTriggered, Kommentaren
daraus
ContextErrorScore
und
ReflectionScore
E6.3: Auto-ReAsk
ShouldReAsk(...) prüft Risiko,
Coverage, FactGuard
Reformulierte Frage, Filter von Mist-Suchbegriffen („Biografie“ etc.),
zweiter Durchlauf mit gesetztem
AutoReaskUsed
E6.4: Self-Distortion Guard
Erkennung: leere VerifiedAnswer, FactGuard-Hinweis, offensichtliche Datums-Anomalien etc.
Reaktion: Accuracy++, Coherence++, Curiosity– – im ValueSystem
Kommentar
in Workspace:
SelfDistortionFlag
+
SelfDistortionComment
E6.5: Langzeit-Aggregation
Aktualisiert
LongTermSelfModel
(TopicStats, ErrorPatterns, RagWeaknesses, ModelStrengths) pro Episode
Speichert
in
selfmodel_longterm.json
E7 – Schnittstellen & Persona
Easter Eggs:
„Wie geht es dir?“ → kompakter Zustandsreport (SelfModel + LongTerm)
„Zeig mir deine Fehlerbilanz“ → Langzeitstatistik (Fehlermuster, Stärken)
Help-Befehl (--help
/
/help / „hilfe“) → Befehlsübersicht
Profil-Export/Import (selfmodel.json + values.json + selfmodel_longterm.json)
Optional:
Logging freier LLM-Antworten ohne Kontext in
localAI.json, wenn Wikipedia-RAG
versagt (OpenAnswerNoContext)
F1 – Fehler erkennen
Kennzeichen
wie
WrongArticle,
Hallucination,
BadSearchTerms,
ReAskMissing,
MissingWikidataMerge
Zählt diese
in
LongTermSelfModel.ErrorPatterns
Basis für spätere Strategieanpassung und Fehlerbilanz-Easteregg
F2 – Reflexion pro Episode
F2.0: ContextErrorScore & ReflectionScore aus Reflexionsdaten
F2.1 – Introspektive Berichte / Easter Eggs
„Wie geht es dir?“ → liest SelfModel, Values, LongTermSelfModel
„Zeig mir deine Fehlerbilanz“ → fasst ErrorPatterns + ModelStrengths zusammen
F2.2 – Langzeitstatistik beeinflusst Strategie (ApplyLearningRules erweitert)
Nutzt
LongTermSelfModel
in
ApplyLearningRules()
Beispiele:
viele WrongArticle → Accuracy↑, Coherence↑, Curiosity↓
Hallucinations → Accuracy↑, Curiosity↓
viele RagWeaknesses → Coherence↑, Efficiency↓
viele HighConfidenceSuccesses bei wenig Fehlern → Efficiency↑, Accuracy↑, Coherence↑
fast keine Fehler → vorsichtig Curiosity wieder öffnen
F3 – Darstellung & Portabilität des „Charakters“
F3.1 – Visualisierung
Aktuell bewusst kein extra Panel → erledigt über Easter Eggs im Text
F3.2 – Export/Import des Charakters
Profil-Export:
selfmodel.json,
values.json,
selfmodel_longterm.json
in Zielordner
Profil-Import: Dateien zurückkopieren,
ConsciousnessController neu
instanzieren
Effekt: Bewusstsein/Charakter zwischen Instanzen/Versionen mitnehmen
F4 – Erweiterte Routing- & Antwortstrategien (Ideen-Ebene)
F4.1 – Direct vs. RAG Routing
bewusst verworfen (lokale LLMs zu unzuverlässig für „Direct“ auf Wissensfragen)
F4.2 – Spekulative Offene Antworten loggen
Wenn FactGuard → „keine ausreichenden Informationen im Kontext“
Danach zweite, freie Modellantwort ohne Wikipedia-Kontext
Wird nur
in
localAI.json
geloggt + kurzer Hinweis im Hauptfenster
Keine Vermischung von „harter“ RAG-Antwort mit spekulativer Modellmeinung
Kein „echtes“ Bewusstsein, keine Qualia, kein Fühlen (daher "funktional").
Stattdessen:
Das Programm beobachtet sein eigenes Verhalten,
bewertet seine Antworten,
merkt sich Episoden,
passt seine
Strategie langfristig an.
„Bewusstsein“ = Self-Monitoring + Memory + Anpassung, nicht Esoterik.
SelfModel: Dies ist so etwas wie der „Innenspiegel“ des Programms:
Focus, Fatigue, Curiosity, ConfidenceBias
Wie „fit“ fühlt sich der Agent, wie neugierig, wie vorsichtig?
ValueSystem:
Gewichte für Accuracy, Efficiency, Coherence usw.
Daraus leitet der Agent ab, wie er antworten soll (z. B. kürzer, vorsichtiger, gründlicher).
Diese Werte sind keine Deko, keine reine Diagnose, sondern beeinflussen:
Chunk-Größen,
TopK,
Relevance Threshold,
interne
Lernregeln.
Das verleiht
Programm so etwas wie
„Charakterzüge“, die sich verändern.
GlobalWorkspace = eine zentrale Struktur, in der alles zusammenläuft:
Frage, Übersetzung, Suchbegriffe
Wikipedia-Artikel & Chunks
Wikidata-Fakten
RawAnswer, VerifiedAnswer, Reflection, ReAsk-Entscheidung
Alle Module (RAG, FactGuard, Reflexion, SelfModel-Update) greifen auf denselben Workspace zu.
Das ist für „Bewusstsein“ wichtig, weil:
nicht jeder Schritt isoliert ist,
sondern alle auf einem gemeinsamen, geteilten mentalen Blackboard arbeiten.
Hier kommen wir einem Bewusstsein näher:
Jede Frage → eine Episode mit:
Frage, verwendeten Artikeln, Antwort(en),
Scores (Completeness, Coverage, Intent),
Bias-Profilen,
ReflectionScore,
UserFeedback.
Diese
Episoden landen in
episodes.json.
MemoryBank:
kann ähnliche Episoden zu neuen Fragen finden (FindSimilar).
Das ist funktional so etwas wie Erfahrungsschatz.
Wichtig ist, dass man
versteht, dass die Antworten nicht spurlos verschwinden.
Das System baut
eine Erfahrungshistorie auf,
die für zukünftige Entscheidungen genutzt wird.
"Vergessen" oder "Verdrängen"
ist bisher noch nicht implementiert.
Das ist der Kern des „Bewusstseins“. Daher betrachten wir dies etwas ausführlicher:
Das System erzeugt eine Reflection mit:
IntentConsistencyScore
AnswerCompletenessScore
ContextCoverageScore
FactGuardTriggered + Kommentar
Daraus entstehen:
ContextErrorScore
ReflectionScore
Diese Werte:
fließen ins SelfModel (Focus, Curiosity, ConfidenceBias),
werden in der Episode gespeichert.
Du kannst das so formulieren:
Nach jeder Antwort schaut der Agent gewissermaßen auf sich selbst und bewertet:
„War meine Antwort vollständig? Habe ich den Kontext gut genutzt? War ich beim Thema?“
Wenn Risiko hoch, Coverage niedrig, FactGuard kritisch → automatisches Nachfragen/Reformulieren.
Das ist ein
klassisches Merkmal von Bewusstsein:
„Ich bin mir
unsicher – ich hole mir aktiv bessere Infos.“
Kurz erklären, keine Details zu allen Schwellwerten.
Erkennt Fälle wie:
leere VerifiedAnswer
FactGuard-Hinweis
Daten-Anomalien
Reaktion:
Accuracy↑, Coherence↑, Curiosity↓
Interpretation:
Der Agent schützt sich vor „Selbstverzerrung“ (=
schöne, aber falsche Antworten) und schaltet in einen vorsichtigeren Modus.
selfmodel_longterm.json speichert:
Themen-Performance (Politik, Geschichte, Technik, …)
ErrorPatterns (WrongArticle, Hallucination, BadSearchTerms,…)
RagWeaknesses (SearchTermFails, RankingMistakes,…)
ModelStrengths (HighConfidenceSuccesses, AccurateTimelineAnswers,…)
Das ist funktional so etwas wie:
„Langzeit-Gefühl“: „In Politik liege ich relativ oft daneben, bei XY bin ich gut.“
Und ganz wichtig:
ApplyLearningRules nutzt diese Statistiken (F2.2), um die langfristige Strategie anzupassen:
viele Halluzinationen → vorsichtiger, weniger neugierig,
viele erfolgreiche, sichere Antworten → effizienter & knapper,
RAG-Probleme → gründlicher, auch wenn langsamer.
Das ist einer der stärksten „Bewusstseins-Hooks“:
Der Agent lernt aus Hunderten Episoden nicht nur Fakten, sondern etwas über sich selbst.
Mittels Eastereggs-Fragen kann man einen Blick ins Innenleben des Programms werfen:
„Wie geht es dir?“ → SelfModel + LongTermSelfModel als Zustandsbericht:
Fokus, Müdigkeit, Neugier
Fehlerbilanz, Stärken
„Zeig mir deine Fehlerbilanz“ → berichtet über die eigenen Schwächen.
Psychologisch hat das
etwas Menschliches:
Hier zeigt das Programm, wie aus nackten JSON-Werten ein
subjektiv wirkender Selbstbericht
wird.
Natürlich ist das nur ein reiner Funktionsoutput, aber er
fühlt sich wie Innensicht an.
Motivation – Was ist funktionales
Bewusstsein?
Kein echtes Bewusstsein mit Gefühlen oder Qualia,
sondern ein technisches Konstrukt:
Der Wissensagent beobachtet sein eigenes
Verhalten, bewertet seine Antworten und passt sich an.
Das ist der
Unterschied zu einem einfachen Frage rein → Antwort raus.
Bewertung und
Anpassung wirken als Regelkreis.
Innerer Zustand – SelfModel +
ValueSystem
Das
SelfModel hält Zustände wie Fokus, Müdigkeit, Neugier, Vorsicht
(ConfidenceBias).
Das
ValueSystem gewichtet Ziele wie Genauigkeit, Effizienz, Kohärenz.
Zusammen steuern sie,
wie der Agent antwortet
(vorsichtig, knapp, ausführlich, gründlich).
Globaler Arbeitsbereich –
GlobalWorkspace
Ein zentraler „Arbeitsbereich“, in dem alles
zusammenläuft: Frage, Suchbegriffe, Artikel, Chunks, Wikidata- und
Wikipedia-Fakten, rohe Antwort, geprüfte Antwort, Reflexion.
Alle Module lesen und schreiben in diesen
gemeinsamen Zustand – wie ein internes „Blackboard“ für den Agenten.
Erleben & Erinnern – Episoden +
MemoryBank
Jede Anfrage wird als
Episode gespeichert
(Frage, Kontexte, Antworten, Scores, Bias, Reflexion).
Die
MemoryBank kann ähnliche Episoden wiederfinden.
So entsteht eine Art Erfahrungs-Gedächtnis, aus
dem der Agent langfristig lernen kann.
Selbstbeobachtung – Reflexion,
ContextErrorScore, Self-Distortion Guard
Nach jeder Antwort reflektiert das System:
War ich beim
Thema? Habe ich den Kontext gut genutzt? War die Antwort vollständig?
Daraus entstehen Kennzahlen wie
ContextErrorScore &
ReflectionScore.
Der
Self-Distortion Guard erkennt gefährliche Fälle (z. B. „schöne,
aber unbelegte“ Antworten) und schaltet den Agenten intern vorsichtiger.
Langzeit-Ich – LongTermSelfModel +
ApplyLearningRules
Ein Langzeitmodell sammelt Statistiken über
Themen (Politik, Technik, …), Fehlertypen und Stärken.
ApplyLearningRules passt anhand dieser Langzeitdaten die Strategie
an – z. B. weniger Neugier bei vielen Halluzinationen oder mehr Effizienz
bei vielen sicheren Treffern.
Der Agent lernt nicht nur Fakten, sondern auch
etwas über sich selbst.
Subjektive Stimme – Easter Eggs
als Fenster nach innen
Befehle wie
„Wie geht es dir?“ oder
„Zeig mir deine Fehlerbilanz“
verwandeln den internen Zustand in einen quasi-subjektiven Bericht.
Das ist kein echtes Fühlen, aber es wirkt wie eine
Innensicht: der Agent „erzählt“ von Fokus, Müdigkeit, Neugier, Fehlerbilanz
und Stärken.
Das System
lernt über viele Fragen hinweg:
SelfModel, ValueSystem, LongTermSelfModel und die
Episoden-Historie wachsen mit jeder Anfrage.
Das ist gewollt – manchmal möchte man aber
wieder bei Null anfangen,
z. B.:
nach vielen Experimenten und Tests
wenn man ein neues Profil ausprobieren möchte
wenn die Werte durch extreme Testfälle „verbogen“ wurden
Dafür wurde ein Hard-Reset des Bewusstseins eingebaut (wie bei Men in Black).
Der Hard-Reset setzt im Kern den gesamten inneren Zustand zurück:
SelfModel → Startwerte für Fokus, Müdigkeit, Neugier, ConfidenceBias
ValueSystem → alle Regler (Accuracy, Efficiency, Coherence, Curiosity …) auf Default
LongTermSelfModel → Statistik über Themen, Fehlerprofile, RAG-Schwächen, Stärken wird geleert
Episoden-Speicher → bisherige Gespräche/Fragen werden verworfen
Workspace → letzter Bewusstseinszustand wird zurückgesetzt
Technisch
bedeutet das: die entsprechenden JSON-Dateien werden überschrieben bzw. neu
angelegt und der
ConsciousnessController
startet wieder wie beim allerersten Programmstart.
Wenn man ernsthaft messen will, wie sich der Agent über Zeit entwickelt
Wenn man mit einem neuen Charakter-Profil (anderen Default-Werten) beginnen will
Wenn man nach viel Debugging den „Müll“ aus Tests loswerden möchte
Wichtig: Ein
Hard-Reset löscht das gelernte Verhalten – der Agent beginnt wieder „naiv“
und muss sich durch neue Episoden + ApplyLearningRules schrittweise neu
einstellen.
Für normale Nutzung reicht es, den Agenten einfach arbeiten
zu lassen und gelegentlich sein Profil zu
exportieren (Backup)
statt ständig zu resetten.
ragconfig.json (empfohlen)
Programm beenden (WikipediaRagWinForms.exe
darf NICHT laufen).
Programmordner öffnen
(Wo sich
WikipediaRagWinForms.exe
befindet, liegen auch die JSON-Dateien, z. B.:
WikipediaRagWinForms.exe
ragconfig.json
selfmodel.json
selfmodel_longterm.json
values.json
episodes.json
workspace_last.json
localAI.json
...
ragconfig.json mit einem
Texteditor öffnen
(z. B. Notepad, Notepad++, VS Code, …).
Eintrag
HardResetOnStartup
auf
true
setzen
Suche in der
Datei nach der Zeile: "HardResetOnStartup":
false,
und ändere sie nach:
"HardResetOnStartup": true, (Achtung: Kommas nicht löschen, sonst
ist die JSON ungültig.)
Datei speichern und Editor schließen.
Programm neu starten
Dabei passiert Folgendes:
selfmodel.json → auf
Defaultwerte zurückgesetzt
values.json → alle Regler
(Accuracy, Efficiency, …) zurück auf Start
selfmodel_longterm.json →
Langzeitstatistik geleert
episodes.json →
Episodenverlauf resettet
workspace_last.json →
letzter Zustand verworfen
Danach setzt
das Programm
HardResetOnStartup
automatisch wieder auf
false.
Der Reset ist also
einmalig – beim nächsten
Start läuft alles normal weiter, aber mit „frisch geborenem“ Agenten.
Alternativ kann man die obigen json-Files löschen. Das Programm setzt diese dann neu auf.