Not just another chatbot, but a reflection assistant that reasons over your own history.
For a long time, I had one frustration with journaling: we write a lot, but very little turns into structured self-understanding.
Entries are scattered across notes, hard to retrieve, and even harder to connect over time. So when we ask, “What’s been draining me lately?”, we usually answer from memory bias, not evidence.
That is why I built InnerTrace — an AI-powered self-growth system based on LLMs, long-term memory, and reflection loops.
The Problem I Wanted to Solve
Most journaling tools are good at capturing thoughts, but weak at helping users reason over them.
Common gaps:
- Plenty of records, low reuse
- Emotional and behavioral patterns are hard to detect
- Reflection outcomes are often intuitive, not evidence-grounded
InnerTrace is designed to bridge that gap:
Raw daily input -> structured understanding -> evidence-based reflection -> actionable suggestions
What InnerTrace Actually Does
At a high level, the system works like this:
- You write freely (no rigid template)
- LLMs extract structured signals (emotion, events, topics, stress/energy)
- The system stores multi-layer memory (raw logs + structured insights + periodic summaries)
- The agent retrieves relevant history by topic/time window
- It returns reasoning results with evidence and suggested actions
So instead of giving generic motivational output, InnerTrace tries to answer with traceable context.
Core Design Principles
1) No hallucinated psychology
InnerTrace reflects only from user-provided history, not assumptions.
2) Evidence-first insight
Key conclusions should be tied to concrete records and time windows.
3) Gentle guidance, not judgment
The goal is practical direction, not moral evaluation.
Technical Stack (Current Version)
Backend
- Java 17
- Spring Boot
- MyBatis-Plus
Storage
- MySQL for structured data
- Redis for cache
- Vector memory via
pgvector / Milvusis in progress
AI Layer
- LLM API for analysis and reasoning
- Embedding model for semantic memory expansion
Infrastructure
- Async task processing
The service architecture is modularized into:
- Journal Module
- Analysis Module
- Memory Module
- Reflection Module
- Agent Module
This makes it easier to evolve toward multi-agent reasoning and deeper personalization later.
How It Differs from Typical AI Journal Apps
I see three practical differences:
- Long-term memory over single-turn chat
- Evidence aggregation over generic comfort text
- Actionable micro-suggestions over abstract advice
If a user asks, “Why have I felt tired recently?”, the goal is not just a fluent answer. The goal is to connect repeated contexts, time ranges, and patterns — then provide a reasoned response backed by historical evidence.
Current Progress & Roadmap
Completed:
- Journal input and storage
- Structured analysis pipeline
In progress / next:
- Vector memory retrieval
- Weekly/monthly reflection reports
- Multi-agent reasoning
- Personalization tuning
- Rich visualization dashboard
What I Learned While Building
Two lessons stood out:
“LLM can speak” != “system can reason well”
Product quality depends heavily on memory modeling, retrieval strategy, and evidence organization.
Growth-oriented AI needs temporal consistency
Without cross-time context, even great single responses become short-lived reassurance.
Screenshots
Quick Start
Backend (8080):
cd InnerTrace
mvn clean package
java -jar target/*.jar
# or
mvn spring-boot:run
Frontend (3000):
cd innertrace_frontend
npm install
npm run dev
Then open http://localhost:3000.
Before running, configure your database and LLM API key in application.yml.
Repositories
- Frontend: https://github.com/yaruyng/InnerTrace_frontend
If you’re also exploring AI for long-term self-growth, I’d love to exchange ideas.
A question I’m actively thinking about: what should a reflection AI optimize for first — accuracy, empathy, or actionability?