Londoolink AI Documentation

An intelligent multi-agent system that securely tracks and links your digital life. Built with cutting-edge AI technology to reduce information overload and boost productivity.

View on GitHub Quick Start API Reference

Multi-Agent AI

Enterprise Security

Semantic Search

Real-time Insights

What is Londoolink AI?

Londoolink AI is a sophisticated multi-agent system that intelligently processes and prioritizes information from various sources including emails, calendars, and social media. By leveraging advanced AI models like GPT-4, Groq, and LangGraph, it reduces information overload and provides actionable insights to boost productivity.

Key Features

Intelligent Multi-Agent System

Coordinated AI agents working together using LangGraph to analyze emails, calendars, and social media for comprehensive insights.

Enterprise-Grade Security

Military-grade AES-256 encryption, Argon2 password hashing, and JWT authentication ensure your data remains secure.

Semantic Search & RAG

ChromaDB-powered vector search enables finding information based on meaning, not just keywords.

Real-time Processing

Groq-powered low-latency inference delivers instant insights and recommendations as data arrives.

Priority Intelligence

AI-driven priority scoring helps you focus on what matters most, reducing decision fatigue.

Modern Responsive UI

Built with Next.js 15 and Tailwind CSS for a beautiful, fast, and mobile-friendly experience.

Technology Stack

Frontend

Next.js 15 (App Router)
TypeScript
Tailwind CSS
shadcn/ui Components

Backend

FastAPI (Python 3.12)
LangGraph & LangChain
PostgreSQL
SQLAlchemy ORM

AI/ML

OpenAI GPT-4
Groq (Fast Inference)
ChromaDB (Vector DB)
Ollama (Local LLM)

Use Cases

For Professionals

Manage multiple inboxes, prioritize meetings, and stay on top of deadlines with AI-powered daily briefings.

For Teams

Coordinate across departments with intelligent priority matrices and automated task delegation.

For Analysts

Extract insights from large volumes of unstructured data using semantic search and AI analysis.

For Entrepreneurs

Stay focused on high-impact tasks while AI handles information triage and prioritization.

Deployment Guide

Quick Start

Deploy Londoolink AI to production in under 15 minutes using Railway (backend) and Netlify (frontend). Both platforms offer generous free tiers perfect for getting started.

Backend (Railway)

Create Railway Account

Visit railway.app and sign up with GitHub

New Project from GitHub

Import your Londoolink-AI repository

Select Backend Directory

Set root directory to /backend

Add PostgreSQL

Add database from Railway's plugin marketplace

Configure Environment

Add required environment variables (see below)

Frontend (Netlify)

Create Netlify Account

Visit netlify.com and sign up

Import from GitHub

Connect your repository

Configure Build Settings

Base: app-frontend

Set Build Command

npm run build

Set Publish Directory

.next or out

Environment Variables

Backend Environment (Railway)

SECRET_KEY=your-super-secret-jwt-key-make-it-long-and-random
ENCRYPTION_KEY=your-32-character-fernet-encryption-key
GROQ_API_KEY=your-groq-api-key-here
OPENAI_API_KEY=your-openai-api-key-here
GEMINI_API_KEY=your-gemini-api-key-here
ENVIRONMENT=production
ALLOWED_ORIGINS=https://your-frontend-url.netlify.app
DATABASE_URL=postgresql://user:pass@host:port/dbname  # Auto-provided by Railway
JWT_ALGORITHM=HS256
ACCESS_TOKEN_EXPIRE_MINUTES=30

Frontend Environment (Netlify)

NEXT_PUBLIC_API_BASE_URL=https://your-backend-url.up.railway.app

Important Notes

After deploying both services, update ALLOWED_ORIGINS in Railway with your actual Netlify URL
Generate a secure SECRET_KEY using: openssl rand -hex 32
Get your API keys from respective platforms (OpenAI, Groq, Gemini)
The DATABASE_URL is automatically provided by Railway when you add PostgreSQL

System Architecture

Londoolink AI follows a modern microservices architecture with intelligent agent orchestration at its core. The system processes data through a sophisticated pipeline designed for scalability, reliability, and intelligent analysis.

Multi-Agent Workflow Architecture

The LangGraph-powered multi-agent system showing how specialized agents (Email, Calendar, Social, Priority) collaborate through stateful orchestration with RAG tools and external service integration.

LangGraph State Flow

Detailed state transitions showing how data flows through the LangGraph coordinator, from initial user query to final briefing generation with error handling and recovery.

Sequential Execution Flow

Step-by-step execution flow showing the temporal sequence of operations from data ingestion through agent processing to final output delivery.

Complete Data Flow

End-to-end data flow from external services through n8n automation, FastAPI endpoints, LangGraph processing, to dual database storage and user presentation.

High-Level Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│                         User Interface                          │
│              (Next.js 15 + TypeScript + Tailwind)              │
└──────────────────────────┬──────────────────────────────────────┘
                           │ HTTPS / JWT Auth
                           ▼
┌─────────────────────────────────────────────────────────────────┐
│                      API Gateway Layer                          │
│                    (FastAPI Endpoints)                          │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │   Auth   │  │  Agents  │  │   RAG    │  │  Search  │      │
│  └──────────┘  └──────────┘  └──────────┘  └──────────┘      │
└──────────────────────────┬──────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────────┐
│                   Multi-Agent Orchestration                     │
│                        (LangGraph)                              │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐      │
│  │  Email   │  │ Calendar │  │ Priority │  │  Social  │      │
│  │  Agent   │  │  Agent   │  │  Agent   │  │  Agent   │      │
│  └─────┬────┘  └─────┬────┘  └─────┬────┘  └─────┬────┘      │
│        └──────────────┼──────────────┼─────────────┘           │
│                       ▼              ▼                          │
│            ┌────────────────────────────┐                       │
│            │    Shared State Object     │                       │
│            │   (Context & Decisions)    │                       │
│            └────────────────────────────┘                       │
└──────────────────────────┬──────────────────────────────────────┘
                           │
      ┌────────────────────┼────────────────────┐
      ▼                    ▼                    ▼
┌──────────┐         ┌──────────┐        ┌──────────┐
│   LLMs   │         │   Data   │        │ External │
│ GPT-4    │         │  Layer   │        │   APIs   │
│ Groq     │         │PostgreSQL│        │  Google  │
│ Ollama   │         │ ChromaDB │        │   n8n    │
└──────────┘         └──────────┘        └──────────┘

Agent System Deep Dive

Email Agent

Capabilities:

• Sentiment analysis of content
• Sender importance scoring
• Urgency detection
• Smart categorization

Output:

• Priority scores (0-1)
• Category labels
• Action items
• Deadline extraction

Calendar Agent

Capabilities:

• Event conflict detection
• Meeting importance assessment
• Time zone optimization
• Recurring pattern analysis

Output:

• Schedule optimization
• Conflict alerts
• Meeting prep time
• Travel time calculations

Priority Agent

Capabilities:

• Cross-domain priority scoring
• Deadline-aware ranking
• Resource allocation
• Decision tree analysis

Output:

• Unified priority matrix
• Task recommendations
• Focus time suggestions
• Delegation opportunities

Social Agent

Capabilities:

• Social sentiment analysis
• Engagement trend detection
• Network relationship mapping
• Content relevance scoring

Output:

• Engagement insights
• Trending topics
• Network analytics
• Posting recommendations

Data Flow Example: Daily Briefing

System Initialization

Load user preferences, historical context, and previous state

Parallel Data Collection

All agents simultaneously gather data from their respective sources

Independent Analysis

Each agent processes data using specialized AI models and algorithms

Cross-Agent Communication

Agents share insights through the LangGraph state object

Priority Synthesis

Priority Agent consolidates all insights into unified recommendations

User Presentation

Frontend displays intelligent briefing with actionable insights

API Reference

Base URL

https://your-backend-url.up.railway.app/api/v1

All endpoints require JWT authentication except for registration and login.

Authentication Endpoints

POST /auth/register

curl -X POST "https://your-backend.railway.app/api/v1/auth/register" \\
  -H "Content-Type: application/json" \\
  -d '{
    "email": "user@example.com",
    "password": "securepassword123"
  }'

POST /auth/login

curl -X POST "https://your-backend.railway.app/api/v1/auth/login" \\
  -H "Content-Type: application/json" \\
  -d '{
    "email": "user@example.com",
    "password": "securepassword123"
  }'

Agent Endpoints

GET /agent/briefing/daily

Get AI-powered daily briefing with prioritized insights

curl -X GET "https://your-backend.railway.app/api/v1/agent/briefing/daily" \\
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

Response includes priority scores, action items, and recommendations

POST /agent/analyze/document

Analyze document content using AI agents

curl -X POST "https://your-backend.railway.app/api/v1/agent/analyze/document" \\
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \\
  -H "Content-Type: application/json" \\
  -d '{
    "content": "Document text here...",
    "type": "email"
  }'

RAG & Search Endpoints

POST /rag/search

Perform semantic search using ChromaDB vector database

curl -X POST "https://your-backend.railway.app/api/v1/rag/search" \\
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \\
  -H "Content-Type: application/json" \\
  -d '{
    "query": "What are my urgent tasks?",
    "limit": 5
  }'

GET /rag/stats

Get RAG pipeline statistics and health

curl -X GET "https://your-backend.railway.app/api/v1/rag/stats" \\
  -H "Authorization: Bearer YOUR_JWT_TOKEN"

Interactive API Documentation

For complete interactive API documentation with request/response examples:

Local Development Setup

Prerequisites

Python 3.12+
uv package manager (recommended)
Docker Desktop (for Windows/Mac) or Docker Engine (Linux)

Getting Started

Clone the Repository

git clone https://github.com/Shakiran-Nannyombi/Londoolink-AI.git

Navigate to the Project Directory
```
cd Londoolink-AI
```
Install Dependencies
```
uv install
```
Start the Development Server
```
uv run
```

Docker Setup (Optional)

If you prefer using Docker, follow these steps:

Build the Docker Image
```
docker build -t londoolink-ai .
```
Run the Docker Container
```
docker run -p 8000:8000 londoolink-ai
```

Access the app at http://localhost:8000.

Security & Privacy

Data Security

Londoolink AI is built with a strong focus on data security and user privacy. We implement industry-standard security practices to protect your data.

• End-to-end encryption for data in transit and at rest
• Regular security audits and vulnerability assessments
• Compliance with GDPR and other data protection regulations

Access Control

We enforce strict access controls to ensure that only authorized users can access sensitive data and functionalities.

• Role-based access control (RBAC) for all users
• Two-factor authentication (2FA) for an extra layer of security
• Regular review and revocation of access rights