🚀 AI-Powered Message Summarization API

Automatically summarize and categorize conversations from email and Slack using OpenAI's GPT-4. This FastAPI service processes message batches and provides intelligent insights by extracting decisions, issues, and reminders.

✨ Features

• Intelligent Message Summarization - Powered by OpenAI GPT-4 • Automatic Categorization - Extracts decisions, issues, and reminders • PostgreSQL Database Storage - Integrated with Supabase for persistence • LangSmith Integration - Comprehensive LLM monitoring and tracing • Rate Limiting & Validation - Built-in protection against abuse • Comprehensive Logging - Request tracking and error monitoring • Connection Pooling - Reliable database connections • Production Ready - Error handling, validation, and monitoring

🏗️ Modular Architecture & Industry Standards

This API follows enterprise-grade architectural patterns used by major tech companies like Netflix, Uber, and Stripe:

Clean Architecture Layers

┌─────────────────┐
│   Routes/API    │ ← FastAPI endpoints (app/routers/)
├─────────────────┤
│   Services      │ ← Business logic (app/services/)
├─────────────────┤
│   Models        │ ← Data validation (app/models/)
├─────────────────┤
│   Middleware    │ ← Cross-cutting concerns (app/middleware/)
└─────────────────┘

Industry Standard Patterns

• Dependency Injection - Clean service management and testing • Service Layer Pattern - Business logic abstraction • Repository Pattern - Database operations separation • Middleware Architecture - Security, logging, and CORS • Configuration Management - Environment-based settings • Error Handling - Custom exceptions with structured responses • API Versioning - /api/v1 prefix for future compatibility

Benefits

• Maintainable - Easy to find and modify specific functionality • Testable - Each component can be unit tested independently • Scalable - Services can be distributed or extracted to microservices • Team-Friendly - Multiple developers can work on different layers • Production-Ready - Follows 12-Factor App principles

🛠️ Tech Stack

• Backend: FastAPI + Python 3.8+ • AI/ML: OpenAI GPT-4 via LangChain • Database: PostgreSQL (Supabase) • Monitoring: LangSmith for LLM operations • Deployment: Docker-ready with environment configuration

🎯 Use Cases

• Team Meeting Summaries - Automatically extract key points from discussions • Customer Support Analysis - Identify common issues and decisions • Project Status Tracking - Monitor progress through conversation analysis • Automated Report Generation - Create structured summaries from chat logs • Slack Channel Insights - Understand team communication patterns

🚀 Quick Start

Prerequisites

• Python 3.8+ • OpenAI API key • Supabase PostgreSQL database • LangSmith API key (optional)

Installation

1. Clone the repository

   git clone https://github.com/yourusername/email-slack-ai-automation-api.git
   cd email-slack-ai-automation-api

2. Create virtual environment

   python -m venv venv
   source venv/bin/activate  # On Windows: venv\Scripts\activate

3. Install dependencies

   pip install -r requirements.txt

4. Set up environment variables

   cp .env.example .env
   # Edit .env with your actual values

5. Run the API

   uvicorn main:app --reload

⚙️ Configuration

Create a .env file with the following variables:

# OpenAI API Key
OPENAI_API_KEY=your_openai_api_key_here

# Supabase Database URL
SUPABASE_DB_URL=your_supabase_database_url_here

# LangSmith Configuration (Optional)
LANGCHAIN_API_KEY=your_langsmith_api_key_here
LANGCHAIN_PROJECT=email-slack-automation
LANGCHAIN_TRACING_V2=true
LANGCHAIN_ENDPOINT=https://api.smith.langchain.com

📡 API Endpoints

POST /api/v1/summarize

Summarize a batch of messages and extract insights using AI.

Request Body (Single Object):

{
  "source": "email",
  "messages": [
    {
      "sender": "[email protected]",
      "text": "Let's schedule a meeting for next week."
    },
    {
      "sender": "[email protected]", 
      "text": "Great idea! How about Tuesday?"
    }
  ]
}

Request Body (Array Format):

[
  {
    "source": "email",
    "messages": [
      {
        "sender": "[email protected]",
        "text": "Let's schedule a meeting for next week."
      },
      {
        "sender": "[email protected]", 
        "text": "Great idea! How about Tuesday?"
      }
    ]
  }
]

Response:

{
  "success": true,
  "data": {
    "summary": "Team discussed scheduling a meeting for next week, with Tuesday suggested as a potential date.",
    "decisions": ["Schedule meeting for next week"],
    "issues": [],
    "reminders": ["Confirm meeting date"]
  },
  "meta": {
    "saved": true,
    "request_id": "uuid-here",
    "processing_time": 2.34,
    "message_count": 2
  }
}

GET /health

Comprehensive health check for all services.

Response:

{
  "status": "healthy",
  "timestamp": "2024-01-15T10:30:00Z",
  "services": {
    "api": true,
    "llm": true,
    "database": true
  },
  "error": null,
  "database_error": null
}

GET /debug/env

Debug endpoint to check environment configuration.

Response:

{
  "environment": {
    "OPENAI_API_KEY": "set",
    "SUPABASE_URL": "set",
    "SUPABASE_ANON_KEY": "set"
  },
  "config": {
    "max_requests_per_minute": 60,
    "max_message_count": 100,
    "max_text_length": 10000
  }
}

GET /

Root endpoint for basic API status.

Response:

{
  "status": "alive",
  "service": "Email-Slack Automation API",
  "version": "1.0.0",
  "timestamp": "2024-01-15T10:30:00Z"
}

🗄️ Database Schema

The API expects the following tables in your Supabase PostgreSQL database:

-- Messages table
CREATE TABLE messages (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    source VARCHAR(255) NOT NULL,
    sender VARCHAR(255) NOT NULL,
    content TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

-- Summaries table
CREATE TABLE summaries (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    message_ids UUID[] NOT NULL,
    summary TEXT NOT NULL,
    categories JSONB NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

🔒 Security & Rate Limiting

• Rate Limiting: 60 requests per minute per client • Input Validation: Maximum 100 messages per request, 10,000 characters per message • Database Security: Connection pooling with automatic cleanup • Error Handling: Comprehensive logging without exposing sensitive information

📊 Monitoring & Observability

• Request Tracking: Unique request IDs for all operations • Performance Metrics: LLM processing time tracking • LangSmith Integration: Full LLM operation tracing and feedback • Structured Logging: JSON-formatted logs with request context • Health Checks: Database connectivity monitoring

📈 Performance

• Database: Connection pooling for optimal performance • LLM: Async processing with timeout handling • Caching: Built-in rate limiting with memory storage • Monitoring: Real-time performance tracking

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• OpenAI for GPT-4 API access • LangChain for LLM orchestration • FastAPI for the web framework • Supabase for database hosting