Search and Memory

ThinkForge builds a private, searchable memory for each project. Documents, conversations, and imported content are automatically indexed so you can find things by meaning — not just exact words.

This system runs entirely on your machine. Embeddings are generated locally, search queries never leave your computer, and each project's memory is isolated from the others.

How it works

When you save a document, import a file, or have a conversation in ThinkForge, the content goes through a local indexing pipeline:

  1. Text extraction — the content is read and prepared for indexing
  2. Chunking — long documents are split into smaller, meaningful pieces (roughly 1000 tokens each with overlap between chunks). Markdown splits on headings, code splits on function boundaries, and plain text splits on semantic boundaries.
  3. Embedding — each chunk is converted into a numerical vector (a 384-dimension representation of meaning) using a local AI model
  4. Storage — chunks and their embeddings are stored in a project-local SQLite database
Fully local embeddings. ThinkForge uses an on-device model (all-MiniLM-L6-v2) to generate vectors. No content is sent to OpenAI, Anthropic, or any external service for embedding. Your AI provider API keys are only used for chat and agent tasks — never for indexing.

What gets indexed

ThinkForge automatically indexes these content types when they appear in your project folder:

  • Markdown files (.md)
  • Plain text (.txt)
  • Rich text (.rtf)
  • HTML, CSS, JavaScript, JSON, XML
  • Code files (C#, Python)

Additionally, these are indexed through direct interaction:

  • Chat conversations — each question-and-answer pair is stored as a searchable chunk
  • Browser captures and imported web content
  • Mind maps and structured notes
  • Agent outputs and artifacts

System folders, build output, and binary files are excluded from indexing.

How search works

ThinkForge offers three search modes, and most search surfaces use a hybrid approach that combines them:

  • Keyword search — finds chunks containing your exact words. Also matches filenames and paths.
  • Semantic search — finds content that means something similar to your query, even if it uses different words. Your query is embedded locally and compared against stored vectors by cosine similarity.
  • Hybrid search — runs both keyword and semantic search in parallel, then merges and ranks results. This is the default mode and gives the best results in most cases.

If the local embedding model is not available, search falls back to keyword-only mode automatically.

Where you can search

Search is available from several places in ThinkForge:

  • Project Navigator — the main search bar runs hybrid search across your project
  • Project Navigator — the Search tab with keyword, smart, and tag toggles
  • Command menu — quick access to memory search from anywhere in the app
  • Browser extension — search your project memory without switching to the desktop app
  • MCP tools — search from Claude Desktop, Cursor, or other MCP-compatible tools

Search results

Results are returned at the chunk level, grouped by source document. Each result shows:

  • The source document title or filename
  • A matching text snippet
  • A relevance score (for semantic matches)
  • Whether the match was found by meaning, keyword, or both

Click a result to open the source document.

Project scoping

Each project has its own separate memory database stored in the project's .fire/memory folder. When you search, you are searching the current project by default.

Cross-project search is available when you need it — the browser extension and MCP tools can search across all your projects and return results tagged with their source project.

Automatic maintenance

ThinkForge keeps memory in sync with your files automatically:

  • New files are indexed when they appear in the project folder
  • Changed files are re-indexed (ThinkForge tracks content hashes to avoid redundant work)
  • Deleted or moved files have their memory entries updated to match
  • A reconciliation runs when you open a project to catch any changes made while the app was closed

You do not need to manually trigger indexing for normal use.

Related