If you find any errors, please let me know.

NEW: You can download the Installer for Second Brain at this Google drive link (If you trust it, which I'm not assuming everybody will. If you don't, you can install it manually with the instructions below.)

• Multi-directory support: Sync and search across multiple directories simultaneously
• Semantic search: searches based on deep semantic meaning.
• Lexical search: finds a needle in a haystack using keywords.
• Supported files: .txt, .pdf, .docx, .gdoc, .png, .jpg, .jpeg, .gif, .webp
• Multimodal in three ways:
  • Can embed and search for both text and images.
  • Can attach text documents and images, and use them to search.
  • Can use AI language models with vision.
• Optional AI Mode:
  • LLM Integration: Supports local models via LM Studio and cloud models, like GPT-5, via OpenAI.
  • Retrieval-Augmented Generation (RAG): Uses search results to provide high-quality AI responses rooted in the knowledge-base.
  • The AI Mode is entirely optional; a search can be run without AI.
• Sync 100,000+ files.
• High-performance sync: Multi-threaded processing for fast synchronization of large directories.
• Security and privacy: local search ensures no data is sent to the internet.
• Works with Google Drive.
• Open source: all the code is right here.

Second Brain is optimized for handling large directories with thousands of files and images:

• Parallel Processing: Uses multi-threading to process text files concurrently (up to 8 workers by default)
• Optimized Image Handling: Larger batch sizes and efficient image loading for faster sync
• Smart Resource Management: Auto-detects optimal worker count based on your CPU
• Expected Performance: 4-8x faster text processing, 3-5x faster image processing compared to sequential processing

For large directories (1000+ files), the improved sync speed means you can keep your knowledge base up-to-date more frequently without long waiting times.

SecondBrainBackend.py

This file handles two things: syncing the directory and performing searches.

Syncing: Scans the target directory, detects new, updated, or deleted files. Extracts text from files and splits it into manageable chunks, while also batching images together for the sake of speed. Converts text chunks and images into vector embeddings using sentence-transformer models. Stores embeddings in a persistent ChromaDB vector database. To enable lexical search, image captions are created and stored along with image embeddings. A lexical index of both text documents and image captions is created using BM25 for lexical search.

Retrieval: Performs both a semantic and lexical search, then combines the outputs, reranks all results using Maximal Marginal Relevance (MMR), takes the top N outputs, and finally filters for relevance using AI (last step optional).

SecondBrainFrontend.py

The frontend code controls the user interface for the application. It controls threading for non-blocking backend operations, prompting patterns for the AI, and logging functions. Manages text and image attachments to construct complex prompts for the LLM. Allows the user to send messages in a chat-like format. Performs many different functions simultaneously, and orchestrates blocking and re-enabling different buttons at different times to prevent crashes. Looks good, too, if I may say so myself.

Uniquely, image and text results can be attached in order to perform continous searches, like web-surfing but through your own filebase. There is no other experience exactly like it. Simply click on an image result or the four squares by a text result and then click "attach result." Other similar amenities are available in the app.

config.json

This file can be edited by the user and changes the cool features of Second Brain (see below).

credentials.json

This file must be added (see below) if using Google Drive (optional), as it allows the syncing of Google Doc (.gdoc) files.

image_labels.csv

This CSV is used as a pool for possible image labels. The image labels are chosen based on how close the image embedding is to each label embedding (a categorization task). It was constructed based on Google's Open Images dataset for object identification.

SecondBrainHotkey.ahk If you want, you can make a hotkey (I do ctrl+j) using AutoHotkey that automatically runs SecondBrainFrontend.py when you are anywhere on your computer. This makes it very convenient. To do this, you'll need to download AutoHotkey itself, and edit it so that the path points to where your SecondBrain folder is. To make the hotkey active when you start your computer, place the script inside your startup files, which you can find (on Windows) using Win+R and then typing shell:startup.

Before running the application, ensure you have the following:

• Python 3.9 or higher - Download Python (Make sure to check "Add Python to PATH" during installation)
• LM Studio (optional, for local AI): Download and install LM Studio with a .gguf model, ideally with vision capabilities (unsloth/gemma-3-4b-it works well, but any model may be used).
• OpenAI API (optional, for cloud AI): Make sure you have an API key from platform.openai.com with sufficient funds.
• System requirements: The search engine can be used with GPU or CPU. It will automatically detect if a GPU exists and use it if available. Different text and image embedding models use different amounts of memory, and can be configured. For example, the default models use 2GB of VRAM/RAM.

NEW: Automatic Setup Scripts!

After downloading the repository, simply run the appropriate script for your system:

.\setup_and_run.ps1

If you get an ExecutionPolicy error, run:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

setup_and_run.bat

chmod +x setup_and_run.sh  # Make executable (first time only)
./setup_and_run.sh

The script will automatically:

• ✅ Check for Python 3.9+
• ✅ Verify all required files are present
• ✅ Create a virtual environment
• ✅ Install all dependencies
• ✅ Launch the application

First run may take 5-15 minutes to download dependencies (~2-3 GB). Subsequent runs will be much faster - just run the same script again!

Download SecondBrainBackend.py, SecondBrainFrontend.py, config.json, image_labels.csv and requirements.txt from this repository. Place them in a folder.

Then install dependencies:

pip install -r requirements.txt

And run:

python SecondBrainFrontend.py

Open config.json and update the target_directories array to point to the folder(s) you want to use as your knowledge base.

You can specify one or multiple directories:

Single directory:

"target_directories": [
    "C:\\Users\\user\\Documents\\MyNotes"
]

Multiple directories:

"target_directories": [
    "C:\\Users\\user\\Documents\\MyNotes",
    "C:\\Users\\user\\My Drive",
    "D:\\Projects\\Documentation"
]

All specified directories will be scanned and synced together into a unified searchable knowledge base.

Note: The old target_directory (singular) format is still supported for backward compatibility.

(Optional - skip if irrelevant) To enable Google Doc syncing, follow the Google Cloud API instructions to get a credentials.json file using OAuth. Either place the file in the project directory, or place it somewhere else and update credentials_path in config.json to point to it. The first time you sync, a browser window will open for you to authorize the application. Authentication is very finnicky and it might be necessary to delete the authorization token (token.json) and then reauthorize to get Drive syncing to work. You can do this with the "Reauthorize Drive" button.

Click the Sync Directory button to start embedding the files from your target_directory. Depending on the size of the directory, it can take a while (hours), but is necessary to enable search. The sync can be cancelled midway through by clicking the Cancel Sync button with no consequences. If restarted, the sync will continue where it left off.

Text results are based on relevant chunks of text from the embedding database. You can click on image results and file paths to open them directly, attach them, see their parent folder, or copy their path.

Toggle the AI Mode checkbox to enable or disable LLM augmented search. When enabled, Second Brain loads the selected LLM from LM Studio or the OpenAI API. Then, searches are enhanced with AI-generated queries, results are filtered by the AI based on relevance, and a final "AI Insights" summary is always streamed in the results container. It is optional but recommended to use vision-enabled models, since it is needed to filter images and give insights on them. When disabled, the LLM is unloaded to save system resources, and the app performs a direct vector/lexical search with no query expansion, filtering, or summary. It is possible to toggle query expansion and filtering (see config: query_expansion and llm_filter_results).

If you attach a text document (.pdf, .docx, etc.), the entire text will be added if it is below a certain size (see config: max_attachment_size). If it is too large, it extracts several relevant chunks to provide focused context for the search. If you attach an image, you can send it to find visually similar images in your database and related documents. You can send an attachment without a message.

If you find that Second Brain has produced a good insight, you can save it for future use. When you click the "Save Insight" button, found after the AI Insights section of a response, the query and response get saved to a .txt file. These text files will be embedded, which gives Second Brain a long-term memory of its own contributions. (You can re-read or delete entries by going to the saved_insights folder, in the Second Brain directory.)

config.json

All Python dependencies are listed in requirements.txt:

pip install -r requirements.txt

OR simply run setup_and_run.bat to install everything automatically.

requests
PyMuPDF
chromadb
python-docx
rank_bm25
flet
numpy
Pillow
langchain_core
transformers
sentence-transformers
scipy
langchain-text-splitters
openai
lmstudio
google-auth-oauthlib
google-api-python-client
torch

These can be found in the code to change minor features. IMG_THUMBNAIL, stop_words, jpeg_quality, min_len, low_compression_threshold, high_compression_threshold, temperature, openai_vision_keywords, image_preview_size

https://lmstudio.ai/docs/python

https://research.trychroma.com/evaluating-chunking

https://github.com/ALucek/chunking-strategies/blob/main/chunking.ipynb

https://flet.dev/docs/

https://huggingface.co/spaces/mteb/leaderboard