Tessera: My Open-Source Project for Local AI, Organization, and a Second Brain
I have published Tessera as an open-source project: a local, privacy-friendly life organizer that I use in my own daily routine. Not as a finished SaaS product, not as a large platform, but as real software that grew out of a concrete need: bringing studies, work, appointments, notes, reminders, and personal finances into one more coherent workflow.
The code is public on GitHub: github.com/tolgaSan/Tessera-open.
For me, Tessera is also a piece of proof of work. It shows how modern fullstack development, local AI, review flows, and understandable automation can work together in practice without sending personal data to a cloud service by default.
Why I Built Tessera
Many organization systems solve only one part of the problem. The calendar knows appointments, the notes app knows thoughts, finance tools know income and expenses, and AI tools know the current prompt. In daily life, these things are connected.
I wanted to build a system that does not treat calendars, notes, reminders, imported information, and personal knowledge as separate islands. At the same time, it should not take control away from the user. Tessera should help suggest, structure, and retrieve information, while important changes remain reviewable.
The core idea is therefore not “an AI that does everything automatically”, but a calm workflow:
- capture information
- generate suggestions
- review changes
- store durable data in a transparent way
- make it findable again later
That posture matters to me. Good automation does not have to feel magical. It should be understandable, controllable, and reliable enough to become part of everyday use.
What Tessera Does
Tessera is calendar-first. The calendar is where many areas of life become visible: lectures, work, appointments, deadlines, routines, and planned tasks.
Around that center, Tessera connects several functions:
- calendar view with a local backend
- AI-assisted chat and support functions
- OCR for screenshots and imported information
- review flows before data is written permanently
- Life Inbox for pending imports, notes, reminders, and import receipts
- Markdown vault as a local second brain
- income, expense, and analytics inputs for private planning
- local app data for state, jobs, and transcripts
The review approach is especially important. When Tessera turns a screenshot or note into structured data, that data should not blindly land in the calendar or vault. First there is a proposal, then a review, then a write.
That may sound unspectacular, but it is essential for trustworthy AI integration. Especially with personal data, calendars, or financial information, a traceable intermediate step is often more valuable than maximum automation.
Why Local-first and Data Privacy Matter
Tessera processes information that should remain private: appointments, notes, reminders, personal planning data, and financial overviews. That is why the architecture is intentionally local-first.
Local-first does not mean external services can never exist. It means the core workflow remains local, and cloud services are not required for daily use. The user should be able to understand where data lives, which processes run, and what is stored permanently.
For Tessera, that means:
- the Tessera Vault is a normal folder with Markdown files and attachments
- local AI and OCR components can run without a central cloud dependency
- app state and local data remain on the user’s device
- external providers or sync mechanisms are optional, not foundational
- there is no analytics, telemetry, or crash reporting in the local app path
These principles matter in business software as well. Law firms, medical practices, tax advisors, and SMEs do not always need more cloud dependency. They need systems that respect sensitive data, simplify workflows, and remain controllable.
Technical Stack and Architecture
Tessera is not a small demo script. The project connects several technical layers:
- Frontend: React, TypeScript, Vite, Tailwind CSS, TanStack Query, and FullCalendar
- Backend: Kotlin with Spring Boot as the central product logic
- AI worker: Python for OCR, vision, and model-adjacent tasks
- Local AI: Ollama for chat experiments and
glm-ocrfor screenshot parsing - Storage: local Tessera Vault as a Markdown filesystem
- Development: Makefile-based local workflows, tests, linting, and setup documentation
The separation is deliberate. The Spring backend coordinates product logic and local providers. The Python worker encapsulates tasks closer to OCR, vision, and model execution. The TypeScript frontend owns the user experience.
This structure keeps AI capabilities from spreading uncontrolled through the entire application. It also makes responsibilities clearer.
The storage model follows the same idea. Durable memories and structured knowledge notes do not disappear into an opaque proprietary database, but into the vault. Markdown is not perfect, but it is readable, versionable, portable, and understandable over time.
How I Use Tessera Privately
I use Tessera privately to organize studies, work, appointments, notes, and finances. The point is not to expose personal details. The important part is the workflow.
One practical benefit is avoiding duplicate maintenance. When an import should become a calendar event, when a note needs to be findable later, or when income and expenses should become part of a private overview, Tessera helps structure those steps.
The second major benefit is the second brain. Some information is not urgent enough for the calendar, but too important to disappear inside a chat history, screenshot, or loose thought. Tessera tries to model exactly that middle space: capture quickly, review later, then store durably.
For me, the project is therefore not only technically interesting. It is a tool I build because I actually need it.
What the Project Shows About My Work
Tessera shows several things that are also relevant in client projects.
First: I do not add AI as decoration. AI features need to be embedded in a real process: with inputs, limits, failure modes, review steps, and traceable results.
Second: data privacy is not a feature to add later. If an application handles sensitive information, the architecture must decide early which data goes where and which parts remain local.
Third: automation needs trust. Trust does not come from a system making as many decisions as possible. It comes from the user understanding what happens and being able to review critical steps.
Fourth: good software is often unspectacular in the best sense. It starts locally, has clear responsibilities, is documented, testable, and repairable. Those qualities turn an experiment into a usable tool.
Open Source as an Honest Reference
Open source is not just a marketing label here. It makes the current state of the project visible: the architecture, the decisions, the limits, the unfinished parts, and the direction.
Tessera is currently a public reference snapshot. It is not a completed mass-market product, and it does not pretend to be. But that is part of its value: you can see how the system is intended to work, how local AI is integrated, how review flows are shaped, and how data privacy becomes visible in architectural decisions instead of only appearing in a privacy policy.
For Sanly Tech, this is relevant because many clients are facing exactly these questions:
- Which processes can be automated in a useful way?
- Where can AI help without removing control?
- Which data can move to the cloud, and which data should stay local?
- How do you build software that does not only impress, but works in daily use?
Tessera is a practical answer. Not a perfect one, but a built one.
Conclusion
Tessera is my attempt to bring organization, local AI, data privacy, and personal knowledge work into one usable system. The focus is not on big promises, but on a traceable workflow: capture, review, store, retrieve.
This is the kind of software I care about: systems that reduce work without removing control. Systems that use AI practically, without automating blindly. Systems that treat sensitive data with respect.
Anyone who wants to look at the code can find the project here: