Ell-ena: AI Product Manager & Personal Assistant

Ell-ena is a mobile-first, AI-powered Product Manager and Personal Assistant designed to help users manage tasks, create tickets, transcribe meetings, and maintain contextual awareness through natural language interactions.

Go through my Extensive documentation regarding this project in docs folder : https://github.com/Sauhard74/Ell-ena/tree/main/docs

Working Implementation as of 31st March 2025 :

Screen.Recording.2025-04-01.at.3.30.28.AM.1.mov

Project Overview

Ell-ena addresses several challenges faced by knowledge workers, students, and professionals:

Context Switching: Reducing the need to move between different tools
Information Fragmentation: Centralizing important details in one system
Cognitive Load: Offloading the mental effort of tracking tasks and commitments
Enhanced AI Integration: Leveraging modern AI capabilities for natural language understanding

Unlike traditional task managers or note-taking apps, Ell-ena functions as an intelligent assistant that understands relationships between tasks, remembers past interactions, and helps users organize their work seamlessly.

Architecture

The application follows a client-server architecture with clear separation of concerns:

Mobile Frontend (React Native + Expo)

Mobile (React Native)
│
├── Chat UI (Gifted Chat) 📲
│   └── Handles all user input/output
│
├── Task View UI (FlatList, Modals) 🗂️
│   └── Show tasks/tickets dynamically
│
└── Audio Transcription UI 🎤
    └── Record/upload → API → Text

Backend (Fastify + TypeScript)

Backend (Fastify + TypeScript)
│
├── /parse (POST) 🧠
│   └── OpenAI Prompt → JSON Task
│
├── /tasks (GET/POST/PUT/DELETE) 📋
│   └── Task CRUD APIs
│
├── /transcribe (POST) 🧾
│   └── Audio file → Whisper → Summary + Tasks
│
├── /context (GET) 🧠
│   └── Return user memory graph (for RAG)
│
└── Auth (Supabase or Clerk) 🔐
    └── JWT token → User identity

Key Features

Natural Language Task Creation
- Create tasks using everyday language
- AI automatically extracts key details like deadlines, priority, and context
Contextual Awareness
- System remembers past conversations and tasks
- Maintains relationships between tasks, projects, and topics
Meeting Transcription
- Record or upload meeting audio
- Automatically transcribe and extract action items
- Generate task summaries from conversations
Integrated Task Management
- View, filter, and manage tasks across projects
- Track deadlines, priorities, and statuses
- Group related tasks and establish dependencies
Graph-based RAG System
- Retrieval-Augmented Generation for improved context
- Knowledge graph linking tasks, topics, and interactions
- Semantic search across your knowledge base

Tech Stack

Frontend

Framework: React Native with Expo
State Management: Context API & React Hooks
UI Components: Custom components with Gifted Chat for messaging
Navigation: React Navigation
Storage: AsyncStorage for local caching

Backend

Framework: Fastify with TypeScript
Authentication: JWT with Supabase integration
Database: PostgreSQL & Neo4j (graph database)
AI Services: OpenAI API (GPT-4, Whisper, Embeddings)
API Documentation: Swagger/OpenAPI

DevOps

Version Control: Git
API Testing: Insomnia/Postman
Error Tracking: Console logging (Sentry integration planned)

Development Journey

Phase 1: Project Foundation

Requirements Analysis
- Identified core use cases and user flows
- Created detailed Technical Requirements Document
- Established architecture and technology choices
Backend Setup
- Established Fastify server with TypeScript
- Implemented JWT authentication
- Created database schema and models
- Set up mock database for development
Frontend Scaffolding
- Initialized React Native project with Expo
- Implemented navigation structure
- Created API service layer with mock fallbacks
- Built core UI components

Phase 2: Core Functionality

Authentication System
- Implemented user registration and login
- Created secure token handling
- Added persistence with AsyncStorage
Task Management
- Developed CRUD operations for tasks
- Implemented filtering and sorting
- Created task visualization components
- Added status updates and priority management
Chat Interface
- Built conversational UI with Gifted Chat
- Implemented message persistence
- Created typing indicators and timestamps
- Added support for different message types

Phase 3: AI Integration

Natural Language Processing
- Integrated OpenAI API for text processing
- Developed prompt templates for task extraction
- Implemented context-aware responses
- Created structured parsing of natural language
Audio Transcription
- Added audio recording capabilities
- Integrated Whisper API for transcription
- Implemented task extraction from transcripts
- Developed meeting summary generation
Context System
- Designed graph database schema
- Implemented context retrieval system
- Created semantic search capabilities
- Built relationship tracking between entities

Setup Instructions

Prerequisites

Node.js (v16+)
npm or yarn
Expo CLI (npm install -g expo-cli)
PostgreSQL (optional for local development)
Neo4j (optional for local development)
OpenAI API key

Backend Setup

Clone the repository

git clone https://github.com/yourusername/ell-ena.git
cd ell-ena/backend

Install dependencies
```
npm install
```

Create a .env file with the following variables:

# Server
PORT=3000
NODE_ENV=development

# Database
DATABASE_URL=postgresql://username:password@localhost:5432/ellena

# Neo4j
NEO4J_URI=neo4j://localhost:7687
NEO4J_USERNAME=neo4j
NEO4J_PASSWORD=password

# Auth
JWT_SECRET=your-secret-key
TOKEN_EXPIRY=7d

# OpenAI
OPENAI_API_KEY=your-openai-api-key

Start the development server
```
npm run dev
```

Frontend Setup

Navigate to the frontend directory
```
cd ../frontend
```
Install dependencies
```
npm install
```
Create a .env file with:
```
API_URL=http://localhost:3000
```
Start the Expo development server
```
npm start
```
Use Expo Go app on your mobile device or an emulator to test the app

Best Practices & Optimizations

Code Organization

Clean Architecture: Separation of concerns with controllers, services, and data access layers
TypeScript: Strong typing for reduced errors and better developer experience
Modular Components: Reusable UI components with clear responsibilities

Performance Optimizations

API Mocking: Fallback to mock data when services are unavailable
Efficient Rendering: List virtualization for better performance with large datasets
Lazy Loading: Components loaded only when needed
Debounced Searches: Reduced API calls for search operations

Security Measures

JWT Authentication: Secure token-based auth with proper expiration
Request Validation: Schema validation for all API endpoints
Secure Storage: Proper handling of sensitive data
Input Sanitization: Protection against injection attacks

Error Handling

Graceful Degradation: Fallbacks when services are unavailable
User-Friendly Errors: Meaningful error messages for users
Error Boundaries: Component-level error catching in React
Consistent Error Responses: Standardized API error formats

Testing Strategy

Unit Testing: Individual component testing
API Testing: Endpoint validation with Postman/Insomnia
Manual Testing: User flow validation on various devices

API Documentation

Authentication

POST /api/auth/register: Register a new user
POST /api/auth/login: Login with credentials
GET /api/auth/verify: Verify authentication token

Workspaces

GET /api/workspaces: Get all workspaces
POST /api/workspaces: Create a new workspace
GET /api/workspaces/:id: Get a specific workspace
PUT /api/workspaces/:id: Update a workspace
DELETE /api/workspaces/:id: Delete a workspace

Tasks

GET /api/tasks: Get tasks with optional filters
POST /api/tasks: Create a new task
GET /api/tasks/:id: Get a specific task
PUT /api/tasks/:id: Update a task
DELETE /api/tasks/:id: Delete a task

NLP & AI

POST /api/nlp/process-message: Process a chat message
POST /api/nlp/parse-text: Parse text into structured task
POST /api/transcribe: Transcribe audio file

Context

GET /api/context/search: Search contextual information
GET /api/context/task/:taskId: Get context for a specific task

Future Enhancements

Advanced Context Awareness
- Enhanced relationship detection between tasks
- Automatic categorization of tasks and topics
- Improved memory and recall of past interactions
Multi-modal Inputs
- Image processing for text extraction
- Document parsing and summarization
- Voice commands and hands-free operation
Integration Ecosystem
- Calendar integration (Google Calendar, Outlook)
- Email processing and task extraction
- Third-party task manager synchronization
Team Collaboration
- Shared workspaces and task assignments
- Team activity feeds and notifications
- Permission management and role-based access
Advanced Analytics
- Productivity insights and patterns
- Task completion statistics
- Time management recommendations

License

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

Acknowledgements

OpenAI for their powerful language models
The React Native and Expo communities
All contributors to this project

Name		Name	Last commit message	Last commit date
Latest commit History 18 Commits
backend		backend
docs		docs
frontend		frontend
.gitignore		.gitignore
README.md		README.md
systemdesign.png		systemdesign.png

Sauhard74/Ell-ena

Folders and files

Latest commit

History

Repository files navigation