Skip to main content

Project Overview

AllMyChats is an AI-powered message analysis and organization platform that helps users make sense of their chat conversations. The application automatically imports, categorizes, and analyzes messages from WhatsApp and other messaging platforms using Large Language Models (LLMs).

What is AllMyChats?​

AllMyChats is a full-stack web application that solves the problem of message overload in modern communication. With the explosion of messaging apps, people accumulate thousands of messages across multiple conversations, making it nearly impossible to:

  • Find important information buried in chats
  • Understand patterns in communication
  • Organize messages by topic or purpose
  • Extract insights from conversation history

AllMyChats addresses these challenges by providing AI-powered tools that automatically organize, categorize, and analyze your chat history.

The Problem: Message Chaos​

Modern messaging creates several pain points:

  • Information Silos: Important messages get lost in endless chat threads
  • No Organization: Messages exist only in chronological order, not by topic
  • Search Limitations: Basic text search doesn't understand context or intent
  • No Insights: Users can't easily see communication patterns or trends
  • Platform Fragmentation: Conversations spread across WhatsApp, Telegram, iMessage, etc.

Our Solution: AI-Powered Organization​

AllMyChats uses artificial intelligence to:

  1. Import messages from any platform (WhatsApp exports, text files, etc.)
  2. Categorize automatically using LLMs that understand message content and context
  3. Enable smart search that finds messages by meaning, not just keywords
  4. Provide insights into communication patterns and trends
  5. Offer conversational AI to chat with your message history

Key Features​

Currently Available (v1.0 Beta)​

Chat Import​

  • File Upload: Import chat exports in .txt format from any messaging platform
  • Copy-Paste: Paste messages directly into the interface
  • WhatsApp Support: Optimized parser for WhatsApp chat exports
  • Batch Processing: Handle large conversation files (up to 25MB)

AI-Powered Categorization​

  • Automatic Sorting: LLMs analyze and categorize messages by topic, intent, or purpose
  • Custom Categories: Create your own category taxonomy (e.g., "Work", "Personal", "Orders")
  • Multi-Provider Support: Works with Claude, GPT-4, GLM, and other LLMs
  • Confidence Scoring: See how confident the AI is about each categorization

Search & Filter​

  • Full-Text Search: Search across all imported conversations
  • Category Filtering: View messages by category
  • Date Range: Filter messages by time period
  • Sender Filtering: Find messages from specific contacts

Category Management​

  • Create Categories: Define custom categories with descriptions
  • CRUD Operations: Full create, read, update, delete functionality
  • Color Coding: Visual organization with category colors
  • Category Stats: See how many messages are in each category

Dashboard​

  • Message Statistics: Overview of total messages, categories, conversations
  • Recent Activity: Track latest imports and categorizations
  • Quick Actions: Easy access to common tasks

User Accounts​

  • Email/Password Auth: Secure authentication with Better Auth
  • Session Management: Persistent login with secure sessions
  • Profile Management: Update user information and preferences

Coming Soon​

Real-Time Sync​

  • Live message synchronization from WhatsApp
  • Automatic background import
  • Webhook-based message ingestion

AI Chat Assistant​

  • Conversational interface to query your messages
  • Ask questions like "What did John say about the project deadline?"
  • Natural language search powered by LLMs

Advanced Analytics​

  • Sentiment Analysis: Understand emotional tone of conversations
  • Communication Patterns: See when you're most active, who you talk to most
  • Topic Trends: Track how conversation topics evolve over time
  • Visual Charts: Graphs and visualizations of chat insights

Export & Integration​

  • Export categorized messages to CSV, JSON, PDF
  • Integration with other productivity tools
  • API access for developers

Tech Stack​

AllMyChats is built with modern, developer-friendly technologies:

Core Framework​

  • TanStack Start: Full-stack React framework with file-based routing
  • React 19: Latest React with concurrent features
  • TypeScript: Full type safety across frontend and backend

Database & ORM​

  • PostgreSQL: Robust relational database
  • Drizzle ORM: Type-safe SQL with excellent DX
  • Docker Compose: Local database containerization

Authentication & Security​

  • Better Auth: Secure, type-safe authentication solution
  • bcrypt: Password hashing
  • Session Management: Secure token-based sessions

AI Integration​

  • LLM-Agnostic Architecture: Support for any AI provider
  • Anthropic Claude: Default AI provider
  • OpenAI GPT-4: Alternative AI provider
  • Zhipu GLM: Chinese AI provider support
  • Extensible Design: Easy to add new providers

Styling & UI​

  • Tailwind CSS 4: Utility-first CSS framework
  • Radix UI: Accessible, unstyled component primitives
  • Lucide Icons: Beautiful icon library
  • Sonner: Toast notifications

State Management & Data Fetching​

  • TanStack Query: Server state management
  • TanStack Router: File-based routing with type safety
  • tRPC: End-to-end typesafe APIs

File Storage​

  • AWS S3 / Cloudflare R2: Cloud object storage
  • Presigned URLs: Direct uploads from browser
  • Multi-provider support: Easy to switch storage providers

Development Tools​

  • Vite: Fast build tool with hot module replacement
  • Playwright: End-to-end testing
  • ESLint & Prettier: Code quality and formatting
  • Husky: Git hooks for pre-commit checks
  • Standard Version: Automated changelog generation

Monitoring & Observability​

  • Sentry: Error tracking and performance monitoring
  • Structured Logging: JSON-based logging system
  • Health Checks: Endpoint monitoring
  • Audit Logging: Track all user actions

High-Level Architecture​

AllMyChats follows a layered architecture with clear separation of concerns:

┌─────────────────────────────────────────────────────────────┐
│                         Routes Layer                         │
│  (File-based routing, page composition, data prefetching)   │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────┐
│                      Components Layer                       │
│           (Reusable UI components, interactions)            │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────┐
│                         Hooks Layer                          │
│      (Custom React hooks, state management, logic)          │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────┐
│                        Queries Layer                         │
│     (TanStack Query definitions, caching, invalidation)     │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────┐
│                    Server Functions Layer                   │
│       (tRPC routers, validation, authentication)            │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────┐
│                    Data Access Layer                         │
│              (Database operations with Drizzle)              │
└──────────────────────────┬──────────────────────────────────┘
                           │
┌──────────────────────────▼──────────────────────────────────┐
│                      PostgreSQL Database                     │
└─────────────────────────────────────────────────────────────┘

Key Architectural Principles​

  1. Layered Design: Each layer has a single responsibility and depends only on the layer below
  2. Type Safety: End-to-end TypeScript with shared types between frontend and backend
  3. LLM Agnostic: All AI features work with any LLM provider
  4. Separation of Concerns: Clear boundaries between UI, business logic, and data access
  5. Scalability: Architecture supports growth in users, messages, and features

Database Schema​

The application uses a comprehensive database schema with the following core entities:

User & Authentication

  • user - User accounts, profiles, subscriptions
  • session - User sessions for authentication
  • account - OAuth and password accounts
  • verification - Email/phone verification codes

Messages & Conversations

  • conversation - Chat conversations (threads)
  • chatMessage - Individual messages in conversations
  • message - Core message entity with rich metadata
  • messageCategory - Many-to-many relationship for categorization

AI & Analysis

  • category - User-defined message categories
  • summary - AI-generated conversation summaries
  • pipelineJob - Async job tracking for AI operations
  • aiUsageLog - LLM usage tracking and cost monitoring

Search & Organization

  • tag - User-defined tags for messages
  • savedFilter - Custom search filters
  • searchHistory - User search query history

Community & Feedback

  • featureRequest - User-submitted feature requests
  • featureVote - Voting on feature requests
  • feedback - User feedback and bug reports

Monitoring & Audit

  • auditLog - Audit trail of all user actions
  • apiKey - API key management for programmatic access
  • apiKeyUsageLog - API key usage tracking

For detailed schema information, see the Architecture Overview documentation.

Project Goals​

Primary Goals​

  1. Solve Message Overload: Help users organize and make sense of their chat history
  2. AI-Powered Insights: Leverage LLMs to understand message content and context
  3. Platform Agnostic: Work with any messaging platform (WhatsApp, Telegram, etc.)
  4. Privacy First: Give users control over their data with self-hosting options
  5. Developer Friendly: Provide APIs for integration and extensibility

Technical Goals​

  1. LLM Agnostic: Support any AI provider without code changes
  2. Type Safe: Full TypeScript coverage with end-to-end type safety
  3. Performance: Handle large chat exports (10,000+ messages) efficiently
  4. Scalability: Architecture supports growth to millions of users
  5. Testability: Comprehensive testing with E2E, integration, and unit tests

User Experience Goals​

  1. Simple Onboarding: Import and analyze messages in under 5 minutes
  2. Intuitive Interface: Clean, modern UI that's easy to navigate
  3. Fast Performance: Responsive UI even with large datasets
  4. Mobile Friendly: Responsive design for all screen sizes
  5. Accessible: WCAG AA compliance for accessibility

Use Cases​

Personal Use​

Organize Personal Messages

  • Categorize messages from friends, family, groups
  • Find important information (addresses, dates, links)
  • Track event planning and coordination
  • Archive sentimental conversations

Professional Use

  • Organize work-related WhatsApp messages
  • Track project discussions and decisions
  • Search for client information or agreements
  • Export categorized messages for reports

Research & Analysis

  • Analyze communication patterns
  • Study group dynamics and engagement
  • Track sentiment over time
  • Extract data for social science research

Business Use​

Customer Support

  • Categorize customer inquiries
  • Track common issues and complaints
  • Search support history
  • Generate insights from customer conversations

Team Communication

  • Organize team chat archives
  • Find decisions and action items
  • Track project progress
  • Onboard new team members with chat history

Compliance & Legal

  • Archive business communications
  • Search for specific discussions or agreements
  • Export messages for legal purposes
  • Maintain audit trails

Developer Use​

API Integration

  • Programmatically import messages
  • Build custom categorization rules
  • Integrate with other tools
  • Create custom dashboards

Research & Development

  • Test AI models on real conversation data
  • Develop new NLP features
  • Experiment with categorization algorithms
  • Benchmark LLM performance

Getting Started​

For Users​

If you're interested in using AllMyChats:

  1. Sign Up: Create an account with your email
  2. Import: Upload your WhatsApp chat export (or paste messages)
  3. Categorize: Let AI automatically categorize your messages
  4. Search: Find messages using smart search
  5. Organize: Create custom categories and filters

See the User Documentation for detailed guides.

For Developers​

If you want to contribute or extend AllMyChats:

  1. Read the Architecture: Understand the system design
  2. Set Up Locally: Follow the Local Development Setup
  3. Explore the Codebase: Check the Project Structure
  4. Make Your First Contribution: See the Contributing Guide
  5. Join the Community: Connect with other developers

See the Developer Documentation for complete technical guides.

Roadmap​

✅ Completed Features (v1.0 Beta)​

  • Multi-Category Support - Full multi-category assignment with AND/OR logic queries
  • AI Chat Assistant - Conversational interface for querying messages and categorization
  • WhatsApp Import - File upload and copy-paste support for chat exports
  • AI-Powered Categorization - Automatic message categorization with confidence scoring
  • Smart Search & Filtering - Full-text search with category, date, and sender filtering
  • Category Management - Complete CRUD operations for custom categories
  • User Authentication - Email/password authentication with secure sessions
  • Dashboard - Message statistics and overview interface

🔄 Currently in Development (Post-Beta)​

  • Real-time WhatsApp sync
  • Sentiment analysis
  • Export functionality (CSV, JSON, PDF)

🔮 Future Roadmap (v1.1 - v1.2)​

Post-Beta Checkpoints (Review Required)​

  1. Stability & Performance Review (2 weeks post-launch)

    • Monitor error rates and performance metrics
    • Gather user feedback and identify pain points
    • Address critical bugs and UX issues

  2. Feature Adoption Analysis (1 month post-launch)

    • Track usage patterns of new features (multi-category, AI chat)
    • Identify which features need improvement or documentation
    • Validate feature roadmap assumptions

  3. Scaling & Optimization (1.5 months post-launch)

    • Optimize database queries for large datasets
    • Improve caching strategies and performance
    • Load testing for higher user volumes

Upcoming Features​

  • Advanced analytics dashboard with charts and graphs
  • Export functionality (CSV, JSON, PDF)
  • Sentiment analysis integration
  • Real-time WhatsApp message sync

🚀 Long Term Vision (v2.0+)​

  • Multi-language support
  • Mobile apps (iOS, Android)
  • Team/collaboration features
  • API for third-party integrations
  • Advanced AI insights (conversation summaries, trend analysis)

Community & Support​

AllMyChats is an open-source project. We welcome contributions, feedback, and ideas.

Next Steps​

Ready to dive deeper?

Welcome to AllMyChats! Let's build the future of message organization together.