Langchain-Chatchat

Implements a pluggable vector store architecture supporting FAISS (local), Milvus (distributed), Elasticsearch (hybrid), and PostgreSQL+pgvector backends through a KBServiceFactory pattern. Document ingestion pipeline chunks text, generates embeddings via configurable embedding models, and stores vectors with metadata. Search operations perform similarity matching with configurable top_k and score_threshold filtering, with Chinese-specific title enhancement (zh_title_enhance) to improve retrieval quality for CJK documents.

Implements a LangChain-based agent framework with a tool registry system that supports function calling across multiple LLM providers (OpenAI, Anthropic, Ollama). Agents decompose user queries into subtasks, invoke registered tools with schema-based function signatures, and maintain execution state across multiple steps. MCP (Model Context Protocol) integration enables bidirectional communication with external tools and services, allowing agents to dynamically discover and invoke capabilities beyond built-in functions.

Provides production-ready Docker images with multi-stage builds that separate build dependencies from runtime dependencies, reducing image size. Includes docker-compose configuration for orchestrating Chatchat application, vector store backends (Milvus, Elasticsearch), and model servers (Ollama, vLLM) as a complete stack. Supports both CPU and GPU deployments through conditional base image selection and CUDA runtime configuration.

Extends RAG capabilities to handle images by generating image embeddings (via CLIP or similar vision models) and storing them alongside text embeddings in the vector store. Supports image upload in knowledge bases, image search via text queries (cross-modal retrieval), and integration with vision-capable LLMs (GPT-4V, Qwen-VL) for image understanding. Retrieved images can be passed to vision models for detailed analysis and grounding LLM responses in visual content.

Designed for complete offline operation: all models (LLM, embedding, reranker) run locally without cloud API calls, vector stores are local (FAISS) or self-hosted (Milvus), and the web UI runs on localhost. No internet connection required after initial setup. Supports multiple model serving backends (Ollama, vLLM, FastChat) for flexible local deployment. Configuration and data are stored locally; no telemetry or external service calls.

Processes uploaded documents through a multi-stage pipeline: text extraction (PDF, Word, Markdown), intelligent chunking with overlap (configurable chunk_size and chunk_overlap), embedding generation via pluggable embedding models, and storage in vector backends. Includes Chinese-specific optimizations like zh_title_enhance that adds semantic titles to chunks, improving retrieval for CJK content. Chunking strategy respects document structure (paragraphs, sections) to preserve semantic boundaries.

Exposes all integrated LLMs (ChatGLM, Qwen, Llama, etc.) through OpenAI SDK-compatible REST endpoints, enabling drop-in replacement of OpenAI API calls with local or alternative models. Implements streaming responses, token counting, and embedding endpoints matching OpenAI's interface. Supports both chat completions and embedding generation with identical request/response schemas, allowing client code to switch backends by changing the API endpoint URL without code changes.

Implements a stateful chat system that maintains conversation history, manages token limits, and streams responses token-by-token to clients. Uses LangChain's memory abstractions (ConversationBufferMemory, ConversationSummaryMemory) to track multi-turn context, automatically truncates or summarizes history when approaching token limits, and supports both RAG-augmented and agent-based response generation. Streaming is implemented via Server-Sent Events (SSE) for real-time token delivery.

Provides REST API endpoints for creating, reading, updating, and deleting knowledge bases with full document lifecycle management. Supports bulk document upload, incremental indexing, document deletion with vector cleanup, and metadata-based filtering (source, date, tags). Implements a knowledge base registry that tracks all indexed documents, their embedding status, and vector store location. Metadata indexing enables filtering retrieved results by document source, creation date, or custom tags before similarity search.

Abstracts multiple LLM providers (ChatGLM, Qwen, Llama, OpenAI, Anthropic) behind a unified interface, enabling model selection at runtime without code changes. Implements provider-specific configuration (API keys, model names, parameters) through a centralized config system (settings.yaml), and exposes all models through OpenAI-compatible endpoints. Supports both local model serving (via Ollama, vLLM) and API-based models (OpenAI, Anthropic) with automatic fallback and retry logic.

Provides a Streamlit-based web interface for chat, knowledge base management, and RAG interaction. Implements real-time streaming of chat responses using Streamlit's session state and callback mechanisms, file upload with progress tracking, knowledge base creation/deletion UI, and document search visualization. The UI maintains conversation history in browser session state and supports both text chat and file-based Q&A (uploading a document and asking questions about it).

Enables users to upload a single document (PDF, Word, Markdown) and ask questions about it without creating a persistent knowledge base. The system extracts text from the file, chunks it, generates embeddings, and retrieves relevant chunks in response to user queries. Retrieved chunks are injected into the LLM prompt as context, enabling the model to answer questions grounded in the document. This is a lightweight alternative to knowledge base creation for ad-hoc document Q&A.

Centralizes all system configuration (model selection, vector store backends, embedding models, API keys, chunking parameters) in YAML files (settings.yaml, kb_settings.yaml) with environment variable override support. Configuration is loaded at startup and exposed through a settings object accessible throughout the application. Supports per-environment configuration (dev, staging, production) through file naming conventions and environment variable prefixes.