Task Tracker using Model Context Protocol (MCP)

A Python-based Task Tracker MCP Server built using the Model Context Protocol (MCP).

The project demonstrates how an MCP server can be used to manage daily work tasks through MCP Tools while storing task information permanently in a SQLite database.

The server is built using FastMCP and can be tested interactively using the MCP Inspector.

Project Overview

The Task Tracker is designed to manage and track daily work activities through an MCP Server.

Users can add work logs, retrieve existing tasks, update task status, delete records, and generate work summaries using MCP Tools.

All task information entered through the MCP interface is stored in:

intern_tracker.db

The project currently demonstrates three important components:

MCP Server
   |
   +-- MCP Tools
   |
   +-- MCP Prompts
   |
   +-- SQLite Database

Related MCP server: Daily Work MCP Server

Features

The current Task Tracker supports:

• Add Daily Work Logs

• List stored Daily Work Logs

• Filter logs based on status

• Update task status to Done

• Delete Daily Work Logs

• Generate work summary

• Automatically calculate the day from the work date

• Automatically assign To Do status to new tasks

• Store all task information permanently in SQLite

• Generate structured Daily Work Log instructions using MCP Prompts

• Test MCP Tools and Prompts through MCP Inspector

Technologies Used

• Python

• Model Context Protocol (MCP)

• FastMCP

• SQLite

• MCP Inspector

• Node.js / NPX

• Visual Studio Code

Project Architecture

                     User / MCP Client
                            |
                            v
                     MCP Inspector
                            |
                            v
                    FastMCP Server
                      (server.py)
                            |
             +--------------+--------------+
             |                             |
             v                             v
        MCP Tools                     MCP Prompts
             |                             |
             |                    Structured Prompt
             |                       Generation
             |
             v
        database.py
             |
             v
          SQLite
             |
             v
     intern_tracker.db
             |
             v
     daily_work_log table

Project Structure

MCP_Server/
│
├── server.py
├── database.py
├── intern_tracker.db
├── requirements.txt
├── README.md
│
├── venv/
│
└── __pycache__/

server.py

Contains the main FastMCP server.

It includes:

• MCP Tools

• MCP Prompts

• Database operations through database.py

• MCP server initialization

database.py

Handles SQLite database functionality including:

• Database connection

• Database initialization

• Table creation

• Database reset functionality

intern_tracker.db

SQLite database used to permanently store Daily Work Log records.

requirements.txt

Contains the Python dependencies required to run the project.

README.md

Contains project documentation, setup instructions, architecture, and usage information.

SQLite Database

The project uses SQLite for persistent task storage.

The database file is:

intern_tracker.db

The main table is:

daily_work_log

Daily Work Log Structure

Task Status Workflow

When a new Daily Work Log is created using:

add_daily_work_log

the task status is automatically set to:

To Do

The status does not need to be entered manually while creating a task.

The task remains:

To Do

until the update_work_status tool is executed.

After updating the work status, it becomes:

Done

Therefore, the basic task lifecycle is:

New Task
   |
   v
 To Do
   |
   | update_work_status
   v
 Done

MCP Tools

The server currently provides five main MCP Tools.

1. add_daily_work_log

Creates a new Daily Work Log and stores it in SQLite.

Inputs

• Work Date

• Task Description

• Deliverables

• Blockers

• Hours Spent

• Notes

Example:

Work Date:
2026-08-05

Task Description:
Implemented SQLite database integration for the MCP Task Tracker.

Deliverables:
Successfully connected MCP tools with SQLite database storage.

Blockers:
N/A

Hours Spent:
8

Notes:
Database integration completed successfully.

The server automatically calculates:

Day

and automatically assigns:

Status: To Do

2. list_daily_work_logs

Retrieves Daily Work Logs stored inside intern_tracker.db.

The tool can return all records or optionally filter them based on status.

Examples:

To Do

or:

Done

This tool is useful for verifying that information entered through the MCP interface has been successfully stored in SQLite.

3. update_work_status

Updates an existing Daily Work Log to:

Done

The tool requires:

Log ID

Example:

Log ID: 5

After execution:

To Do
   |
   v
Done

The updated_at timestamp is also updated.

4. delete_daily_work_log

Deletes an existing Daily Work Log from the SQLite database.

The tool requires the:

Log ID

Example:

Log ID: 5

The corresponding record is permanently removed from the daily_work_log table.

5. get_work_summary

Generates an overall summary of the stored work logs.

The summary contains:

• Total Work Logs

• Completed Work Logs

• To Do Work Logs

• Total Hours Spent

Example output:

{
    "total_work_logs": 6,
    "completed": 3,
    "todo": 3,
    "total_hours": 48
}

MCP Prompts

The project also demonstrates MCP Prompt functionality.

Prompts are different from Tools.

MCP Tool
   |
   +-- Performs an operation

MCP Prompt
   |
   +-- Provides structured instructions/context

For example, a Tool can insert a task into SQLite, while a Prompt can help structure the information that should be used for creating a Daily Work Log.

create_daily_work_log_prompt

This prompt accepts basic work information and generates structured instructions for preparing a professional Daily Work Log.

Inputs

Work Date
Work Done

Example:

Work Date:
2026-08-05

Work Done:
Created the SQLite database and connected it with the MCP server.

The prompt structures the information around:

Work Date
Day
Task Description
Deliverables
Blockers
Hours Spent
Status
Notes

New work is treated as:

Status: To Do

MCP Prompts generate structured instructions. They do not directly insert information into the SQLite database. Database operations are handled by MCP Tools.

Setup Instructions

1. Open the Project

Open PowerShell or the VS Code terminal and navigate to the project directory:

cd D:\MCP_Server

2. Activate the Virtual Environment

Run:

.\venv\Scripts\Activate.ps1

The terminal should change to:

(venv) PS D:\MCP_Server>

PowerShell Execution Policy Issue

If PowerShell prevents the virtual environment from activating, run:

Set-ExecutionPolicy -Scope Process -ExecutionPolicy RemoteSigned

Then activate the environment again:

.\venv\Scripts\Activate.ps1

Running the Project

Step 1 - Check server.py

Before starting the MCP server, verify that server.py does not contain Python syntax errors.

Run:

python -m py_compile server.py

If no output appears, the file compiled successfully.

Step 2 - Verify MCP Server Loading

Run:

python -c "from server import mcp; print('Server loaded successfully')"

Expected output:

Server loaded successfully

Step 3 - Initialize SQLite Database

Run:

python database.py

Expected output:

==================================================
Intern Tracker Database Initialized Successfully
==================================================

This creates:

intern_tracker.db

and the:

daily_work_log

table if they do not already exist.

Existing data is not removed during normal initialization.

Step 4 - Start MCP Inspector

Run:

npx @modelcontextprotocol/inspector python server.py

Expected output will be similar to:

Starting MCP inspector...

MCP Inspector Web is up and running at:
http://localhost:6274?MCP_INSPECTOR_API_TOKEN=...

Sandbox (MCP Apps):
http://localhost:xxxxx/sandbox

Auth token: ...

Opening browser...

MCP Inspector should automatically open in the browser.

The MCP Inspector authentication token and port numbers may change each time the Inspector is started.

Quick Start

For normal development, the project can be started using:

cd D:\MCP_Server

.\venv\Scripts\Activate.ps1

python -m py_compile server.py

python database.py

npx @modelcontextprotocol/inspector python server.py

Optional server verification:

python -c "from server import mcp; print('Server loaded successfully')"

Using MCP Inspector

After MCP Inspector opens, the server can be tested from the browser interface.

Testing Tools

Open:

Tools

Available tools include:

add_daily_work_log
list_daily_work_logs
update_work_status
delete_daily_work_log
get_work_summary

To create a task:

Tools
   |
   v
add_daily_work_log
   |
   v
Enter Task Information
   |
   v
Execute Tool
   |
   v
server.py
   |
   v
SQLite
   |
   v
intern_tracker.db

After adding a task, execute:

list_daily_work_logs

to confirm that the record has been stored.

Using MCP Prompts

Open:

Prompts

Select:

create_daily_work_log_prompt

Enter:

Work Date
Work Done

The MCP server will return the structured prompt that can be used by an MCP-compatible AI client.

Data Flow

The database workflow is:

User
 |
 v
MCP Inspector
 |
 v
MCP Tool
 |
 v
server.py
 |
 v
get_connection()
        |
        v
    database.py
        |
        v
     SQLite
        |
        v
intern_tracker.db
        |
        v
  daily_work_log

For example:

User enters task information
          |
          v
 add_daily_work_log
          |
          v
      server.py
          |
          v
    SQL INSERT
          |
          v
 intern_tracker.db
          |
          v
 daily_work_log

Viewing Stored Data

The intern_tracker.db file is a SQLite binary database file.

Therefore, it should not be opened as a normal text file.

Use a SQLite database viewer/editor extension in VS Code.

Open:

intern_tracker.db

Then navigate to:

TABLES
   |
   └── daily_work_log

The stored task records will appear in table format.

Verify Data Using Terminal

The database can also be checked directly from PowerShell:

python -c "import sqlite3; con=sqlite3.connect('intern_tracker.db'); rows=con.execute('SELECT * FROM daily_work_log').fetchall(); print(rows); con.close()"

This retrieves all records stored in:

daily_work_log

Current Project Status

The following functionality has been implemented:

• Python MCP Server

• FastMCP integration

• SQLite database

• daily_work_log table

• Add Daily Work Log Tool

• List Daily Work Logs Tool

• Update Work Status Tool

• Delete Daily Work Log Tool

• Work Summary Tool

• Automatic day calculation

• Automatic To Do status

• Update task status to Done

• SQLite data persistence

• MCP Inspector integration

• MCP Tool testing

• MCP Prompt implementation

• Daily Work Log Prompt

• End-to-end MCP and SQLite testing

Future Development

The project can be extended with:

• MCP Resources

• Additional MCP Prompts

• Task editing functionality

• Input validation

• Duplicate date handling

• Search functionality

• Date-based filtering

• Weekly work summaries

• Monthly work summaries

• Improved reporting

• Export functionality

• Integration with an MCP-compatible AI client

A future architecture could look like:

                 AI Client
                     |
                     v
                MCP Server
                     |
       +-------------+-------------+
       |             |             |
       v             v             v
     Tools         Prompts      Resources
       |                           |
       +-------------+-------------+
                     |
                     v
                   SQLite
                     |
                     v
              intern_tracker.db

Developer

Soham Thoke

AI Engineer | GenAI | Prompt Engineering

Project Purpose

The Task Tracker using MCP was developed to understand the practical implementation of the Model Context Protocol using Python.

The project demonstrates how an MCP Server can expose Tools and Prompts while integrating with a persistent SQLite database.

It provides hands-on experience with:

• MCP Server development

• FastMCP

• MCP Tools

• MCP Prompts

• SQLite integration

• CRUD operations

• Persistent task storage

• MCP Inspector

• Client-server interaction

The project serves as a practical implementation of an MCP-based task management system.