llm-universe

Implements a complete Retrieval-Augmented Generation pipeline using LangChain as the orchestration layer, connecting document loaders, text splitters, embedding generators, vector databases (ChromaDB), and LLM inference endpoints. The architecture follows a modular data flow pattern: documents → chunking → embeddings → vector storage → retrieval → prompt augmentation → LLM response generation. Each component is independently configurable and replaceable, enabling users to swap embedding providers (OpenAI, local models) or vector stores without rewriting pipeline logic.

Abstracts document loading across multiple formats (PDF, Markdown, plain text, URLs) using LangChain's document loader ecosystem, then applies text preprocessing including cleaning, normalization, and language-specific tokenization (Jieba for Chinese). Documents are split into semantic chunks using configurable chunk size and overlap parameters, preserving metadata (source, page number) throughout the pipeline. This enables heterogeneous knowledge bases where documents from different sources are uniformly processed before embedding.

Provides setup instructions and configuration patterns for initializing development environments, including Python dependency installation, API key management, and LLM endpoint configuration. The implementation covers: (1) virtual environment creation (venv or conda), (2) pip dependency installation from requirements.txt, (3) environment variable setup for API keys (OpenAI, Anthropic), (4) LLM endpoint configuration (OpenAI API, local Ollama). Configuration is externalized using environment variables and config files, enabling different settings for development, testing, and production without code changes.

Structures the entire RAG application development process as a series of Jupyter notebooks, each focusing on a single concept or component. Notebooks are designed for progressive learning where earlier notebooks teach fundamentals (LLM basics, prompt engineering) and later notebooks build on those concepts (RAG pipeline, evaluation). Each notebook includes executable code cells, explanatory markdown, and exercises for hands-on practice. The notebook format enables interactive learning where developers can modify code and see results immediately without setting up complex projects.

Abstracts embedding generation across multiple providers (OpenAI, local models) through a unified interface, converting text chunks into fixed-dimensional vectors (1536-dim for OpenAI). The implementation handles API authentication, batch processing, rate limiting, and error recovery transparently. Embeddings are generated once during knowledge base construction and cached in ChromaDB, avoiding redundant API calls during retrieval. The abstraction layer enables swapping embedding providers without modifying downstream retrieval logic.

Integrates ChromaDB as the vector store backend, handling vector persistence, indexing, and similarity search operations. Documents are stored with their embeddings and metadata in ChromaDB collections, enabling fast approximate nearest-neighbor (ANN) search to retrieve top-k relevant chunks for a given query. The integration abstracts ChromaDB's API behind LangChain's VectorStore interface, allowing queries to be executed with a single method call while ChromaDB handles index optimization and distance metric computation (cosine similarity by default).

Abstracts LLM inference across multiple providers (OpenAI, Anthropic, local models via Ollama) through LangChain's LLM interface, handling authentication, request formatting, and response parsing. Implements prompt templating using LangChain's PromptTemplate class, enabling dynamic insertion of retrieved context and user queries into structured prompts. The implementation demonstrates prompt engineering best practices including clear instructions, context formatting, and chain-of-thought patterns. Provider switching is achieved by changing a single configuration parameter without modifying downstream chain logic.

Composes a complete QA chain by connecting retrieval, prompt templating, and LLM inference using LangChain's Chain abstraction. The implementation follows the pattern: (1) embed user query, (2) retrieve top-k similar documents from ChromaDB, (3) format retrieved context into prompt template, (4) send augmented prompt to LLM, (5) parse and return response. This chain composition enables complex multi-step reasoning where each component's output feeds into the next. The abstraction allows chaining additional steps (e.g., response validation, citation extraction) without modifying core logic.

Teaches prompt engineering fundamentals through executable examples demonstrating clear instruction design, context framing, and chain-of-thought patterns. The implementation shows how prompt structure impacts LLM response quality, including techniques like: (1) explicit role definition ('You are a helpful assistant'), (2) clear task description with examples, (3) context insertion with source attribution, (4) output format specification. Prompt templates are parameterized using LangChain's PromptTemplate, enabling dynamic insertion of retrieved context and user queries while maintaining consistent instruction structure across requests.

Provides a Streamlit-based web interface for deploying RAG applications without frontend development expertise. The implementation handles session state management for conversation history, file upload for document ingestion, and real-time streaming of LLM responses. Streamlit abstracts HTML/CSS/JavaScript complexity, enabling developers to build interactive UIs with pure Python. The interface includes controls for retrieval parameters (top_k, similarity threshold) and LLM settings (temperature, max_tokens), enabling end-users to tune system behavior without code changes.

Provides methods for evaluating and optimizing retrieval performance, including metrics for measuring whether the correct documents are being retrieved for given queries. The implementation covers: (1) precision/recall evaluation using labeled query-document pairs, (2) similarity score analysis to understand retrieval confidence, (3) chunk size/overlap optimization through empirical testing, (4) embedding model comparison (OpenAI vs local models). Evaluation results guide optimization decisions such as adjusting chunk size, changing embedding providers, or refining document preprocessing.

Provides methods for evaluating the quality of generated responses, including semantic similarity metrics (BLEU, ROUGE, cosine similarity to reference answers) and human evaluation frameworks. The implementation demonstrates how to measure whether generated answers are factually grounded in retrieved documents, whether they answer the user's question, and whether they match reference answers. Evaluation results guide prompt optimization and retrieval parameter tuning. The framework includes both automated metrics (fast, scalable) and human evaluation guidelines (more accurate but expensive).