When I joined the Coral Hackathon, I didn't start with a fully formed project idea.

In fact, the first two days were spent understanding Coral itself.

I had never worked with Coral MCP or Coral SQL before, so before building anything, I needed to understand:

• What Coral MCP is

• How Coral SQL works

• How different sources can be connected

• How schema discovery works

• What kind of applications Coral enables

By the end of the hackathon, this learning journey became Task Harbor AI, an AI-powered productivity workspace that connects Notion, GitHub, Gmail, and Google Calendar through Coral.

This log documents exactly how I built it and what I learned along the way.

The Problem

Modern productivity information is fragmented.

A developer or student typically manages work across:

• Notion for tasks

• GitHub for development activity

• Gmail for communication

• Google Calendar for scheduling

Each platform contains useful information, but none of them understand each other.

I wanted to build a workspace that could bring these systems together and provide intelligent recommendations based on all available context.

The Idea

Task Harbor AI would act as a unified productivity workspace.

Instead of jumping between multiple applications, users would get:

• Task visibility

• Development visibility

• Email visibility

• Calendar visibility

• AI-generated recommendations

all in one dashboard.

The key challenge was connecting these systems without writing custom integrations for everything.

That's where Coral came in.

Day 1 – Learning Coral Fundamentals

The first day was entirely focused on learning.

I explored:

• Coral MCP

• Coral SQL

• Documentation

• Example projects

• Community discussions

At this stage, I wasn't writing application code.

I was trying to understand:

"What makes Coral different from traditional API integrations?"

The biggest realization was that Coral provides a unified layer over multiple data sources.

Instead of manually integrating separate APIs, Coral allows applications to access connected sources through a consistent interface.

Day 2 – Understanding MCP and Planning the Project

On the second day, I focused on understanding how MCP-based integrations work.

I explored:

• GitHub source integration

• Notion source integration

• Schema discovery

• Coral SQL capabilities

This was also when the idea for Task Harbor AI started taking shape.

I sketched the first architecture:

User
 ↓
Dashboard
 ↓
Coral MCP
 ↓
Notion + GitHub + Gmail + Calendar
 ↓
Insights

The goal became clear:

Build a productivity workspace powered by Coral.

Day 3 – Actual Development Begins

This was the first real development day.

I created the Streamlit dashboard foundation and started building the user interface.

The initial version focused on:

• Dashboard layout

• Workspace overview

• Coral integration layer

I also started connecting external sources through Coral MCP.

The first major milestone was successfully retrieving information from connected services and displaying it inside the dashboard.

At this point, Task Harbor AI was no longer just an idea.

It had become a working application.

Day 4 – Coral SQL and Intelligence Features

This was the most important technical day of the project.

I implemented several Coral-powered features.

Cross-Source Joins

One of the most interesting capabilities of Coral is the ability to correlate information across different sources.

I created a Coral SQL join between:

• Notion tasks

• GitHub notifications

This allowed related work items and development activity to be displayed together.

Instead of isolated information, users could see relationships.

Schema Discovery

Next, I built the Schema Explorer.

Using Coral's metadata capabilities, the dashboard could dynamically discover:

• Sources

• Tables

• Columns

• Sample records

without hardcoding schemas.

This became one of the strongest demonstrations of Coral's capabilities.

Query Caching

Repeated Coral queries were becoming expensive.

To improve responsiveness, I implemented a lightweight caching layer.

Benefits:

• Faster dashboard updates

• Reduced repeated queries

• Better user experience

Multi-Source Reasoning

Finally, I built the Coral Agent Layer.

This layer combines information from:

• Notion

• GitHub

• Calendar

• Gmail

to generate recommendations.

Example:

A Notion task might be identified as important.

The system could then detect related GitHub activity and verify calendar availability before recommending it as the next focus area.

This transformed Task Harbor AI from a dashboard into an intelligent workspace assistant.

Day 5 – Polish, Documentation, and Submission

The final day focused on turning a working project into a polished submission.

Dashboard Redesign

The user interface received a major redesign:

• Premium dark theme

• Improved card layouts

• Better readability

• Coral-focused visual identity

Architecture Documentation

I created an architecture diagram showing:

Task Harbor AI Dashboard
        ↓
      Coral MCP
        ↓
Notion | GitHub | Gmail | Calendar
        ↓
   Coral SQL Engine
        ↓
Cross-Source Intelligence
        ↓
Coral Copilot

This made it easier for judges to understand how the system works.

Demo Video

I recorded and edited the final project demonstration.

The demo showcases:

• Dashboard

• Coral Command Center

• Coral SQL Insights

• Schema Explorer

• Multi-Source Reasoning

while staying under the submission time limit.

README and Documentation

The repository was updated with:

• Architecture

• Screenshots

• Feature descriptions

• Installation guide

• Coral feature mapping

Final Architecture

User
 │
 ▼
Task Harbor AI Dashboard
 │
 ▼
Coral MCP
 │
 ├── Notion
 ├── GitHub
 ├── Gmail
 └── Google Calendar
 │
 ▼
Coral SQL Engine
 │
 ├── Cross-Source Joins
 ├── Schema Discovery
 └── Query Caching
 │
 ▼
Task Harbor AI Agent
 │
 ▼
Multi-Source Reasoning
 │
 ▼
Coral Copilot & Insights

Coral Features Implemented

✅ Coral MCP Integration

✅ Coral SQL Queries

✅ Cross-Source Joins

✅ Schema Discovery

✅ Query Caching

✅ Multi-Source Reasoning

Tech Stack

Frontend

• Streamlit

Backend

• Python

Coral Components

• Coral MCP

• Coral SQL

Data Sources

• Notion

• GitHub

• Gmail

• Google Calendar

Development Tools

• Git

• GitHub

• Claude

• Antigravity

Challenges

GitHub Authentication

One of the biggest challenges was resolving GitHub authentication issues.

Several rounds of debugging were required before live GitHub data could be queried successfully through Coral.

Validating Cross-Source Joins

I needed to ensure that joins were genuinely performed by Coral SQL rather than manually recreated in Python.

This required additional testing and validation.

Dashboard UX

A working dashboard isn't automatically a good dashboard.

Significant effort went into improving:

• Navigation

• Readability

• Layout consistency

• Visual hierarchy

What I Learned

The biggest lesson from this project is that the value of productivity tools is not in the data itself.

The value comes from understanding the relationships between different pieces of information.

Coral made this possible by providing a unified interface for data access, querying, schema discovery, and reasoning.

Instead of spending most of my time building integrations, I was able to focus on building the actual product experience.

Resources

GitHub Repository

https://github.com/sathishreddyakepati/task-harbor-ai

Demo Video

https://youtu.be/taSizqZwlJ0

Thanks for reading, and I hope this Captain's Log helps another builder understand what's possible with Coral MCP and Coral SQL.