@adminide-stack/yantra-help-browser 12.0.16-alpha.27 → 12.0.16-alpha.29

package/lib/templates/content/technical-questions/performance-optimization.md

@@ -1,83 +1,105 @@
 # Performance Optimization
 
-Technical optimizations for speed and efficiency.
+How Yantra achieves sub-second response times at scale — and how you can get the most out of the platform.
 
-## System Performance
+---
 
-### Response Time Optimization
+## System Performance Targets
 
-- **Query Optimization**: Database query optimization
-- **Caching Strategies**: Intelligent caching
-- **CDN Integration**: Content delivery network
-- **Load Balancing**: Advanced load balancing
+| Metric                    | Target         | Current        |
+| ------------------------- | -------------- | -------------- |
+| Search latency (P50)      | < 200 ms       | 145 ms         |
+| Search latency (P99)      | < 1 s          | 780 ms         |
+| AI response latency (P50) | < 800 ms       | 620 ms         |
+| API uptime                | 99.95%         | 99.98%         |
+| Throughput                | 10,000 req/min | 14,200 req/min |
 
-### Throughput Optimization
+---
 
-- **Parallel Processing**: Multi-threaded processing
-- **Async Operations**: Asynchronous operations
-- **Connection Pooling**: Database connection pooling
-- **Resource Management**: Efficient resource management
+## Caching Strategy
+
+Yantra uses a **multi-layer caching architecture** to minimize redundant computation:
+
+### Layer 1 — Edge cache (CDN)
+
+Static assets and frequently requested API responses are cached at 200+ edge locations worldwide. Cache hit rates typically exceed 85%.
+
+### Layer 2 — Application cache (Redis)
+
+- **Query result cache** — Identical queries return cached results within 5 ms.
+- **Session cache** — User sessions and preferences are stored in Redis for instant access.
+- **Embedding cache** — Pre-computed embeddings for popular documents avoid redundant inference.
+
+### Layer 3 — Database cache
+
+- **Connection pooling** — PgBouncer maintains a pool of warm database connections, eliminating connection overhead.
+- **Materialized views** — Complex aggregation queries use pre-computed materialized views refreshed every 5 minutes.
+- **Query plan caching** — PostgreSQL's prepared statements reuse optimized query plans.
+
+---
 
 ## Database Optimization
 
-### Query Performance
+### Indexing strategy
 
-- **Index Optimization**: Database index optimization
-- **Query Analysis**: Query performance analysis
-- **Execution Plans**: Query execution optimization
-- **Connection Optimization**: Database connection optimization
+- **B-tree indexes** on primary keys and frequently filtered columns.
+- **GIN indexes** on JSONB fields for flexible metadata queries.
+- **Partial indexes** on hot data subsets (e.g., active users, recent content).
+- **Covering indexes** that include all queried columns to avoid table lookups.
 
-### Storage Optimization
+### Query optimization
 
-- **Data Partitioning**: Database partitioning
-- **Compression**: Data compression techniques
-- **Archiving**: Data archiving strategies
-- **Cleanup**: Automated data cleanup
+Every query is analyzed for:
 
-## Application Optimization
+1. **Execution plan review** — EXPLAIN ANALYZE is run on all new queries during code review.
+2. **N+1 detection** — Automated detection of N+1 query patterns in development.
+3. **Slow query logging** — Queries exceeding 100 ms are logged and reviewed weekly.
+4. **Connection management** — Read replicas handle analytics queries to keep the primary database responsive.
 
-### Code Optimization
+---
 
-- **Algorithm Optimization**: Algorithm efficiency
-- **Memory Management**: Memory optimization
-- **CPU Optimization**: CPU usage optimization
-- **I/O Optimization**: Input/output optimization
+## Application-Level Optimization
 
-### Framework Optimization
+### Frontend performance
 
-- **Framework Tuning**: Framework configuration
-- **Middleware Optimization**: Middleware performance
-- **Library Optimization**: Third-party library optimization
-- **Dependency Management**: Dependency optimization
+- **Code splitting** — Routes are lazy-loaded so users only download the JavaScript they need.
+- **Image optimization** — All images are served in WebP/AVIF format with responsive srcsets.
+- **Prefetching** — The most likely next navigation target is prefetched in the background.
+- **Bundle analysis** — We maintain strict bundle size budgets (< 200 KB initial JS, < 50 KB CSS).
 
-## Infrastructure Optimization
+### Backend performance
 
-### Server Optimization
+- **Async I/O** — All I/O-bound operations (database queries, API calls, file reads) are non-blocking.
+- **Worker pools** — CPU-intensive tasks (embedding generation, document parsing) run in dedicated worker processes.
+- **Streaming responses** — AI-generated responses stream token-by-token for perceived instant feedback.
+- **Graceful degradation** — If a dependency is slow, the system returns partial results rather than timing out entirely.
 
-- **Hardware Optimization**: Hardware configuration
-- **OS Tuning**: Operating system tuning
-- **Network Optimization**: Network performance
-- **Storage Optimization**: Storage performance
+---
+
+## Infrastructure Optimization
 
-### Cloud Optimization
+### Auto-scaling
 
-- **Resource Allocation**: Optimal resource allocation
-- **Auto-scaling**: Intelligent auto-scaling
-- **Cost Optimization**: Cloud cost optimization
-- **Performance Monitoring**: Performance monitoring
+| Component              | Scaling metric                | Scale range        |
+| ---------------------- | ----------------------------- | ------------------ |
+| API servers            | Request rate + latency        | 4 to 64 pods       |
+| AI workers             | GPU utilization + queue depth | 2 to 16 nodes      |
+| Kafka consumers        | Consumer lag                  | 3 to 24 partitions |
+| Database read replicas | Connection count              | 1 to 4 replicas    |
 
-## Monitoring and Profiling
+### Cost optimization
 
-### Performance Monitoring
+- **Spot instances** for batch processing workloads (60% cost savings).
+- **Reserved instances** for always-on services (40% cost savings).
+- **Right-sizing** — Monthly reviews of resource utilization with automated recommendations.
+- **Tiered storage** — Infrequently accessed data is automatically moved to cheaper storage tiers.
 
-- **Real-time Monitoring**: Real-time performance monitoring
-- **Metrics Collection**: Performance metrics collection
-- **Alerting**: Performance alerting
-- **Dashboards**: Performance dashboards
+---
 
-### Profiling Tools
+## Tips for Optimizing Your Experience
 
-- **Application Profiling**: Application performance profiling
-- **Database Profiling**: Database performance profiling
-- **Network Profiling**: Network performance profiling
-- **System Profiling**: System performance profiling
+1. **Use specific queries** — More precise queries return faster, more relevant results.
+2. **Apply filters** — Narrowing by date, source, or content type reduces the search space.
+3. **Enable caching** — For API integrations, respect cache headers to avoid unnecessary requests.
+4. **Use batch endpoints** — Bundle multiple operations into a single batch request.
+5. **Monitor your usage** — The Dashboard shows your API usage patterns and suggests optimizations.

package/lib/templates/content/technical-questions/search-algorithms.md

@@ -1,83 +1,105 @@
-# Search Algorithms
+# Search Algorithms & Ranking
 
-Technical details about Yantra's search algorithms.
+How Yantra finds the most relevant results in milliseconds — the algorithms, ranking signals, and optimizations behind the search experience.
+
+---
 
 ## Search Architecture
 
-### Core Algorithms
+Yantra's search system combines **three complementary approaches** to deliver highly relevant results:
 
-- **Vector Search**: Semantic vector search
-- **Keyword Search**: Traditional keyword matching
-- **Hybrid Search**: Combined vector and keyword search
-- **Ranking Algorithms**: Advanced ranking algorithms
+### 1. Keyword search (BM25)
 
-### Search Pipeline
+Traditional lexical matching using the BM25 algorithm. This excels at exact-match queries where the user knows specific terms.
 
-- **Query Processing**: Query analysis and processing
-- **Index Lookup**: Search index lookup
-- **Result Ranking**: Result ranking and scoring
-- **Result Filtering**: Result filtering and refinement
+- **How it works** — Documents are scored based on term frequency (TF), inverse document frequency (IDF), and document length normalization.
+- **Best for** — Error codes, product names, exact phrases, technical identifiers.
 
-## Ranking Algorithms
+### 2. Semantic search (vector similarity)
 
-### Relevance Scoring
+Neural embedding-based search that understands meaning beyond exact words.
 
-- **TF-IDF**: Term frequency-inverse document frequency
-- **BM25**: Best Matching 25 algorithm
-- **Semantic Similarity**: Semantic similarity scoring
-- **User Behavior**: User behavior-based ranking
+- **How it works** — Both the query and documents are converted to high-dimensional vectors. Results are ranked by cosine similarity.
+- **Best for** — Natural language questions, conceptual queries, "how do I..." questions.
 
-### Ranking Factors
+### 3. Hybrid search (default)
 
-- **Content Quality**: Content quality assessment
-- **Source Authority**: Source authority scoring
-- **Recency**: Content recency scoring
-- **User Preferences**: Personalized ranking
+Combines keyword and semantic results using **Reciprocal Rank Fusion (RRF)**, producing results that are both lexically precise and semantically relevant.
 
-## Indexing System
+```
+RRF_score = sum(1 / (k + rank_i)) for each ranking system i
+```
 
-### Search Index
+This is Yantra's default search mode and performs best for most queries.
 
-- **Inverted Index**: Traditional inverted index
-- **Vector Index**: Semantic vector index
-- **Metadata Index**: Metadata indexing
-- **Full-text Index**: Full-text search index
+---
 
-### Index Management
+## Ranking Signals
 
-- **Index Updates**: Real-time index updates
-- **Index Optimization**: Index optimization
-- **Index Partitioning**: Index partitioning
-- **Index Backup**: Index backup and recovery
+After initial retrieval, results are re-ranked using a learned ranking model that weighs multiple signals:
 
-## Query Processing
+| Signal            | Weight | Description                                          |
+| ----------------- | ------ | ---------------------------------------------------- |
+| Text relevance    | 35%    | BM25 + semantic similarity combined score            |
+| Source authority  | 20%    | Domain reputation, citation count, editorial quality |
+| Content freshness | 15%    | Recency of creation or last update                   |
+| User engagement   | 15%    | Click-through rate, time-on-page, bookmarks          |
+| Personalization   | 10%    | User's search history, preferred sources, role       |
+| Content quality   | 5%     | Readability score, completeness, structure           |
+
+### Boosting and suppression
 
-### Query Analysis
+- **Recency boost** — Content published in the last 30 days receives a configurable relevance boost.
+- **Source pinning** — Admins can pin trusted sources to always appear in the top results.
+- **Duplicate suppression** — Near-duplicate documents (> 85% similarity) are collapsed, showing only the highest-quality version.
+
+---
+
+## Indexing System
 
-- **Query Parsing**: Natural language query parsing
-- **Query Expansion**: Query expansion techniques
-- **Query Optimization**: Query optimization
-- **Query Caching**: Query result caching
+### How content gets indexed
+
+1. **Document intake** — New or updated content enters the indexing queue via the data pipeline.
+2. **Analysis** — The document is processed through language-specific analyzers (tokenization, stemming, synonym expansion).
+3. **Embedding** — A vector representation is generated using the configured embedding model.
+4. **Storage** — The analyzed text, metadata, and vector are written to Elasticsearch shards.
+5. **Availability** — The document becomes searchable within 1-2 seconds (near real-time).
+
+### Index management
+
+- **Shard allocation** — Each index is distributed across multiple shards for parallel query execution.
+- **Replica configuration** — Each shard has at least one replica for fault tolerance and read throughput.
+- **Index lifecycle** — Older indexes are automatically merged, force-merged, or moved to warm storage based on access patterns.
+
+---
+
+## Query Processing
 
-### Intent Recognition
+### What happens when you search
 
-- **Intent Classification**: User intent classification
-- **Entity Recognition**: Named entity recognition
-- **Context Understanding**: Context analysis
-- **Query Disambiguation**: Query disambiguation
+1. **Query parsing** — The raw input is tokenized and analyzed using the same pipeline as indexed documents.
+2. **Query expansion** — Synonyms and related terms are added automatically (e.g., "k8s" expands to "kubernetes").
+3. **Spell correction** — Common typos are detected and corrected using edit-distance algorithms.
+4. **Intent detection** — The system classifies whether the user wants a factual answer, a list, a comparison, or a how-to guide.
+5. **Execution** — The query runs against both keyword and vector indexes in parallel.
+6. **Fusion + re-ranking** — Results are merged via RRF, then re-ranked by the learned ranking model.
+7. **Response assembly** — Top results are formatted with highlighted snippets and source metadata.
 
-## Performance Optimization
+---
 
-### Search Performance
+## Performance
 
-- **Response Time**: Sub-second response times
-- **Throughput**: High query throughput
-- **Scalability**: Horizontal scaling
-- **Caching**: Multi-layer caching
+| Metric                     | Value                         |
+| -------------------------- | ----------------------------- |
+| Average search latency     | 145 ms                        |
+| P99 search latency         | < 780 ms                      |
+| Index refresh interval     | 1 second                      |
+| Maximum concurrent queries | 12,000/sec                    |
+| Index size                 | 500M+ documents across 8.7 TB |
 
-### Optimization Techniques
+### Optimization techniques
 
-- **Index Optimization**: Search index optimization
-- **Query Optimization**: Query performance optimization
-- **Caching Strategies**: Intelligent caching
-- **Load Balancing**: Search load balancing
+- **Query caching** — Identical queries are served from Redis cache (5-minute TTL).
+- **Shard routing** — Queries are routed to the shard most likely to contain relevant results.
+- **Early termination** — If the top results are already confident, remaining shards stop processing.
+- **Parallel execution** — Keyword and vector searches run concurrently, not sequentially.

package/lib/templates/content/technical-questions/technical-overview.md

@@ -1,83 +1,107 @@
-# Technical Overview
+# Technical Architecture Overview
 
-Technical architecture and implementation details.
+A high-level look at Yantra's system design, technology choices, and engineering principles.
+
+---
 
 ## System Architecture
 
-### Core Components
+Yantra is built as a collection of loosely coupled **microservices** communicating over gRPC and async message queues. This design enables independent scaling, deployment, and fault isolation.
 
-- **Search Engine**: Advanced search processing engine
-- **AI Integration**: Multiple AI model integration
-- **Data Processing**: Real-time data processing pipeline
-- **API Layer**: RESTful API architecture
+### Core components
 
-### Infrastructure
+| Component            | Responsibility                                        | Technology                       |
+| -------------------- | ----------------------------------------------------- | -------------------------------- |
+| API Gateway          | Request routing, auth, rate limiting                  | Kong / custom middleware         |
+| Search Service       | Query processing, ranking, retrieval                  | Elasticsearch + custom vector DB |
+| AI Service           | Model inference, prompt assembly, response generation | Python (FastAPI) + GPU clusters  |
+| Data Pipeline        | Content ingestion, processing, indexing               | Apache Kafka + Kafka Streams     |
+| User Service         | Authentication, profiles, preferences                 | Node.js (Express) + PostgreSQL   |
+| Notification Service | Real-time alerts, webhooks, emails                    | Go (Gin) + Redis Pub/Sub         |
+
+### Communication patterns
 
-- **Cloud Infrastructure**: Scalable cloud infrastructure
-- **Microservices**: Microservices architecture
-- **Load Balancing**: Advanced load balancing
-- **Caching**: Multi-layer caching system
+- **Synchronous** — REST/gRPC for user-facing requests where latency matters.
+- **Asynchronous** — Kafka events for background processing (indexing, analytics, notifications).
+- **Pub/Sub** — Redis for real-time features (live search updates, collaborative cursors).
+
+---
 
 ## Technology Stack
 
-### Backend Technologies
+### Backend
 
-- **Programming Languages**: Python, Node.js, Go
-- **Frameworks**: FastAPI, Express.js, Gin
-- **Databases**: PostgreSQL, Redis, Elasticsearch
-- **Message Queues**: Apache Kafka, RabbitMQ
+| Layer         | Technologies                              |
+| ------------- | ----------------------------------------- |
+| Languages     | Python 3.12, Node.js 20, Go 1.22          |
+| Frameworks    | FastAPI, Express.js, Gin                  |
+| Databases     | PostgreSQL 16, Redis 7, Elasticsearch 8.x |
+| Message Queue | Apache Kafka 3.7                          |
+| ML/AI         | PyTorch, vLLM, LangChain                  |
 
-### Frontend Technologies
+### Frontend
 
-- **Web Framework**: React, TypeScript
-- **Mobile**: React Native, Flutter
-- **Build Tools**: Webpack, Vite, Rollup
-- **Testing**: Jest, Cypress, Playwright
+| Layer     | Technologies                 |
+| --------- | ---------------------------- |
+| Framework | React 18 + TypeScript 5      |
+| Routing   | Remix (SSR)                  |
+| Styling   | Tailwind CSS + shadcn/ui     |
+| State     | Zustand + React Query        |
+| Mobile    | React Native (iOS & Android) |
+
+### Infrastructure
+
+| Layer             | Technologies                        |
+| ----------------- | ----------------------------------- |
+| Container runtime | Docker + Kubernetes (EKS)           |
+| CI/CD             | GitHub Actions + ArgoCD             |
+| Monitoring        | Prometheus, Grafana, Sentry         |
+| CDN               | CloudFront + edge caching           |
+| DNS               | Route 53 with latency-based routing |
+
+---
 
 ## AI Integration
 
-### Model Architecture
+### Multi-model approach
 
-- **GPT Integration**: OpenAI GPT model integration
-- **Claude Integration**: Anthropic Claude integration
-- **Custom Models**: Proprietary model development
-- **Model Selection**: Intelligent model routing
+Rather than being locked into a single AI provider, Yantra maintains integrations with multiple model providers:
 
-### Processing Pipeline
+- **OpenAI** (GPT-4o, text-embedding-3-large)
+- **Anthropic** (Claude 3.5 Sonnet, Claude 3 Haiku)
+- **Open-source** (Llama 3, Mistral) for on-premise deployments
 
-- **Query Analysis**: Natural language query analysis
-- **Intent Recognition**: User intent recognition
-- **Context Management**: Conversation context management
-- **Response Generation**: AI response generation
+The **Intelligent Router** selects the best model for each request based on task type, latency requirements, and cost constraints.
 
-## Data Architecture
+### RAG (Retrieval-Augmented Generation)
 
-### Data Storage
+Yantra's core AI workflow follows the RAG pattern:
 
-- **Primary Database**: PostgreSQL for structured data
-- **Search Index**: Elasticsearch for search functionality
-- **Cache Layer**: Redis for high-speed caching
-- **File Storage**: S3-compatible object storage
+1. **Retrieve** relevant documents from the vector index based on the user's query.
+2. **Augment** the prompt with retrieved context, conversation history, and system instructions.
+3. **Generate** a grounded response that cites specific sources.
 
-### Data Processing
+This approach ensures responses are factually anchored to your data rather than relying solely on the model's training data.
 
-- **ETL Pipelines**: Extract, transform, load processes
-- **Real-time Processing**: Stream processing with Kafka
-- **Data Validation**: Comprehensive data validation
-- **Data Quality**: Data quality monitoring
+---
 
 ## Security Architecture
 
-### Security Measures
+### Defense in depth
 
-- **Authentication**: Multi-factor authentication
-- **Authorization**: Role-based access control
-- **Encryption**: End-to-end encryption
-- **Network Security**: Network-level security
+| Layer       | Measures                                                   |
+| ----------- | ---------------------------------------------------------- |
+| Network     | VPC isolation, WAF, DDoS protection, private subnets       |
+| Application | Input validation, CSRF protection, Content Security Policy |
+| Data        | AES-256 encryption at rest, TLS 1.3 in transit             |
+| Access      | RBAC, MFA, API key rotation, session management            |
+| Audit       | Immutable audit logs, real-time anomaly detection          |
 
 ### Compliance
 
-- **GDPR Compliance**: European data protection compliance
-- **SOC 2**: Security and compliance certification
-- **ISO 27001**: Information security management
-- **Privacy by Design**: Privacy-first architecture
+Yantra maintains the following certifications and compliance standards:
+
+- **SOC 2 Type II** — Independently audited annually
+- **GDPR** — Full compliance with EU data protection regulations
+- **ISO 27001** — Information security management certification
+- **HIPAA** — Available for healthcare customers on Enterprise plans

package/lib/templates/content/threads/conversation-management.md

@@ -1,67 +1,103 @@
 # Conversation Management
 
-Managing and organizing your conversation threads.
+Tips and tools for keeping your Yantra conversations organized, productive, and easy to find.
 
-## Thread Management
+---
 
-### Creating Conversations
+## Organizing Conversations
 
-- **New Thread**: Start new conversation thread
-- **Topic Definition**: Define conversation topic
-- **Context Setting**: Set conversation context
-- **Participant Invitation**: Invite conversation participants
+### Naming threads
 
-### Organizing Threads
+By default, threads are named after your first query. Rename them for better organization:
 
-- **Topic Grouping**: Group threads by topic
-- **Priority Setting**: Set thread priorities
-- **Status Tracking**: Track thread status
-- **Archive Management**: Archive completed threads
+1. Click the thread title in the sidebar or at the top of the conversation.
+2. Type a descriptive name (e.g., "React performance optimization research").
+3. Press Enter.
 
-## Conversation Features
+### Pinning important threads
 
-### Context Preservation
+Pin threads you reference frequently:
 
-- **History Tracking**: Track conversation history
-- **Reference Linking**: Link to previous discussions
-- **Context Awareness**: Maintain context across messages
-- **Follow-up Management**: Manage follow-up questions
+- Click **⋯** > **Pin** on any thread.
+- Pinned threads stay at the top of the sidebar, regardless of age.
+- Unpin anytime via **⋯** > **Unpin**.
 
-### Collaboration Tools
+### Tagging
 
-- **Member Roles**: Assign conversation roles
-- **Permission Control**: Control conversation permissions
-- **Activity Monitoring**: Monitor conversation activity
-- **Communication Tools**: Use built-in communication tools
+Add tags to threads for categorization:
 
-## Thread Organization
+- Click the tag icon in the thread header.
+- Add tags like "work," "personal," "research," "client: Acme Corp."
+- Filter the thread list by tag.
 
-### Structure Management
+---
 
-- **Hierarchical Organization**: Organize threads hierarchically
-- **Category System**: Use category system
-- **Tagging System**: Tag conversations for easy finding
-- **Search Functionality**: Search within conversations
+## Thread Actions
 
-### Content Management
+| Action         | Shortcut (Mac) | Shortcut (Windows) | Description                               |
+| -------------- | -------------- | ------------------ | ----------------------------------------- |
+| New thread     | ⌘ + N          | Ctrl + N           | Start a fresh conversation                |
+| Search threads | ⌘ + F          | Ctrl + F           | Find threads by keyword                   |
+| Pin/unpin      | —              | —                  | Keep threads accessible                   |
+| Archive        | —              | —                  | Move to archive (not deleted)             |
+| Delete         | —              | —                  | Permanently remove (30-day recovery)      |
+| Export         | —              | —                  | Download as Markdown, PDF, or text        |
+| Branch         | —              | —                  | Fork the conversation at a specific point |
 
-- **Message Organization**: Organize messages within threads
-- **Attachment Management**: Manage file attachments
-- **Link Management**: Manage external links
-- **Citation Tracking**: Track source citations
+---
 
-## Advanced Features
+## Branching Conversations
 
-### Thread Analytics
+When a conversation takes you in an unexpected direction, branch it instead of cluttering the original thread:
 
-- **Participation Metrics**: Track participation metrics
-- **Activity Analysis**: Analyze conversation activity
-- **Engagement Tracking**: Track engagement levels
-- **Productivity Metrics**: Measure conversation productivity
+1. Hover over any message in the thread.
+2. Click the **Branch** icon.
+3. A new thread is created with the conversation history up to that point.
+4. Continue the original thread and the branch independently.
 
-### Integration Features
+This is especially useful for:
 
-- **External Tools**: Integrate with external tools
-- **API Access**: Programmatic access to threads
-- **Export Options**: Export conversation data
-- **Sync Capabilities**: Sync across devices
+- Exploring "what if" scenarios
+- Separating sub-topics into their own threads
+- Trying different approaches without losing the original context
+
+---
+
+## Search and Filter
+
+### Full-text search
+
+Search across all your conversations:
+
+- Search by **keywords** in your messages or Yantra's responses.
+- Search by **date range** to find conversations from a specific period.
+- Search by **search mode** (Regular, Pro, Deep Research).
+
+### Filters
+
+| Filter | Options                                    |
+| ------ | ------------------------------------------ |
+| Date   | Today, this week, this month, custom range |
+| Mode   | Regular, Pro Search, Deep Research         |
+| Tags   | Your custom tags                           |
+| Shared | Only shared threads, only private          |
+
+---
+
+## Auto-Cleanup
+
+Configure automatic thread management:
+
+- **Auto-archive** — Threads with no activity for X days are archived (default: 90 days).
+- **Auto-delete** — Archived threads are deleted after X days (default: never).
+- **Configurable** — Adjust at **Settings > Preferences > Threads**.
+
+---
+
+## Best Practices
+
+1. **One topic per thread** — Keeps context clean and makes threads easier to find later.
+2. **Name your threads** — A good name saves time when searching later.
+3. **Use branches** — Don't let a tangent derail a focused research thread.
+4. **Pin active projects** — Keep your current focus areas at the top.
+5. **Archive regularly** — A clean sidebar helps you focus on what matters now.