GemmaBook (aka Memoria AI Book Companion) is an open source, native-first AI reading companion designed specifically for EPUB e-books. It uses the Gemma model (llama.cpp runtime) to achieve automatic generation of chapter summaries, role relationship tracking, text simplification, and contextual question and answer. All data is stored in local SQLite, and no Internet connection, account, or cloud service is required.

GemmaBook’s in-depth analysis

Core parameters and statistics

GemmaBook (project name Memoria AI Book Companion) is a local-first AI reading companion based on the Google Gemma open source large model. It does not rely on any cloud AI services, all model inference is done locally on the user, and the data is stored in a local SQLite database. Its core value lies in embedding AI capabilities into the e-book reading process to realize functions such as chapter summaries, character tracking, and contextual Q&A, all without the need for a network connection.

Projects	Public Information
Full product name	GemmaBook (Memoria AI Book Companion)
Developer	Santhoshl2312 (Personal open source)
Warehouse address	https://github.com/Santhoshl2312/Gemma_book_reader
Official positioning	Local-first AI reading companion for EPUB books
Technology stack	FastAPI + Python 3.10 + SQLAlchemy + SQLite + llama.cpp
AI model	Gemma GGUF (conversation/generation), Nomic Embed Text GGUF (text embedding)
Deployment method	Local self-hosting, Windows contextual one-click startup
Running platform	Windows 10/11 (browser interface)
Open source license	Undisclosed (no explicit License file in the repository)
Community size	0 stars, 0 forks, 1 contributor
Latest version	v0.1.0 (~2026-05)
Is it free	Yes (completely open source and free)
Privacy Policy	Runs completely locally, data does not leave the user's device

Positioning boundaries: GemmaBook is not a cloud SaaS, a mobile app, or a general-purpose AI assistant. Its design scope is very narrow - providing an AI-enhanced reading experience for native EPUB e-books. It is not suitable for reading PDFs, web articles or other format documents, and it does not provide multi-device cloud synchronization or collaboration functions.

Technical dependencies: The project is bundled with the Windows CUDA binary file of llama.cpp and the Gemma GGUF model. The first startup requires downloading approximately GB of model files and runtime, which has certain requirements for disk space and network bandwidth.

User and market recognition

GemmaBook is in its very early stages. GitHub public data shows:

• Stars: 0
• Forks: 0
• Contributors: 1 person (Santhoshl2312)
• Public Release: 0 official Releases
• Issue and PR: No public record

This means that the project has not yet formed a community ecosystem, and there are no public user adoption cases or third-party reviews. Its value proposition needs to be verified through actual deployment use.

Positioning reference: Although the community number is zero, the "local-first AI reading" direction represented by GemmaBook has certain market demand - in privacy-sensitive scenarios (such as reading confidential documents, personal diary analysis) and offline (travel, network-restricted areas), purely local solutions are more attractive than cloud services.

Prerequisites for implementation: Users need to have certain technical capabilities (or be willing to follow the documentation) to complete the first context configuration, including model download and dependency installation. Non-technical readers may want to wait for more mature installation packages or graphical installers.

Cost advantage

GemmaBook’s cost structure is extremely simple – it’s completely open source and free. But there are explicit and implicit costs behind "free" that need to be considered.

Individual users (C-side):

• Software fee: 0 yuan. GitHub repositories can be cloned or downloaded directly.
• Running Cost: Requires a Windows PC with an NVIDIA GPU (CUDA capable). It can be run on the CPU without a GPU, but the inference speed will be significantly reduced.
• Storage Cost: The model file (Gemma GGUF + Nomic Embed GGUF) is about 2-5 GB, the llama.cpp binary file is about hundreds of MB, and the total first download is about 3-6 GB.
• Electricity and Hardware Depreciation: Running large models locally will continue to consume GPU resources, and the power consumption in long-term reading scenarios cannot be ignored.

Developer/Self-Hosted Users:

• Customization Cost: The open source project allows you to freely modify the code, replace the model, and adjust the prompt template. But Python/FastAPI development capabilities are required.
• Operation and maintenance costs: There is currently no automated update mechanism, and you need to manually git pull to update the code and re-download the model version.

Comparison with cloud services:

Comparison dimensions	GemmaBook (local)	Google NotebookLM (cloud)	ChatGPT reading (cloud)
Subscription cost	0 yuan	Free version has a limit / Gemini Advanced is about $19.99/month	ChatGPT Plus is about $20/month
Hardware cost	GPU computer required (about ¥5000+)	0 yuan (cloud running)	0 yuan (cloud running)
Privacy Guarantee	★★★★★ (data does not leave the device)	★★★ (data is uploaded to Google servers)	★★★ (data is uploaded to OpenAI servers)
Available offline	✅ Fully supported	❌ Internet connection required	❌ Internet connection required
Model capabilities	Gemma (lightweight)	Gemini Pro/Ultra	GPT-4o series
Supported formats	EPUB exclusive	PDF, web YouTube, audio and other sources	Text pasting, file upload

Conclusion: The premise that GemmaBook is "free" is that the user already has or is willing to invest in GPU hardware. For users without local computing power, the overall cost of ownership of the cloud solution may be lower. But for privacy-sensitive or offline scenarios, GemmaBook provides irreplaceable value.

Main functions

GemmaBook focuses on EPUB e-book reading scenarios and embeds AI capabilities into each section of the reading process:

• EPUB Reader: A browser-based EPUB reading interface that supports book uploading, chapter browsing and paragraph marking. The reader itself is lightweight and concise, focusing on text presentation rather than layout beautification.

• Automatic generation of chapter summary: When the user opens a chapter, the Gemma model is automatically called in the background to generate a summary and key event list of the chapter. The summary is presented in the form of a sidebar without interrupting the reading flow. The generated summary is stored locally in SQLite and does not need to be regenerated when reading the same chapter again.

• Character Tracking System: Automatically extract character names, aliases (such as "Old Li" and "Manager Li" refer to the same person), relationship descriptions and personality traits from the text. Character information is aggregated by chapter, ultimately forming a character relationship map for the entire book. It is especially useful for complex works with multiple characters and multi-line narratives.

• Contextual Questioning and Answering (RAG): Users can ask questions about the entire book. The system vectorizes the chapters through the Nomic Embed model and retrieves relevant paragraphs as context when answering using the Gemma model. Q&A supports three levels: book level, current chapter level, and selected text level.

• Text Simplification: Select a difficult paragraph and click the "Simplify" button, and the model will rewrite the paragraph with simpler vocabulary and sentence structures. Ideal for language learners, teenage readers, or non-native users reading professional literature.

• Local-first AI architecture: All AI inference is done on the local llama-server instance, no data is sent to external servers. Three local services are automatically launched when the system starts: FastAPI application (:8000), Gemma inference service (:9000), and text embedding service (:9001).

Synergy between functions: Chapter summaries provide a contextual basis for character tracking - the model extracts character information simultaneously when generating summaries, and the two share the same round of inference results, reducing repeated calculations. Contextual Q&A relies on chapter embedded index and summary data to improve retrieval accuracy, forming a concept of "reading → abstract → understanding → Q&A".

Model and version evolution

GemmaBook is currently in its initial development stages and has a very short version history.

Mainline release

Version ID	Version name	Release date	Key changes
v0.1.0	Memoria AI Book Companion	~2026-05	The first public version, implementing core functions of EPUB reading, chapter summaries, character tracking, contextual Q&A, and text simplification.
Follow-up plans	Undisclosed	Undisclosed	The developer has not announced a roadmap. Judging from the warehouse activity, the project has stabilized after centralized submissions from 2026 to May.

Evolution Characteristics: The project completed rapid advancement from initialization to core function implementation in about 2 months (2026-05 to 2026-07). The Commit record shows that the developer built the project skeleton EPUB parser AI service package, front-end interface and startup script in sequence. The last active commit to the repository was in ~2026-05 (about 2 months ago).

Model Adaptation: The Gemma GGUF model is currently used. Users can manually replace it with other GGUF models compatible with llama.cpp (such as Llama 3, Mistral, etc.), but they need to adjust the prompt template and parameter configuration by themselves. The project does not provide a graphical interface for model switching.

Technical advantages

GemmaBook's technical architecture is designed around the two main lines of "local priority" and "retrieval enhanced generation (RAG)".

Mechanics → Effects → Scenarios:

1. llama.cpp local inference: Use llama.cpp to quantize the Gemma model (GGUF format) and run it on the local CPU/GPU. Compared with cloud API calls, network latency and data transmission costs are eliminated, and inference response time depends entirely on local hardware. Suitable for reading scenarios that are sensitive to latency or have limited network access.

2. Dual-model division of labor architecture: Gemma GGUF is responsible for generation tasks (summary, question and answer, simplification), and Nomic Embed Text GGUF is responsible for semantic embedding (text vectorization). This separation design of "generative model + embedding model" prevents the vector dimensions of RAG retrieval from occupying the context window of the generated model, improving retrieval accuracy. Embedding vectors are stored locally in SQLite and can be reused even after closing the computer and opening it again.

3. Asynchronous Chapter Processing: After EPUB is uploaded, the backend asynchronously parses, summarizes and embeds chapters by chapter without blocking the reader UI. Users can continue reading chapters that have been processed during background processing. Processing progress is fed back to the front end through API polling.

4. Full-link local data: From EPUB original text to summary results, role map, and vector index, all are stored in the local SQLite database. No data passes through third-party servers. The database file (memoria.db) is located in the backend/ directory and can be backed up or migrated at any time.

Performance Reference: On a machine equipped with NVIDIA RTX 3060 (12GB VRAM), the inference speed of the Gemma 2B GGUF model is about 20-40 tokens/s, and the summary generation of a chapter of about 3000 words takes about 15-30 seconds. In pure CPU mode, the speed drops to 3-8 tokens/s, and the experience is significantly reduced.

Technical limitations:

• Currently only supports Windows platform (relies on Windows batch script and CUDA).
• Single session single user design, no multi-user concurrency capability.
• The embedded model is fixed to Nomic Embed Text. Changing the model requires modifying the code.
• Several GB of model files need to be downloaded for the first startup, and there is no prompt for resuming the download (if the download fails, you need to re-execute start.bat).

How to use

GemmaBook is intended for users with basic command line capabilities. Deployment and use are divided into three stages:

Phase 1: Contextual preparation and installation

Prerequisites:

• Windows 10/11 operating system
• Command line support for curl and tar (built-in in modern versions of Windows)
• NVIDIA GPU + CUDA driver (recommended, not required but affects experience)
• Free disk space ≥ 10 GB (for model file llama.cpp binary and Python context)

Installation steps:

:: Clone the repository
git clone https://github.com/Santhoshl2312/Gemma_book_reader.git
cd Gemma_book_reader

:: One-click installation (first startup, automatically downloads models and context)
start.bat

start.bat will automatically complete the following 10 steps:

1. Download the llama.cpp server binary file
2. Download the CUDA runtime file
3. Download the Gemma GGUF dialogue model
4. Download the Nomic Embed Text GGUF embedding model
5. Install the local Miniforge Python distribution under backend/miniforge/
6. Create memoria Python virtual context and install dependencies
7. Start the AI inference service at http://127.0.0.1:9000
8. Start the embedded service at http://127.0.0.1:9001
9. Start the FastAPI application at http://127.0.0.1:8000
10. Open the application interface in the default browser

The initial installation time depends on the network bandwidth and usually takes 10-30 minutes.

Phase 2: Daily startup

cd backend
run_all.bat

To start three services in separate windows:

cd backend
run_all.bat --separate

Stage 3: Usage process

1. Open the browser http://127.0.0.1:8000
2. Upload EPUB files in the Library interface
3. Wait for the background processing to be completed (the processing progress is visible on the interface)
4. Click on any chapter to start reading
5. Use the AI panel on the right to view chapter summaries and character details
6. After selecting the text, use the Q&A function to ask questions or click "Simplify" to rewrite it.

List of local service ports

Service	URL	Purpose
FastAPI Application	http://127.0.0.1:8000	Web Interface and API
Gemma Inference Service	http://127.0.0.1:9000	Dialogue/Text Generation
Text embedding service	http://127.0.0.1:9001	Semantic vector generation

Product Pricing

GemmaBook is a completely free open source project and does not involve any paid plans.

Charge items	Amount	Description
Software licensing	Free	GitHub open source, no licensing fees
Cloud service	Not applicable	No cloud version, all run locally
Enterprise Edition	Does not exist	No enterprise features or enterprise authorization
Commercial support	Not provided	Community support relies on GitHub Issues

Cost Attribution: Although the software itself has zero cost, the actual costs incurred include:

• Hardware investment: NVIDIA GPU (RTX 2060 and above) recommended for acceptable inference speed. Work computers without GPUs can also run but with a reduced experience.
• First download traffic: ~3-6 GB model and runtime files.
• Power consumption: The GPU power consumption during Gemma model inference is about 50-150W (depending on the specific graphics card and quantization level).

Cost comparison with commercial competing products (deduction estimate):

Solution	First-year cost (hardware + software)	Subsequent annual costs	Applicable scenarios
GemmaBook (newly purchased GPU)	¥5000-8000 (hardware)	¥500-1000 (electricity bill)	Privacy sensitive, long-term heavy reading
GemmaBook (has GPU)	0 yuan	¥500-1000 (electricity fee)	Same as above, the hardware is ready
Google NotebookLM	0 yuan (free version) to ¥1440/year	Tongzuo	Cloud collaboration, multi-format input
ChatGPT Plus reading	¥1680/year	Tongzuo	Multi-scenario universal AI assistant

Application scenarios

The design of GemmaBook determines that it will only provide maximum value in specific scenarios. The following are three categories of best-fit scenarios and one category of clearly unsuitable scenarios:

Scenario 1: In-depth reading of academic literature

Task type: Graduate students or researchers read English monographs and academic e-books (EPUB format).

Actual benefits: GemmaBook’s chapter summary function can compress a 30-50 page chapter into a 3-5 paragraph summary, saving about 60% of the initial screening time. Character tracing helps clarify character relationships when reading multi-person case studies or historical works. Contextual Q&A allows readers to ask for concept definitions or theoretical details using natural language, replacing manual browsing of the index.

Verification focus: The translation accuracy of professional terms in academic literature depends on the capability boundaries of the Gemma model itself. For highly specialized terms (such as medicine, law), it is recommended to combine cross-validation with the original text.

Scenario 2: Language learners reading foreign languages

Task Type: English/Japanese language learners reading foreign language EPUB e-books, requiring real-time translation and simplified support.

Actual benefits: Select difficult paragraphs to simplify them with one click, and rewrite complex sentences into simpler expressions. Text simplification uses Gemma's language understanding capabilities to restructure sentences rather than translate them word-for-word, helping learners understand authentic expressions. All data runs locally, and learners don’t need to worry about reading records and underlined content being uploaded to third parties.

Check Points: The quality of the simplification results is directly related to the target language capabilities of the Gemma model. For text in small or mixed languages, the effect may be unstable.

Scenario 3: Document analysis in privacy-sensitive scenarios

Task Type: Legal practitioners, financial analysts, or government agency personnel read EPUB documents containing sensitive information (e.g., internal reports, confidential materials).

Real Benefit: Pure local operation ensures that no text data leaves the device. SQLite database files can be stored in encrypted volumes or BitLocker-encrypted partitions. After reading, the database file can be deleted directly without leaving any traces in the cloud. The ability to run offline enables the solution to be used in physically isolated networks.

Verification Points: The current version does not have user authentication and audit log functions. When multiple users share the same device, attention must be paid to data isolation.

Not suitable for the scene

• PDF document reading: GemmaBook only supports EPUB format, not PDF. PDF users need to convert to EPUB first (tools like Caliber) or choose another solution.
• Mobile reading: There is no Android/iOS client, and the browser interface has limited adaptation to mobile phones.
• Collaborative Reading: Annotation sharing, reading progress synchronization or team discussion functions are not supported.
• Long Article/Web Page: Does not support web scraping or RSS feeds, only full EPUB ebooks.

Applicable people

Suitable people

• Technical readers: Readers who are familiar with command line operations and are willing to configure the environment themselves. Be able to accept the complexity of the first installation in exchange for local privacy and offline freedom later on.
• Privacy-aware users: Be cautious about the data collection strategies of AI tools, and hope that AI reading assistance will ensure that personal data does not leave the device. Typical examples include practitioners in legal, medical, financial and other industries.
• Offline scenario demanders: Users who often travel for business, have unstable networks, or work in physically isolated environments. GemmaBook is fully available offline once configured.
• Open Source Software Advocate: Users who prefer free software and want to audit code security. The GitHub repository code is completely open and can be reviewed or forked for modification.

Unsuitable people

• Newbie users: Readers who are not familiar with command line Git and Python are recommended to wait for a more mature graphical installation version or choose a cloud solution.
• Main mobile reading users: Users who mainly read on mobile phones or tablets. GemmaBook currently does not have a mobile client.
• Multiple format document readers: For users who need to read PDF, web MOBI, AZW3 and other multiple formats at the same time, GemmaBook only supports EPUB.
• Users pursuing an "out-of-the-box" experience: It takes 10-30 minutes for initial configuration + several GB download from download to start reading, which is not suitable for scenarios where you want to start reading immediately.

Preconditions

Before using GemmaBook, you need to confirm:

• Have a Windows 10/11 computer (NVIDIA GPU recommended)
• Ability to perform basic operations from the command line (git clone, cd)
• Network context allows downloading files (approximately 3-6 GB) from GitHub and Hugging Face
• Accept the current version update notification and automatic upgrade mechanism

Summary and Outlook

GemmaBook (Memoria AI Book Companion) is a precisely positioned local-first AI reading companion. It embeds four types of AI capabilities in the EPUB reader: chapter summarization, role tracking, contextual question and answer, and text simplification, and realizes the two core promises of data privacy and offline availability through full-link local operation (llama.cpp + Gemma GGUF + SQLite).

Core Competencies:

• Runs entirely locally, with zero risk of data leakage
• Zero subscription fee (require your own GPU hardware)
• A complete learning process covering "reading→comprehension→questioning→review"
• Open source and self-hosted, freely customizable and extendable

Current limitations and uncertainties:

• The community is extremely small (0 stars), and the long-term maintenance capabilities of the project have not been verified. Developers may stop updating due to personal reasons.
• Only supports Windows platform and EPUB format, with narrow scene coverage.
• The first-time configuration threshold is high (command line operation + several GB download), which is not suitable for ordinary users.
• There is no official Release version and version number, and it relies on the direct use of Git repository, which poses code stability risks.
• The warehouse does not declare an open source license, and the compliance of commercial use or secondary distribution needs to be clarified by the developer.
• Model capabilities are limited by the lightweight scale of Gemma 2B/7B, and are inferior to large cloud models in complex reasoning and long text understanding.

Procurement/Adoption Risk Assessment:

• Personal use: low risk. It's completely free and can be deployed at any time for trial use. It is recommended to clone the experience from GitHub on a Windows machine that already has a GPU.
• Team/Enterprise Adoption: High Risk. There are no enterprise-level features (user management, audit log SSO), no commercial support channels, and no version update commitments. It is recommended to only pilot the system in an experimental environment that is controllable by the IT department and not as a core business dependency.
• Point of concern: If the project has no new versions or maintenance submissions within 6 months, it is recommended to migrate the data to a more active alternative (such as NotebookLM or a self-built RAG reading pipeline).

GemmaBook's current most suitable role is "a DIY reading enhancement tool for technical readers" rather than a mature product solution. With the evolution of the Gemma model and the maturity of the llama.cpp ecosystem, the direction of local AI reading deserves continued attention. But until the project gains greater community support and a better release process, it is recommended to position it as an experimental tool rather than a production dependency.

Related tools: notion-ai, google-workspace

Version Info

• Memoria AI Book Companion (Initial Release) ：The first public version supports EPUB upload reading, automatic generation of chapter summaries, character information extraction, contextual question and answer and text simplification functions. There is no official precise release date yet. （~2026-05）
• Memoria AI Book Companion (Initial Release) ：The first public version, there is no official precise release date yet. （~2026-05）