Local GPT

Combines vector similarity search with BM25 keyword matching to retrieve relevant document chunks, using late chunking and AI-powered reranking to surface the most contextually relevant results. The system maintains parallel vector and keyword indices, executes both search paths concurrently, and applies a learned reranker to fuse results before passing to the LLM, enabling both semantic and lexical relevance.

Processes documents in multiple formats (PDF, DOCX, TXT, Markdown) through a unified pipeline that extracts text, applies contextual enrichment to preserve document structure and relationships, and batches processing for efficiency. The system uses format-specific parsers, maintains document metadata, and enriches chunks with surrounding context before vectorization to improve retrieval quality.

Ensures all data processing (documents, embeddings, chat history, model inference) occurs locally without external API calls or data transmission, using local storage (LanceDB for vectors, SQLite for chat history) and Ollama for model inference. The system is designed for air-gapped or restricted-network environments where data cannot leave the organization.

Implements a multi-service architecture where document processing, retrieval, generation, and API layers are independently deployable and configurable services orchestrated by a central run_system.py script. Each service has well-defined responsibilities and APIs, allowing developers to swap components (e.g., different embedding models, retrieval strategies) without modifying other services.

Manages local LLM and embedding model inference through Ollama, allowing users to run multiple model types (chat, embedding, reranking) on local hardware without external API calls. The system communicates with Ollama via HTTP endpoints (localhost:11434), handles model lifecycle management, and supports dynamic model switching based on query complexity through smart routing.

Maintains conversation state across multiple turns using SQLite-backed session management, enabling context-aware follow-up questions and multi-turn reasoning. The system streams responses in real-time to the web interface, tracks session metadata, and allows users to manage multiple independent conversation threads without context bleed.

Breaks complex multi-part questions into sub-queries, executes each independently through the RAG pipeline, and verifies answers against source documents before returning to the user. The system uses the LLM to decompose queries, routes each sub-query through retrieval and generation, and applies verification logic to detect hallucinations or unsupported claims.

Caches embeddings and retrieval results for semantically similar queries, avoiding redundant vector search and LLM inference when users ask variations of the same question. The system compares incoming query embeddings against cached queries using similarity thresholds, returns cached results when similarity exceeds the threshold, and updates the cache with new queries.

Provides a browser-based UI for document upload, query submission, and result viewing with real-time progress indicators showing document processing, retrieval, and generation stages. The frontend communicates with the backend via REST APIs and WebSockets, displays streaming responses as they arrive, and provides visual feedback on system state and processing stages.

Manages document indices with operations to create, update, delete, and rebuild indices without losing chat history or requiring system restart. The system tracks document metadata, supports incremental indexing for new documents, and provides tools to reindex specific documents or entire collections when needed.

Allows users to configure different LLM and embedding models through YAML configuration files, supporting multiple backends (Ollama, HuggingFace) and enabling easy model swapping without code changes. The system reads configuration at startup, validates model availability, and routes inference requests to the configured backends.

Exposes system functionality through RESTful endpoints for document upload, query submission, session management, and index operations, with comprehensive health monitoring endpoints that report system status, service availability, and performance metrics. The API includes request validation, error handling, and status codes that enable external systems to monitor and orchestrate LocalGPT.